@love-moon/conductor-cli 0.2.42 → 0.3.0

package/bin/conductor-task.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+
+/**
+ * conductor task — entity-oriented task management.
+ *
+ * Subcommands:
+ *   list [--project ...] [--issue <id>] [--status ...]
+ *   show <id>
+ *   send <id> [<message>] [--stdin] [--from-file FILE] [--metadata-json '{...}']
+ *   messages <id> [--limit N] [--before <msg-id>]
+ *
+ * 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,
+  readMessageInput,
+  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 taskAsObject(task) {
+  if (!task) return null;
+  if (typeof task.asObject === "function") return task.asObject();
+  return {
+    id: task.id,
+    projectId: task.projectId,
+    issueId: task.issueId ?? null,
+    title: task.title,
+    status: task.status,
+    backendType: task.backendType,
+    sessionId: task.sessionId,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+  };
+}
+
+function parseStatusList(value) {
+  if (!value) return undefined;
+  return String(value)
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function parseMetadataJson(value) {
+  if (!value) return undefined;
+  try {
+    const parsed = JSON.parse(String(value));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("must be a JSON object");
+    }
+    return parsed;
+  } catch (err) {
+    const e = new Error(`Invalid --metadata-json: ${err instanceof Error ? err.message : String(err)}`);
+    e.code = "ARGS";
+    throw e;
+  }
+}
+
+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.tasks.listTasks({
+    projectId: project.id,
+    issueId: argv.issue ? String(argv.issue) : undefined,
+    status: parseStatusList(argv.status),
+  });
+  const objects = (Array.isArray(list) ? list : []).map(taskAsObject);
+  if (argv.json) {
+    printJson(deps.stdout, objects);
+    return EXIT.OK;
+  }
+  if (objects.length === 0) {
+    printPretty(deps.stdout, "(no tasks)");
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `${pad("ID", 24)} ${pad("STATUS", 12)} TITLE`);
+  for (const task of objects) {
+    printPretty(
+      deps.stdout,
+      `${pad(task.id, 24)} ${pad(task.status, 12)} ${task.title ?? ""}`,
+    );
+  }
+  return EXIT.OK;
+}
+
+async function handleShow(argv, deps) {
+  const apis = await buildApis(deps);
+  const task = await apis.tasks.getTask(argv.id);
+  if (!task) {
+    const err = new Error(`Task not found: ${argv.id}`);
+    err.statusCode = 404;
+    throw err;
+  }
+  const obj = taskAsObject(task);
+  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 handleSend(argv, deps) {
+  const apis = await buildApis(deps);
+  const content = readMessageInput({
+    positional: argv.message,
+    fromFile: argv.fromFile,
+    useStdin: Boolean(argv.stdin),
+    stdin: deps.stdin,
+  });
+  const extraMetadata = parseMetadataJson(argv.metadataJson);
+  // `buildAuditMetadata(env, extra)` namespaces `audit.*` so that user-supplied
+  // `--metadata-json '{"actor":"system"}'` cannot spoof CLI audit fields
+  // (review H1). The CLI's `actor: "cli"` always wins inside `audit`.
+  const metadata = buildAuditMetadata(deps.env, extraMetadata || {});
+  const body = {
+    role: "user",
+    content,
+    metadata,
+  };
+  if (argv.dryRun) {
+    emitDryRun(
+      deps.stdout,
+      argv.json,
+      makeDryRunPayload(
+        "POST",
+        `${buildBaseUrl(apis.config)}/api/tasks/${encodeURIComponent(argv.id)}/messages`,
+        body,
+      ),
+    );
+    return EXIT.OK;
+  }
+  // SDK signature is `sendTaskMessage(taskId, content, options?)`. Earlier we
+  // were passing the body object as the second arg, which caused the SDK's
+  // `typeof content === 'string'` guard to throw at runtime (review B1).
+  const result = await apis.tasks.sendTaskMessage(argv.id, content, {
+    role: body.role,
+    metadata: body.metadata,
+  });
+  if (argv.json) {
+    printJson(deps.stdout, result ?? { sent: true });
+    return EXIT.OK;
+  }
+  const id = result?.id ? `${result.id} ` : "";
+  printPretty(deps.stdout, `Sent message ${id}to task ${argv.id}`);
+  return EXIT.OK;
+}
+
+async function handleMessages(argv, deps) {
+  const apis = await buildApis(deps);
+  const list = await apis.tasks.listTaskMessages(argv.id, {
+    limit: argv.limit ? Number(argv.limit) : undefined,
+    before: argv.before ? String(argv.before) : undefined,
+  });
+  if (argv.json) {
+    printJson(deps.stdout, Array.isArray(list) ? list : []);
+    return EXIT.OK;
+  }
+  for (const msg of Array.isArray(list) ? list : []) {
+    const role = msg.role || "msg";
+    const content = (msg.content || "").toString();
+    printPretty(deps.stdout, `[${role}] ${content}`);
+  }
+  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 task")
+      .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 tasks in a project",
+        (cmd) => cmd
+          .option("issue", { type: "string", describe: "Filter by linked issue id" })
+          .option("status", { type: "string", describe: "Comma-separated status filter" }),
+        async (argv) => {
+          exitCode = await handleList(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "show <id>",
+        "Show one task's detail",
+        (cmd) => cmd.positional("id", { type: "string", demandOption: true }),
+        async (argv) => {
+          exitCode = await handleShow(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "send <id> [message]",
+        "Send a user message into a running task",
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .positional("message", { type: "string" })
+          .option("stdin", { type: "boolean", default: false })
+          .option("from-file", { type: "string" })
+          .option("metadata-json", { type: "string", describe: "Extra JSON metadata to merge into the message" }),
+        async (argv) => {
+          exitCode = await handleSend(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "messages <id>",
+        "Pull a slice of task messages and exit (no --follow in this RFC)",
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .option("limit", { type: "number" })
+          .option("before", { type: "string", describe: "Cursor: message id to paginate before" }),
+        async (argv) => {
+          exitCode = await handleMessages(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .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));
+  });
+}

package/bin/conductor.js

@@ -12,6 +12,9 @@
  *   send-file - Upload a local file into a task session
  *   channel  - Connect user-owned chat channel providers
  *   serve-ai - Start an OpenAI-compatible local AI server
+ *   project  - Manage Conductor projects (list/show/create/...)
+ *   issue    - Manage issues (list/show/create/update/start/done)
+ *   task     - Manage tasks (list/show/send/messages)
  */
 
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -35,7 +38,19 @@ export function runConductorCli(args = argv, deps = {}) {
   const processArgv = deps.processArgv || process.argv;
   const fsExistsSync = deps.existsSync || fs.existsSync;
   const checkForUpdates = deps.maybeCheckForUpdates || maybeCheckForUpdates;
-  const validSubcommands = ["fire", "daemon", "config", "update", "diagnose", "send-file", "channel", "serve-ai"];
+  const validSubcommands = [
+    "fire",
+    "daemon",
+    "config",
+    "update",
+    "diagnose",
+    "send-file",
+    "channel",
+    "serve-ai",
+    "project",
+    "issue",
+    "task",
+  ];
 
   if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
     showHelp(consoleImpl);
@@ -117,6 +132,9 @@ Subcommands:
   send-file Upload a local file into a task session
   channel   Connect user-owned chat channel providers
   serve-ai  Start an OpenAI-compatible local AI server
+  project   Manage Conductor projects (list/show/create/...)
+  issue     Manage issues (list/show/create/update/start/done)
+  task      Manage tasks (list/show/send/messages)
 
 Options:
   -h, --help     Show this help message
@@ -132,6 +150,9 @@ Examples:
   conductor serve-ai --port 8787
   conductor config
   conductor update
+  conductor project list
+  conductor issue create --title "Refactor module" --priority P2
+  conductor task send <task-id> "please add a unit test"
 
 For subcommand-specific help:
   conductor fire --help
@@ -142,6 +163,9 @@ For subcommand-specific help:
   conductor send-file --help
   conductor channel --help
   conductor serve-ai --help
+  conductor project --help
+  conductor issue --help
+  conductor task --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.42",
-  "gitCommitId": "f79f36f",
+  "version": "0.3.0",
+  "gitCommitId": "b9f33cd",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lovemoon-ai/conductor.git"
+  },
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -11,7 +15,8 @@
     "src"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "scripts": {
     "test": "node --test test/*.test.js"
@@ -19,7 +24,7 @@
   "dependencies": {
     "@love-moon/ai-manager": "0.2.42",
     "@love-moon/ai-sdk": "0.2.42",
-    "@love-moon/conductor-sdk": "0.2.42",
+    "@love-moon/conductor-sdk": "0.3.0",
     "@github/copilot-sdk": "^0.2.2",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",

package/src/ai-manager-handlers.js

@@ -78,7 +78,23 @@ export function createAiManagerHandlers(opts = {}) {
   }
 
   async function listAccounts() {
-    return { accounts: await manager.listCodexAccounts() };
+    const accounts = await manager.listCodexAccounts();
+    // Enrich each account with its on-disk cached quota so the web UI can
+    // restore inactive-account snapshots across page refreshes. The cache is
+    // read without any network call, so missing/empty caches just leave the
+    // field undefined and cost effectively nothing. We swallow per-account
+    // errors because one broken auth.json shouldn't fail the whole list.
+    const enriched = await Promise.all(
+      accounts.map(async (acct) => {
+        try {
+          const cachedQuota = await manager.readCachedCodexQuota(acct.path);
+          return cachedQuota ? { ...acct, cachedQuota } : acct;
+        } catch {
+          return acct;
+        }
+      }),
+    );
+    return { accounts: enriched };
   }
 
   async function switchAccount(args = {}) {