@exaudeus/workrail 3.32.0 → 3.33.0

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

@@ -11,3 +11,4 @@ export { executeWorktrainTellCommand, type Priority, type QueuedMessage, type Wo
 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';
+export { executeWorktrainDaemonCommand, type WorktrainDaemonCommandDeps, type WorktrainDaemonCommandOpts, } from './worktrain-daemon.js';

package/dist/cli/commands/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.executeWorktrainDaemonCommand = 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; } });
@@ -33,3 +33,5 @@ Object.defineProperty(exports, "executeWorktrainSpawnCommand", { enumerable: tru
 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; } });
+var worktrain_daemon_js_1 = require("./worktrain-daemon.js");
+Object.defineProperty(exports, "executeWorktrainDaemonCommand", { enumerable: true, get: function () { return worktrain_daemon_js_1.executeWorktrainDaemonCommand; } });

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

@@ -4,7 +4,7 @@ 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 LOCK_FILE_NAMES = ['daemon-console.lock', 'dashboard.lock'];
 const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
 const DEFAULT_POLL_INTERVAL_MS = 3000;
 function parseDurationMs(raw) {
@@ -34,15 +34,17 @@ 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;
+    for (const lockFileName of LOCK_FILE_NAMES) {
+        const lockPath = deps.joinPath(deps.homedir(), '.workrail', lockFileName);
+        try {
+            const raw = await deps.readFile(lockPath);
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.port === 'number' && parsed.port > 0) {
+                return parsed.port;
+            }
+        }
+        catch {
         }
-    }
-    catch {
     }
     return DEFAULT_CONSOLE_PORT;
 }

package/dist/cli/commands/worktrain-daemon-install.d.ts

@@ -0,0 +1,35 @@
+import type { CliResult } from '../types/cli-result.js';
+export interface WorktrainDaemonInstallCommandDeps {
+    readonly mkdir: (path: string, opts: {
+        recursive: boolean;
+    }) => Promise<void>;
+    readonly writeFile: (path: string, content: string) => Promise<void>;
+    readonly readFile: (path: string) => Promise<string>;
+    readonly unlink: (path: string) => Promise<void>;
+    readonly exists: (path: string) => Promise<boolean>;
+    readonly homedir: () => string;
+    readonly joinPath: (...paths: string[]) => string;
+    readonly resolveCliScript: () => string;
+    readonly nodeExecPath: () => string;
+    readonly execLaunchctl: (args: readonly string[]) => Promise<{
+        readonly ok: boolean;
+        readonly stderr: string;
+    }>;
+    readonly platform: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly print: (line: string) => void;
+}
+export interface WorktrainDaemonInstallCommandOpts {
+    readonly workspace?: string;
+}
+export interface WorktrainDaemonUninstallCommandOpts {
+}
+export declare function buildPlistContent(opts: {
+    readonly nodeExecPath: string;
+    readonly cliScriptPath: string;
+    readonly workspacePath: string;
+    readonly homeDir: string;
+    readonly envVars: Readonly<Record<string, string>>;
+}): string;
+export declare function executeWorktrainDaemonInstallCommand(deps: WorktrainDaemonInstallCommandDeps, opts?: WorktrainDaemonInstallCommandOpts): Promise<CliResult>;
+export declare function executeWorktrainDaemonUninstallCommand(deps: WorktrainDaemonInstallCommandDeps, _opts?: WorktrainDaemonUninstallCommandOpts): Promise<CliResult>;

package/dist/cli/commands/worktrain-daemon-install.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlistContent = buildPlistContent;
+exports.executeWorktrainDaemonInstallCommand = executeWorktrainDaemonInstallCommand;
+exports.executeWorktrainDaemonUninstallCommand = executeWorktrainDaemonUninstallCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+const SERVICE_LABEL = 'io.worktrain.daemon';
+const PLIST_FILENAME = `${SERVICE_LABEL}.plist`;
+const ENV_VARS_TO_BAKE = [
+    'AWS_PROFILE',
+    'AWS_ACCESS_KEY_ID',
+    'ANTHROPIC_API_KEY',
+    'WORKRAIL_TRIGGERS_ENABLED',
+];
+function buildPlistContent(opts) {
+    const { nodeExecPath, cliScriptPath, workspacePath, homeDir, envVars } = opts;
+    const logDir = `${homeDir}/.workrail/logs`;
+    const envEntries = Object.entries(envVars)
+        .map(([k, v]) => `    <key>${k}</key><string>${v}</string>`)
+        .join('\n');
+    const envSection = Object.keys(envVars).length > 0
+        ? `  <key>EnvironmentVariables</key>\n  <dict>\n${envEntries}\n  </dict>\n`
+        : '';
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+
+  <!--
+    ProgramArguments: absolute paths only. launchd does not expand ~ or use PATH.
+    WHY node + script (not shebang): launchd's minimal launch environment may not
+    include the user's PATH, so #!/usr/bin/env node resolution can fail.
+    Using the absolute node binary from process.execPath at install time is deterministic.
+    If you upgrade Node via nvm after installing, re-run: worktrain daemon --install
+  -->
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodeExecPath}</string>
+    <string>${cliScriptPath}</string>
+    <string>daemon</string>
+    <string>--workspace</string>
+    <string>${workspacePath}</string>
+  </array>
+
+  <key>WorkingDirectory</key>
+  <string>${workspacePath}</string>
+
+  <!-- Start the service automatically at login. -->
+  <key>RunAtLoad</key>
+  <true/>
+
+  <!--
+    KeepAlive=true: launchd restarts the daemon if it exits for any reason.
+    This is the root fix: the daemon survives MCP server reconnects because it
+    is owned by launchd, not by any IDE process tree.
+  -->
+  <key>KeepAlive</key>
+  <true/>
+
+  <!--
+    ThrottleInterval: minimum seconds between restarts.
+    WHY 30s: prevents launchd from spinning in a tight restart loop if the daemon
+    exits immediately (e.g., missing credentials or bad workspace path).
+  -->
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+
+  <key>StandardOutPath</key>
+  <string>${logDir}/daemon.stdout.log</string>
+
+  <key>StandardErrorPath</key>
+  <string>${logDir}/daemon.stderr.log</string>
+
+${envSection}</dict>
+</plist>
+`;
+}
+async function resolveWorkspace(deps, opts) {
+    if (opts.workspace) {
+        return { workspacePath: opts.workspace };
+    }
+    const configPath = deps.joinPath(deps.homedir(), '.workrail', 'config.json');
+    try {
+        const raw = await deps.readFile(configPath);
+        const config = JSON.parse(raw);
+        const configured = config['WORKRAIL_DEFAULT_WORKSPACE'];
+        if (typeof configured === 'string' && configured.trim() !== '') {
+            return { workspacePath: configured.trim() };
+        }
+    }
+    catch {
+    }
+    return {
+        error: 'No workspace configured. Provide --workspace <path> or run `worktrain init` first.',
+    };
+}
+function collectEnvVars(env) {
+    const result = {};
+    for (const key of ENV_VARS_TO_BAKE) {
+        const value = env[key];
+        if (typeof value === 'string' && value.trim() !== '') {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+async function runInstallSection(deps, workspacePath) {
+    const homeDir = deps.homedir();
+    const plistDir = deps.joinPath(homeDir, 'Library', 'LaunchAgents');
+    const plistPath = deps.joinPath(plistDir, PLIST_FILENAME);
+    const logDir = deps.joinPath(homeDir, '.workrail', 'logs');
+    const envVars = collectEnvVars(deps.env);
+    const hasCredentials = !!envVars['AWS_PROFILE'] ||
+        !!envVars['AWS_ACCESS_KEY_ID'] ||
+        !!envVars['ANTHROPIC_API_KEY'];
+    try {
+        await deps.mkdir(logDir, { recursive: true });
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            message: `Failed to create log directory ${logDir}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    try {
+        await deps.mkdir(plistDir, { recursive: true });
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            message: `Failed to create LaunchAgents directory: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const nodeExecPath = deps.nodeExecPath();
+    const cliScriptPath = deps.resolveCliScript();
+    const plistContent = buildPlistContent({
+        nodeExecPath,
+        cliScriptPath,
+        workspacePath,
+        homeDir,
+        envVars,
+    });
+    await deps.execLaunchctl(['unload', '-w', plistPath]);
+    try {
+        await deps.writeFile(plistPath, plistContent);
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            message: `Failed to write plist to ${plistPath}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const loadResult = await deps.execLaunchctl(['load', '-w', plistPath]);
+    if (!loadResult.ok) {
+        return {
+            kind: 'error',
+            message: `launchctl load failed: ${loadResult.stderr.trim() || '(no stderr output)'}. ` +
+                `Plist written to ${plistPath} but service was not started.`,
+        };
+    }
+    if (!hasCredentials) {
+        return {
+            kind: 'warning',
+            summary: `Service installed at ${plistPath} and loaded.`,
+            warning: 'No LLM credentials found in current environment. The service will fail to start ' +
+                'until you set AWS_PROFILE (Bedrock) or ANTHROPIC_API_KEY (Anthropic) and re-run: ' +
+                'worktrain daemon --install',
+        };
+    }
+    return {
+        kind: 'configured',
+        summary: `Service installed at ${plistPath} and loaded. Node: ${nodeExecPath}. Script: ${cliScriptPath}.`,
+    };
+}
+async function runUninstallSection(deps) {
+    const plistPath = deps.joinPath(deps.homedir(), 'Library', 'LaunchAgents', PLIST_FILENAME);
+    const plistExists = await deps.exists(plistPath);
+    if (!plistExists) {
+        return { kind: 'skipped', reason: `No plist found at ${plistPath} (service was not installed)` };
+    }
+    await deps.execLaunchctl(['unload', '-w', plistPath]);
+    try {
+        await deps.unlink(plistPath);
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            message: `Failed to delete plist at ${plistPath}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    return {
+        kind: 'configured',
+        summary: `Service unloaded and plist removed: ${plistPath}`,
+    };
+}
+async function executeWorktrainDaemonInstallCommand(deps, opts = {}) {
+    if (deps.platform !== 'darwin') {
+        return (0, cli_result_js_1.failure)(`worktrain daemon --install is macOS only (detected platform: ${deps.platform}). ` +
+            'Linux/systemd support is not yet implemented.', { suggestions: ['On Linux, start the daemon manually: workrail daemon --workspace <path>'] });
+    }
+    deps.print('');
+    deps.print('WorkTrain Daemon Install');
+    deps.print('════════════════════════════════════════');
+    deps.print('');
+    const workspaceResult = await resolveWorkspace(deps, opts);
+    if ('error' in workspaceResult) {
+        return (0, cli_result_js_1.failure)(workspaceResult.error, {
+            suggestions: ['Run `worktrain init` to configure a default workspace, or pass --workspace <path>'],
+        });
+    }
+    const { workspacePath } = workspaceResult;
+    deps.print(`[ 1/1 ] Install launchd service`);
+    deps.print(`  Workspace: ${workspacePath}`);
+    const installResult = await runInstallSection(deps, workspacePath);
+    printSectionResult(deps, installResult);
+    if (installResult.kind === 'error') {
+        return (0, cli_result_js_1.failure)(installResult.message, {
+            suggestions: [
+                'Check that ~/Library/LaunchAgents/ is writable.',
+                'Check that launchctl is available (macOS only).',
+            ],
+        });
+    }
+    deps.print('');
+    deps.print('Service is running. To verify:');
+    deps.print(`  launchctl list ${SERVICE_LABEL}`);
+    deps.print('');
+    deps.print('Logs:');
+    deps.print(`  tail -f ~/.workrail/logs/daemon.stdout.log`);
+    deps.print(`  tail -f ~/.workrail/logs/daemon.stderr.log`);
+    deps.print('');
+    deps.print('Credential note:');
+    deps.print('  LLM credentials (AWS_PROFILE or ANTHROPIC_API_KEY) are baked into the');
+    deps.print('  plist at install time. Re-run --install after changing credentials.');
+    deps.print('  AWS SSO: the profile name is baked in, not STS tokens -- the SDK');
+    deps.print('  auto-refreshes tokens at runtime. Run `aws sso login` when the session expires.');
+    deps.print('');
+    deps.print('To uninstall: worktrain daemon --uninstall');
+    const detailLine = installResult.kind === 'warning'
+        ? `warning: ${installResult.summary} -- ${installResult.warning}`
+        : installResult.kind === 'configured'
+            ? `configured: ${installResult.summary}`
+            : `done`;
+    return (0, cli_result_js_1.success)({
+        message: 'WorkTrain daemon installed as a launchd service',
+        details: [detailLine],
+    });
+}
+async function executeWorktrainDaemonUninstallCommand(deps, _opts = {}) {
+    if (deps.platform !== 'darwin') {
+        return (0, cli_result_js_1.failure)(`worktrain daemon --uninstall is macOS only (detected platform: ${deps.platform}).`);
+    }
+    deps.print('');
+    deps.print('WorkTrain Daemon Uninstall');
+    deps.print('════════════════════════════════════════');
+    deps.print('');
+    deps.print('[ 1/1 ] Remove launchd service');
+    const uninstallResult = await runUninstallSection(deps);
+    printSectionResult(deps, uninstallResult);
+    if (uninstallResult.kind === 'error') {
+        return (0, cli_result_js_1.failure)(uninstallResult.message);
+    }
+    deps.print('');
+    deps.print('To reinstall: worktrain daemon --install');
+    return (0, cli_result_js_1.success)({
+        message: uninstallResult.kind === 'skipped'
+            ? 'WorkTrain daemon service was not installed (nothing to remove)'
+            : 'WorkTrain daemon uninstalled',
+    });
+}
+function printSectionResult(deps, result) {
+    switch (result.kind) {
+        case 'skipped':
+            deps.print(`  Skipped: ${result.reason}`);
+            break;
+        case 'configured':
+            deps.print(`  Done: ${result.summary}`);
+            break;
+        case 'warning':
+            deps.print(`  Done: ${result.summary}`);
+            deps.print(`  Warning: ${result.warning}`);
+            break;
+        case 'error':
+            deps.print(`  Error: ${result.message}`);
+            break;
+    }
+    deps.print('');
+}

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

@@ -0,0 +1,31 @@
+import type { CliResult } from '../types/cli-result.js';
+export interface WorktrainDaemonCommandDeps {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly platform: string;
+    readonly worktrainBinPath: string;
+    readonly nodeBinPath: string;
+    readonly homedir: () => string;
+    readonly joinPath: (...paths: string[]) => string;
+    readonly mkdir: (path: string, opts: {
+        recursive: boolean;
+    }) => Promise<unknown>;
+    readonly writeFile: (path: string, content: string) => Promise<void>;
+    readonly chmod: (path: string, mode: number) => Promise<void>;
+    readonly readFile: (path: string) => Promise<string>;
+    readonly removeFile: (path: string) => Promise<void>;
+    readonly exists: (path: string) => Promise<boolean>;
+    readonly exec: (command: string, args: string[]) => Promise<{
+        readonly stdout: string;
+        readonly stderr: string;
+        readonly exitCode: number;
+    }>;
+    readonly print: (line: string) => void;
+    readonly sleep: (ms: number) => Promise<void>;
+    readonly startDaemon?: () => Promise<void>;
+}
+export interface WorktrainDaemonCommandOpts {
+    readonly install?: boolean;
+    readonly uninstall?: boolean;
+    readonly status?: boolean;
+}
+export declare function executeWorktrainDaemonCommand(deps: WorktrainDaemonCommandDeps, opts: WorktrainDaemonCommandOpts): Promise<CliResult>;