feat: ship cork CLI inside the app bundle and link it onto PATH

Add a skeleton cork CLI as a separate lean crate in a new Cargo
workspace, embed it into Cork.app via Tauri's externalBin sidecar, and
expose it on PATH through a Homebrew Cask binary stanza — so installing
the app also installs the cork command. The CLI version is injected from
package.json at build time so it never drifts from the app.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: koki-develop

.lintstagedrc.js

@@ -1,6 +1,6 @@
 export default {
   "*.{js,jsx,ts,tsx}": "oxlint --fix",
   "*.{js,jsx,ts,tsx,css,json,jsonc,md,html}": "oxfmt",
-  "src-tauri/src/**/*.rs": () =>
-    "cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets -- --deny warnings",
+  "src-tauri/**/*.rs": () =>
+    "cargo clippy --manifest-path src-tauri/Cargo.toml --workspace --all-targets -- --deny warnings",
 };

AGENTS.md

@@ -2,6 +2,7 @@
 
 Frontend = React + atomic design (see `src/AGENTS.md`).
 Backend = Tauri v2 + Rust (see `src-tauri/AGENTS.md`).
+CLI = the `cork` command, a separate lean Rust crate shipped **inside** the app bundle (see `src-tauri/AGENTS.md` → "CLI distribution").
 Multi-window: a single process can host any number of windows, each with its own workspace. The `File > New Window` menu / `Cmd+Shift+N` opens an empty welcome window, and the macOS Dock-reopen path restores the last-used workspace into a fresh window. Per-window state lives in `AppState` keyed by `WebviewWindow::label()`; see `src-tauri/AGENTS.md` for the state model.
 
 ## Stack
@@ -14,17 +15,18 @@ Multi-window: a single process can host any number of windows, each with its own
 
 ## Commands
 
-| Command             | What it does                                                               |
-| ------------------- | -------------------------------------------------------------------------- |
-| `bun run dev`       | Vite dev server on port 1420 (frontend only — Tauri APIs error in browser) |
-| `bun run build`     | `tsc && vite build` (full typecheck + bundle)                              |
-| `bun run tauri`     | Tauri CLI passthrough (e.g. `bun run tauri dev`, `bun run tauri build`)    |
-| `bun run format`    | `oxlint --fix && oxfmt` (lint fix + format)                                |
-| `bun run lint`      | `oxlint` (lint check only)                                                 |
-| `bun run lint:fix`  | `oxlint --fix` (lint with autofix)                                         |
-| `bun run fmt`       | `oxfmt` (format only)                                                      |
-| `bun run fmt:check` | `oxfmt --check` (check formatting)                                         |
-| `bun run preview`   | `vite preview` (serve production build)                                    |
+| Command                 | What it does                                                                                                                                                             |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `bun run dev`           | Vite dev server on port 1420 (frontend only — Tauri APIs error in browser)                                                                                               |
+| `bun run build`         | `tsc && vite build` (full typecheck + bundle)                                                                                                                            |
+| `bun run build:sidecar` | Build the `cork` CLI and stage it as a Tauri sidecar (`src-tauri/binaries/cork-cli-<triple>`). Run automatically by `tauri dev` / `tauri build` via the before-commands. |
+| `bun run tauri`         | Tauri CLI passthrough (e.g. `bun run tauri dev`, `bun run tauri build`)                                                                                                  |
+| `bun run format`        | `oxlint --fix && oxfmt` (lint fix + format)                                                                                                                              |
+| `bun run lint`          | `oxlint` (lint check only)                                                                                                                                               |
+| `bun run lint:fix`      | `oxlint --fix` (lint with autofix)                                                                                                                                       |
+| `bun run fmt`           | `oxfmt` (format only)                                                                                                                                                    |
+| `bun run fmt:check`     | `oxfmt --check` (check formatting)                                                                                                                                       |
+| `bun run preview`       | `vite preview` (serve production build)                                                                                                                                  |
 
 ## Pre-commit
 

package.json

@@ -7,6 +7,7 @@
     "prepare": "husky",
     "dev": "vite",
     "build": "tsc && vite build",
+    "build:sidecar": "bun run ./scripts/build-sidecar.ts",
     "preview": "vite preview",
     "tauri": "tauri",
     "format": "oxlint --fix && oxfmt",

scripts/build-cask.ts

@@ -33,6 +33,10 @@ cask "cork" do
 
   app "Cork.app"
 
+  # \`cork\` CLI を PATH に公開する。Cork.app に同梱した sidecar バイナリ
+  # (Contents/MacOS/cork-cli) を \`cork\` という名前でシンボリックリンクする。
+  binary "#{appdir}/Cork.app/Contents/MacOS/cork-cli", target: "cork"
+
   preflight do
     # ad-hoc 署名で designated requirement を identifier のみに設定
     # これにより、ビルドが変わっても TCC が同じアプリとして認識する

scripts/build-sidecar.ts

@@ -0,0 +1,42 @@
+import { execFileSync } from "node:child_process";
+import { chmodSync, copyFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Builds the `cork` CLI and stages it as a Tauri sidecar so `tauri build` / `tauri dev`
+// embed it into `Cork.app/Contents/MacOS/cork-cli`. Tauri requires the binary to carry a
+// `-<target-triple>` suffix (see tauri.conf.json `bundle.externalBin`), which it strips when
+// bundling. The Homebrew Cask then symlinks the embedded binary onto PATH as `cork`.
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const srcTauri = join(scriptDir, "..", "src-tauri");
+
+function hostTargetTriple(): string {
+  const out = execFileSync("rustc", ["-vV"], { encoding: "utf8" });
+  const line = out.split("\n").find((l) => l.startsWith("host:"));
+  if (!line) {
+    throw new Error("could not determine host target triple from `rustc -vV`");
+  }
+  return line.slice("host:".length).trim();
+}
+
+function main() {
+  console.log("Building cork CLI (release)...");
+  execFileSync("cargo", ["build", "--release", "-p", "cork-cli"], {
+    cwd: srcTauri,
+    stdio: "inherit",
+  });
+
+  const triple = hostTargetTriple();
+  const source = join(srcTauri, "target", "release", "cork-cli");
+  const binariesDir = join(srcTauri, "binaries");
+  const dest = join(binariesDir, `cork-cli-${triple}`);
+
+  mkdirSync(binariesDir, { recursive: true });
+  copyFileSync(source, dest);
+  chmodSync(dest, 0o755);
+
+  console.log(`Sidecar staged: ${dest}`);
+}
+
+main();

src-tauri/.gitignore

@@ -5,3 +5,6 @@
 # Generated by Tauri
 # will have schema files for capabilities auto-completion
 /gen/schemas
+
+# Tauri sidecar binaries staged by scripts/build-sidecar.ts (target-triple suffixed)
+/binaries/

src-tauri/AGENTS.md

@@ -1,5 +1,24 @@
 # Rust backend (`src-tauri/`)
 
+## Cargo workspace
+
+`src-tauri/Cargo.toml` is both the **app package** (`cork`) and the **workspace root** (`resolver = "2"`). Members:
+
+- `cork` (this dir) — the Tauri desktop app. `main.rs` → `cork_lib::run()`.
+- `cork-cli` (`cli/`) — the `cork` command-line tool. A deliberately lean crate (depends only on `clap`) so it never drags Tauri / axum / rmcp / objc2 into its compile-and-link. Shared logic, if it ever appears, should be factored into a third `core` member rather than pulling `cork_lib` (which is Tauri-bound) into the CLI.
+
+Build them separately: `tauri build` builds only the `cork` package; the CLI is built with `cargo build -p cork-cli` (wrapped by `bun run build:sidecar`). Both share `src-tauri/target/`. The app executable inside the bundle is `Contents/MacOS/cork` (named after the Cargo package, lowercase), which is why the CLI binary is named `cork-cli` — `cork` would collide on the case-insensitive APFS.
+
+## CLI distribution
+
+The `cork` CLI ships **inside** `Cork.app` and is exposed on `PATH` by Homebrew — installing the app gives you the command, with nothing extra to download.
+
+1. **Build + stage** — `scripts/build-sidecar.ts` (`bun run build:sidecar`) runs `cargo build --release -p cork-cli`, then copies the binary to `src-tauri/binaries/cork-cli-<host-target-triple>` (the suffix Tauri's `externalBin` requires; the dir is gitignored). It's wired into `tauri.conf.json` → `build.beforeDevCommand` / `beforeBuildCommand`, so `tauri dev` and `tauri build` stage it with no extra step (and dev won't fail on a missing sidecar).
+2. **Embed** — `tauri.conf.json` → `bundle.externalBin: ["binaries/cork-cli"]` tells Tauri to strip the triple suffix and embed the binary as `Cork.app/Contents/MacOS/cork-cli`.
+3. **Expose on PATH** — `scripts/build-cask.ts` emits a Homebrew `binary "#{appdir}/Cork.app/Contents/MacOS/cork-cli", target: "cork"` stanza, symlinking the embedded binary to `$(brew --prefix)/bin/cork`. Invoked as `cork`, argv[0] makes `clap` print `cork` in usage; `--version` reads from the `name = "cork"` attribute. The cask's existing ad-hoc `codesign --deep` preflight re-signs the embedded CLI too, so it runs from the terminal without Gatekeeper complaints.
+
+The CLI version is **not** maintained separately: `cli/build.rs` reads the repo-root `package.json` `version` (the single source release-please bumps) and injects it as `CORK_VERSION` at compile time. DMG-only installs (drag-to-Applications, no Homebrew) don't get the `cork` symlink — a future `cork`-self-install subcommand can cover that.
+
 ## Layout
 
 `main.rs` is the entry point and calls `cork_lib::run()`. `lib.rs` only declares modules and wires plugins, state, `#[tauri::command]`s, the `on_window_event` cleanup hook, and the macOS `RunEvent::Reopen` handler in `run()` — domain logic lives in the per-module files below.

src-tauri/Cargo.lock

@@ -1,3 +1,7 @@
+[workspace]
+members = ["cli"]
+resolver = "2"
+
 [package]
 name = "cork"
 description = "A Tauri App"

src-tauri/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "cork-cli"
+version = "0.0.0"
+description = "Command-line interface for Cork"
+edition = "2021"
+
+# The user-facing command is `cork`; the binary is named `cork-cli` to avoid
+# colliding with the Tauri app executable (also `cork`) inside the bundle's
+# `Contents/MacOS/` directory. The Homebrew Cask symlinks it onto PATH as `cork`.
+[[bin]]
+name = "cork-cli"
+path = "src/main.rs"
+
+[dependencies]
+clap = { version = "=4.6.1", features = ["derive"] }
+
+[build-dependencies]
+serde_json = "=1.0.150"