agent-tempo 1.0.1

package/dist/cli/config-command.d.ts

@@ -0,0 +1,8 @@
+/** Interactive config setup: `agent-tempo config` */
+export declare function configInteractive(): Promise<void>;
+/** Non-interactive: `agent-tempo config set <key> <value>` */
+export declare function configSet(key: string, value: string): void;
+/** Show current config: `agent-tempo config show` */
+export declare function configShow(): void;
+/** Route `agent-tempo config [subcommand] [args...]` */
+export declare function configCommand(positional: string[]): Promise<void>;

package/dist/cli/config-command.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.configInteractive = configInteractive;
+exports.configSet = configSet;
+exports.configShow = configShow;
+exports.configCommand = configCommand;
+const readline = __importStar(require("readline"));
+const config_1 = require("../config");
+const config_2 = require("../config");
+const out = __importStar(require("./output"));
+// NOTE: `createTemporalConnection` is dynamic-imported inside `configInteractive`'s
+// connection-test step (issue #157 PR C). Top-level static import would pull in
+// `@temporalio/client`, defeating the crash-proof property of `config show` /
+// `config set` — both of which are pure fs operations and must remain operable
+// under a broken Temporal SDK install.
+const SECRET_KEYS = new Set(['temporalApiKey']);
+/** Read a line from stdin with a prompt and optional default value. */
+function ask(prompt, defaultVal, mask = false) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const display = defaultVal ? `${prompt} (${defaultVal}): ` : `${prompt}: `;
+        if (mask) {
+            // For secret input: write prompt manually, mute output
+            process.stdout.write(`? ${display}`);
+            const stdin = process.stdin;
+            const wasRaw = stdin.isRaw;
+            if (stdin.setRawMode)
+                stdin.setRawMode(true);
+            let input = '';
+            const onData = (ch) => {
+                const c = ch.toString();
+                if (c === '\n' || c === '\r') {
+                    if (stdin.setRawMode)
+                        stdin.setRawMode(wasRaw ?? false);
+                    stdin.removeListener('data', onData);
+                    process.stdout.write('\n');
+                    rl.close();
+                    resolve(input || defaultVal || '');
+                }
+                else if (c === '\u0003') {
+                    // Ctrl+C
+                    rl.close();
+                    process.exit(0);
+                }
+                else if (c === '\u007f' || c === '\b') {
+                    // Backspace
+                    if (input.length > 0) {
+                        input = input.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                }
+                else {
+                    input += c;
+                    process.stdout.write('*');
+                }
+            };
+            stdin.on('data', onData);
+        }
+        else {
+            rl.question(`? ${display}`, (answer) => {
+                rl.close();
+                resolve(answer.trim() || defaultVal || '');
+            });
+        }
+    });
+}
+/** Ask user to choose from a list of options. Returns the selected option. */
+async function choose(prompt, options) {
+    console.log(`? ${prompt}:`);
+    for (let i = 0; i < options.length; i++) {
+        console.log(`  ${i + 1}. ${options[i]}`);
+    }
+    const answer = await ask('Choice', '1');
+    const idx = parseInt(answer, 10) - 1;
+    if (idx >= 0 && idx < options.length)
+        return options[idx];
+    return options[0];
+}
+/** Interactive config setup: `agent-tempo config` */
+async function configInteractive() {
+    out.heading('agent-tempo config');
+    const existing = (0, config_1.loadConfigFile)();
+    const address = await ask('Temporal address', existing.temporalAddress || 'localhost:7233');
+    const namespace = await ask('Temporal namespace', existing.temporalNamespace || 'default');
+    const authMethod = await choose('Auth method', ['None', 'API key', 'mTLS']);
+    const config = {
+        temporalAddress: address,
+        temporalNamespace: namespace,
+    };
+    if (authMethod === 'API key') {
+        config.temporalApiKey = await ask('API key', existing.temporalApiKey, true);
+    }
+    else if (authMethod === 'mTLS') {
+        config.temporalTlsCertPath = await ask('TLS cert path', existing.temporalTlsCertPath);
+        config.temporalTlsKeyPath = await ask('TLS key path', existing.temporalTlsKeyPath);
+    }
+    // Default agent type
+    const agentChoice = await choose('Default agent', ['claude', 'copilot']);
+    if (agentChoice === 'copilot') {
+        config.defaultAgent = 'copilot';
+    }
+    // Don't set defaultAgent if claude — it's the default, keeps config clean
+    (0, config_1.saveConfigFile)(config);
+    out.success(`Saved to ${config_1.CONFIG_FILE_PATH}`);
+    // Test connection
+    try {
+        const resolved = (0, config_2.getConfig)({
+            temporalAddress: config.temporalAddress,
+            temporalNamespace: config.temporalNamespace,
+            temporalApiKey: config.temporalApiKey,
+            temporalTlsCertPath: config.temporalTlsCertPath,
+            temporalTlsKeyPath: config.temporalTlsKeyPath,
+        });
+        // Dynamic import keeps `config show` / `config set` crash-proof under
+        // a broken Temporal SDK install (#157 PR C). Interactive setup's
+        // connection test is the only path that actually needs the SDK.
+        const { createTemporalConnection } = await Promise.resolve().then(() => __importStar(require('../connection')));
+        const conn = await Promise.race([
+            createTemporalConnection(resolved),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000)),
+        ]);
+        await conn.close();
+        out.success('Connected successfully');
+    }
+    catch (err) {
+        out.warn(`Could not connect: ${err?.message || err}`);
+        out.log(`  Config was saved — you can fix the connection and re-run ${out.dim('agent-tempo config')}`);
+    }
+}
+/** Non-interactive: `agent-tempo config set <key> <value>` */
+function configSet(key, value) {
+    const config = (0, config_1.loadConfigFile)();
+    const keyMap = {
+        temporalAddress: 'temporalAddress',
+        'temporal-address': 'temporalAddress',
+        temporalNamespace: 'temporalNamespace',
+        'temporal-namespace': 'temporalNamespace',
+        temporalApiKey: 'temporalApiKey',
+        'temporal-api-key': 'temporalApiKey',
+        temporalTlsCertPath: 'temporalTlsCertPath',
+        'temporal-tls-cert': 'temporalTlsCertPath',
+        'temporal-tls-cert-path': 'temporalTlsCertPath',
+        temporalTlsKeyPath: 'temporalTlsKeyPath',
+        'temporal-tls-key': 'temporalTlsKeyPath',
+        'temporal-tls-key-path': 'temporalTlsKeyPath',
+        defaultAgent: 'defaultAgent',
+        'default-agent': 'defaultAgent',
+        claudeBin: 'claudeBin',
+        'claude-bin': 'claudeBin',
+    };
+    const configKey = keyMap[key];
+    if (!configKey) {
+        out.error(`Unknown config key: "${key}"`);
+        out.log(`  Valid keys: ${Object.keys(keyMap).join(', ')}`);
+        process.exit(1);
+    }
+    // Validate agent type
+    if (configKey === 'defaultAgent' && value !== 'claude' && value !== 'copilot') {
+        out.error(`Invalid agent type: "${value}". Must be "claude" or "copilot".`);
+        process.exit(1);
+    }
+    config[configKey] = value;
+    (0, config_1.saveConfigFile)(config);
+    out.success(`Set ${configKey} = ${configKey.includes('Key') ? '****' : value}`);
+}
+/** Show current config: `agent-tempo config show` */
+function configShow() {
+    out.heading('agent-tempo config');
+    const { config, sources } = (0, config_1.getConfigWithSources)();
+    const keys = [
+        { key: 'temporalAddress', configKey: 'temporalAddress' },
+        { key: 'temporalNamespace', configKey: 'temporalNamespace' },
+        { key: 'temporalApiKey', configKey: 'temporalApiKey' },
+        { key: 'temporalTlsCertPath', configKey: 'temporalTlsCertPath' },
+        { key: 'temporalTlsKeyPath', configKey: 'temporalTlsKeyPath' },
+        { key: 'defaultAgent', configKey: 'defaultAgent' },
+        { key: 'claudeBin', configKey: 'claudeBin' },
+    ];
+    out.log(`  Config file: ${out.dim(config_1.CONFIG_FILE_PATH)}`);
+    console.log();
+    out.log(`  ${'Key'.padEnd(22)} ${'Value'.padEnd(30)} ${out.dim('Source')}`);
+    out.log(`  ${'─'.repeat(22)} ${'─'.repeat(30)} ${'─'.repeat(15)}`);
+    for (const { key, configKey } of keys) {
+        const value = config[configKey];
+        const source = sources[configKey];
+        const isSecret = SECRET_KEYS.has(key);
+        const display = !value ? '(not set)' : isSecret ? '****' : value;
+        out.log(`  ${key.padEnd(22)} ${display.padEnd(30)} ${out.dim(source)}`);
+    }
+    console.log();
+}
+/** Route `agent-tempo config [subcommand] [args...]` */
+async function configCommand(positional) {
+    const sub = positional[1]; // positional[0] is "config"
+    if (!sub) {
+        // Interactive setup
+        await configInteractive();
+    }
+    else if (sub === 'set') {
+        const key = positional[2];
+        const value = positional[3];
+        if (!key || !value) {
+            out.error('Usage: agent-tempo config set <key> <value>');
+            process.exit(1);
+        }
+        configSet(key, value);
+    }
+    else if (sub === 'show') {
+        configShow();
+    }
+    else {
+        out.error(`Unknown config subcommand: "${sub}"`);
+        out.log(`  Usage: ${out.dim('agent-tempo config')}             Interactive setup`);
+        out.log(`         ${out.dim('agent-tempo config show')}        Show current config`);
+        out.log(`         ${out.dim('agent-tempo config set <k> <v>')} Set a config value`);
+        process.exit(1);
+    }
+}

package/dist/cli/daemon-command.d.ts

@@ -0,0 +1,57 @@
+import { CliOverrides } from '../config';
+import { type DaemonProcessInfo, type DaemonStatus } from './daemon';
+/**
+ * Discriminated union describing the outcome of the `daemon start` pre-flight
+ * check. Exported for direct unit testing of the decision logic — the handler
+ * just maps these actions to console output + `process.exit` / spawn.
+ *
+ *   already-running — pid file is valid, no-op (not an error)
+ *   abort           — orphan daemons detected and `force` is false; caller
+ *                     should print the list + exit 1
+ *   spawn           — safe to proceed with `startDaemon`; caller should
+ *                     delete a stale pid file first when `cleanupStalePid`
+ *                     is true (only set on the `force` path)
+ *
+ * @internal
+ */
+export type StartPreflight = {
+    action: 'already-running';
+    pid: number;
+} | {
+    action: 'abort';
+    orphans: DaemonProcessInfo[];
+} | {
+    action: 'spawn';
+    cleanupStalePid: boolean;
+};
+/**
+ * Pure decision function for `daemon start`. Given a scanner result and the
+ * current daemon status, computes whether to no-op, abort with orphans, or
+ * spawn. `force` bypasses the orphan check and signals that a stale pid file
+ * (if any) should be cleared before the spawn.
+ *
+ * `otherProfilePid` is the live PID (if any) of the opposite profile's
+ * daemon (dev's prod sibling, or prod's dev sibling). Including it in the
+ * known-PID set keeps cross-profile coexistence working (ADR 0014 §5.6) —
+ * starting the dev daemon must not flag the prod daemon as an orphan, and
+ * vice versa.
+ *
+ * @internal — exported for unit tests in test/daemon-start-orphan-check.test.ts.
+ */
+export declare function evaluateStartPreflight(scanned: DaemonProcessInfo[], status: DaemonStatus, force: boolean, otherProfilePid?: number): StartPreflight;
+export interface DaemonOpts extends CliOverrides {
+    subcommand?: string;
+    /**
+     * Only meaningful for the `start` subcommand. Skips the orphan-process
+     * pre-flight check and spawns a daemon even if scanner-matched processes
+     * are found. Also cleans up a stale pid file if present. Use only when
+     * you've verified no conflicting agent-tempo daemons exist — or in CI
+     * scripts where idempotent-start is required (see `daemon status` first).
+     */
+    force?: boolean;
+}
+export declare function daemon(opts: DaemonOpts): Promise<void>;
+/** Pretty-print a byte count as MB (rounded). Pure helper, exported for tests. */
+export declare function formatBytesAsMb(n: unknown): string;
+/** Pretty-print a millisecond uptime as `Xh Ym Zs`. Pure helper, exported for tests. */
+export declare function formatUptime(ms: unknown): string;