@crewx/cli 0.9.0-rc.12 → 0.9.0-rc.121

package/dist/commands/result.js

@@ -4,25 +4,95 @@
  * Retrieves the result of a completed task by its ID.
  *
  * Usage:
- *   crewx result <task-id>         Print raw result
- *   crewx result <task-id> --json  Print full task record as JSON
- *   crewx result                   List recent tasks (latest 10)
+ *   crewx result <task-id>            Print raw result
+ *   crewx result <task-id> --json     Print full task record as JSON
+ *   crewx result <task-id> --wait=<seconds> Poll (1s interval) up to the given
+ *                                    number of seconds for
+ *                                    the task to leave 'pending'/'running'. Exit 124 on
+ *                                    timeout. --wait=0 behaves like no --wait
+ *                                    (single immediate check).
+ *   crewx result                      List recent tasks (latest 10)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleResult = handleResult;
+const sdk_1 = require("@crewx/sdk");
 const repository_1 = require("@crewx/sdk/repository");
+const cal_1 = require("./cal");
+const POLL_INTERVAL_MS = 1000;
+const REAP_INTERVAL_MS = 10_000;
 function statusIcon(status) {
     switch (status) {
+        case 'pending': return '🕓';
         case 'running': return '⏳';
         case 'success': return '✅';
         case 'failed': return '❌';
+        case 'stopped': return '⏹';
+        case 'runner_lost': return '⚠️';
         default: return '❓';
     }
 }
+function isActiveStatus(status) {
+    return status === 'pending' || status === 'running';
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resultCommandId(status) {
+    switch (status) {
+        case 'pending': return 'crewx.result-pending';
+        case 'running': return 'crewx.result-running';
+        case 'success': return 'crewx.result-done';
+        case 'failed':
+        case 'stopped':
+        case 'runner_lost':
+            return 'crewx.result-terminal-abnormal';
+        default: return 'crewx.result';
+    }
+}
+function writeResultCalFooter(task, lastWaitSeconds) {
+    const params = { taskId: task.id };
+    if (task.agent_id)
+        params.agent = task.agent_id;
+    if (task.thread_id)
+        params.thread = task.thread_id;
+    if (isActiveStatus(task.status)) {
+        params.wait = String((0, cal_1.suggestWaitSeconds)({
+            startedAt: task.started_at,
+            lastWaitSeconds,
+        }));
+    }
+    (0, cal_1.writeCalFooter)({ commandId: resultCommandId(task.status), params });
+}
+function formatRuntimeDuration(startedAt, now = Date.now()) {
+    const startedAtMs = Date.parse(startedAt);
+    const elapsedSeconds = Number.isFinite(startedAtMs)
+        ? Math.max(0, Math.floor((now - startedAtMs) / 1000))
+        : 0;
+    const hours = Math.floor(elapsedSeconds / 3600);
+    const minutes = Math.floor((elapsedSeconds % 3600) / 60);
+    const seconds = elapsedSeconds % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m ${seconds}s`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+}
+/** Parses `--wait=<seconds>`. Returns undefined when the flag is absent. */
+function parseWaitSeconds(args) {
+    const arg = args.find(a => a.startsWith('--wait='));
+    if (arg === undefined)
+        return undefined;
+    const n = Number(arg.slice('--wait='.length));
+    return Number.isFinite(n) && n >= 0 ? n : 0;
+}
 async function handleResult(args) {
     const jsonMode = args.includes('--json');
+    const waitSeconds = parseWaitSeconds(args);
     const taskId = args.find(a => !a.startsWith('--'));
     const repo = new repository_1.TaskRepository();
+    const initialReaped = repo.reapOrphanedTasks({ tickIntervalMs: REAP_INTERVAL_MS });
+    if (initialReaped > 0)
+        console.error(`Reaped ${initialReaped} orphaned task(s)`);
     if (!taskId) {
         const all = repo.getAllTasks();
         const recent = all.slice(0, 10);
@@ -36,35 +106,97 @@ async function handleResult(args) {
             const icon = statusIcon(task.status);
             console.log(`${idx + 1}. ${icon} ${task.id}`);
             console.log(`   Agent: ${task.agent_id ?? '—'}  Mode: ${task.mode ?? '—'}`);
-            console.log(`   Started: ${new Date(task.started_at).toLocaleString()}`);
+            console.log(`   Started: ${(0, sdk_1.formatDisplayTimestamp)(new Date(task.started_at))}`);
             if (task.completed_at) {
-                console.log(`   Completed: ${new Date(task.completed_at).toLocaleString()}`);
+                console.log(`   Completed: ${(0, sdk_1.formatDisplayTimestamp)(new Date(task.completed_at))}`);
             }
             console.log('');
         });
         console.log('Tip: Run `crewx result <task-id>` to see full output.');
+        if (!jsonMode)
+            writeResultCalFooter(recent[0]);
         return;
     }
-    const task = repo.getTask(taskId);
+    let task = repo.getTask(taskId);
     if (!task) {
         console.error(`Error: Task not found: ${taskId}`);
         process.exit(1);
         return;
     }
+    if (waitSeconds !== undefined && waitSeconds > 0 && isActiveStatus(task.status)) {
+        const deadline = Date.now() + waitSeconds * 1000;
+        let lastReapAt = Date.now();
+        while (task && isActiveStatus(task.status)) {
+            if (Date.now() >= deadline) {
+                console.error(`Task ${taskId} is still ${task.status} (waited ${waitSeconds}s; ` +
+                    `running for ${formatRuntimeDuration(task.started_at)}). ` +
+                    'Not stalled — check again with a longer wait.');
+                writeResultCalFooter(task, waitSeconds);
+                process.exit(124);
+                return;
+            }
+            await sleep(Math.min(POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
+            if (Date.now() - lastReapAt >= REAP_INTERVAL_MS) {
+                const reaped = repo.reapOrphanedTasks({ tickIntervalMs: REAP_INTERVAL_MS });
+                if (reaped > 0)
+                    console.error(`Reaped ${reaped} orphaned task(s)`);
+                lastReapAt = Date.now();
+            }
+            task = repo.getTask(taskId);
+            if (!task) {
+                console.error(`Error: Task not found: ${taskId}`);
+                process.exit(1);
+                return;
+            }
+        }
+    }
     if (jsonMode) {
         console.log(JSON.stringify(task, null, 2));
         return;
     }
+    if (task.status === 'pending') {
+        console.error(`🕓 Task ${taskId} is pending (waiting to start — runner has not adopted the task yet).`);
+        const nextWaitSeconds = (0, cal_1.suggestWaitSeconds)({
+            startedAt: task.started_at,
+            lastWaitSeconds: waitSeconds,
+        });
+        console.error(`Use \`crewx result ${taskId} --wait=${nextWaitSeconds}\` to wait for completion.`);
+        writeResultCalFooter(task, waitSeconds);
+        process.exit(1);
+        return;
+    }
     if (task.status === 'running') {
         console.error(`Task ${taskId} is still running.`);
-        console.error(`Use \`crewx kill ${taskId}\` to stop it.`);
+        const nextWaitSeconds = (0, cal_1.suggestWaitSeconds)({
+            startedAt: task.started_at,
+            lastWaitSeconds: waitSeconds,
+        });
+        console.error(`Use \`crewx result ${taskId} --wait=${nextWaitSeconds}\` to wait longer or \`crewx log ${taskId}\` to inspect progress.`);
+        writeResultCalFooter(task, waitSeconds);
+        process.exit(1);
+        return;
+    }
+    if (task.status === 'stopped') {
+        if (task.result !== null && task.result !== undefined) {
+            console.log(task.result);
+        }
+        console.error(`⏹ Task ${taskId} was stopped by user: ${task.error ?? 'no further details'}.`);
+        writeResultCalFooter(task);
+        process.exit(1);
+        return;
+    }
+    if (task.status === 'runner_lost') {
+        console.error(`⚠️ Task ${taskId} runner lost before completion: ${task.error ?? 'no further details'}.`);
+        writeResultCalFooter(task);
         process.exit(1);
         return;
     }
     if (task.status === 'failed') {
         console.error(`Task ${taskId} failed: ${task.error ?? 'unknown error'}`);
+        writeResultCalFooter(task);
         process.exit(1);
         return;
     }
     console.log(task.result ?? '');
+    writeResultCalFooter(task);
 }

package/dist/commands/shortcut.d.ts

@@ -0,0 +1 @@
+export declare function handleShortcut(args: string[]): Promise<void>;

package/dist/commands/shortcut.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleShortcut = handleShortcut;
+/**
+ * crewx shortcut handler — thin CLI wrapper over @crewx/sdk/desktop.
+ *
+ * Usage:
+ *   crewx shortcut status [--json]
+ *   crewx shortcut install [--force] [--json]
+ *   crewx shortcut uninstall [--json]
+ *
+ * All win32/foreign/superseded/force judgment lives in @crewx/sdk/desktop.
+ * This module only parses argv, forwards options, and renders the result.
+ */
+const desktop_1 = require("@crewx/sdk/desktop");
+const parse_common_flags_1 = require("./parse-common-flags");
+const NOT_WINDOWS_MESSAGE = 'NOT_WINDOWS: Desktop shortcuts are only supported on Windows.';
+function parseShortcutFlags(args, allowForce) {
+    let json = false;
+    let force = false;
+    for (const arg of args) {
+        if (arg === '--json') {
+            json = true;
+            continue;
+        }
+        if (arg === '--force' && allowForce) {
+            force = true;
+            continue;
+        }
+        throw new parse_common_flags_1.UnknownOptionError(`Unknown option: ${arg}`);
+    }
+    return { json, force };
+}
+/** Forwarded verbatim to stderr as each SDK phase starts — never buffered. */
+function onProgress(event) {
+    process.stderr.write(`[shortcut] ${event.message}\n`);
+}
+function printJson(payload) {
+    console.log(JSON.stringify(payload));
+}
+/** Prints the error and exits 1. Never returns (matches `process.exit`'s `never` type). */
+function failWithError(err, json) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (json) {
+        printJson({ success: false, error: message });
+    }
+    else {
+        console.error(`✗ ${message}`);
+    }
+    process.exit(1);
+}
+/** The SDK returns `supported:false` (no throw) for install/uninstall on non-Windows. */
+function failNotWindows(json) {
+    if (json) {
+        printJson({ success: false, supported: false, state: 'unsupported', error: NOT_WINDOWS_MESSAGE });
+    }
+    else {
+        console.error(`✗ ${NOT_WINDOWS_MESSAGE}`);
+    }
+    process.exit(1);
+}
+/**
+ * Detects the two ways a resolved (non-thrown) install result must NOT be
+ * read as success: a `superseded` shortcut (checked via both `state` and the
+ * `errors[]` entry, since either alone could otherwise be missed) and an
+ * unconfirmed global install (`installedGlobal:false` with
+ * `GLOBAL_INSTALL_UNCONFIRMED` in errors — npm exited 0 but re-detection
+ * could not confirm it).
+ */
+function installFailureReason(result) {
+    const supersededError = result.errors.find((e) => e.startsWith('SUPERSEDED:'));
+    if (result.state === 'superseded' || supersededError) {
+        return supersededError ?? 'Installed shortcut belongs to a newer CrewX version; refusing to modify it.';
+    }
+    const unconfirmedError = result.errors.find((e) => e.startsWith('GLOBAL_INSTALL_UNCONFIRMED:'));
+    if (!result.installedGlobal && unconfirmedError) {
+        return unconfirmedError;
+    }
+    if (result.errors.length > 0) {
+        return result.errors[0];
+    }
+    return null;
+}
+/**
+ * Only these two re-detected states mean the Desktop truly has no CrewX
+ * shortcut left. Everything else — `foreign`/`superseded` (SDK refused to
+ * touch it) and `installed`/`stale` (the `.lnk` unlink threw and was
+ * swallowed as "already gone" — install.ts `uninstallShortcut`) — means the
+ * file is still on disk. A success ALLOWLIST is used instead of enumerating
+ * failure states so an unlink failure (EPERM/EBUSY/locked/AV hook) that
+ * re-detects back to `installed` fails closed by construction, rather than
+ * requiring every new failure path to be added to an exclusion list.
+ */
+const UNINSTALL_SUCCESS_STATES = new Set(['declined', 'not-installed']);
+function uninstallFailureReason(result) {
+    if (UNINSTALL_SUCCESS_STATES.has(result.state)) {
+        return null;
+    }
+    const supersededError = result.errors.find((e) => e.startsWith('SUPERSEDED:'));
+    if (result.state === 'superseded' || supersededError) {
+        return supersededError ?? 'Installed shortcut belongs to a newer CrewX version; nothing was removed.';
+    }
+    if (result.state === 'foreign') {
+        const nsisError = result.errors.find((e) => e.startsWith('NSIS_PRESENT:'));
+        return nsisError ?? 'Existing Desktop shortcut is not managed by CrewX; nothing was removed.';
+    }
+    if (result.errors.length > 0) {
+        return result.errors[0];
+    }
+    return `CrewX desktop shortcut could not be removed (state: ${result.state}).`;
+}
+function printStatusHuman(status) {
+    switch (status.state) {
+        case 'unsupported':
+            console.log('Desktop shortcuts are only supported on Windows.');
+            break;
+        case 'not-installed':
+            console.log('No CrewX desktop shortcut installed yet.');
+            console.log('Run `crewx shortcut install` to create one.');
+            break;
+        case 'declined':
+            console.log('CrewX desktop shortcut setup was previously dismissed.');
+            console.log('Run `crewx shortcut install` to create one.');
+            break;
+        case 'installed':
+            console.log('✓ CrewX desktop shortcut is installed and up to date.');
+            if (status.shortcutPath)
+                console.log(`  Shortcut: ${status.shortcutPath}`);
+            break;
+        case 'stale':
+            console.log('⚠ CrewX desktop shortcut needs an update.');
+            console.log('Run `crewx shortcut install` to refresh it.');
+            break;
+        case 'foreign':
+            console.log('⚠ A Desktop shortcut exists that CrewX does not manage.');
+            console.log('Run `crewx shortcut install --force` to replace it.');
+            break;
+        case 'superseded':
+            console.log('⚠ The installed shortcut belongs to a newer CrewX version than the one running.');
+            console.log('Update CrewX before touching the shortcut.');
+            break;
+    }
+    for (const e of status.errors) {
+        console.log(`  note: ${e}`);
+    }
+}
+async function runStatus(args) {
+    const { json } = parseShortcutFlags(args, false);
+    let status;
+    try {
+        status = await (0, desktop_1.getShortcutStatus)();
+    }
+    catch (err) {
+        failWithError(err, json);
+    }
+    if (json) {
+        printJson(status);
+        return;
+    }
+    printStatusHuman(status);
+}
+async function runInstall(args) {
+    const { json, force } = parseShortcutFlags(args, true);
+    let result;
+    try {
+        result = await (0, desktop_1.installShortcut)({ force, onProgress });
+    }
+    catch (err) {
+        failWithError(err, json);
+    }
+    if (!result.supported) {
+        failNotWindows(json);
+    }
+    const failure = installFailureReason(result);
+    if (failure) {
+        if (json) {
+            printJson({ ...result, success: false });
+        }
+        else {
+            console.error(`✗ ${failure}`);
+        }
+        process.exit(1);
+    }
+    if (json) {
+        printJson({ ...result, success: true });
+        return;
+    }
+    if (result.changed) {
+        console.log('✓ CrewX desktop shortcut installed. Double-click "CrewX" on your Desktop to launch it.');
+    }
+    else {
+        console.log('✓ CrewX desktop shortcut is already up to date. Double-click "CrewX" on your Desktop to launch it.');
+    }
+    if (result.shortcutPath)
+        console.log(`  Shortcut: ${result.shortcutPath}`);
+}
+async function runUninstall(args) {
+    const { json } = parseShortcutFlags(args, false);
+    let result;
+    try {
+        result = await (0, desktop_1.uninstallShortcut)();
+    }
+    catch (err) {
+        failWithError(err, json);
+    }
+    if (!result.supported) {
+        failNotWindows(json);
+    }
+    const failure = uninstallFailureReason(result);
+    if (failure) {
+        if (json) {
+            printJson({ ...result, success: false });
+        }
+        else {
+            console.error(`✗ ${failure}`);
+            for (const e of result.errors) {
+                if (e !== failure)
+                    console.error(`  note: ${e}`);
+            }
+        }
+        process.exit(1);
+    }
+    if (json) {
+        printJson({ ...result, success: true });
+        return;
+    }
+    console.log('✓ CrewX desktop shortcut removed.');
+}
+function printHelp() {
+    console.log(`
+crewx shortcut — manage the Windows Desktop shortcut for CrewX
+
+Usage:
+  crewx shortcut status [--json]
+  crewx shortcut install [--force] [--json]
+  crewx shortcut uninstall [--json]
+
+Options:
+  --json     Print machine-readable JSON to stdout (progress/log always go to stderr)
+  --force    (install only) Overwrite a Desktop shortcut CrewX does not manage.
+             Never overwrites a shortcut created by a newer CrewX version.
+
+Notes:
+  Windows only. On macOS/Linux, \`status\` reports state "unsupported" (exit 0);
+  \`install\`/\`uninstall\` exit 1 with no changes made.
+`.trim());
+}
+async function handleShortcut(args) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+        printHelp();
+        return;
+    }
+    const rest = args.slice(1);
+    switch (subcommand) {
+        case 'status':
+            return runStatus(rest);
+        case 'install':
+            return runInstall(rest);
+        case 'uninstall':
+            return runUninstall(rest);
+        default:
+            console.error(`Unknown shortcut subcommand: ${subcommand}`);
+            console.error('Run `crewx shortcut help` for usage.');
+            process.exit(1);
+    }
+}

package/dist/commands/slack.js

@@ -44,6 +44,7 @@ exports.handleSlack = handleSlack;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const https = __importStar(require("https"));
+const sdk_1 = require("@crewx/sdk");
 const adapter_slack_1 = require("@crewx/adapter-slack");
 const crewx_cli_1 = require("../bootstrap/crewx-cli");
 const markdown_1 = require("../slack/markdown");
@@ -186,7 +187,7 @@ async function handleListFiles(threadId) {
             console.log(`  📎 ${file.fileName}`);
             console.log(`     Size: ${formatFileSize(file.fileSize)}`);
             console.log(`     Path: ${file.filePath}`);
-            console.log(`     Downloaded: ${file.downloadedAt.toLocaleString()}`);
+            console.log(`     Downloaded: ${(0, sdk_1.formatDisplayTimestamp)(file.downloadedAt)}`);
             console.log('');
         }
         console.log(`Total: ${files.length} file${files.length > 1 ? 's' : ''}\n`);

package/dist/commands/stop.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Stop a running task through the SDK's cooperative-stop pipeline.
+ *
+ * `kill` is kept as a compatibility alias; both entry points use this same
+ * handler so server, CLI, and future adapters share one stop contract.
+ */
+/** Handle `crewx stop` and the compatibility `crewx kill` alias. */
+export declare function handleStop(args: string[], invokedAs?: 'stop' | 'kill'): Promise<void>;

package/dist/commands/stop.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Stop a running task through the SDK's cooperative-stop pipeline.
+ *
+ * `kill` is kept as a compatibility alias; both entry points use this same
+ * handler so server, CLI, and future adapters share one stop contract.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStop = handleStop;
+const sdk_1 = require("@crewx/sdk");
+const repository_1 = require("@crewx/sdk/repository");
+const cal_1 = require("./cal");
+function parseGrace(args) {
+    const flag = args.find((arg) => arg === '--grace' || arg.startsWith('--grace='));
+    if (!flag)
+        return { graceMs: 5_000 };
+    const raw = flag === '--grace'
+        ? args[args.indexOf(flag) + 1]
+        : flag.slice('--grace='.length);
+    const value = Number(raw);
+    if (!raw || !Number.isFinite(value) || value < 0) {
+        return { graceMs: 5_000, error: `Invalid --grace value: ${raw ?? '(missing)'}` };
+    }
+    return { graceMs: Math.trunc(value) };
+}
+function taskIdFromArgs(args) {
+    return args.find((arg, index) => {
+        if (arg === '--grace')
+            return false;
+        if (index > 0 && args[index - 1] === '--grace')
+            return false;
+        return !arg.startsWith('--');
+    });
+}
+function writeUsage() {
+    process.stderr.write('Error: Please provide a task ID or use --all to stop all running tasks.\n');
+    process.stderr.write('\nUsage:\n');
+    process.stderr.write('  crewx stop <task-id>    Stop a running task\n');
+    process.stderr.write('  crewx stop --all        Stop all running tasks\n');
+    process.stderr.write('  crewx stop <task-id> --grace=<ms>\n');
+}
+function formatGrace(graceMs) {
+    return `${graceMs / 1000}s`;
+}
+function reportResult(taskId, result, elapsedMs, graceMs) {
+    if (result.status === 'stopped') {
+        if (result.method === 'forced') {
+            process.stdout.write(`Stopped ${taskId} (forced after ${formatGrace(graceMs)} grace)\n`);
+        }
+        else {
+            process.stdout.write(`Stopped ${taskId} (cooperative, ${(elapsedMs / 1000).toFixed(1)}s)\n`);
+        }
+        return 0;
+    }
+    if (result.status === 'not_running') {
+        process.stdout.write(`Task ${taskId} is not running (${result.finalStatus ?? 'unknown'})\n`);
+        return 0;
+    }
+    if (result.status === 'already_requested') {
+        process.stderr.write(`Task ${taskId} already has a stop request; it remains ${result.finalStatus ?? 'running'}.\n`);
+        return 2;
+    }
+    if (result.status === 'ownership_unverified') {
+        const pid = result.pid ? ` (pid ${result.pid})` : '';
+        process.stderr.write(`Could not verify the process owner of ${taskId}; not terminated${pid}. ` +
+            'Row stays running — the reaper will settle it.\n');
+        return 2;
+    }
+    process.stderr.write(`Could not stop ${taskId}: ${result.error ?? 'unknown error'}\n`);
+    return 1;
+}
+/** Handle `crewx stop` and the compatibility `crewx kill` alias. */
+async function handleStop(args, invokedAs = 'stop') {
+    if (invokedAs === 'kill')
+        process.stderr.write('kill is an alias of stop\n');
+    const stopAll = args.includes('--all');
+    const { graceMs, error } = parseGrace(args);
+    if (error) {
+        process.stderr.write(`Error: ${error}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const taskId = taskIdFromArgs(args);
+    if (!taskId && !stopAll) {
+        writeUsage();
+        process.exitCode = 1;
+        return;
+    }
+    const repo = new repository_1.TaskRepository();
+    const stopOne = async (id, withFooter) => {
+        const startedAt = Date.now();
+        const result = await (0, sdk_1.stopTask)(repo, id, { graceMs, origin: 'cli' });
+        const exitCode = reportResult(id, result, Date.now() - startedAt, graceMs);
+        if (withFooter && (result.status === 'stopped' || result.status === 'not_running')) {
+            (0, cal_1.writeCalFooter)({
+                commandId: 'crewx.stop.done',
+                params: { taskId: id },
+            });
+        }
+        return exitCode;
+    };
+    if (stopAll) {
+        const running = repo.getRunningTasks();
+        if (running.length === 0) {
+            process.stdout.write('No running tasks found.\n');
+            return;
+        }
+        let exitCode = 0;
+        for (const task of running) {
+            exitCode = Math.max(exitCode, await stopOne(task.id, false));
+        }
+        if (exitCode > 0)
+            process.exitCode = exitCode;
+        return;
+    }
+    const exitCode = await stopOne(taskId, true);
+    if (exitCode > 0)
+        process.exitCode = exitCode;
+}

package/dist/commands/write-output.d.ts

@@ -0,0 +1,3 @@
+export declare function writeResult(out: string | undefined, data: string): void;
+/** On failure: if out is specified, append to file (avoid empty file). stderr is kept by the caller. */
+export declare function appendError(out: string | undefined, message: string): void;

package/dist/commands/write-output.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeResult = writeResult;
+exports.appendError = appendError;
+/**
+ * EPIPE-safe result output.
+ * - out specified: write success result to file (sync, no stream EPIPE)
+ * - out not specified: fall back to existing stdout (console.log)
+ */
+const fs_1 = require("fs");
+function writeResult(out, data) {
+    if (out) {
+        (0, fs_1.writeFileSync)(out, data, 'utf8');
+    }
+    else {
+        console.log(data);
+    }
+}
+/** On failure: if out is specified, append to file (avoid empty file). stderr is kept by the caller. */
+function appendError(out, message) {
+    if (out) {
+        (0, fs_1.appendFileSync)(out, message.endsWith('\n') ? message : message + '\n', 'utf8');
+    }
+}

package/dist/index.d.ts

@@ -1 +1 @@
-export { handleInit, type InitResult } from './commands/init';
+export { buildDefaultAgents, handleInit, parseInitProvider, resolveInitProvider, type InitProvider, type InitResult, } from './commands/init';

package/dist/index.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleInit = void 0;
+exports.resolveInitProvider = exports.parseInitProvider = exports.handleInit = exports.buildDefaultAgents = void 0;
 var init_1 = require("./commands/init");
+Object.defineProperty(exports, "buildDefaultAgents", { enumerable: true, get: function () { return init_1.buildDefaultAgents; } });
 Object.defineProperty(exports, "handleInit", { enumerable: true, get: function () { return init_1.handleInit; } });
+Object.defineProperty(exports, "parseInitProvider", { enumerable: true, get: function () { return init_1.parseInitProvider; } });
+Object.defineProperty(exports, "resolveInitProvider", { enumerable: true, get: function () { return init_1.resolveInitProvider; } });

package/dist/logging.d.ts

@@ -9,7 +9,7 @@
  *
  * Format mirrors cli-bak TaskManagementService for backward compatibility.
  */
-import type { Crewx } from '@crewx/sdk';
+import { type Crewx } from '@crewx/sdk';
 /**
  * Attach file-based logging to a Crewx instance.
  * Subscribes to task:start and task:end events and writes log files.