@love-moon/conductor-cli 0.2.42 → 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,133 @@
+# @love-moon/conductor-cli
+
+## 0.3.1
+
+### Patch Changes
+
+- 4e8d4e5: Include `CHANGELOG.md` in published npm tarballs.
+
+  The `files` array in each package's `package.json` previously only
+  listed the build output (`bin`/`src` for the CLI, `dist` for the
+  modules). npm's `files` whitelist replaces the default include set,
+  and CHANGELOG is not one of the auto-included files (only
+  `package.json`, `README*`, `LICENSE*`, and `main` are unconditional).
+
+  As a result, every release through 0.3.0 published tarballs with no
+  CHANGELOG, so a consumer running `npm install` or unpacking the brew
+  artifact had no way to see what changed in the version they just
+  installed. The repo `cli/CHANGELOG.md` and the GitHub Release body
+  remain the canonical source until 0.3.1 ships with this fix.
+
+- Updated dependencies [4e8d4e5]
+  - @love-moon/conductor-sdk@0.3.1
+  - @love-moon/ai-sdk@0.3.1
+  - @love-moon/ai-manager@0.3.1
+
+## 0.3.0
+
+### Minor Changes
+
+- be3b3cb: Project list now merges same-name git projects that share a remote URL across daemons into a single card.
+
+  - `ProjectContext.snapshot()` (SDK) now captures the origin remote URL via `git config --get remote.origin.url` and exposes a `normalizeGitRemoteUrl` helper for callers that need their own equality comparison.
+  - The daemon's `validate_project_path` response carries a new `git_remote_url` field. Old daemons that don't send it stay forward-compatible — the web server treats missing values as "unmergeable" so projects from those daemons render standalone until they're refreshed.
+  - New web API surface:
+    - `PATCH /api/projects { mergeOptOut: true }` opts a project out of auto-grouping (manual split for accidental name collisions).
+    - `PATCH /api/projects { refresh: true }` re-runs the daemon validation handshake and back-fills `git_remote_url` for projects created before this feature.
+    - `GET /api/issues?project_ids=a,b` fetches issues from multiple projects in one call; responses include `daemonHost` + `projectName` for cross-daemon attribution.
+  - Schema: two new optional columns on `projects`: `git_remote_url` (nullable string) and `merge_opt_out` (boolean, default false). Run `pnpm -C web db:push` before upgrading.
+
+- 23ac015: Add `fire_tmux_mode` for the daemon. When enabled (via the `fire_tmux_mode: true`
+  key in `~/.conductor/config.yaml` or the `CONDUCTOR_FIRE_TMUX_MODE=true`
+  environment variable), each Fire process is launched inside a detached
+  `tmux new-session -d` so that it runs under the tmux server with no
+  parent/child relationship to the daemon. Restarting or terminating the daemon
+  no longer affects running Fire processes; explicit `stop_task` requests use
+  `tmux kill-session` to terminate the corresponding session.
+
+  If `fire_tmux_mode` is enabled but `tmux` is not installed on PATH, the daemon
+  logs a warning at startup and silently falls back to direct spawn instead of
+  failing every `create_task` with ENOENT.
+
+  If a tmux session fails to launch (e.g. duplicate session name, tmux server
+  crashed), the daemon now reports a terminal status to the backend instead of
+  leaving the task stuck on RUNNING.
+
+  Session names embed a per-spawn uniqueness suffix
+  (`conductor-fire-<taskId>-<base36-time><rand>`) so a re-spawn of the same task
+  id while a prior session is still alive does not collide. The daemon also runs
+  a periodic best-effort liveness reaper (default every 30s; override via
+  `config.TMUX_LIVENESS_POLL_MS`) that walks tmux-mode entries in
+  `activeTaskProcesses` and removes any whose session no longer exists, so the
+  in-memory map does not accumulate stale entries when Fire exits naturally
+  inside its session.
+
+### Other Changes (retroactively documented)
+
+The following changes shipped in `@love-moon/conductor-cli@0.3.0` but were
+merged without a `changeset` entry and so didn't make it into the
+auto-generated section above. See
+`claw/lessons/arch_release-packages-pnpm-changesets-20260512.md` for the
+process gap and the rule that every PR touching `cli/**` or `modules/**`
+must run `npm run changeset`.
+
+**New CLI commands**
+
+- `cli`: `conductor project|issue|task` entity commands (RFC 0025). Adds
+  scriptable CLI access to project/issue/task CRUD against the connected
+  daemon. (`2e10756`)
+- `cli`: `conductor project` accepts `--daemon-host` to disambiguate
+  same-named projects across multiple daemons. (`08eefee`)
+- `cli`: `conductor project list` now prints a daemon column. (`552731b`)
+
+**Daemon — Fire tmux mode (companion to `fire_tmux_mode`)**
+
+- Daemon now `tmux send-keys`-friendly: env vars are propagated via
+  `tmux -e` flags so the Fire process inherits the spawn environment.
+  (`3cd3022`)
+- Live Fire output is now visible via `tmux attach` thanks to a `tee`
+  inside the session shell. (`f07fbc6`)
+- `stop_task` and `cleanup_task_worktree` now reap orphan tmux sessions.
+  (`1f7ef28`)
+- A killed tmux-mode task reports `KILLED` directly from the daemon
+  instead of waiting on Fire to flip the status. (`59c6472`)
+- `restart_task` clears stale tmux entries before re-spawning and refuses
+  with a clearer error if the session can't be acquired. (`c659663`)
+
+**Daemon stability**
+
+- Fix: reconcile / stale-recovery no longer kills `init` successor tasks
+  that haven't received their initial websocket message yet. (`d9258ba`)
+- Fix: late websocket send after disconnect no longer crashes daemon
+  restart. (`a3532cc`)
+- Fix: stale fire task attach is now guarded against double-binding.
+  (`dc73be9`)
+
+**Worktree**
+
+- Worktree folders are now named by branch (slugified) rather than by
+  the task id, making them human-meaningful inside repos with many
+  concurrent tasks. (`ed124b5`)
+- The worktree scanner now skips symlinks that are git-tracked, so user
+  symlinks inside a worktree don't get treated as candidates. (`5281952`)
+
+**Quota / accounts UI**
+
+- Codex quota snapshots are now restored from the daemon cache on
+  refresh, so the daemon page doesn't blank out while a fresh fetch is
+  in flight. (`130bd93`)
+
+**Internal refactor (no consumer API change)**
+
+- `modules/ai-sdk`: resume logic has been split into per-provider
+  modules under `src/resume/<provider>.js`. The public exports
+  (`createAiSession`, `BUILT_IN_BACKENDS`, etc.) are unchanged.
+  Source-level only; the published `@love-moon/ai-sdk` version pinned
+  in `cli@0.3.0`'s manifest is still `0.2.42`, so consumer behavior is
+  identical to before — the refactor will reach npm with the next
+  ai-sdk release that includes a `changeset`. (`846f05a`)
+
+### Patch Changes
+
+- Updated dependencies [be3b3cb]
+  - @love-moon/conductor-sdk@0.3.0

package/bin/conductor-fire.js

@@ -1466,10 +1466,28 @@ function buildEnv() {
   return env;
 }
 
-async function ensureTaskContext(conductor, opts) {
-  if (opts.providedTaskId) {
+function isBackendNotFoundError(error) {
+  return Boolean(error && typeof error === "object" && Number(error.statusCode) === 404);
+}
+
+export async function ensureTaskContext(conductor, opts) {
+  const providedTaskId =
+    typeof opts.providedTaskId === "string" ? opts.providedTaskId.trim() : "";
+  if (providedTaskId) {
+    if (typeof conductor.getTask === "function") {
+      try {
+        await conductor.getTask(providedTaskId);
+      } catch (error) {
+        if (isBackendNotFoundError(error)) {
+          throw new Error(
+            `CONDUCTOR_TASK_ID points to missing task ${providedTaskId}; unset CONDUCTOR_TASK_ID or use an existing task id`,
+          );
+        }
+        throw error;
+      }
+    }
     return {
-      taskId: opts.providedTaskId,
+      taskId: providedTaskId,
       appUrl: null,
       shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
       initialPromptDelivery: opts.initialPrompt ? "synthetic" : "none",

package/bin/conductor-issue.js

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+
+/**
+ * conductor issue — entity-oriented issue management.
+ *
+ * Subcommands:
+ *   list [--project ...] [--status <s>] [--limit N]
+ *   show <id>
+ *   create --title <t> [--description <d> | --description-file FILE | --description-stdin]
+ *          [--priority P1|P2|P3] [--status backlog|doing|done]
+ *          [--client-request-id <key>] [--project ...]
+ *   update <id> [--title ...] [--description ...] [--priority ...] [--status ...]
+ *   start <id>          (alias for update --status doing)
+ *   done <id> [--evidence <text>|@FILE]
+ *
+ * Global flags supported on every write subcommand:
+ *   --json, --dry-run, --project, --config-file
+ */
+
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+
+import {
+  EXIT,
+  buildApis,
+  buildAuditMetadata,
+  emitDryRun,
+  exitCodeForError,
+  makeDryRunPayload,
+  pad,
+  printJson,
+  printPretty,
+  readDescription,
+  readEvidence,
+  reportError,
+  resolveProject,
+} from "../src/entity-helpers.js";
+
+const isMainModule = (() => {
+  const currentFile = fileURLToPath(import.meta.url);
+  const entryFile = process.argv[1] ? path.resolve(process.argv[1]) : "";
+  return entryFile === currentFile;
+})();
+
+function buildBaseUrl(config) {
+  const raw = (config?.backendUrl || "").replace(/\/+$/, "");
+  return raw || "http://localhost";
+}
+
+function issueAsObject(issue) {
+  if (!issue) return null;
+  if (typeof issue.asObject === "function") return issue.asObject();
+  return {
+    id: issue.id,
+    title: issue.title,
+    status: issue.status,
+    priority: issue.priority,
+    description: issue.description,
+    projectId: issue.projectId,
+    metadata: issue.metadata,
+    createdAt: issue.createdAt,
+    updatedAt: issue.updatedAt,
+  };
+}
+
+function parseStatusList(value) {
+  if (!value) return undefined;
+  return String(value)
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+async function handleList(argv, deps) {
+  const apis = await buildApis(deps);
+  const project = await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
+  const list = await apis.issues.listIssues({
+    projectId: project.id,
+    status: parseStatusList(argv.status),
+    limit: argv.limit ? Number(argv.limit) : undefined,
+  });
+  const objects = (Array.isArray(list) ? list : []).map(issueAsObject);
+  if (argv.json) {
+    printJson(deps.stdout, objects);
+    return EXIT.OK;
+  }
+  if (objects.length === 0) {
+    printPretty(deps.stdout, "(no issues)");
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `${pad("ID", 24)} ${pad("STATUS", 9)} ${pad("PRIO", 5)} TITLE`);
+  for (const issue of objects) {
+    printPretty(
+      deps.stdout,
+      `${pad(issue.id, 24)} ${pad(issue.status, 9)} ${pad(issue.priority ?? "", 5)} ${issue.title ?? ""}`,
+    );
+  }
+  return EXIT.OK;
+}
+
+async function handleShow(argv, deps) {
+  const apis = await buildApis(deps);
+  const issue = await apis.issues.getIssue(argv.id);
+  if (!issue) {
+    const err = new Error(`Issue not found: ${argv.id}`);
+    err.statusCode = 404;
+    throw err;
+  }
+  const obj = issueAsObject(issue);
+  if (argv.json) {
+    printJson(deps.stdout, obj);
+    return EXIT.OK;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined || value === null) continue;
+    if (typeof value === "object") {
+      printPretty(deps.stdout, `${key}: ${JSON.stringify(value)}`);
+    } else {
+      printPretty(deps.stdout, `${key}: ${value}`);
+    }
+  }
+  return EXIT.OK;
+}
+
+async function handleCreate(argv, deps) {
+  const apis = await buildApis(deps);
+  const project = await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
+  const description = readDescription({
+    description: argv.description,
+    descriptionFile: argv.descriptionFile,
+    descriptionStdin: argv.descriptionStdin,
+    stdin: deps.stdin,
+  });
+  const metadata = buildAuditMetadata(deps.env);
+  const body = {
+    projectId: project.id,
+    title: String(argv.title),
+    ...(description !== undefined ? { description } : {}),
+    ...(argv.priority ? { priority: String(argv.priority) } : {}),
+    ...(argv.status ? { status: String(argv.status) } : {}),
+    ...(argv.clientRequestId ? { clientRequestId: String(argv.clientRequestId) } : {}),
+    metadata,
+  };
+  if (argv.dryRun) {
+    emitDryRun(
+      deps.stdout,
+      argv.json,
+      makeDryRunPayload("POST", `${buildBaseUrl(apis.config)}/api/issues`, body),
+    );
+    return EXIT.OK;
+  }
+  const created = await apis.issues.createIssue(body);
+  const obj = issueAsObject(created);
+  if (argv.json) {
+    printJson(deps.stdout, obj);
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `Created issue ${obj.id}: ${obj.title}`);
+  return EXIT.OK;
+}
+
+async function handleUpdate(argv, deps, overrides = {}) {
+  const apis = await buildApis(deps);
+  const description = readDescription({
+    description: argv.description,
+    descriptionFile: argv.descriptionFile,
+    descriptionStdin: argv.descriptionStdin,
+    stdin: deps.stdin,
+  });
+  // `--description ""` is intentionally treated as a no-op (readDescription
+  // returns undefined). To clear an existing description, the server expects
+  // an explicit `null` — exposing that requires a follow-up flag and is out of
+  // scope here (review M5 — current behavior accepted as documented).
+  const status = overrides.status || argv.status;
+  const evidence = overrides.evidence;
+  const metadata = buildAuditMetadata(deps.env);
+  const body = {
+    ...(argv.title ? { title: String(argv.title) } : {}),
+    ...(description !== undefined ? { description } : {}),
+    ...(argv.priority ? { priority: String(argv.priority) } : {}),
+    ...(status ? { status: String(status) } : {}),
+    metadata,
+  };
+  if (Object.keys(body).filter((key) => key !== "metadata").length === 0) {
+    const err = new Error("Nothing to update: pass at least one of --title/--description/--priority/--status");
+    err.code = "ARGS";
+    throw err;
+  }
+  if (argv.dryRun) {
+    // Surface evidence in the preview body so the user sees what the SDK will
+    // merge into `metadata.qa.evidence` server-side. The real call still
+    // round-trips the existing metadata; this preview is an approximation.
+    const previewBody = evidence === undefined
+      ? body
+      : {
+          ...body,
+          metadata: {
+            ...body.metadata,
+            qa: { ...((body.metadata && body.metadata.qa) || {}), evidence },
+          },
+        };
+    const previewOptions = evidence !== undefined
+      ? { note: "preview omits server-side metadata round-trip; live PATCH merges existing metadata.qa fields" }
+      : {};
+    emitDryRun(
+      deps.stdout,
+      argv.json,
+      makeDryRunPayload(
+        "PATCH",
+        `${buildBaseUrl(apis.config)}/api/issues/${encodeURIComponent(argv.id)}`,
+        previewBody,
+        previewOptions,
+      ),
+    );
+    return EXIT.OK;
+  }
+  // Pick the SDK call:
+  //   - If we have `evidence`, route through `updateIssueStatus` so the SDK
+  //     round-trips the existing metadata and merges `qa.evidence` instead of
+  //     clobbering. We pass `metadata` so the CLI's audit namespace flows
+  //     through.
+  //   - Otherwise call `updateIssue` so a multi-field patch (title + status)
+  //     reaches the server intact (review B2: previously the CLI passed the
+  //     full body as the SDK's third arg, which was ignored).
+  let updated;
+  if (evidence !== undefined && status && typeof apis.issues.updateIssueStatus === "function") {
+    updated = await apis.issues.updateIssueStatus(argv.id, String(status), {
+      evidence,
+      metadata,
+    });
+  } else {
+    updated = await apis.issues.updateIssue(argv.id, body);
+  }
+  const obj = issueAsObject(updated);
+  if (argv.json) {
+    printJson(deps.stdout, obj);
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `Updated issue ${obj.id}`);
+  return EXIT.OK;
+}
+
+export async function main(argvInput = hideBin(process.argv), deps = {}) {
+  const stdout = deps.stdout || process.stdout;
+  const stderr = deps.stderr || process.stderr;
+  const env = deps.env || process.env;
+  const cwd = deps.cwd || process.cwd();
+  const consoleErr = { error: (msg) => stderr.write(`${msg}\n`) };
+  const handlerDeps = { ...deps, stdout, stderr, env, cwd };
+
+  let exitCode = EXIT.OK;
+  try {
+    await yargs(argvInput)
+      .scriptName("conductor issue")
+      .strict()
+      .help()
+      .option("json", { type: "boolean", default: false })
+      .option("dry-run", { type: "boolean", default: false })
+      .option("project", { type: "string", describe: "Project id or name override" })
+      .option("config-file", { type: "string", describe: "Path to Conductor config file" })
+      .command(
+        "list",
+        "List issues",
+        (cmd) => cmd
+          .option("status", { type: "string", describe: "Comma-separated status filter (e.g. backlog,doing)" })
+          .option("limit", { type: "number" }),
+        async (argv) => {
+          exitCode = await handleList(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "show <id>",
+        "Show one issue's full detail",
+        (cmd) => cmd.positional("id", { type: "string", demandOption: true }),
+        async (argv) => {
+          exitCode = await handleShow(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "create",
+        "Create a new issue",
+        (cmd) => cmd
+          .option("title", { type: "string", demandOption: true })
+          .option("description", { type: "string" })
+          .option("description-file", { type: "string" })
+          .option("description-stdin", { type: "boolean", default: false })
+          .option("priority", { choices: ["P1", "P2", "P3"] })
+          .option("status", { choices: ["backlog", "doing", "done"] })
+          .option("client-request-id", { type: "string" }),
+        async (argv) => {
+          exitCode = await handleCreate(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "update <id>",
+        "Update an issue's fields (any subset)",
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .option("title", { type: "string" })
+          .option("description", { type: "string" })
+          .option("description-file", { type: "string" })
+          .option("description-stdin", { type: "boolean", default: false })
+          .option("priority", { choices: ["P1", "P2", "P3"] })
+          .option("status", { choices: ["backlog", "doing", "done"] }),
+        async (argv) => {
+          exitCode = await handleUpdate(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "start <id>",
+        "Mark issue as doing (alias for update --status doing)",
+        (cmd) => cmd.positional("id", { type: "string", demandOption: true }),
+        async (argv) => {
+          exitCode = await handleUpdate(argv, { ...handlerDeps, configFile: argv.configFile }, { status: "doing" });
+        },
+      )
+      .command(
+        "done <id>",
+        "Mark issue as done (optionally attach QA evidence)",
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .option("evidence", { type: "string", describe: "Inline text or @path/to/file" }),
+        async (argv) => {
+          const evidence = readEvidence(argv.evidence);
+          exitCode = await handleUpdate(argv, { ...handlerDeps, configFile: argv.configFile }, {
+            status: "done",
+            ...(evidence !== undefined ? { evidence } : {}),
+          });
+        },
+      )
+      .demandCommand(1)
+      .fail((msg, err) => {
+        if (err) {
+          throw err;
+        }
+        stderr.write(`${msg}\n`);
+        exitCode = EXIT.ARGS;
+      })
+      .parseAsync();
+  } catch (err) {
+    exitCode = reportError(consoleErr, err);
+  }
+  return exitCode;
+}
+
+if (isMainModule) {
+  main().then((code) => {
+    if (code !== 0) process.exit(code);
+  }).catch((err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(exitCodeForError(err));
+  });
+}