crewx-agent-cli 0.2.0

package/dist/index.js

@@ -0,0 +1,618 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { stdin, stdout } from 'node:process';
+import { resolve } from 'node:path';
+import * as tls from 'node:tls';
+import { fileURLToPath } from 'node:url';
+import { Command, InvalidArgumentError } from 'commander';
+import { parseAdapter, probeAdapter, runAdapter } from './adapters.js';
+import { CrewXApi } from './api.js';
+import { resolveConfig, saveConfig, readStoredConfig } from './config.js';
+import { CLI_NAME, CLI_VERSION, DEFAULT_ADAPTER, DEFAULT_POLL_INTERVAL_MS } from './constants.js';
+import { runDaemon } from './daemon.js';
+import { CliError, errorMessage, redactSecrets } from './errors.js';
+import { decodeJoinCode } from './join.js';
+import { ui } from './ui.js';
+function trustSystemCertificateAuthorities() {
+    if (typeof tls.getCACertificates !== 'function' || typeof tls.setDefaultCACertificates !== 'function')
+        return;
+    try {
+        tls.setDefaultCACertificates([
+            ...new Set([...tls.getCACertificates('default'), ...tls.getCACertificates('system')]),
+        ]);
+    }
+    catch {
+        // Older Node 22 releases may not expose every certificate-store mode.
+    }
+}
+trustSystemCertificateAuthorities();
+function positiveInteger(value) {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new InvalidArgumentError('must be a positive integer');
+    }
+    return parsed;
+}
+function memoryImportance(value) {
+    const parsed = positiveInteger(value);
+    if (parsed > 5)
+        throw new InvalidArgumentError('must be between 1 and 5');
+    return parsed;
+}
+async function readStdin() {
+    if (stdin.isTTY)
+        return '';
+    stdin.setEncoding('utf8');
+    let value = '';
+    for await (const chunk of stdin)
+        value += chunk;
+    return value;
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function commaSeparated(value) {
+    return [...new Set(value.split(',').map((item) => item.trim()).filter(Boolean))];
+}
+async function listenForWork(options) {
+    if (!options.codingCommand) {
+        const runtime = await probeAdapter(options.adapter);
+        if (!runtime.available) {
+            throw new CliError(`Cannot start the ${options.adapter} runner: ${runtime.error ?? 'the local runtime is unavailable'}. Run \`crewx doctor\` for installation details.`);
+        }
+        console.log(ui.muted(`  Runtime ${options.adapter}${runtime.version ? ` (${runtime.version})` : ''}`));
+    }
+    if (options.adapter === 'openclaw') {
+        console.log(ui.warning('OpenClaw uses its own configured workspace, sandbox, tools, and approvals; CrewX does not rewrite them.'));
+    }
+    const controller = new AbortController();
+    let interrupts = 0;
+    const stop = () => {
+        interrupts += 1;
+        if (interrupts === 1) {
+            console.log('\nStopping CrewX agent…');
+            controller.abort();
+        }
+        else {
+            process.exitCode = 130;
+        }
+    };
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+    try {
+        await runDaemon({
+            api: options.api,
+            adapter: options.adapter,
+            ...(options.name ? { name: options.name } : {}),
+            cwd: resolve(options.cwd),
+            pollIntervalMs: options.pollIntervalMs,
+            once: options.once,
+            ...(options.codingCommand ? { codingCommand: options.codingCommand } : {}),
+            ...(options.environment ? { environment: options.environment } : {}),
+            signal: controller.signal,
+            log: (message) => console.log(ui.muted(`[crewx] ${message}`)),
+        });
+    }
+    finally {
+        process.removeListener('SIGINT', stop);
+        process.removeListener('SIGTERM', stop);
+    }
+}
+export function createProgram() {
+    const program = new Command();
+    program
+        .name(CLI_NAME)
+        .description('Bring your local coding agents into a CrewX workspace.')
+        .version(CLI_VERSION)
+        .option('--join <code>', 'join an agent profile using the command copied from CrewX')
+        .option('-a, --adapter <adapter>', 'override the runtime encoded in a join command')
+        .option('--coding-cmd <command>', 'advanced: run a local argv command and append the prompt (use {prompt} to position it)')
+        .option('--once', 'poll once, process available work, then exit')
+        .option('--poll-interval <milliseconds>', 'delay between polls', positiveInteger, DEFAULT_POLL_INTERVAL_MS)
+        .option('-C, --cwd <directory>', 'local working directory', process.cwd())
+        .showHelpAfterError()
+        .configureHelp({ sortSubcommands: true, sortOptions: true })
+        .action(async (options) => {
+        if (!options.join) {
+            program.outputHelp();
+            return;
+        }
+        const joined = decodeJoinCode(options.join);
+        const adapter = parseAdapter(options.adapter ?? joined.adapter);
+        const api = new CrewXApi(joined);
+        await api.status(AbortSignal.timeout(10_000));
+        console.log(ui.success(`✓ Joined CrewX with ${adapter}`));
+        console.log(`  Server  ${api.baseUrl}`);
+        console.log(`  Folder  ${resolve(options.cwd)}`);
+        console.log(ui.muted('  Runs in this terminal. Press Ctrl+C to disconnect.'));
+        if (options.codingCmd) {
+            console.log(ui.warning('  Custom command enabled; CrewX will execute it directly without a shell.'));
+        }
+        await listenForWork({
+            api,
+            adapter,
+            cwd: options.cwd,
+            pollIntervalMs: options.pollInterval,
+            once: options.once ?? false,
+            ...(options.codingCmd ? { codingCommand: options.codingCmd } : {}),
+            environment: { CREWX_URL: joined.url, CREWX_TOKEN: joined.token },
+        });
+    });
+    program
+        .command('connect')
+        .description('Authenticate this machine with a CrewX workspace')
+        .requiredOption('--url <url>', 'CrewX server URL')
+        .requiredOption('--token <token>', 'agent connection token')
+        .option('--name <name>', 'friendly name for this machine')
+        .action(async (options) => {
+        const api = new CrewXApi({ url: options.url, token: options.token });
+        await api.status(AbortSignal.timeout(10_000));
+        const path = await saveConfig(options);
+        console.log(ui.success('✓ Connected to CrewX'));
+        console.log(`  Server  ${api.baseUrl}`);
+        if (options.name)
+            console.log(`  Name    ${options.name}`);
+        console.log(`  Config  ${path} ${ui.muted('(mode 0600)')}`);
+        console.log(`\nStart listening with ${ui.heading('crewx daemon')}.`);
+    });
+    program
+        .command('status')
+        .description('Show the current CrewX connection')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (options) => {
+        const config = await resolveConfig();
+        const api = new CrewXApi(config);
+        const response = await api.status(AbortSignal.timeout(10_000));
+        if (options.json) {
+            printJson({ connected: true, url: api.baseUrl, name: config.name, response });
+            return;
+        }
+        console.log(ui.success('● CrewX is reachable'));
+        console.log(`  Server  ${api.baseUrl}`);
+        if (config.name)
+            console.log(`  Name    ${config.name}`);
+        console.log(`  Auth    ${config.tokenSource === 'environment' ? 'CREWX_TOKEN' : config.path}`);
+    });
+    program
+        .command('doctor')
+        .description('Check local agent binaries and CrewX connectivity')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (options) => {
+        const adapters = await Promise.all(['codex', 'claude', 'pi', 'hermes', 'openclaw'].map(async (adapter) => [adapter, await probeAdapter(adapter)]));
+        let connection = {
+            configured: false,
+            reachable: false,
+        };
+        try {
+            const config = await resolveConfig();
+            const api = new CrewXApi(config);
+            connection = { configured: true, reachable: true, url: api.baseUrl };
+            try {
+                await api.status(AbortSignal.timeout(10_000));
+            }
+            catch (error) {
+                connection.reachable = false;
+                connection.error = redactSecrets(errorMessage(error), [config.token]);
+            }
+        }
+        catch {
+            // An absent connection is a normal doctor result.
+        }
+        const result = { node: process.version, adapters: Object.fromEntries(adapters), connection };
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log(ui.heading('CrewX doctor'));
+        console.log(`  Node     ${process.version} ${Number(process.versions.node.split('.')[0]) >= 22 ? ui.success('✓') : ui.warning('requires 22+')}`);
+        for (const [adapter, probe] of adapters) {
+            console.log(`  ${adapter.padEnd(8)} ${probe.available ? ui.success('✓') : ui.warning('–')} ${probe.version ?? probe.error ?? 'not found'}`);
+        }
+        console.log(`  API      ${connection.reachable ? ui.success('✓ reachable') : connection.configured ? ui.warning(`unreachable — ${connection.error}`) : ui.warning('not configured')}`);
+    });
+    const task = program.command('task').description('List, create, and update CrewX tasks');
+    task
+        .command('list')
+        .description('List tasks visible to this connected agent')
+        .option('--status <status>', 'filter by task status')
+        .option('--assigned-to-me', 'show only tasks assigned to this agent')
+        .option('--include-epics', 'include epics in the result')
+        .option('--search <text>', 'search titles and descriptions')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (options) => {
+        const api = new CrewXApi(await resolveConfig());
+        const tasks = await api.listTasks({
+            ...(options.status ? { status: options.status } : {}),
+            ...(options.assignedToMe ? { assignedToMe: true } : {}),
+            ...(options.includeEpics ? { includeEpics: true } : {}),
+            ...(options.search ? { search: options.search } : {}),
+        });
+        if (options.json) {
+            printJson({ tasks });
+            return;
+        }
+        if (tasks.length === 0) {
+            console.log(ui.muted('No matching tasks.'));
+            return;
+        }
+        for (const item of tasks) {
+            console.log(`#${item.id} [${item.status}] ${item.title}${item.assigned_to_me ? ' (assigned to me)' : ''}`);
+        }
+    });
+    task
+        .command('create')
+        .description('Create a workspace task')
+        .requiredOption('--title <title>', 'task title')
+        .option('--description <markdown>', 'task description')
+        .option('--status <status>', 'backlog, todo, in_progress, review, done, or cancelled')
+        .option('--priority <priority>', 'low, medium, high, or urgent')
+        .option('--labels <labels>', 'comma-separated labels')
+        .option('--due <date>', 'due date (YYYY-MM-DD)')
+        .option('--project <channel-id>', 'project channel ID', positiveInteger)
+        .option('--epic <task-id>', 'epic task ID', positiveInteger)
+        .option('--assign-to-me', 'assign the new task to this connected agent')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (options) => {
+        const api = new CrewXApi(await resolveConfig());
+        const created = await api.createTask({
+            title: options.title,
+            ...(options.description !== undefined ? { description: options.description } : {}),
+            ...(options.status ? { status: options.status } : {}),
+            ...(options.priority ? { priority: options.priority } : {}),
+            ...(options.labels !== undefined ? { labels: commaSeparated(options.labels) } : {}),
+            ...(options.due ? { due_at: options.due } : {}),
+            ...(options.project !== undefined ? { project_channel_id: options.project } : {}),
+            ...(options.epic !== undefined ? { epic_id: options.epic } : {}),
+            ...(options.assignToMe ? { assign_to_me: true } : {}),
+        });
+        if (options.json) {
+            printJson({ task: created });
+            return;
+        }
+        console.log(ui.success(`✓ Created task #${created.id}: ${created.title}`));
+    });
+    task
+        .command('update')
+        .description('Update a task assigned to this connected agent')
+        .argument('<id>', 'task ID', positiveInteger)
+        .option('--title <title>', 'replace the task title')
+        .option('--description <markdown>', 'replace the task description')
+        .option('--status <status>', 'set task status')
+        .option('--priority <priority>', 'set task priority')
+        .option('--labels <labels>', 'replace labels with a comma-separated list')
+        .option('--due <date>', 'set due date (YYYY-MM-DD)')
+        .option('--result <markdown>', 'record the work result')
+        .option('--pull-request <url>', 'record a pull request URL')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (id, options) => {
+        const attributes = {
+            ...(options.title !== undefined ? { title: options.title } : {}),
+            ...(options.description !== undefined ? { description: options.description } : {}),
+            ...(options.status ? { status: options.status } : {}),
+            ...(options.priority ? { priority: options.priority } : {}),
+            ...(options.labels !== undefined ? { labels: commaSeparated(options.labels) } : {}),
+            ...(options.due ? { due_at: options.due } : {}),
+            ...(options.result !== undefined ? { result: options.result } : {}),
+            ...(options.pullRequest !== undefined ? { pull_request_url: options.pullRequest } : {}),
+        };
+        if (Object.keys(attributes).length === 0)
+            throw new CliError('Provide at least one task field to update.');
+        const api = new CrewXApi(await resolveConfig());
+        const updated = await api.updateTask(id, attributes);
+        if (options.json) {
+            printJson({ task: updated });
+            return;
+        }
+        console.log(ui.success(`✓ Updated task #${updated.id}: ${updated.title} [${updated.status}]`));
+    });
+    const doc = program.command('doc').description('List, create, and update CrewX documents');
+    doc
+        .command('list')
+        .description('List documents readable by connected agents')
+        .option('--search <text>', 'search document titles and contents')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (options) => {
+        const api = new CrewXApi(await resolveConfig());
+        const documents = await api.listDocuments(options.search ? { search: options.search } : {});
+        if (options.json) {
+            printJson({ documents });
+            return;
+        }
+        if (documents.length === 0) {
+            console.log(ui.muted('No matching documents.'));
+            return;
+        }
+        for (const document of documents) {
+            console.log(`#${document.id} v${document.current_version} ${document.title}${document.protected ? ' (protected)' : ''}`);
+        }
+    });
+    doc
+        .command('create')
+        .description('Create an agent-readable workspace document')
+        .requiredOption('--title <title>', 'document title')
+        .option('--content <markdown>', 'document content')
+        .option('--folder <folder-id>', 'folder ID', positiveInteger)
+        .option('--summary <summary>', 'version summary')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (options) => {
+        const api = new CrewXApi(await resolveConfig());
+        const created = await api.createDocument({
+            title: options.title,
+            ...(options.content !== undefined ? { content: options.content } : {}),
+            ...(options.folder !== undefined ? { folder_id: options.folder } : {}),
+            ...(options.summary ? { summary: options.summary } : {}),
+        });
+        if (options.json) {
+            printJson({ document: created });
+            return;
+        }
+        console.log(ui.success(`✓ Created document #${created.id} v${created.current_version}: ${created.title}`));
+    });
+    doc
+        .command('update')
+        .description('Update an agent-readable, unprotected document')
+        .argument('<id>', 'document ID', positiveInteger)
+        .requiredOption('--expected-version <version>', 'current version from doc list', positiveInteger)
+        .option('--title <title>', 'replace the document title')
+        .option('--content <markdown>', 'replace the document content')
+        .option('--folder <folder-id>', 'move to a folder', positiveInteger)
+        .option('--summary <summary>', 'version summary')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (id, options) => {
+        const attributes = {
+            expected_version: options.expectedVersion,
+            ...(options.title !== undefined ? { title: options.title } : {}),
+            ...(options.content !== undefined ? { content: options.content } : {}),
+            ...(options.folder !== undefined ? { folder_id: options.folder } : {}),
+            ...(options.summary ? { summary: options.summary } : {}),
+        };
+        if (Object.keys(attributes).length === 1)
+            throw new CliError('Provide at least one document field to update.');
+        const api = new CrewXApi(await resolveConfig());
+        const updated = await api.updateDocument(id, attributes);
+        if (options.json) {
+            printJson({ document: updated });
+            return;
+        }
+        console.log(ui.success(`✓ Updated document #${updated.id} to v${updated.current_version}: ${updated.title}`));
+    });
+    const memory = program.command('memory').description('List, create, and update durable CrewX memories');
+    memory
+        .command('list')
+        .description('List memories visible to this connected agent')
+        .option('--search <text>', 'search memory titles, contents, and sources')
+        .option('--category <category>', 'filter by category')
+        .option('--scope <scope>', 'workspace or channel')
+        .option('--channel <channel-id>', 'filter by channel ID', positiveInteger)
+        .option('--json', 'print machine-readable JSON')
+        .action(async (options) => {
+        if (options.scope && !['workspace', 'channel'].includes(options.scope)) {
+            throw new CliError('Memory scope must be workspace or channel.');
+        }
+        const api = new CrewXApi(await resolveConfig());
+        const memories = await api.listMemories({
+            ...(options.search ? { search: options.search } : {}),
+            ...(options.category ? { category: options.category } : {}),
+            ...(options.scope ? { scope: options.scope } : {}),
+            ...(options.channel !== undefined ? { channelId: options.channel } : {}),
+        });
+        if (options.json) {
+            printJson({ memories });
+            return;
+        }
+        if (memories.length === 0) {
+            console.log(ui.muted('No matching memories.'));
+            return;
+        }
+        for (const item of memories) {
+            const scope = item.scope === 'channel' ? `channel ${item.channel?.name ?? ''}`.trim() : 'workspace';
+            console.log(`#${item.id} [${item.category}] ${item.title} (${scope})`);
+        }
+    });
+    memory
+        .command('create')
+        .description('Record a durable learning for this workspace')
+        .requiredOption('--content <text>', 'memory content')
+        .option('--title <title>', 'memory title; generated from content when omitted')
+        .option('--category <category>', 'memory category', 'general')
+        .option('--importance <level>', 'importance from 1 to 5', memoryImportance, 3)
+        .option('--source <source>', 'memory source', 'agent')
+        .option('--channel <channel-id>', 'scope the memory to a visible channel', positiveInteger)
+        .option('--json', 'print machine-readable JSON')
+        .action(async (options) => {
+        const api = new CrewXApi(await resolveConfig());
+        const created = await api.createMemory({
+            content: options.content,
+            ...(options.title ? { title: options.title } : {}),
+            category: options.category,
+            importance: options.importance,
+            source: options.source,
+            ...(options.channel !== undefined ? { channel_id: options.channel } : {}),
+        });
+        if (options.json) {
+            printJson({ memory: created });
+            return;
+        }
+        console.log(ui.success(`✓ Saved memory #${created.id}: ${created.title}`));
+    });
+    memory
+        .command('update')
+        .description('Update a memory recorded by this connected agent')
+        .argument('<id>', 'memory ID', positiveInteger)
+        .option('--title <title>', 'replace the memory title')
+        .option('--content <text>', 'replace the memory content')
+        .option('--category <category>', 'replace the category')
+        .option('--importance <level>', 'importance from 1 to 5', memoryImportance)
+        .option('--source <source>', 'replace the source')
+        .option('--channel <channel-id>', 'move the memory to a visible channel', positiveInteger)
+        .option('--workspace-scope', 'move the memory to workspace scope')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (id, options) => {
+        if (options.channel !== undefined && options.workspaceScope) {
+            throw new CliError('Choose either --channel or --workspace-scope, not both.');
+        }
+        const attributes = {
+            ...(options.title !== undefined ? { title: options.title } : {}),
+            ...(options.content !== undefined ? { content: options.content } : {}),
+            ...(options.category !== undefined ? { category: options.category } : {}),
+            ...(options.importance !== undefined ? { importance: options.importance } : {}),
+            ...(options.source !== undefined ? { source: options.source } : {}),
+            ...(options.channel !== undefined ? { channel_id: options.channel } : {}),
+            ...(options.workspaceScope ? { channel_id: null } : {}),
+        };
+        if (Object.keys(attributes).length === 0)
+            throw new CliError('Provide at least one memory field to update.');
+        const api = new CrewXApi(await resolveConfig());
+        const updated = await api.updateMemory(id, attributes);
+        if (options.json) {
+            printJson({ memory: updated });
+            return;
+        }
+        console.log(ui.success(`✓ Updated memory #${updated.id}: ${updated.title}`));
+    });
+    const integration = program
+        .command('integration')
+        .description('Search connected Slack, Notion, and Google Drive knowledge');
+    integration
+        .command('list')
+        .description('List knowledge providers connected to this workspace')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (options) => {
+        const api = new CrewXApi(await resolveConfig());
+        const integrations = await api.listIntegrations();
+        if (options.json) {
+            printJson({ integrations });
+            return;
+        }
+        if (integrations.length === 0) {
+            console.log(ui.muted('No knowledge integrations are connected.'));
+            return;
+        }
+        for (const item of integrations) {
+            console.log(`${item.provider}${item.account_name ? ` — ${item.account_name}` : ''}`);
+        }
+    });
+    integration
+        .command('search')
+        .description('Search one connected knowledge provider')
+        .argument('<provider>', 'slack, notion, or google_drive')
+        .argument('<query...>', 'search query')
+        .option('--json', 'print machine-readable JSON')
+        .action(async (provider, queryParts, options) => {
+        if (!['slack', 'notion', 'google_drive'].includes(provider)) {
+            throw new CliError('Provider must be slack, notion, or google_drive.');
+        }
+        const query = queryParts.join(' ').trim();
+        if (!query)
+            throw new CliError('Provide a search query.');
+        const api = new CrewXApi(await resolveConfig());
+        const results = await api.searchIntegration(provider, query);
+        if (options.json) {
+            printJson({ results });
+            return;
+        }
+        if (results.length === 0) {
+            console.log(ui.muted('No matching provider results.'));
+            return;
+        }
+        for (const item of results) {
+            console.log(`${item.title ?? 'Untitled'}${item.url ? `\n  ${item.url}` : ''}`);
+        }
+    });
+    program
+        .command('daemon')
+        .description('Listen for CrewX work and execute it with a local agent')
+        .option('-a, --adapter <adapter>', 'codex, claude, pi, hermes, or openclaw', process.env.CREWX_ADAPTER || DEFAULT_ADAPTER)
+        .option('--coding-cmd <command>', 'advanced: run a local argv command and append the prompt (use {prompt} to position it)')
+        .option('--once', 'poll once, process available work, then exit')
+        .option('--poll-interval <milliseconds>', 'delay between polls', positiveInteger, DEFAULT_POLL_INTERVAL_MS)
+        .option('-C, --cwd <directory>', 'local working directory', process.cwd())
+        .action(async (options) => {
+        // Commander treats the identically named root options as global even
+        // when they appear after `daemon`. Read those values explicitly so
+        // `crewx daemon --adapter claude --once` does not silently use the
+        // subcommand defaults instead.
+        const globalOptions = program.opts();
+        const adapter = parseAdapter(globalOptions.adapter ?? options.adapter);
+        const config = await resolveConfig();
+        const api = new CrewXApi(config);
+        await listenForWork({
+            api,
+            adapter,
+            ...(config.name ? { name: config.name } : {}),
+            cwd: globalOptions.cwd ?? options.cwd,
+            pollIntervalMs: globalOptions.pollInterval ?? options.pollInterval,
+            once: globalOptions.once ?? options.once ?? false,
+            ...((globalOptions.codingCmd ?? options.codingCmd)
+                ? { codingCommand: globalOptions.codingCmd ?? options.codingCmd }
+                : {}),
+        });
+    });
+    program
+        .command('run')
+        .description('Run one local agent without connecting to CrewX')
+        .argument('<adapter>', 'codex, claude, pi, hermes, or openclaw')
+        .argument('[prompt...]', 'prompt (reads stdin when omitted)')
+        .option('-C, --cwd <directory>', 'local working directory', process.cwd())
+        .option('--coding-cmd <command>', 'advanced: run a local argv command and append the prompt (use {prompt} to position it)')
+        .action(async (adapterName, promptParts, options) => {
+        const globalOptions = program.opts();
+        const adapter = parseAdapter(adapterName);
+        const argumentPrompt = promptParts.join(' ').trim();
+        const prompt = argumentPrompt || (await readStdin()).trim();
+        if (!prompt)
+            throw new CliError('Provide a prompt argument or pipe a prompt on stdin.');
+        let displayedMessages = 0;
+        const result = await runAdapter({
+            adapter,
+            prompt,
+            cwd: resolve(globalOptions.cwd ?? options.cwd),
+            ...((globalOptions.codingCmd ?? options.codingCmd)
+                ? { codingCommand: globalOptions.codingCmd ?? options.codingCmd }
+                : {}),
+            onMessage(message) {
+                stdout.write(message.endsWith('\n') ? message : `${message}\n`);
+                displayedMessages += 1;
+            },
+            onStderr(line) {
+                process.stderr.write(`${line}\n`);
+            },
+        });
+        if (displayedMessages === 0 && result.stdout.length > 0) {
+            stdout.write(`${result.stdout.join('\n')}\n`);
+        }
+        if (result.exitCode !== 0) {
+            throw new CliError(`${adapter} exited with code ${String(result.exitCode)}.`, result.exitCode ?? 1);
+        }
+    });
+    return program;
+}
+export async function main(argv = process.argv) {
+    try {
+        await createProgram().parseAsync(argv);
+    }
+    catch (error) {
+        const stored = await readStoredConfig().catch(() => undefined);
+        console.error(ui.warning(`Error: ${redactSecrets(errorMessage(error), stored ? [stored.token] : [])}`));
+        process.exitCode = error instanceof CliError ? error.exitCode : 1;
+    }
+}
+export function isMainModule(moduleUrl, invokedPath = process.argv[1]) {
+    if (!invokedPath)
+        return false;
+    try {
+        return realpathSync.native(fileURLToPath(moduleUrl)) === realpathSync.native(resolve(invokedPath));
+    }
+    catch {
+        return false;
+    }
+}
+if (isMainModule(import.meta.url)) {
+    await main();
+}
+export { CrewXApi } from './api.js';
+export { configPath, readStoredConfig, resolveConfig, saveConfig } from './config.js';
+export { decodeJoinCode, encodeJoinCode } from './join.js';
+export { assemblePrompt, assignmentFromEvent } from './prompt.js';
+export { buildAdapterInvocation, parseAdapterLine, parseCodingCommand, runAdapter } from './adapters.js';
+//# sourceMappingURL=index.js.map