agent-tempo 1.0.1

package/dist/cli/dev-verbs.js

@@ -0,0 +1,254 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_VERBS = void 0;
+exports.dispatchDevVerb = dispatchDevVerb;
+/**
+ * Dev-mode scriptable CLI verbs (#432).
+ *
+ * Five thin shell-scriptable wrappers over the MCP tool surface, available
+ * only when `--dev` / `AGENT_TEMPO_DEV_MODE=1` is active. Production CLI
+ * was collapsed to TUI/MCP-only in #288; this module restores
+ * shell-scriptable access for autonomous E2E validation harnesses without
+ * re-introducing the public surface that #288 retired.
+ *
+ * ## Allowlist discipline
+ *
+ * `DEV_VERBS` is an explicit `ReadonlySet<string>`, NOT derived from
+ * `REMOVED_VERBS` keys. Promoting a removed verb to a dev-mode verb must
+ * be a deliberate, code-reviewed action. The mechanical-enforcement test
+ * in `test/cli-dev-verbs.test.ts` asserts the DEV_VERBS ↔ REMOVED_VERBS
+ * ↔ `cli.ts` switch invariants.
+ *
+ * ## NOT crash-proof
+ *
+ * This module touches Temporal directly. It is deliberately excluded from
+ * `test/cli-crash-proof-isolation.test.ts`'s `CRASH_PROOF_MODULES` allowlist
+ * — dev mode requires Temporal anyway.
+ */
+const config_1 = require("../config");
+const resolve_1 = require("../activities/resolve");
+const maestro_signals_1 = require("../workflows/maestro-signals");
+const signals_1 = require("../workflows/signals");
+const ensemble_ops_1 = require("../utils/ensemble-ops");
+const validation_1 = require("../utils/validation");
+const commands_1 = require("./commands");
+const out = __importStar(require("./output"));
+/** Allowlist of verbs accepted in dev mode. Single source of truth. */
+exports.DEV_VERBS = new Set([
+    'cue',
+    'pause',
+    'play',
+    'release',
+    'set-ensemble-description',
+]);
+async function cueCommand(args) {
+    const playerId = args.positional[1];
+    const message = args.positional.slice(2).join(' ');
+    if (!playerId || !message) {
+        out.error('Usage: agent-tempo --dev cue <player> <message>');
+        process.exit(1);
+    }
+    const nameError = (0, validation_1.validatePlayerName)(playerId);
+    if (nameError) {
+        out.error(nameError);
+        process.exit(1);
+    }
+    if (message.length > validation_1.MESSAGE_MAX) {
+        out.error(`Message exceeds max length (${validation_1.MESSAGE_MAX}).`);
+        process.exit(1);
+    }
+    const { connection, client } = await (0, commands_1.verbClient)(args);
+    try {
+        const handle = await (0, resolve_1.resolveSession)(client, args.ensemble, playerId);
+        if (!handle) {
+            // Throw rather than exit — `connection.close()` in finally must run
+            // first; `process.exit()` skips finally blocks.
+            throw new Error(`No active session named "${playerId}" in ensemble "${args.ensemble}".`);
+        }
+        await handle.signal(signals_1.receiveMessageSignal, { from: 'cli', text: message });
+        out.success(`Cued ${playerId}.`);
+    }
+    finally {
+        await connection.close();
+    }
+}
+async function pauseCommand(args) {
+    const { connection, client } = await (0, commands_1.verbClient)(args);
+    try {
+        const [toggle, sessions] = await Promise.all([
+            (0, ensemble_ops_1.pauseMaestroAndScheduler)(client, args.ensemble),
+            (0, ensemble_ops_1.signalAllSessions)(client, args.ensemble, signals_1.setPausedSignal.name, true),
+        ]);
+        out.log(`  ${out.dim('paused')} ${sessions.sent} session${sessions.sent !== 1 ? 's' : ''}`);
+        if (toggle.maestro)
+            out.log(`  ${out.dim('paused')} maestro`);
+        if (toggle.scheduler)
+            out.log(`  ${out.dim('paused')} scheduler`);
+        if (sessions.failed > 0) {
+            out.warn(`${sessions.failed} session pause signal${sessions.failed !== 1 ? 's' : ''} failed.`);
+        }
+        out.success(`Ensemble "${args.ensemble}" paused.`);
+    }
+    finally {
+        await connection.close();
+    }
+}
+async function playCommand(args) {
+    const { connection, client } = await (0, commands_1.verbClient)(args);
+    try {
+        const [toggle, sessions] = await Promise.all([
+            (0, ensemble_ops_1.unpauseMaestroAndScheduler)(client, args.ensemble),
+            (0, ensemble_ops_1.signalAllSessions)(client, args.ensemble, signals_1.setPausedSignal.name, false),
+        ]);
+        out.log(`  ${out.dim('resumed')} ${sessions.sent} session${sessions.sent !== 1 ? 's' : ''}`);
+        if (toggle.maestro)
+            out.log(`  ${out.dim('resumed')} maestro`);
+        if (toggle.scheduler)
+            out.log(`  ${out.dim('resumed')} scheduler`);
+        if (sessions.failed > 0) {
+            out.warn(`${sessions.failed} session resume signal${sessions.failed !== 1 ? 's' : ''} failed.`);
+        }
+        out.success(`Ensemble "${args.ensemble}" resumed.`);
+    }
+    finally {
+        await connection.close();
+    }
+}
+/**
+ * `release [<player>]` — with `<player>`, signals one session directly.
+ * Without, scans the ensemble and signals every session whose outbox is
+ * currently locked (matches the production `release` semantics in
+ * `commands.ts`).
+ */
+async function releaseCommand(args) {
+    const player = args.positional[1];
+    const { connection, client } = await (0, commands_1.verbClient)(args);
+    try {
+        if (player) {
+            const nameError = (0, validation_1.validatePlayerName)(player);
+            if (nameError)
+                throw new Error(nameError);
+            const handle = await (0, resolve_1.resolveSession)(client, args.ensemble, player);
+            if (!handle) {
+                throw new Error(`No active session named "${player}" in ensemble "${args.ensemble}".`);
+            }
+            await handle.signal(signals_1.releaseHeldSignal);
+            out.success(`Released ${player}.`);
+            return;
+        }
+        // Ensemble-wide — same algorithm as `release()` in commands.ts.
+        const sanitized = args.ensemble.replace(/["\\\n\r]/g, '');
+        const query = `WorkflowType = "agentSessionWorkflow" AND ExecutionStatus = "Running" AND AgentTempoEnsemble = "${sanitized}"`;
+        let released = 0;
+        for await (const wf of client.workflow.list({ query })) {
+            try {
+                const handle = client.workflow.getHandle(wf.workflowId);
+                const locked = await handle.query(signals_1.outboxLockedQuery);
+                if (locked) {
+                    await handle.signal(signals_1.releaseHeldSignal);
+                    released++;
+                    const sa = wf.searchAttributes || {};
+                    const playerId = Array.isArray(sa.AgentTempoPlayerId) ? String(sa.AgentTempoPlayerId[0]) : wf.workflowId;
+                    out.log(`  ${out.dim('released')} ${playerId}`);
+                }
+            }
+            catch {
+                // Skip failed queries (terminated workflows, etc.)
+            }
+        }
+        if (released > 0) {
+            out.success(`Released ${released} player${released !== 1 ? 's' : ''}.`);
+        }
+        else {
+            out.log('No held players found.');
+        }
+    }
+    finally {
+        await connection.close();
+    }
+}
+async function setEnsembleDescriptionCommand(args) {
+    if (args.positional.length < 2) {
+        out.error('Usage: agent-tempo --dev set-ensemble-description "<description>" (use "" to clear)');
+        process.exit(1);
+    }
+    const description = args.positional.slice(1).join(' ');
+    if (description.length > validation_1.ENSEMBLE_DESCRIPTION_MAX) {
+        out.error(`Description exceeds max length (${validation_1.ENSEMBLE_DESCRIPTION_MAX}).`);
+        process.exit(1);
+    }
+    const { connection, client } = await (0, commands_1.verbClient)(args);
+    try {
+        const handle = client.workflow.getHandle((0, config_1.maestroWorkflowId)(args.ensemble));
+        await handle.signal(maestro_signals_1.setEnsembleDescriptionSignal.name, description);
+        if (description.trim().length === 0) {
+            out.success(`Ensemble "${args.ensemble}" description cleared.`);
+        }
+        else {
+            out.success(`Ensemble "${args.ensemble}" description updated: "${description}"`);
+        }
+    }
+    finally {
+        await connection.close();
+    }
+}
+/**
+ * Dispatch a dev-mode verb. Caller (`cli.ts`) gates on `isDevMode()` +
+ * `DEV_VERBS.has(verb)` before calling. Throws `Error` for unknown verbs
+ * — the mechanical test in `cli-dev-verbs.test.ts` asserts that this
+ * is unreachable in practice.
+ */
+async function dispatchDevVerb(verb, args) {
+    switch (verb) {
+        case 'cue':
+            await cueCommand(args);
+            return;
+        case 'pause':
+            await pauseCommand(args);
+            return;
+        case 'play':
+            await playCommand(args);
+            return;
+        case 'release':
+            await releaseCommand(args);
+            return;
+        case 'set-ensemble-description':
+            await setEnsembleDescriptionCommand(args);
+            return;
+        default:
+            throw new Error(`dispatchDevVerb: unknown dev verb "${verb}" (not in DEV_VERBS allowlist)`);
+    }
+}

package/dist/cli/help-text.d.ts

@@ -0,0 +1 @@
+export declare function printHelp(): void;

package/dist/cli/help-text.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHelp = printHelp;
+/**
+ * Help-text module for `agent-tempo help` / `--help` / `-h`.
+ *
+ * **Critical constraint**: this module must NOT import from `@temporalio/*`,
+ * `../workflows/*`, `../adapters/*`, `../spawn`, `../client`, `./commands`,
+ * `./preflight`, `./config-command`, or any module that transitively pulls in
+ * the Temporal SDK. The `help` command must remain operable when the Temporal
+ * SDK itself is broken (see issue #157 PR C — users need to be able to read
+ * help to find the recovery path).
+ *
+ * Kept in its own file (instead of inlined in `src/cli.ts`) so the static
+ * help string doesn't bloat the CLI entrypoint. The test
+ * `test/cli-crash-proof-isolation.test.ts` enumerates this module and asserts
+ * its `require.cache` has no Temporal-adjacent leaks.
+ */
+const out = __importStar(require("./output"));
+const types_1 = require("../types");
+// `AGENT_TYPES` lives in `src/types.ts`, which the crash-proof contract
+// (#157) explicitly permits — it's pure-types-only with no `@temporalio/*`
+// imports. Composing the help string from the canonical tuple means
+// adding a new adapter automatically updates this surface.
+const AGENT_OPTIONS = types_1.AGENT_TYPES.join('|');
+function printHelp() {
+    console.log(`
+${out.bold('agent-tempo')} — Multi-session Claude Code coordination via Temporal
+
+${out.bold('Getting started:')}
+  ${out.cyan('agent-tempo up')}                  Start infrastructure, then launch the TUI with ${out.dim('agent-tempo')}
+
+${out.bold('Usage:')}
+  agent-tempo                         Launch the TUI (auto-provisions + opens home view)
+  agent-tempo <ensemble>              Launch the TUI directly into an ensemble view
+  agent-tempo <command> [options]
+
+${out.bold('Commands:')}
+  ${out.cyan('up')}                       Start infrastructure only — Temporal, daemon, MCP registration
+  ${out.cyan('down')}                     Stop infrastructure; workflows stay parked for the next ${out.dim('up')}
+  ${out.cyan('down --destroy [-y]')}      Terminate every workflow across every ensemble, then stop infrastructure
+  ${out.cyan('server')}                   Start the Temporal dev server and register search attributes
+  ${out.cyan('status')}  [ensemble]       Show active sessions and Temporal health
+  ${out.cyan('ensemble')} <sub>           Manage saved ensemble lineups (save/list/show)
+  ${out.cyan('broadcast')} <message>      Send a message to all active players
+  ${out.cyan('destroy')} <ensemble> [-y]  Terminate every workflow in one ensemble (typed confirmation)
+  ${out.cyan('attachment-info')} <name>   Inspect the V2 attachment phase + current holder
+  ${out.cyan('recall')} <name>            Read a player's message history (--limit/--offset/--preview/--from/--since/--include-sent/--json)
+  ${out.cyan('hosts')}                    List daemons polling this Temporal namespace with advertised capabilities (--all/--json)
+  ${out.cyan('refresh-host-profile')}     Re-advertise this daemon's capability profile to the global Maestro
+  ${out.cyan('restore')} <ensemble>       Restore orphaned sessions in one ensemble on this host (--all-hosts for cluster-view listing)
+  ${out.cyan('release')} [ensemble]       Release all held players (unlock outbox, deliver messages)
+  ${out.cyan('agent-types')} <sub>        Manage player type definitions (list/show/init)
+  ${out.cyan('daemon')}    <sub>          Manage the worker daemon (start/stop/status/logs)
+  ${out.cyan('dashboard')}                Open the web dashboard (--no-open / --pair / --json)
+  ${out.cyan('upgrade')}  [version]       Upgrade agent-tempo to latest (or specific version)
+  ${out.cyan('config')}                   Configure Temporal connection settings
+  ${out.cyan('init')}                     Register MCP server globally (or --project for .mcp.json)
+  ${out.cyan('preflight')}                Run preflight checks only
+  ${out.cyan('help')}                     Show this help message
+
+${out.bold('Removed — use the TUI:')}
+  ${out.dim('stop / restart / detach / migrate')}   → ${out.dim('/destroy · /restart · /shutdown')}
+  ${out.dim('conduct / start / recruit / disband')} → ${out.dim('launch `agent-tempo` · /recruit · /destroy')}
+  ${out.dim('resume')}                              → ${out.dim('/play')}
+  See https://github.com/vinceblank/agent-tempo/issues/285 for the full migration table.
+
+${out.bold('Connection options (all commands):')}
+  --temporal-address <addr>    Temporal server address (default: localhost:7233)
+  --temporal-namespace <ns>    Temporal namespace (default: default)
+  --temporal-api-key <key>     Temporal API key (for Temporal Cloud)
+  --temporal-tls-cert <path>   Path to TLS client certificate
+  --temporal-tls-key <path>    Path to TLS client key
+
+${out.bold('Other options:')}
+  --name <name>                Set session window name (up only)
+  --agent <name>               Agent type to spawn — ${AGENT_OPTIONS} (default: from config; up)
+  --dev                        Use the dev profile (~/.agent-tempo-dev, port 8474, namespace agent-tempo-dev)
+  --skip-preflight             Skip preflight checks
+  --background                 Run Temporal in background (server only)
+  --project                    Use per-project .mcp.json instead of global (init only)
+  --keep-mcp                   Don't remove MCP config (down only)
+  --keep-daemon                Don't stop the worker daemon (down only)
+  --destroy                    Also terminate every workflow (down only)
+  --kill-shared-temporal       Tear down the Temporal dev server even if the other profile is active (down only, #423)
+  -y, --yes                    Skip confirmation prompt (down --destroy, destroy)
+  --lineup <name|file>         Load ensemble lineup by name or file path (up)
+  --scenario <name|path>       Force every mock player in the lineup into mockMode:scripted with this scenario (dev-mode-only, up + --lineup)
+  --no-hold                    Skip startup hold (requires --lineup on up)
+  --ensemble <name>            Target a specific ensemble (broadcast, destroy, restore)
+  --all-hosts                  List cross-host orphans across the whole namespace (restore — read-only, #151)
+  -d, --dir <path>             Target directory (default: cwd)
+
+${out.bold('Config command:')}
+  ${out.dim('agent-tempo config')}              Interactive connection setup
+  ${out.dim('agent-tempo config show')}         Show resolved config
+  ${out.dim('agent-tempo config set <k> <v>')}  Set a config value
+
+  Settings are saved to ~/.agent-tempo/config.json.
+  Also reads ~/.config/temporalio/temporal.yaml as a fallback.
+
+  ${out.bold('Resolution order:')} CLI flag > env var > config file > temporal CLI config > default
+
+${out.bold('First time? Run this:')}
+  ${out.dim('cd your-project')}
+  ${out.dim('agent-tempo up')}
+  ${out.dim('agent-tempo')}            # Launch the TUI
+
+${out.bold('Typical workflow:')}
+  ${out.dim('agent-tempo up')}                 Start infrastructure (once per host)
+  ${out.dim('agent-tempo')}                    Launch the TUI
+  ${out.dim('agent-tempo status myband')}      Check who's active in an ensemble
+
+${out.bold('Environment:')}
+  AGENT_TEMPO_ENSEMBLE       Default ensemble name (fallback: "default")
+  TEMPORAL_ADDRESS            Default Temporal address (fallback: localhost:7233)
+  TEMPORAL_NAMESPACE          Default Temporal namespace (fallback: "default")
+  TEMPORAL_API_KEY            Temporal API key
+  TEMPORAL_TLS_CERT_PATH      Path to TLS client certificate
+  TEMPORAL_TLS_KEY_PATH       Path to TLS client key
+  AGENT_TEMPO_DEFAULT_AGENT  Default agent type: claude or copilot (fallback: claude)
+  AGENT_TEMPO_DEV_MODE       Set to "1" or "true" to enable the dev profile (alternative to --dev)
+  AGENT_TEMPO_HOME_OVERRIDE  Override the home dir entirely (escape hatch for triple-isolated envs)
+`);
+}

package/dist/cli/legacy-migration.d.ts

@@ -0,0 +1,35 @@
+/** Marker file name dropped in the new home post-migration. */
+export declare const MIGRATION_MARKER_FILENAME = ".migrated-from-claude-tempo";
+export type MigrationStatus = 'no-legacy' | 'already-migrated' | 'migrated' | 'skipped' | 'failed';
+export interface LegacyMigrationResult {
+    status: MigrationStatus;
+    legacyHome?: string;
+    newHome?: string;
+    /** Relative paths inside the new home that were copied this run. */
+    copiedFiles?: string[];
+    /** Errors collected during partial-copy resume; populated when status === 'failed'. */
+    errors?: string[];
+    /** Set when status === 'skipped' to explain why. */
+    reason?: string;
+}
+export interface LegacyMigrationOpts {
+    /** Don't write anything; report what would happen. */
+    dryRun?: boolean;
+    /** Override the conflict guard (existing new-home without marker) AND the volatile-state guard. */
+    force?: boolean;
+    /** Which profile to migrate. `'prod'` = `~/.claude-tempo` → `~/.agent-tempo`; `'dev'` = `-dev` variants. Default `'prod'`. */
+    profile?: 'prod' | 'dev';
+    /** Test seam — override `homedir()`. */
+    homeDir?: string;
+}
+/**
+ * One-shot legacy home migration. See module doc-comment for the full
+ * contract. Never throws — all error paths return a structured
+ * {@link LegacyMigrationResult}.
+ */
+export declare function migrateLegacyHome(opts?: LegacyMigrationOpts): Promise<LegacyMigrationResult>;
+/**
+ * Format a {@link LegacyMigrationResult} for human display (CLI verb output
+ * + bootstrap step `notes`).
+ */
+export declare function formatMigrationResult(r: LegacyMigrationResult): string;