@exaudeus/workrail 3.25.0 → 3.26.1

package/dist/cli/commands/index.d.ts

@@ -6,3 +6,8 @@ export { executeStartCommand, type StartCommandDeps, type RpcServer } from './st
 export { executeCleanupCommand, type CleanupCommandDeps, type CleanupCommandOptions } from './cleanup.js';
 export { executeVersionCommand, type VersionCommandDeps } from './version.js';
 export { executeMigrateCommand, migrateWorkflow, migrateWorkflowFile, detectWorkflowVersion, type MigrationResult, type FileMigrationResult, type MigrateCommandOptions, type MigrateFileDeps, type MigrateFileOptions, } from './migrate.js';
+export { executeWorktrainInitCommand, type WorktrainInitCommandDeps, type WorktrainInitCommandOpts, } from './worktrain-init.js';
+export { executeWorktrainTellCommand, type Priority, type QueuedMessage, type WorktrainTellCommandDeps, type WorktrainTellCommandOpts, } from './worktrain-tell.js';
+export { executeWorktrainInboxCommand, type OutboxMessage, type InboxCursor, type WorktrainInboxCommandDeps, type WorktrainInboxCommandOpts, } from './worktrain-inbox.js';
+export { executeWorktrainSpawnCommand, type WorktrainSpawnCommandDeps, type WorktrainSpawnCommandOpts, } from './worktrain-spawn.js';
+export { executeWorktrainAwaitCommand, parseDurationMs, type WorktrainAwaitCommandDeps, type WorktrainAwaitCommandOpts, type SessionOutcome, type SessionResult, type AwaitResult, } from './worktrain-await.js';

package/dist/cli/commands/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectWorkflowVersion = exports.migrateWorkflowFile = exports.migrateWorkflow = exports.executeMigrateCommand = exports.executeVersionCommand = exports.executeCleanupCommand = exports.executeStartCommand = exports.executeValidateCommand = exports.executeListCommand = exports.getWorkflowSources = exports.executeSourcesCommand = exports.executeInitConfigCommand = exports.executeInitCommand = void 0;
+exports.parseDurationMs = exports.executeWorktrainAwaitCommand = exports.executeWorktrainSpawnCommand = exports.executeWorktrainInboxCommand = exports.executeWorktrainTellCommand = exports.executeWorktrainInitCommand = exports.detectWorkflowVersion = exports.migrateWorkflowFile = exports.migrateWorkflow = exports.executeMigrateCommand = exports.executeVersionCommand = exports.executeCleanupCommand = exports.executeStartCommand = exports.executeValidateCommand = exports.executeListCommand = exports.getWorkflowSources = exports.executeSourcesCommand = exports.executeInitConfigCommand = exports.executeInitCommand = void 0;
 var init_js_1 = require("./init.js");
 Object.defineProperty(exports, "executeInitCommand", { enumerable: true, get: function () { return init_js_1.executeInitCommand; } });
 Object.defineProperty(exports, "executeInitConfigCommand", { enumerable: true, get: function () { return init_js_1.executeInitConfigCommand; } });
@@ -22,3 +22,14 @@ Object.defineProperty(exports, "executeMigrateCommand", { enumerable: true, get:
 Object.defineProperty(exports, "migrateWorkflow", { enumerable: true, get: function () { return migrate_js_1.migrateWorkflow; } });
 Object.defineProperty(exports, "migrateWorkflowFile", { enumerable: true, get: function () { return migrate_js_1.migrateWorkflowFile; } });
 Object.defineProperty(exports, "detectWorkflowVersion", { enumerable: true, get: function () { return migrate_js_1.detectWorkflowVersion; } });
+var worktrain_init_js_1 = require("./worktrain-init.js");
+Object.defineProperty(exports, "executeWorktrainInitCommand", { enumerable: true, get: function () { return worktrain_init_js_1.executeWorktrainInitCommand; } });
+var worktrain_tell_js_1 = require("./worktrain-tell.js");
+Object.defineProperty(exports, "executeWorktrainTellCommand", { enumerable: true, get: function () { return worktrain_tell_js_1.executeWorktrainTellCommand; } });
+var worktrain_inbox_js_1 = require("./worktrain-inbox.js");
+Object.defineProperty(exports, "executeWorktrainInboxCommand", { enumerable: true, get: function () { return worktrain_inbox_js_1.executeWorktrainInboxCommand; } });
+var worktrain_spawn_js_1 = require("./worktrain-spawn.js");
+Object.defineProperty(exports, "executeWorktrainSpawnCommand", { enumerable: true, get: function () { return worktrain_spawn_js_1.executeWorktrainSpawnCommand; } });
+var worktrain_await_js_1 = require("./worktrain-await.js");
+Object.defineProperty(exports, "executeWorktrainAwaitCommand", { enumerable: true, get: function () { return worktrain_await_js_1.executeWorktrainAwaitCommand; } });
+Object.defineProperty(exports, "parseDurationMs", { enumerable: true, get: function () { return worktrain_await_js_1.parseDurationMs; } });

package/dist/cli/commands/worktrain-await.d.ts

@@ -0,0 +1,35 @@
+import type { CliResult } from '../types/cli-result.js';
+export interface WorktrainAwaitCommandDeps {
+    readonly fetch: (url: string) => Promise<{
+        readonly ok: boolean;
+        readonly status: number;
+        readonly json: () => Promise<unknown>;
+    }>;
+    readonly readFile: (path: string) => Promise<string>;
+    readonly stdout: (line: string) => void;
+    readonly stderr: (line: string) => void;
+    readonly homedir: () => string;
+    readonly joinPath: (...paths: string[]) => string;
+    readonly sleep: (ms: number) => Promise<void>;
+    readonly now: () => number;
+}
+export interface WorktrainAwaitCommandOpts {
+    readonly sessions: string;
+    readonly mode?: 'all' | 'any';
+    readonly timeout?: string;
+    readonly port?: number;
+    readonly pollInterval?: number;
+}
+export type SessionOutcome = 'success' | 'failed' | 'timeout' | 'not_found' | 'not_awaited';
+export interface SessionResult {
+    readonly handle: string;
+    readonly outcome: SessionOutcome;
+    readonly status: string | null;
+    readonly durationMs: number;
+}
+export interface AwaitResult {
+    readonly results: readonly SessionResult[];
+    readonly allSucceeded: boolean;
+}
+export declare function parseDurationMs(raw: string): number | null;
+export declare function executeWorktrainAwaitCommand(deps: WorktrainAwaitCommandDeps, opts: WorktrainAwaitCommandOpts): Promise<CliResult>;

package/dist/cli/commands/worktrain-await.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDurationMs = parseDurationMs;
+exports.executeWorktrainAwaitCommand = executeWorktrainAwaitCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+const DEFAULT_CONSOLE_PORT = 3456;
+const LOCK_FILE_NAME = 'dashboard.lock';
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+const DEFAULT_POLL_INTERVAL_MS = 3000;
+function parseDurationMs(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    if (/^\d+$/.test(trimmed)) {
+        const n = parseInt(trimmed, 10);
+        return Number.isFinite(n) && n > 0 ? n * 1000 : null;
+    }
+    const match = /^(\d+)(s|m|h)$/i.exec(trimmed);
+    if (!match)
+        return null;
+    const n = parseInt(match[1] ?? '0', 10);
+    if (!Number.isFinite(n) || n <= 0)
+        return null;
+    const unit = (match[2] ?? '').toLowerCase();
+    if (unit === 's')
+        return n * 1000;
+    if (unit === 'm')
+        return n * 60 * 1000;
+    if (unit === 'h')
+        return n * 60 * 60 * 1000;
+    return null;
+}
+async function discoverConsolePort(deps, portOverride) {
+    if (portOverride !== undefined && portOverride > 0) {
+        return portOverride;
+    }
+    const lockPath = deps.joinPath(deps.homedir(), '.workrail', LOCK_FILE_NAME);
+    try {
+        const raw = await deps.readFile(lockPath);
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.port === 'number' && parsed.port > 0) {
+            return parsed.port;
+        }
+    }
+    catch {
+    }
+    return DEFAULT_CONSOLE_PORT;
+}
+const TERMINAL_STATUSES = new Set(['complete', 'complete_with_gaps', 'blocked', 'dormant']);
+const SUCCESS_STATUSES = new Set(['complete', 'complete_with_gaps']);
+function statusToOutcome(status) {
+    if (!TERMINAL_STATUSES.has(status))
+        return null;
+    if (SUCCESS_STATUSES.has(status))
+        return 'success';
+    if (status === 'blocked')
+        return 'failed';
+    return 'timeout';
+}
+async function pollSession(sessionHandle, port, deps) {
+    const url = `http://127.0.0.1:${port}/api/v2/sessions/${encodeURIComponent(sessionHandle)}`;
+    const response = await deps.fetch(url);
+    if (response.status === 404) {
+        return { outcome: 'not_found', status: null };
+    }
+    if (!response.ok) {
+        throw new Error(`Unexpected HTTP ${response.status} polling session ${sessionHandle}`);
+    }
+    const body = await response.json();
+    if (!body['success']) {
+        return { outcome: 'not_found', status: null };
+    }
+    const data = body['data'];
+    if (!data)
+        return null;
+    const runs = data['runs'];
+    if (Array.isArray(runs) && runs.length > 0) {
+        const firstRun = runs[0];
+        const runStatus = typeof firstRun['status'] === 'string' ? firstRun['status'] : null;
+        if (runStatus !== null) {
+            const outcome = statusToOutcome(runStatus);
+            if (outcome !== null) {
+                return { outcome, status: runStatus };
+            }
+            return null;
+        }
+    }
+    const summaryStatus = typeof data['status'] === 'string' ? data['status'] : null;
+    if (summaryStatus !== null) {
+        const outcome = statusToOutcome(summaryStatus);
+        if (outcome !== null) {
+            return { outcome, status: summaryStatus };
+        }
+    }
+    return null;
+}
+async function executeWorktrainAwaitCommand(deps, opts) {
+    const rawSessions = opts.sessions.trim();
+    if (!rawSessions) {
+        return (0, cli_result_js_1.misuse)('--sessions is required and must not be empty.');
+    }
+    const handles = rawSessions
+        .split(',')
+        .map((h) => h.trim())
+        .filter((h) => h.length > 0);
+    if (handles.length === 0) {
+        return (0, cli_result_js_1.misuse)('--sessions must contain at least one session handle.');
+    }
+    const mode = opts.mode ?? 'all';
+    if (mode !== 'all' && mode !== 'any') {
+        return (0, cli_result_js_1.misuse)(`--mode must be 'all' or 'any', got: ${mode}`);
+    }
+    let timeoutMs = DEFAULT_TIMEOUT_MS;
+    if (opts.timeout !== undefined) {
+        const parsed = parseDurationMs(opts.timeout);
+        if (parsed === null) {
+            return (0, cli_result_js_1.misuse)(`--timeout must be a duration like '30m', '1h', '90s', got: ${opts.timeout}`);
+        }
+        timeoutMs = parsed;
+    }
+    const pollInterval = opts.pollInterval ?? DEFAULT_POLL_INTERVAL_MS;
+    const port = await discoverConsolePort(deps, opts.port);
+    deps.stderr(`Awaiting ${handles.length} session(s) on port ${port} (mode: ${mode}, timeout: ${timeoutMs / 1000}s)...`);
+    const startMs = deps.now();
+    const pending = new Set(handles);
+    const results = new Map();
+    while (pending.size > 0) {
+        const elapsed = deps.now() - startMs;
+        if (elapsed >= timeoutMs) {
+            for (const handle of pending) {
+                results.set(handle, {
+                    handle,
+                    outcome: 'timeout',
+                    status: null,
+                    durationMs: deps.now() - startMs,
+                });
+            }
+            pending.clear();
+            deps.stderr(`Timeout reached after ${Math.round(elapsed / 1000)}s.`);
+            break;
+        }
+        for (const handle of [...pending]) {
+            let pollResult;
+            try {
+                pollResult = await pollSession(handle, port, deps);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                deps.stderr(`Warning: error polling session ${handle}: ${message}`);
+                results.set(handle, {
+                    handle,
+                    outcome: 'failed',
+                    status: null,
+                    durationMs: deps.now() - startMs,
+                });
+                pending.delete(handle);
+                continue;
+            }
+            if (pollResult !== null) {
+                results.set(handle, {
+                    handle,
+                    outcome: pollResult.outcome,
+                    status: pollResult.status,
+                    durationMs: deps.now() - startMs,
+                });
+                pending.delete(handle);
+                deps.stderr(`Session ${handle}: ${pollResult.outcome} (status: ${pollResult.status ?? 'n/a'})`);
+                if (mode === 'any' && pollResult.outcome === 'success') {
+                    for (const remaining of pending) {
+                        results.set(remaining, {
+                            handle: remaining,
+                            outcome: 'not_awaited',
+                            status: null,
+                            durationMs: deps.now() - startMs,
+                        });
+                    }
+                    pending.clear();
+                    break;
+                }
+            }
+        }
+        if (pending.size > 0) {
+            deps.stderr(`${pending.size} session(s) still running... (${Math.round((deps.now() - startMs) / 1000)}s elapsed)`);
+            await deps.sleep(pollInterval);
+        }
+    }
+    const resultArray = handles.map((handle) => {
+        return (results.get(handle) ?? {
+            handle,
+            outcome: 'not_found',
+            status: null,
+            durationMs: deps.now() - startMs,
+        });
+    });
+    const allSucceeded = mode === 'all'
+        ? resultArray.every((r) => r.outcome === 'success')
+        : resultArray.some((r) => r.outcome === 'success');
+    const awaitResult = {
+        results: resultArray,
+        allSucceeded,
+    };
+    deps.stdout(JSON.stringify(awaitResult, null, 2));
+    if (!allSucceeded) {
+        return (0, cli_result_js_1.failure)('One or more sessions did not succeed.', { exitCode: { kind: 'general_error' } });
+    }
+    return { kind: 'success' };
+}

package/dist/cli/commands/worktrain-inbox.d.ts

@@ -0,0 +1,23 @@
+import type { CliResult } from '../types/cli-result.js';
+export interface OutboxMessage {
+    readonly id: string;
+    readonly message: string;
+    readonly timestamp: string;
+}
+export interface InboxCursor {
+    readonly lastReadCount: number;
+}
+export interface WorktrainInboxCommandDeps {
+    readonly readFile: (path: string) => Promise<string>;
+    readonly writeFile: (path: string, content: string) => Promise<void>;
+    readonly mkdir: (path: string, options: {
+        recursive: boolean;
+    }) => Promise<string | undefined>;
+    readonly homedir: () => string;
+    readonly joinPath: (...paths: string[]) => string;
+    readonly print: (line: string) => void;
+}
+export interface WorktrainInboxCommandOpts {
+    readonly watch?: boolean;
+}
+export declare function executeWorktrainInboxCommand(deps: WorktrainInboxCommandDeps, opts?: WorktrainInboxCommandOpts): Promise<CliResult>;

package/dist/cli/commands/worktrain-inbox.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorktrainInboxCommand = executeWorktrainInboxCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+async function executeWorktrainInboxCommand(deps, opts = {}) {
+    if (opts.watch) {
+        deps.print('Watch mode is not yet implemented (requires the daemon coordinator loop).');
+        deps.print('Run `worktrain inbox` without --watch to read queued messages now.');
+        return (0, cli_result_js_1.success)({ message: 'Watch mode not yet implemented.' });
+    }
+    const workrailDir = deps.joinPath(deps.homedir(), '.workrail');
+    const outboxPath = deps.joinPath(workrailDir, 'outbox.jsonl');
+    const cursorPath = deps.joinPath(workrailDir, 'inbox-cursor.json');
+    let outboxContent;
+    try {
+        outboxContent = await deps.readFile(outboxPath);
+    }
+    catch (err) {
+        if (isEnoent(err)) {
+            deps.print('No messages.');
+            return (0, cli_result_js_1.success)({ message: 'No messages.' });
+        }
+        return (0, cli_result_js_1.failure)(`Failed to read outbox: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const allLines = outboxContent.split('\n').filter((line) => line.trim() !== '');
+    const parsed = [];
+    let malformedCount = 0;
+    for (const line of allLines) {
+        try {
+            const msg = JSON.parse(line);
+            parsed.push(msg);
+        }
+        catch {
+            malformedCount++;
+        }
+    }
+    const totalLines = parsed.length;
+    let lastReadCount = 0;
+    try {
+        const cursorContent = await deps.readFile(cursorPath);
+        const cursor = JSON.parse(cursorContent);
+        if (typeof cursor.lastReadCount === 'number' && cursor.lastReadCount >= 0) {
+            lastReadCount = cursor.lastReadCount;
+        }
+    }
+    catch {
+        lastReadCount = 0;
+    }
+    if (lastReadCount > totalLines) {
+        lastReadCount = 0;
+    }
+    const unread = parsed.slice(lastReadCount);
+    const newCount = unread.length;
+    if (malformedCount > 0) {
+        deps.print(`Warning: skipped ${malformedCount} malformed line(s) in outbox.jsonl.`);
+    }
+    if (newCount === 0) {
+        deps.print('No new messages.');
+    }
+    else {
+        for (const msg of unread) {
+            deps.print(`[${msg.timestamp}] ${msg.message}`);
+        }
+        deps.print('');
+        deps.print(`${newCount} new message(s).`);
+    }
+    const newCursor = { lastReadCount: totalLines };
+    try {
+        await deps.mkdir(workrailDir, { recursive: true });
+        await deps.writeFile(cursorPath, JSON.stringify(newCursor, null, 2) + '\n');
+    }
+    catch (err) {
+        deps.print(`Warning: could not update read cursor: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return (0, cli_result_js_1.success)({ message: `${newCount} new message(s).` });
+}
+function isEnoent(err) {
+    return (err !== null &&
+        typeof err === 'object' &&
+        'code' in err &&
+        err.code === 'ENOENT');
+}

package/dist/cli/commands/worktrain-init.d.ts

@@ -0,0 +1,23 @@
+import type { CliResult } from '../types/cli-result.js';
+export interface WorktrainInitCommandDeps {
+    readonly prompt: (question: string, defaultValue?: string) => Promise<string>;
+    readonly mkdir: (path: string, options: {
+        recursive: boolean;
+    }) => Promise<string | undefined>;
+    readonly readFile: (path: string) => Promise<string>;
+    readonly writeFile: (path: string, content: string) => Promise<void>;
+    readonly exists: (path: string) => Promise<boolean>;
+    readonly homedir: () => string;
+    readonly cwd: () => string;
+    readonly joinPath: (...paths: string[]) => string;
+    readonly runSmoke: () => Promise<{
+        readonly ok: boolean;
+        readonly output: string;
+    }>;
+    readonly print: (line: string) => void;
+    readonly env: Readonly<Record<string, string | undefined>>;
+}
+export interface WorktrainInitCommandOpts {
+    readonly yes?: boolean;
+}
+export declare function executeWorktrainInitCommand(deps: WorktrainInitCommandDeps, opts?: WorktrainInitCommandOpts): Promise<CliResult>;