@exaudeus/workrail 3.24.4 → 3.26.0

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

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorktrainInitCommand = executeWorktrainInitCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+const soul_template_js_1 = require("../../daemon/soul-template.js");
+function buildTriggersYml(workspacePath) {
+    return `# WorkRail trigger configuration
+# Generated by worktrain init
+#
+# This file is read by the WorkRail daemon (workrail daemon --workspace <path>).
+# Add or edit triggers to control which workflows run and when.
+#
+# Polling triggers (github, gitlab) are coming in a future release.
+# See: https://github.com/exaudeus/workrail/blob/main/docs/triggers.md
+
+triggers:
+  - id: my-first-trigger
+    provider: generic
+    workflowId: coding-task-workflow-agentic
+    workspacePath: ${workspacePath}
+    goal: "Handle incoming coding task"
+    # hmacSecret: $WEBHOOK_SECRET   # uncomment and set env var to enable HMAC validation
+    #
+    # To fire this trigger manually:
+    #   curl -X POST http://localhost:3200/webhook/my-first-trigger \\
+    #        -H "Content-Type: application/json" \\
+    #        -d '{"task": "describe the task here"}'
+`;
+}
+async function runCredentialsSection(deps, opts) {
+    const hasBedrock = !!deps.env['AWS_PROFILE'] || !!deps.env['AWS_ACCESS_KEY_ID'];
+    const hasAnthropic = !!deps.env['ANTHROPIC_API_KEY'];
+    if (hasBedrock) {
+        return {
+            kind: 'skipped',
+            reason: `Bedrock credentials detected (AWS_PROFILE=${deps.env['AWS_PROFILE'] ?? 'set'})`,
+        };
+    }
+    if (hasAnthropic) {
+        return {
+            kind: 'skipped',
+            reason: 'Anthropic API key detected (ANTHROPIC_API_KEY is set)',
+        };
+    }
+    deps.print('');
+    deps.print('LLM credentials not found.');
+    let choice;
+    if (opts.yes) {
+        choice = 'anthropic';
+        deps.print('  Using default: Anthropic API key (--yes mode)');
+    }
+    else {
+        deps.print('  Which LLM provider do you want to use?');
+        deps.print('    1) AWS Bedrock (requires AWS SSO profile)');
+        deps.print('    2) Anthropic API key (direct access)');
+        choice = await deps.prompt('  Enter 1 or 2 [2]: ', '2');
+    }
+    if (choice === '1') {
+        deps.print('');
+        deps.print('  To use AWS Bedrock, set your AWS SSO profile:');
+        deps.print('    export AWS_PROFILE=your-sso-profile-name');
+        deps.print('  Then run: aws sso login --profile your-sso-profile-name');
+        return {
+            kind: 'configured',
+            summary: 'Printed Bedrock setup instructions (set AWS_PROFILE in your shell profile)',
+        };
+    }
+    else {
+        deps.print('');
+        deps.print('  To use the Anthropic API, set your API key:');
+        deps.print('    export ANTHROPIC_API_KEY=sk-ant-...');
+        deps.print('  Add this line to ~/.zshrc or ~/.bashrc to persist across sessions.');
+        return {
+            kind: 'configured',
+            summary: 'Printed Anthropic API key instructions (set ANTHROPIC_API_KEY in your shell profile)',
+        };
+    }
+}
+async function runWorkspaceSection(deps, opts) {
+    const configDir = deps.joinPath(deps.homedir(), '.workrail');
+    const configPath = deps.joinPath(configDir, 'config.json');
+    let existingConfig = {};
+    try {
+        const raw = await deps.readFile(configPath);
+        existingConfig = JSON.parse(raw);
+    }
+    catch {
+    }
+    if (typeof existingConfig['WORKRAIL_DEFAULT_WORKSPACE'] === 'string' &&
+        existingConfig['WORKRAIL_DEFAULT_WORKSPACE'].trim() !== '') {
+        const existing = existingConfig['WORKRAIL_DEFAULT_WORKSPACE'];
+        if (opts.yes) {
+            return {
+                result: {
+                    kind: 'skipped',
+                    reason: `Workspace already set to: ${existing}`,
+                },
+                workspacePath: existing,
+            };
+        }
+        deps.print('');
+        deps.print(`  Current workspace: ${existing}`);
+    }
+    let workspacePath;
+    if (opts.yes) {
+        workspacePath = deps.cwd();
+        deps.print(`  Using default workspace: ${workspacePath} (--yes mode)`);
+    }
+    else {
+        deps.print('');
+        deps.print('  Enter the default workspace path for the daemon.');
+        deps.print('  This is the root directory of the repository the agent will work in.');
+        const defaultPath = typeof existingConfig['WORKRAIL_DEFAULT_WORKSPACE'] === 'string'
+            ? existingConfig['WORKRAIL_DEFAULT_WORKSPACE']
+            : deps.homedir();
+        workspacePath = await deps.prompt(`  Workspace path [${defaultPath}]: `, defaultPath);
+        if (!workspacePath.trim()) {
+            workspacePath = defaultPath;
+        }
+    }
+    const pathExists = await deps.exists(workspacePath);
+    let warning;
+    if (!pathExists) {
+        warning = `Directory not found: ${workspacePath}. Create it before starting the daemon.`;
+    }
+    const updatedConfig = {
+        ...existingConfig,
+        WORKRAIL_DEFAULT_WORKSPACE: workspacePath,
+    };
+    try {
+        await deps.mkdir(configDir, { recursive: true });
+        await deps.writeFile(configPath, JSON.stringify(updatedConfig, null, 2) + '\n');
+    }
+    catch (err) {
+        return {
+            result: {
+                kind: 'error',
+                message: `Failed to write config.json: ${err instanceof Error ? err.message : String(err)}`,
+            },
+            workspacePath,
+        };
+    }
+    if (warning) {
+        return {
+            result: {
+                kind: 'warning',
+                summary: `Workspace path written to config.json: ${workspacePath}`,
+                warning,
+            },
+            workspacePath,
+        };
+    }
+    return {
+        result: {
+            kind: 'configured',
+            summary: `Workspace path written to config.json: ${workspacePath}`,
+        },
+        workspacePath,
+    };
+}
+async function runScmTokenSection(deps, opts) {
+    if (opts.yes) {
+        return {
+            kind: 'skipped',
+            reason: 'SCM token setup skipped in --yes mode (set GITHUB_TOKEN or GITLAB_TOKEN manually)',
+        };
+    }
+    const hasGithub = !!deps.env['GITHUB_TOKEN'];
+    const hasGitlab = !!deps.env['GITLAB_TOKEN'];
+    if (hasGithub && hasGitlab) {
+        return { kind: 'skipped', reason: 'GITHUB_TOKEN and GITLAB_TOKEN already set' };
+    }
+    if (hasGithub) {
+        return { kind: 'skipped', reason: 'GITHUB_TOKEN already set' };
+    }
+    if (hasGitlab) {
+        return { kind: 'skipped', reason: 'GITLAB_TOKEN already set' };
+    }
+    deps.print('');
+    deps.print('  GitHub / GitLab token (optional -- press Enter to skip).');
+    deps.print('  Required if you want to use polling triggers for MR/PR reviews.');
+    const token = await deps.prompt('  Personal access token: ', '');
+    if (!token.trim()) {
+        return {
+            kind: 'skipped',
+            reason: 'No token provided (skipped)',
+        };
+    }
+    deps.print('');
+    deps.print('  Add the following to your ~/.zshrc or ~/.bashrc:');
+    deps.print(`    export GITHUB_TOKEN=${token}`);
+    deps.print('  (Use GITLAB_TOKEN instead if you are using GitLab.)');
+    deps.print('  Then run: source ~/.zshrc  (or restart your terminal)');
+    return {
+        kind: 'configured',
+        summary: 'Printed token export instructions (token NOT written to disk)',
+    };
+}
+async function runTriggersSection(deps, opts, workspacePath) {
+    const triggersPath = deps.joinPath(workspacePath, 'triggers.yml');
+    const exists = await deps.exists(triggersPath);
+    if (exists) {
+        return { kind: 'skipped', reason: `${triggersPath} already exists` };
+    }
+    if (!workspacePath.trim()) {
+        return {
+            kind: 'skipped',
+            reason: 'Workspace path not set -- skipping triggers.yml generation',
+        };
+    }
+    const content = buildTriggersYml(workspacePath);
+    try {
+        await deps.mkdir(workspacePath, { recursive: true });
+        await deps.writeFile(triggersPath, content);
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            message: `Failed to write triggers.yml: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    return {
+        kind: 'configured',
+        summary: `Written: ${triggersPath}`,
+    };
+}
+async function runDaemonSoulSection(deps) {
+    const soulPath = deps.joinPath(deps.homedir(), '.workrail', 'daemon-soul.md');
+    const exists = await deps.exists(soulPath);
+    if (exists) {
+        return { kind: 'skipped', reason: `${soulPath} already exists` };
+    }
+    try {
+        await deps.mkdir(deps.joinPath(deps.homedir(), '.workrail'), { recursive: true });
+        await deps.writeFile(soulPath, soul_template_js_1.DAEMON_SOUL_TEMPLATE);
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            message: `Failed to write daemon-soul.md: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    return {
+        kind: 'configured',
+        summary: `Written: ${soulPath}`,
+    };
+}
+async function runSmokeSection(deps) {
+    const result = await deps.runSmoke();
+    if (result.ok) {
+        return {
+            kind: 'configured',
+            summary: `workrail list succeeded:\n${result.output}`,
+        };
+    }
+    return {
+        kind: 'warning',
+        summary: 'Smoke test failed (installation may not be complete)',
+        warning: result.output || 'workrail list returned an error. Is workrail installed and on your PATH?',
+    };
+}
+async function executeWorktrainInitCommand(deps, opts = {}) {
+    deps.print('');
+    deps.print('WorkTrain Onboarding');
+    deps.print('════════════════════════════════════════');
+    if (opts.yes) {
+        deps.print('Running in non-interactive mode (--yes). Using safe defaults.');
+    }
+    deps.print('');
+    const sectionLabels = [
+        'LLM credentials',
+        'Workspace',
+        'SCM token',
+        'triggers.yml',
+        'daemon-soul.md',
+        'Smoke test',
+    ];
+    deps.print('[ 1/6 ] LLM credentials');
+    const credResult = await runCredentialsSection(deps, opts);
+    printSectionResult(deps, credResult);
+    deps.print('[ 2/6 ] Workspace');
+    const { result: wsResult, workspacePath } = await runWorkspaceSection(deps, opts);
+    printSectionResult(deps, wsResult);
+    if (wsResult.kind === 'error') {
+        return (0, cli_result_js_1.failure)(wsResult.message, {
+            suggestions: ['Check write permissions for ~/.workrail/config.json'],
+        });
+    }
+    deps.print('[ 3/6 ] SCM token (GitHub / GitLab)');
+    const scmResult = await runScmTokenSection(deps, opts);
+    printSectionResult(deps, scmResult);
+    deps.print('[ 4/6 ] triggers.yml');
+    const triggersResult = await runTriggersSection(deps, opts, workspacePath);
+    printSectionResult(deps, triggersResult);
+    deps.print('[ 5/6 ] daemon-soul.md');
+    const soulResult = await runDaemonSoulSection(deps);
+    printSectionResult(deps, soulResult);
+    deps.print('[ 6/6 ] Smoke test');
+    const smokeResult = await runSmokeSection(deps);
+    printSectionResult(deps, smokeResult);
+    deps.print('');
+    deps.print('Setup complete. To start the daemon:');
+    deps.print(`  workrail daemon --workspace ${workspacePath || '<your-workspace>'}`);
+    deps.print('');
+    void sectionLabels;
+    return (0, cli_result_js_1.success)({
+        message: 'WorkTrain onboarding complete',
+        details: buildSummaryDetails(credResult, wsResult, scmResult, triggersResult, soulResult, smokeResult),
+    });
+}
+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('');
+}
+function buildSummaryDetails(...results) {
+    return results.map((r) => {
+        switch (r.kind) {
+            case 'skipped': return `skipped: ${r.reason}`;
+            case 'configured': return `configured: ${r.summary}`;
+            case 'warning': return `warning: ${r.summary} -- ${r.warning}`;
+            case 'error': return `error: ${r.message}`;
+        }
+    });
+}

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

@@ -0,0 +1,28 @@
+import type { CliResult } from '../types/cli-result.js';
+export interface WorktrainSpawnCommandDeps {
+    readonly fetch: (url: string, opts: {
+        method: string;
+        headers: Record<string, string>;
+        body: 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 pathIsAbsolute: (p: string) => boolean;
+    readonly statPath: (p: string) => Promise<{
+        isDirectory: () => boolean;
+    }>;
+}
+export interface WorktrainSpawnCommandOpts {
+    readonly workflow: string;
+    readonly goal: string;
+    readonly workspace: string;
+    readonly port?: number;
+}
+export declare function executeWorktrainSpawnCommand(deps: WorktrainSpawnCommandDeps, opts: WorktrainSpawnCommandOpts): Promise<CliResult>;

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorktrainSpawnCommand = executeWorktrainSpawnCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+const DEFAULT_CONSOLE_PORT = 3456;
+const LOCK_FILE_NAME = 'dashboard.lock';
+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;
+}
+async function executeWorktrainSpawnCommand(deps, opts) {
+    const workflowId = opts.workflow.trim();
+    if (!workflowId) {
+        return (0, cli_result_js_1.misuse)('--workflow is required and must not be empty.');
+    }
+    const goal = opts.goal.trim();
+    if (!goal) {
+        return (0, cli_result_js_1.misuse)('--goal is required and must not be empty.');
+    }
+    const workspace = opts.workspace.trim();
+    if (!workspace) {
+        return (0, cli_result_js_1.misuse)('--workspace is required and must not be empty.');
+    }
+    if (!deps.pathIsAbsolute(workspace)) {
+        return (0, cli_result_js_1.misuse)(`--workspace must be an absolute path, got: ${workspace}`);
+    }
+    try {
+        const stat = await deps.statPath(workspace);
+        if (!stat.isDirectory()) {
+            return (0, cli_result_js_1.failure)(`--workspace must be an existing directory: ${workspace}`);
+        }
+    }
+    catch {
+        return (0, cli_result_js_1.failure)(`--workspace does not exist: ${workspace}`);
+    }
+    const port = await discoverConsolePort(deps, opts.port);
+    const url = `http://127.0.0.1:${port}/api/v2/auto/dispatch`;
+    deps.stderr(`Dispatching workflow '${workflowId}' to daemon at port ${port}...`);
+    let responseBody;
+    try {
+        const response = await deps.fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ workflowId, goal, workspacePath: workspace }),
+        });
+        responseBody = await response.json();
+        if (!response.ok) {
+            const errorMsg = isErrorResponse(responseBody)
+                ? responseBody.error
+                : `HTTP ${response.status}`;
+            if (response.status === 503) {
+                return (0, cli_result_js_1.failure)(`WorkTrain daemon is not ready: ${errorMsg}\n` +
+                    'Ensure the daemon is running with: worktrain daemon');
+            }
+            return (0, cli_result_js_1.failure)(`Dispatch failed: ${errorMsg}`);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const isConnectionRefused = message.includes('ECONNREFUSED') ||
+            message.includes('fetch failed') ||
+            message.includes('connect ECONNREFUSED');
+        if (isConnectionRefused) {
+            return (0, cli_result_js_1.failure)(`Could not connect to WorkTrain daemon on port ${port}.\n` +
+                'Ensure the daemon is running with: worktrain daemon\n' +
+                `If the daemon is running on a different port, use: --port <n>`);
+        }
+        return (0, cli_result_js_1.failure)(`Dispatch request failed: ${message}`);
+    }
+    if (!isSuccessResponse(responseBody)) {
+        const errorMsg = isErrorResponse(responseBody)
+            ? responseBody.error
+            : 'unexpected response shape';
+        return (0, cli_result_js_1.failure)(`Dispatch failed: ${errorMsg}`);
+    }
+    const sessionHandle = responseBody.data.sessionHandle;
+    if (typeof sessionHandle !== 'string' || !sessionHandle) {
+        return (0, cli_result_js_1.failure)('Dispatch succeeded but no session handle was returned. Is the daemon up to date?');
+    }
+    deps.stdout(sessionHandle);
+    return { kind: 'success' };
+}
+function isSuccessResponse(body) {
+    return (body !== null &&
+        typeof body === 'object' &&
+        body['success'] === true &&
+        typeof body['data'] === 'object');
+}
+function isErrorResponse(body) {
+    return (body !== null &&
+        typeof body === 'object' &&
+        body['success'] === false &&
+        typeof body['error'] === 'string');
+}

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

@@ -0,0 +1,25 @@
+import type { CliResult } from '../types/cli-result.js';
+export type Priority = 'high' | 'normal' | 'low';
+export interface QueuedMessage {
+    readonly id: string;
+    readonly message: string;
+    readonly timestamp: string;
+    readonly workspaceHint?: string;
+    readonly priority: Priority;
+}
+export interface WorktrainTellCommandDeps {
+    readonly appendFile: (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;
+    readonly now: () => string;
+    readonly generateId: () => string;
+}
+export interface WorktrainTellCommandOpts {
+    readonly workspace?: string;
+    readonly priority?: Priority;
+}
+export declare function executeWorktrainTellCommand(messageText: string, deps: WorktrainTellCommandDeps, opts?: WorktrainTellCommandOpts): Promise<CliResult>;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorktrainTellCommand = executeWorktrainTellCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+async function executeWorktrainTellCommand(messageText, deps, opts = {}) {
+    if (!messageText || !messageText.trim()) {
+        return (0, cli_result_js_1.misuse)('Message text cannot be empty.', [
+            'Usage: worktrain tell "<message>"',
+        ]);
+    }
+    const priority = opts.priority ?? 'normal';
+    const queueDir = deps.joinPath(deps.homedir(), '.workrail');
+    const queuePath = deps.joinPath(queueDir, 'message-queue.jsonl');
+    const entry = {
+        id: deps.generateId(),
+        message: messageText.trim(),
+        timestamp: deps.now(),
+        ...(opts.workspace ? { workspaceHint: opts.workspace } : {}),
+        priority,
+    };
+    try {
+        await deps.mkdir(queueDir, { recursive: true });
+        await deps.appendFile(queuePath, JSON.stringify(entry) + '\n');
+    }
+    catch (err) {
+        return (0, cli_result_js_1.failure)(`Failed to queue message: ${err instanceof Error ? err.message : String(err)}`, { suggestions: [`Check write permissions for ${queuePath}`] });
+    }
+    deps.print(`Message queued (priority: ${priority}).`);
+    return (0, cli_result_js_1.success)({
+        message: `Message queued (priority: ${priority}).`,
+    });
+}

package/dist/cli-worktrain.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};