agent-tempo 1.0.1

package/dist/channel.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMessagePoller = startMessagePoller;
+const log = (...args) => console.error('[claude-tempo:poller]', ...args);
+const POLL_BASE_MS = 2000;
+const POLL_BACKOFF_FACTOR = 1.5;
+const POLL_MAX_MS = 30000;
+function startMessagePoller(handle, onMessages) {
+    let stopped = false;
+    let timeout = null;
+    let currentInterval = POLL_BASE_MS;
+    let consecutiveErrors = 0;
+    const poll = async () => {
+        if (stopped)
+            return;
+        try {
+            const messages = await handle.query('pendingMessages');
+            if (messages.length > 0) {
+                const ids = messages.map((m) => m.id);
+                // Deliver messages first — only mark delivered after successful notification.
+                // If onMessages throws, messages stay undelivered and retry on next poll cycle.
+                await onMessages(messages);
+                await handle.signal('markDelivered', ids);
+            }
+            // Reset backoff on successful poll
+            currentInterval = POLL_BASE_MS;
+            consecutiveErrors = 0;
+        }
+        catch (err) {
+            consecutiveErrors++;
+            // Apply exponential backoff on errors
+            currentInterval = Math.min(currentInterval * POLL_BACKOFF_FACTOR, POLL_MAX_MS);
+            log(`Poll error (attempt ${consecutiveErrors}, next in ${Math.round(currentInterval)}ms):`, err);
+        }
+        if (!stopped) {
+            timeout = setTimeout(poll, currentInterval);
+        }
+    };
+    // Start the first poll
+    timeout = setTimeout(poll, POLL_BASE_MS);
+    return () => {
+        stopped = true;
+        if (timeout) {
+            clearTimeout(timeout);
+            timeout = null;
+        }
+    };
+}

package/dist/cli/commands.d.ts

@@ -0,0 +1,245 @@
+import { Client, Connection } from '@temporalio/client';
+import { Config, CliOverrides } from '../config';
+import { AgentType, ScheduleEntry } from '../types';
+interface StatusOpts extends CliOverrides {
+    ensemble?: string;
+}
+export declare function status(opts: StatusOpts): Promise<void>;
+interface InitOpts {
+    dir: string;
+    project?: boolean;
+}
+export declare function init(opts: InitOpts): Promise<void>;
+interface ServerOpts extends CliOverrides {
+    background: boolean;
+}
+export declare function server(opts: ServerOpts): Promise<void>;
+interface UpOpts extends CliOverrides {
+    ensemble: string;
+    name?: string;
+    lineup?: string;
+    agent: AgentType;
+    /**
+     * Issue #172: when true, skip the "defer conductor instructions + hold
+     * players until user's first message" behavior and use the legacy
+     * immediate-start semantics. Ignored when `--lineup` is not set.
+     */
+    noHold?: boolean;
+    /**
+     * `--scenario <name>` (PR-3 of #340-followup, ADR 0014 §5.5). Forces
+     * every `agent: "mock"` player in the lineup into `mockMode: "scripted"`
+     * with this scenario. Bare name (resolved against shipped `scenarios/`)
+     * or absolute path. Ignored when no `--lineup` is given.
+     *
+     * Dev-mode-only — silently no-ops outside dev mode because mock players
+     * can't exist there anyway (gate 3 in recruit pre-flight).
+     */
+    scenario?: string;
+}
+export declare function up(opts: UpOpts): Promise<void>;
+/**
+ * Format a `ScheduleEntry` recurrence for the `status` display.
+ *
+ * #586 — cron entries previously rendered as `'one-shot'` because the inline
+ * formatter only checked `sched.interval`. The display formatter now mirrors
+ * the wire-type triplet (`'once' | 'interval' | 'cron'`) from
+ * `ScheduleEntry.type` so cron schedules from the lineup loader (and the
+ * MCP `load_lineup` path) read correctly in `agent-tempo status`.
+ *
+ * Exported for unit tests.
+ */
+export declare function formatScheduleRecurrence(sched: ScheduleEntry): string;
+/**
+ * Convert a lineup schedule definition to a ScheduleEntry for the scheduler
+ * workflow.
+ *
+ * #586 — cron entries now produce `type: 'cron'` with `cronExpression` +
+ * `timezone` populated; previously they fell through to the default
+ * `nextFireAt = now + 60_000` with `type: 'once'`, firing once and getting
+ * garbage-collected. The cron branch mirrors the MCP-side `load_lineup` tool
+ * at `src/tools/load-lineup.ts:280-300` so both load paths agree on the wire
+ * shape submitted to the scheduler workflow.
+ *
+ * Exported for unit tests; consumed internally by `up` /
+ * `ensembleCommand` after a lineup is parsed.
+ */
+export declare function lineupScheduleToEntry(sched: NonNullable<import('../ensemble/schema').EnsembleLineup['schedules']>[number], 
+/** Injectable clock for deterministic tests. Defaults to `Date.now()`. */
+now?: number): ScheduleEntry;
+interface DownOpts extends CliOverrides {
+    removeMcp: boolean;
+    keepDaemon: boolean;
+    yes: boolean;
+    /** When true, terminate every workflow across every ensemble before
+     *  stopping infra. Without it, workflows stay on the Temporal server and
+     *  resume on the next `up`. */
+    destroy: boolean;
+    /**
+     * `--kill-shared-temporal` (#423): bypass the cross-profile coexistence
+     * guard and kill the shared Temporal dev server unconditionally. Without
+     * it, `down` skips the Temporal kill when the OPPOSITE profile shows any
+     * sign of life (PID file, port file) — see ADR 0014 §5.6 for the same
+     * guard `stopDaemon`'s zombie reaper applies. The flag is the explicit
+     * opt-in for the hard-reset case.
+     */
+    killSharedTemporal: boolean;
+    dir: string;
+}
+/**
+ * Options for {@link stopTemporalServer} — exported for unit tests so we
+ * can inject stubs without spawning real processes or touching the
+ * developer's home dir. Production callers should pass only
+ * `killSharedTemporal` and accept the defaults.
+ *
+ * @internal
+ */
+export interface StopTemporalServerOpts {
+    /** When true, bypass the cross-profile coexistence guard. Maps to the
+     *  `--kill-shared-temporal` CLI flag (#423). */
+    killSharedTemporal: boolean;
+    /** Cross-profile coexistence probe — defaults to {@link isOtherProfileLikelyRunning}. */
+    isOtherProfileLikelyRunning?: () => boolean;
+    /** Process exec hook — defaults to `execFileSync` with stdio ignored. */
+    exec?: (command: string, args: string[]) => void;
+    /** Platform override — defaults to `process.platform`. */
+    platform?: NodeJS.Platform;
+}
+/** Outcome of {@link stopTemporalServer}, surfaced so callers (and tests)
+ *  can shape user-facing messages. */
+export type StopTemporalResult = {
+    action: 'killed';
+} | {
+    action: 'failed';
+    error: unknown;
+} | {
+    action: 'skipped-cross-profile';
+};
+/**
+ * Stop the shared Temporal dev server, with the same cross-profile guard
+ * that `stopDaemon`'s zombie reaper already applies (ADR 0014 §5.6).
+ *
+ * The Temporal dev server is a single OS-wide process — `pkill -f` on
+ * POSIX and `taskkill /IM temporal.exe` on Windows kill it by name and
+ * cannot distinguish dev-profile vs prod-profile ownership. So when
+ * `agent-tempo --dev down` runs while the prod profile is also active,
+ * the unconditional kill takes down the prod profile's Temporal as
+ * collateral damage. This is exactly the bug `isOtherProfileLikelyRunning`
+ * was introduced to prevent on the daemon side; the missing piece was
+ * `down`'s own Temporal kill (#423).
+ *
+ * `--kill-shared-temporal` (passed as `killSharedTemporal: true`) is the
+ * explicit opt-in for the hard-reset case where the user accepts cross-
+ * profile collateral damage.
+ */
+export declare function stopTemporalServer(opts: StopTemporalServerOpts): StopTemporalResult;
+export declare function down(opts: DownOpts): Promise<void>;
+interface AgentTypesCommandOpts {
+    subcommand?: string;
+    name?: string;
+}
+export declare function agentTypesCommand(opts: AgentTypesCommandOpts): Promise<void>;
+interface BroadcastOpts extends CliOverrides {
+    ensemble?: string;
+    message: string;
+    type?: string;
+    includeStale?: boolean;
+}
+export declare function broadcast(opts: BroadcastOpts): Promise<void>;
+interface VerbOpts extends CliOverrides {
+    name: string;
+    ensemble?: string;
+}
+interface DestroyCliOpts extends CliOverrides {
+    ensemble: string;
+    yes: boolean;
+}
+/**
+ * Shared connection + client helper for verb commands. Exported so the
+ * dev-mode verb dispatcher (`./dev-verbs.ts`) can use the same connection
+ * idiom — single source of truth for the 3-second timeout + error-exit
+ * behavior across all CLI verbs.
+ */
+export declare function verbClient(opts: CliOverrides): Promise<{
+    config: Config;
+    connection: Connection;
+    client: Client;
+}>;
+/**
+ * `agent-tempo destroy <ensemble> [-y]` — terminate every workflow in an
+ * ensemble (#288). Prompts with the ensemble name and workflow count unless
+ * `-y` is passed. The per-player destroy path lives in the TUI (`/destroy
+ * --player`).
+ */
+export declare function destroy(opts: DestroyCliOpts): Promise<void>;
+export declare function attachmentInfo(opts: VerbOpts): Promise<void>;
+export interface HostsCliOpts extends CliOverrides {
+    ensemble?: string;
+    /** Include stale hosts (those not seen in the last minute). CLI default: false. */
+    all?: boolean;
+    /** Emit raw `HostInfo[]` JSON instead of the formatted table. */
+    json?: boolean;
+}
+export declare function hosts(opts: HostsCliOpts): Promise<void>;
+export interface RefreshHostProfileCliOpts extends CliOverrides {
+    ensemble?: string;
+    /** Max wait for the new profile to appear in the maestro `hostProfiles` map. Default 10s. */
+    confirmTimeoutMs?: number;
+}
+/**
+ * #274 AC5d (M12) — manual re-signal of this host's profile to the
+ * global maestro. The daemon otherwise only re-signals on boot; this
+ * subcommand re-computes the profile + signals fresh.
+ *
+ * Exit semantics (per my implementation-time call to the conductor,
+ * approved): await ensureGlobalMaestro → signal → short poll on
+ * `hostProfiles()` to confirm the new version is visible → exit 0.
+ * Exits nonzero if the poll timeout elapses without confirmation.
+ */
+export declare function refreshHostProfile(opts: RefreshHostProfileCliOpts): Promise<void>;
+export interface RecallCliOpts extends VerbOpts {
+    limit?: number;
+    offset?: number;
+    previewLength?: number;
+    since?: string;
+    from?: string;
+    includeSent?: boolean;
+    /** Emit raw JSON `{ received, sent, total, shown, hasMore, text }` instead of the formatted timeline. */
+    json?: boolean;
+}
+export declare function recall(opts: RecallCliOpts): Promise<void>;
+interface RestoreCliOpts extends CliOverrides {
+    /** Required for the default local-restore flow; ignored when `allHosts` is set. */
+    ensemble?: string;
+    /**
+     * #151: cluster-view listing mode. Lists cross-host orphans the local
+     * daemon's `agent-tempo restore <ensemble>` would otherwise skip
+     * silently. Read-only: never enqueues a `restart`. Recovery still
+     * happens through the remote daemon's `reconcileOnBoot` when it
+     * returns, or a deliberate TUI `/migrate <player> <host> --force`.
+     */
+    allHosts?: boolean;
+}
+/**
+ * `agent-tempo restore <ensemble>` — delegate to {@link TempoClient.restore},
+ * which reattaches orphans AND unpauses maestro + scheduler (#298 — the
+ * direct-to-`restoreOrphansOnce` path left the ensemble paused after a
+ * `shutdown → restore` roundtrip). The TUI home view (#290) is the picker
+ * surface; the CLI is the scriptable bulk operation, one ensemble at a time.
+ *
+ * `--all-hosts` (#151): switches to cluster-view readonly listing — the
+ * positional `<ensemble>` becomes optional (when set, narrows the listing;
+ * when omitted, lists across every ensemble). Never enqueues a restart.
+ * See `formatCrossHostOrphans` for the output shape.
+ */
+export declare function restore(opts: RestoreCliOpts): Promise<void>;
+interface EnsembleCommandOpts extends CliOverrides {
+    subcommand?: string;
+    name?: string;
+}
+export declare function ensembleCommand(opts: EnsembleCommandOpts): Promise<void>;
+interface ReleaseOpts extends CliOverrides {
+    ensemble: string;
+}
+/** Release all held sessions in an ensemble (unlock outbox, deliver initial messages). */
+export declare function release(opts: ReleaseOpts): Promise<void>;
+export {};