@smithers-orchestrator/cli 0.16.8 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/cli",
-  "version": "0.16.8",
+  "version": "0.17.0",
   "description": "Smithers command-line interface, TUI, MCP server, and local workflow tools",
   "type": "module",
   "sideEffects": false,
@@ -20,32 +20,41 @@
     "src/"
   ],
   "dependencies": {
+    "@mdx-js/esbuild": "^3.1.1",
     "@effect/workflow": "^0.18.0",
+    "@clack/prompts": "^0.10.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opentui/core": "^0.1.100",
     "@opentui/react": "^0.1.100",
+    "cron-parser": "^5.5.0",
+    "drizzle-orm": "^0.45.2",
     "effect": "^3.21.1",
     "incur": "^0.4.1",
     "picocolors": "^1.1.1",
     "react": "^19.2.5",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/components": "0.16.8",
-    "@smithers-orchestrator/agents": "0.16.8",
-    "@smithers-orchestrator/observability": "0.16.8",
-    "@smithers-orchestrator/driver": "0.16.8",
-    "@smithers-orchestrator/db": "0.16.8",
-    "@smithers-orchestrator/errors": "0.16.8",
-    "@smithers-orchestrator/scheduler": "0.16.8",
-    "@smithers-orchestrator/time-travel": "0.16.8",
-    "@smithers-orchestrator/server": "0.16.8",
-    "smithers-orchestrator": "0.16.8"
+    "@smithers-orchestrator/agents": "0.17.0",
+    "@smithers-orchestrator/accounts": "0.17.0",
+    "@smithers-orchestrator/components": "0.17.0",
+    "@smithers-orchestrator/db": "0.17.0",
+    "@smithers-orchestrator/devtools": "0.17.0",
+    "@smithers-orchestrator/memory": "0.17.0",
+    "@smithers-orchestrator/driver": "0.17.0",
+    "@smithers-orchestrator/errors": "0.17.0",
+    "@smithers-orchestrator/engine": "0.17.0",
+    "@smithers-orchestrator/observability": "0.17.0",
+    "@smithers-orchestrator/protocol": "0.17.0",
+    "@smithers-orchestrator/openapi": "0.17.0",
+    "@smithers-orchestrator/scheduler": "0.17.0",
+    "@smithers-orchestrator/time-travel": "0.17.0",
+    "@smithers-orchestrator/server": "0.17.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "~5.9.3"
   },
   "scripts": {
-    "test": "bun test tests",
+    "test": "bun test --timeout=60000 --max-concurrency=1 tests",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "build": "tsup --dts-only"
   }

package/src/InitWorkflowPackOptions.ts

@@ -1,4 +1,6 @@
 export type InitWorkflowPackOptions = {
+    agentsOnly?: boolean;
     force?: boolean;
     rootDir?: string;
+    skipInstall?: boolean;
 };

package/src/InitWorkflowPackResult.ts

@@ -1,6 +1,12 @@
+type InitInstallResult = {
+    reason?: string;
+    status: "failed" | "ok" | "skipped";
+};
+
 export type InitWorkflowPackResult = {
+    install: InitInstallResult;
+    preservedPaths: string[];
     rootDir: string;
-    writtenFiles: string[];
     skippedFiles: string[];
-    preservedPaths: string[];
+    writtenFiles: string[];
 };

package/src/agent-commands/agentAddWizard.js

@@ -0,0 +1,190 @@
+import { confirm, intro, isCancel, note, outro, password, select, spinner, text } from "@clack/prompts";
+import { defaultConfigDir } from "@smithers-orchestrator/accounts";
+import { runAgentAdd, pingAccount } from "./runAgentAdd.js";
+
+/** @typedef {import("@smithers-orchestrator/accounts").AccountProvider} AccountProvider */
+
+const PROVIDER_CHOICES = [
+    { value: "claude-code", label: "Claude Code (subscription)", hint: "Pro / Max plan via `claude` CLI" },
+    { value: "codex", label: "Codex (subscription)", hint: "ChatGPT Plus/Pro via `codex` CLI" },
+    { value: "gemini", label: "Gemini (subscription)", hint: "Google account via `gemini` CLI" },
+    { value: "kimi", label: "Kimi (subscription)", hint: "OAuth via `kimi` CLI" },
+    { value: "anthropic-api", label: "Anthropic API key", hint: "Pay-per-token via api.anthropic.com" },
+    { value: "openai-api", label: "OpenAI API key", hint: "Pay-per-token via api.openai.com (used by Codex)" },
+    { value: "gemini-api", label: "Gemini API key", hint: "Pay-per-token via Google AI Studio" },
+];
+
+const SUBSCRIPTION_LOGIN_BIN = {
+    "claude-code": "claude",
+    "codex": "codex",
+    "gemini": "gemini",
+    "kimi": "kimi",
+};
+
+const SUBSCRIPTION_DIR_ENV_VAR = {
+    "claude-code": "CLAUDE_CONFIG_DIR",
+    "codex": "CODEX_HOME",
+    "gemini": "GEMINI_DIR",
+    "kimi": "KIMI_SHARE_DIR",
+};
+
+/**
+ * Provider-specific login command + on-screen instructions. Some CLIs use a
+ * dedicated subcommand (`codex login`, `kimi login`); others authenticate via
+ * a slash command inside the REPL (`claude` then /login).
+ *
+ * @type {Record<string, { args: string[]; postInstructions?: string }>}
+ */
+const SUBSCRIPTION_LOGIN_RECIPE = {
+    "claude-code": { args: [], postInstructions: "Inside Claude Code, type /login and follow the browser flow." },
+    "codex": { args: ["login"] },
+    "gemini": { args: [], postInstructions: "Inside Gemini, type /auth (or follow the prompt) to sign in." },
+    "kimi": { args: ["login"] },
+};
+
+function bail() {
+    outro("Cancelled.");
+    process.exit(130);
+}
+
+/**
+ * Interactive `smithers agents add` wizard. Loops until the user is done
+ * adding accounts. Returns the list of labels that were added in this session.
+ *
+ * @param {{ env?: NodeJS.ProcessEnv; cwd?: string; loop?: boolean; skipIntro?: boolean }} [opts]
+ * @returns {Promise<string[]>}
+ */
+export async function agentAddWizard(opts = {}) {
+    const env = opts.env ?? process.env;
+    const cwd = opts.cwd ?? process.cwd();
+    if (!opts.skipIntro) intro("Add a Smithers agent account");
+    /** @type {string[]} */
+    const added = [];
+    while (true) {
+        const provider = await select({
+            message: "Which provider?",
+            options: PROVIDER_CHOICES,
+        });
+        if (isCancel(provider)) bail();
+        const label = await text({
+            message: "Label this account",
+            placeholder: provider === "claude-code" ? "claude-work" : `${provider}-1`,
+            validate(value) {
+                if (!value || !value.trim()) return "Label cannot be empty";
+                if (!/^[A-Za-z0-9._-]+$/.test(value)) return "Use letters, digits, '.', '_' or '-'";
+            },
+        });
+        if (isCancel(label)) bail();
+        const isSubscription = SUBSCRIPTION_LOGIN_BIN[provider] !== undefined;
+        /** @type {string | undefined} */
+        let configDir;
+        /** @type {string | undefined} */
+        let apiKey;
+        if (isSubscription) {
+            const useDefault = await confirm({
+                message: `Store credentials at the default location (~/.smithers/accounts/${label})?`,
+                initialValue: true,
+            });
+            if (isCancel(useDefault)) bail();
+            if (useDefault) {
+                configDir = defaultConfigDir(label, env);
+            }
+            else {
+                const customDir = await text({
+                    message: "Path to existing CLI config dir (e.g. ~/.claude or ~/.codex)",
+                    validate(value) {
+                        if (!value || !value.trim()) return "Path cannot be empty";
+                    },
+                });
+                if (isCancel(customDir)) bail();
+                configDir = customDir.replace(/^~(?=\/|$)/, env.HOME ?? "");
+            }
+            const bin = SUBSCRIPTION_LOGIN_BIN[provider];
+            const envVar = SUBSCRIPTION_DIR_ENV_VAR[provider];
+            const recipe = SUBSCRIPTION_LOGIN_RECIPE[provider] ?? { args: [] };
+            const loginCmd = `${envVar}=${configDir} ${bin}${recipe.args.length ? " " + recipe.args.join(" ") : ""}`;
+            const lines = [
+                "Open another terminal and run:",
+                "",
+                `  ${loginCmd}`,
+            ];
+            if (recipe.postInstructions) {
+                lines.push("", recipe.postInstructions);
+            }
+            lines.push("", "Come back here once you're done.");
+            note(lines.join("\n"), "Log in");
+            const ready = await confirm({
+                message: "Logged in?",
+                initialValue: true,
+            });
+            if (isCancel(ready)) bail();
+            // Trust the user: if they say they logged in, register without
+            // re-checking the dir. We surface success/failure via a ping below.
+            const sp = spinner();
+            sp.start("Registering account…");
+            const result = runAgentAdd({
+                provider: /** @type {AccountProvider} */ (provider),
+                label,
+                configDir,
+                env,
+                cwd,
+                skipLogin: true,
+            });
+            if (!result.ok) {
+                sp.stop(`Could not register: ${result.reason}`);
+                note(result.detail ?? "");
+            }
+            else {
+                sp.stop(`Registered ${result.account.label} (${result.account.provider}).`);
+                added.push(result.account.label);
+                if (result.regen?.rewritten) note(`Updated ${result.regen.path}`, ".smithers/agents.ts");
+                if (ready) {
+                    const ping = pingAccount(result.account);
+                    if (ping.ran) {
+                        const status = ping.exitCode === 0 ? "OK" : `non-zero exit (${ping.exitCode ?? "?"})`;
+                        note(`${ping.cmd}\n→ ${status}`, "Ping");
+                    }
+                }
+                else {
+                    note(`Registered without verifying. Run \`smithers agents test ${result.account.label}\` after logging in.`);
+                }
+            }
+        }
+        else {
+            const key = await password({
+                message: "Paste your API key (kept locally in ~/.smithers/accounts.json, mode 0600)",
+                validate(value) {
+                    if (!value) return "API key cannot be empty";
+                },
+            });
+            if (isCancel(key)) bail();
+            apiKey = key;
+            const sp = spinner();
+            sp.start("Registering account…");
+            const result = runAgentAdd({
+                provider: /** @type {AccountProvider} */ (provider),
+                label,
+                apiKey,
+                env,
+                cwd,
+            });
+            if (!result.ok) {
+                sp.stop(`Could not register: ${result.reason}`);
+                note(result.detail ?? "");
+            }
+            else {
+                sp.stop(`Registered ${result.account.label} (${result.account.provider}).`);
+                added.push(result.account.label);
+                if (result.regen?.rewritten) note(`Updated ${result.regen.path}`, ".smithers/agents.ts");
+            }
+        }
+        if (!opts.loop) break;
+        const another = await confirm({
+            message: "Add another account?",
+            initialValue: false,
+        });
+        if (isCancel(another) || !another) break;
+    }
+    if (!opts.skipIntro) outro(`Added ${added.length} account(s).`);
+    return added;
+}

package/src/agent-commands/regenerateAgentsTsIfPresent.js

@@ -0,0 +1,28 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { generateAgentsTs } from "../agent-detection.js";
+
+/**
+ * If the current working directory contains a `.smithers/agents.ts` that was
+ * previously generated by smithers (sentinel comment present), regenerate it
+ * to reflect the current accounts registry. User-edited files are left alone.
+ *
+ * @param {string} [cwd]
+ * @returns {{ rewritten: boolean; path: string | null; reason?: string }}
+ */
+export function regenerateAgentsTsIfPresent(cwd = process.cwd()) {
+    const path = join(cwd, ".smithers", "agents.ts");
+    if (!existsSync(path)) {
+        return { rewritten: false, path: null, reason: "no .smithers/agents.ts in cwd" };
+    }
+    const existing = readFileSync(path, "utf8");
+    if (!existing.startsWith("// smithers-source: generated")) {
+        return { rewritten: false, path, reason: "agents.ts has been edited by hand; not overwriting" };
+    }
+    const next = generateAgentsTs(process.env);
+    if (next === existing) {
+        return { rewritten: false, path, reason: "no changes" };
+    }
+    writeFileSync(path, next, "utf8");
+    return { rewritten: true, path };
+}

package/src/agent-commands/runAgentAdd.js

@@ -0,0 +1,147 @@
+import { mkdirSync, existsSync, readdirSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { addAccount, defaultConfigDir } from "@smithers-orchestrator/accounts";
+import { regenerateAgentsTsIfPresent } from "./regenerateAgentsTsIfPresent.js";
+
+/** @typedef {import("@smithers-orchestrator/accounts").AccountProvider} AccountProvider */
+
+/**
+ * Provider id → CLI binary name. For API-key providers this is null because
+ * they don't have a separate CLI to log into.
+ * @type {Record<string, string | null>}
+ */
+const SUBSCRIPTION_LOGIN_BIN = {
+    "claude-code": "claude",
+    "codex": "codex",
+    "gemini": "gemini",
+    "kimi": "kimi",
+    "anthropic-api": null,
+    "openai-api": null,
+    "gemini-api": null,
+};
+
+/**
+ * Subcommand args appended to the login command. Some CLIs use a dedicated
+ * subcommand (`codex login`, `kimi login`); others authenticate via a slash
+ * command inside the REPL (the user types /login after launching).
+ * @type {Record<string, string[]>}
+ */
+const SUBSCRIPTION_LOGIN_ARGS = {
+    "claude-code": [],
+    "codex": ["login"],
+    "gemini": [],
+    "kimi": ["login"],
+};
+
+/**
+ * Provider id → env var the CLI reads to find its config dir.
+ * @type {Record<string, string | null>}
+ */
+const SUBSCRIPTION_DIR_ENV_VAR = {
+    "claude-code": "CLAUDE_CONFIG_DIR",
+    "codex": "CODEX_HOME",
+    "gemini": "GEMINI_DIR",
+    "kimi": "KIMI_SHARE_DIR",
+    "anthropic-api": null,
+    "openai-api": null,
+    "gemini-api": null,
+};
+
+/**
+ * @param {string} dir
+ * @returns {boolean}
+ */
+function dirHasContents(dir) {
+    if (!existsSync(dir)) return false;
+    try { return readdirSync(dir).length > 0; }
+    catch { return false; }
+}
+
+/**
+ * @typedef {{
+ *   provider: AccountProvider;
+ *   label: string;
+ *   configDir?: string;
+ *   apiKey?: string;
+ *   model?: string;
+ *   skipLogin?: boolean;
+ *   force?: boolean;
+ *   replace?: boolean;
+ *   env?: NodeJS.ProcessEnv;
+ *   cwd?: string;
+ *   loginInstructions?: (cmd: string) => void;
+ * }} RunAgentAddInput
+ */
+
+/**
+ * Non-interactive entry point: register an account from already-resolved
+ * inputs. Used by both the flag-driven CLI and the clack wizard. Returns the
+ * persisted account plus a summary of the register/regen operation.
+ *
+ * @param {RunAgentAddInput} input
+ */
+export function runAgentAdd(input) {
+    const env = input.env ?? process.env;
+    const cwd = input.cwd ?? process.cwd();
+    const isSubscription = SUBSCRIPTION_LOGIN_BIN[input.provider] !== null;
+    const isApiKey = !isSubscription;
+    if (isSubscription) {
+        const configDir = input.configDir ?? defaultConfigDir(input.label, env);
+        mkdirSync(configDir, { recursive: true });
+        // Verify there's something there before registering, unless --force or
+        // --skip-login (e2e tests pre-populate a fake credentials file).
+        const populated = dirHasContents(configDir);
+        if (!populated && !input.skipLogin && !input.force) {
+            const bin = SUBSCRIPTION_LOGIN_BIN[input.provider];
+            const envVar = SUBSCRIPTION_DIR_ENV_VAR[input.provider];
+            const subArgs = SUBSCRIPTION_LOGIN_ARGS[input.provider] ?? [];
+            const cmd = `${envVar}=${configDir} ${bin}${subArgs.length ? " " + subArgs.join(" ") : ""}`;
+            const detail = `Config dir ${configDir} is empty. Run the following in another terminal to log in, then re-run \`smithers agents add\`:\n\n  ${cmd}\n\n(or pass --skip-login to register the empty dir, --force to register without verification)`;
+            return { ok: false, reason: "login-required", detail, configDir };
+        }
+        const account = addAccount({
+            label: input.label,
+            provider: input.provider,
+            configDir,
+            model: input.model,
+        }, { env, replace: input.replace });
+        const regen = regenerateAgentsTsIfPresent(cwd);
+        return { ok: true, account, regen };
+    }
+    if (isApiKey) {
+        if (typeof input.apiKey !== "string") {
+            return { ok: false, reason: "missing-api-key", detail: `Provider ${input.provider} requires --api-key (may be empty for env-var-only).` };
+        }
+        const account = addAccount({
+            label: input.label,
+            provider: input.provider,
+            apiKey: input.apiKey,
+            model: input.model,
+        }, { env, replace: input.replace });
+        const regen = regenerateAgentsTsIfPresent(cwd);
+        return { ok: true, account, regen };
+    }
+    return { ok: false, reason: "unknown-provider", detail: `Unknown provider: ${input.provider}` };
+}
+
+/**
+ * Quick health check: spawn `<bin> --version` (or equivalent) under the
+ * account's env vars and report whether the CLI starts cleanly. Best-effort —
+ * a non-zero exit is reported but does not throw.
+ *
+ * @param {{ provider: AccountProvider; configDir?: string; apiKey?: string }} account
+ * @returns {{ ran: boolean; exitCode: number | null; cmd: string }}
+ */
+export function pingAccount(account) {
+    const bin = SUBSCRIPTION_LOGIN_BIN[account.provider];
+    if (!bin) return { ran: false, exitCode: null, cmd: "(api-key provider; no CLI to ping)" };
+    const envVar = SUBSCRIPTION_DIR_ENV_VAR[account.provider];
+    const env = { ...process.env };
+    if (envVar && account.configDir) env[envVar] = account.configDir;
+    const result = spawnSync(bin, ["--version"], { env, encoding: "utf8" });
+    return {
+        ran: true,
+        exitCode: result.status,
+        cmd: `${envVar ? `${envVar}=${account.configDir} ` : ""}${bin} --version`,
+    };
+}