@almyty/chat 1.2.0 → 1.4.0

package/dist/exit-codes.d.ts

@@ -0,0 +1,32 @@
+export declare const EXIT: {
+    /** Success. */
+    readonly OK: 0;
+    /** Unexpected failure (a thrown error with no better classification). */
+    readonly ERROR: 1;
+    /** Bad or missing arguments, or an unknown command. */
+    readonly USAGE: 2;
+    /** No stored credential, or the API rejected the one we had. */
+    readonly AUTH: 3;
+    /** The named agent / gateway / skill / run does not exist. */
+    readonly NOT_FOUND: 4;
+    /** The command ran; the operation it asked for failed. */
+    readonly FAILED: 5;
+};
+export type ExitCode = (typeof EXIT)[keyof typeof EXIT];
+/** One line per code, for `--help` output and READMEs. */
+export declare const EXIT_CODE_HELP: string;
+/**
+ * Classify a thrown value into an exit code.
+ *
+ * The sibling CLIs read the status back out of the message string.
+ * This one does not have to: the shared client now puts `status` on
+ * the error it throws, which `inspectError` reads.
+ */
+export declare function exitCodeForError(err: unknown): ExitCode;
+/**
+ * The exit code a finished turn earns, so a chat call can gate a shell
+ * script: a run that ran and failed is 5, not 1, so
+ * `almyty chat deploy-check -m "ok?" || case $? in 5) ...` can tell a
+ * failed answer from a broken invocation.
+ */
+export declare function exitCodeForStatus(status: 'completed' | 'failed' | 'cancelled' | 'waiting_input'): ExitCode;

package/dist/exit-codes.js

@@ -0,0 +1,65 @@
+/**
+ * Exit codes shared by every almyty CLI.
+ *
+ * Scripts need to tell "you are not logged in" apart from "that agent
+ * does not exist" apart from "the run you asked for failed" without
+ * grepping stderr. Every almyty CLI uses this same table, so
+ * `almyty agents run x || case $? in 3) almyty login;; esac` behaves
+ * the same whichever binary produced the code.
+ */
+import { inspectError } from './errors.js';
+export const EXIT = {
+    /** Success. */
+    OK: 0,
+    /** Unexpected failure (a thrown error with no better classification). */
+    ERROR: 1,
+    /** Bad or missing arguments, or an unknown command. */
+    USAGE: 2,
+    /** No stored credential, or the API rejected the one we had. */
+    AUTH: 3,
+    /** The named agent / gateway / skill / run does not exist. */
+    NOT_FOUND: 4,
+    /** The command ran; the operation it asked for failed. */
+    FAILED: 5,
+};
+/** One line per code, for `--help` output and READMEs. */
+export const EXIT_CODE_HELP = [
+    '  0  success',
+    '  1  unexpected error',
+    '  2  usage error (bad flags, unknown command)',
+    '  3  not authenticated — run `almyty login`',
+    '  4  not found (agent, gateway, skill, or run)',
+    '  5  the operation ran and failed',
+].join('\n');
+/**
+ * Classify a thrown value into an exit code.
+ *
+ * The sibling CLIs read the status back out of the message string.
+ * This one does not have to: the shared client now puts `status` on
+ * the error it throws, which `inspectError` reads.
+ */
+export function exitCodeForError(err) {
+    const f = inspectError(err);
+    if (f.aborted)
+        return EXIT.FAILED;
+    if (f.network)
+        return EXIT.ERROR;
+    if (f.code === 'AGENT_AUTH_REQUIRED' || f.code === 'AGENT_AUTH_INVALID' || f.code === 'AGENT_AUTH_EXPIRED')
+        return EXIT.AUTH;
+    if (f.status === 401 || f.status === 403 || f.code === 'AGENT_AUTH_FORBIDDEN')
+        return EXIT.AUTH;
+    if (f.status === 404)
+        return EXIT.NOT_FOUND;
+    if (f.status !== undefined && f.status >= 400)
+        return EXIT.FAILED;
+    return EXIT.ERROR;
+}
+/**
+ * The exit code a finished turn earns, so a chat call can gate a shell
+ * script: a run that ran and failed is 5, not 1, so
+ * `almyty chat deploy-check -m "ok?" || case $? in 5) ...` can tell a
+ * failed answer from a broken invocation.
+ */
+export function exitCodeForStatus(status) {
+    return status === 'completed' || status === 'waiting_input' ? EXIT.OK : EXIT.FAILED;
+}

package/dist/headless.d.ts

@@ -0,0 +1,44 @@
+/**
+ * chat without a terminal.
+ *
+ * A CLI that only draws to a tty cannot be piped, scripted or put in
+ * CI, which is half of what a CLI is for. This path answers one
+ * question — from --message, or from stdin — writes the answer to
+ * stdout, writes attribution to stderr so stdout stays clean for a
+ * pipe, and exits 0 or 1 on whether the run actually completed.
+ *
+ * `--json` prints one object per answer instead, with the text, the
+ * cost and the ids needed to resume.
+ */
+import type { AgentInfo, RunLimits } from '@almyty/client';
+import { type ErrorContext } from './errors.js';
+import { type TurnResult, type TurnTarget } from './turn.js';
+export interface HeadlessIO {
+    out(text: string): void;
+    err(text: string): void;
+}
+export interface HeadlessOptions {
+    message: string;
+    agent: AgentInfo;
+    target: TurnTarget;
+    json: boolean;
+    /** False buffers the answer and prints it once. */
+    stream: boolean;
+    conversationId?: string;
+    limits?: RunLimits;
+    signal?: AbortSignal;
+    io: HeadlessIO;
+    errorContext?: ErrorContext;
+}
+/** Everything --json promises, in one object. */
+export declare function jsonResult(result: TurnResult, agent: AgentInfo): Record<string, unknown>;
+/** Read all of stdin, for `echo "..." | almyty chat <agent> --stdin`. */
+export declare function readStdin(stream: AsyncIterable<string | Buffer>): Promise<string>;
+/**
+ * Answer once and return the process exit code.
+ *
+ * Streaming to a pipe writes the tokens as they arrive, which is what
+ * makes `almyty chat bot -m "..." | less` feel alive; --json buffers,
+ * because half a JSON object is not JSON.
+ */
+export declare function runHeadless(options: HeadlessOptions): Promise<number>;

package/dist/headless.js

@@ -0,0 +1,106 @@
+/**
+ * chat without a terminal.
+ *
+ * A CLI that only draws to a tty cannot be piped, scripted or put in
+ * CI, which is half of what a CLI is for. This path answers one
+ * question — from --message, or from stdin — writes the answer to
+ * stdout, writes attribution to stderr so stdout stays clean for a
+ * pipe, and exits 0 or 1 on whether the run actually completed.
+ *
+ * `--json` prints one object per answer instead, with the text, the
+ * cost and the ids needed to resume.
+ */
+import { explainError } from './errors.js';
+import { exitCodeForError, exitCodeForStatus } from './exit-codes.js';
+import { formatUsage } from './stream.js';
+import { runTurn } from './turn.js';
+/** Everything --json promises, in one object. */
+export function jsonResult(result, agent) {
+    return {
+        status: result.status,
+        output: result.text,
+        agent: { id: agent.id, name: agent.name, slug: agent.slug, mode: agent.mode },
+        model: result.usage.model ?? null,
+        routing: result.usage.model
+            ? { model: result.usage.model, rationale: result.usage.rationale ?? null, attempt: result.usage.attempt ?? null }
+            : null,
+        usage: { cost: result.usage.cost, tokens: result.usage.tokens, steps: result.usage.steps },
+        runId: result.runId ?? null,
+        conversationId: result.conversationId ?? null,
+        ...(result.error ? { error: result.error } : {}),
+    };
+}
+/** Read all of stdin, for `echo "..." | almyty chat <agent> --stdin`. */
+export async function readStdin(stream) {
+    const parts = [];
+    for await (const chunk of stream)
+        parts.push(typeof chunk === 'string' ? chunk : chunk.toString('utf-8'));
+    return parts.join('').trim();
+}
+/**
+ * Answer once and return the process exit code.
+ *
+ * Streaming to a pipe writes the tokens as they arrive, which is what
+ * makes `almyty chat bot -m "..." | less` feel alive; --json buffers,
+ * because half a JSON object is not JSON.
+ */
+export async function runHeadless(options) {
+    const { io, json, agent } = options;
+    let written = 0;
+    try {
+        const result = await runTurn(options.target, options.message, {
+            mode: agent.mode,
+            conversationId: options.conversationId,
+            limits: options.limits,
+            signal: options.signal,
+            hooks: json || !options.stream
+                ? undefined
+                : {
+                    partial: (text) => {
+                        // Only the new tail: the reducer hands back the whole
+                        // buffer each time.
+                        if (text.length > written) {
+                            io.out(text.slice(written));
+                            written = text.length;
+                        }
+                    },
+                },
+        });
+        if (json) {
+            io.out(JSON.stringify(jsonResult(result, agent), null, 2) + '\n');
+            return exitCodeForStatus(result.status);
+        }
+        if (options.stream) {
+            // Anything the stream did not already print (a non-streaming
+            // provider, or a final output that replaced the buffer).
+            if (result.text.length > written)
+                io.out(result.text.slice(written));
+            if (result.text)
+                io.out('\n');
+        }
+        else if (result.text) {
+            io.out(result.text + '\n');
+        }
+        const attribution = formatUsage(result.usage);
+        if (attribution)
+            io.err(attribution + '\n');
+        if (result.status === 'failed')
+            io.err(`Run failed: ${result.error ?? 'no reason given'}\n`);
+        if (result.status === 'cancelled')
+            io.err('Cancelled.\n');
+        if (result.status === 'waiting_input' && result.conversationId) {
+            io.err(`The agent asked a question. Continue with: almyty chat ${agent.slug ?? agent.name} --resume ${result.conversationId}\n`);
+        }
+        return exitCodeForStatus(result.status);
+    }
+    catch (err) {
+        const message = explainError(err, options.errorContext);
+        if (json) {
+            io.out(JSON.stringify({ status: 'error', error: message }, null, 2) + '\n');
+        }
+        else {
+            io.err(message + '\n');
+        }
+        return exitCodeForError(err);
+    }
+}

package/dist/history.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Input history that survives the session.
+ *
+ * History used to be derived from the messages on screen, so it emptied
+ * on /clear and every new session started with nothing to press up
+ * into. It is kept in a file next to the credentials instead, one entry
+ * per line, oldest first.
+ *
+ * Nothing the agent says is written here — only what the user typed —
+ * and slash commands are kept because re-running one is the common case.
+ */
+/** How many lines are kept. Beyond this the oldest are dropped. */
+export declare const HISTORY_LIMIT = 500;
+/** Longest line kept, so a pasted file cannot bloat the file. */
+export declare const HISTORY_MAX_LINE = 4000;
+export declare function historyFile(env?: Record<string, string | undefined>): string;
+/** Newlines are the record separator, so they are escaped on the way in. */
+export declare function encodeEntry(value: string): string;
+export declare function decodeEntry(value: string): string;
+/**
+ * How many appends go by before the file is trimmed.
+ *
+ * Trimming reads and rewrites the whole file, so doing it on every
+ * message put two extra filesystem round-trips in front of every turn.
+ * The file is allowed to run a little over the limit between trims.
+ */
+export declare const TRIM_EVERY = 50;
+/** Forget the in-process memo. Tests use this; nothing else needs it. */
+export declare function resetHistoryState(): void;
+/** Oldest first. Never throws: no history is a worse day, not a crash. */
+export declare function loadHistory(file?: string): string[];
+/** Cut the file back to the newest HISTORY_LIMIT entries. */
+export declare function trimHistory(file?: string): void;
+/**
+ * Append one entry, skipping a repeat of the line before it.
+ *
+ * One filesystem write on the common path: this runs on the keystroke
+ * that submits a message, so it is not the place for a read, a mkdir
+ * and a rewrite.
+ */
+export declare function appendHistory(entry: string, file?: string): void;
+/**
+ * Where up/down land, given how far back the cursor already is.
+ *
+ * `idx` is -1 for "at the live prompt" and counts backwards from the
+ * newest entry. Returns the new index and the text to show.
+ */
+export declare function walkHistory(history: string[], idx: number, direction: 'up' | 'down'): {
+    idx: number;
+    value: string;
+};

package/dist/history.js

@@ -0,0 +1,146 @@
+/**
+ * Input history that survives the session.
+ *
+ * History used to be derived from the messages on screen, so it emptied
+ * on /clear and every new session started with nothing to press up
+ * into. It is kept in a file next to the credentials instead, one entry
+ * per line, oldest first.
+ *
+ * Nothing the agent says is written here — only what the user typed —
+ * and slash commands are kept because re-running one is the common case.
+ */
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+/** How many lines are kept. Beyond this the oldest are dropped. */
+export const HISTORY_LIMIT = 500;
+/** Longest line kept, so a pasted file cannot bloat the file. */
+export const HISTORY_MAX_LINE = 4000;
+export function historyFile(env = process.env) {
+    if (env.ALMYTY_CHAT_HISTORY)
+        return env.ALMYTY_CHAT_HISTORY;
+    return join(homedir(), '.almyty', 'chat-history');
+}
+/** Newlines are the record separator, so they are escaped on the way in. */
+export function encodeEntry(value) {
+    return value.replace(/\\/g, '\\\\').replace(/\n/g, '\\n');
+}
+export function decodeEntry(value) {
+    let out = '';
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === '\\' && i + 1 < value.length) {
+            const next = value[i + 1];
+            if (next === 'n') {
+                out += '\n';
+                i++;
+                continue;
+            }
+            if (next === '\\') {
+                out += '\\';
+                i++;
+                continue;
+            }
+        }
+        out += value[i];
+    }
+    return out;
+}
+/**
+ * How many appends go by before the file is trimmed.
+ *
+ * Trimming reads and rewrites the whole file, so doing it on every
+ * message put two extra filesystem round-trips in front of every turn.
+ * The file is allowed to run a little over the limit between trims.
+ */
+export const TRIM_EVERY = 50;
+/** Last entry written per file, so a repeat costs no read. */
+const lastAppended = new Map();
+const appendsSinceTrim = new Map();
+/** Forget the in-process memo. Tests use this; nothing else needs it. */
+export function resetHistoryState() {
+    lastAppended.clear();
+    appendsSinceTrim.clear();
+}
+/** Oldest first. Never throws: no history is a worse day, not a crash. */
+export function loadHistory(file = historyFile()) {
+    try {
+        return readFileSync(file, 'utf-8')
+            .split('\n')
+            .filter((line) => line.length > 0)
+            .map(decodeEntry);
+    }
+    catch {
+        return [];
+    }
+}
+/** Cut the file back to the newest HISTORY_LIMIT entries. */
+export function trimHistory(file = historyFile()) {
+    try {
+        const entries = loadHistory(file);
+        if (entries.length <= HISTORY_LIMIT)
+            return;
+        writeFileSync(file, entries.slice(entries.length - HISTORY_LIMIT).map(encodeEntry).join('\n') + '\n', 'utf-8');
+    }
+    catch {
+        /* a history file we cannot rewrite is not worth failing a turn over */
+    }
+}
+/**
+ * Append one entry, skipping a repeat of the line before it.
+ *
+ * One filesystem write on the common path: this runs on the keystroke
+ * that submits a message, so it is not the place for a read, a mkdir
+ * and a rewrite.
+ */
+export function appendHistory(entry, file = historyFile()) {
+    const value = entry.trim();
+    if (!value || value.length > HISTORY_MAX_LINE)
+        return;
+    if (lastAppended.get(file) === value)
+        return;
+    try {
+        const line = encodeEntry(value) + '\n';
+        try {
+            appendFileSync(file, line, 'utf-8');
+        }
+        catch (err) {
+            if (err?.code !== 'ENOENT')
+                throw err;
+            mkdirSync(dirname(file), { recursive: true });
+            appendFileSync(file, line, 'utf-8');
+        }
+        lastAppended.set(file, value);
+        const count = (appendsSinceTrim.get(file) ?? 0) + 1;
+        if (count >= TRIM_EVERY) {
+            appendsSinceTrim.set(file, 0);
+            trimHistory(file);
+        }
+        else {
+            appendsSinceTrim.set(file, count);
+        }
+    }
+    catch {
+        /* history is a convenience, never a reason to fail a turn */
+    }
+}
+/**
+ * Where up/down land, given how far back the cursor already is.
+ *
+ * `idx` is -1 for "at the live prompt" and counts backwards from the
+ * newest entry. Returns the new index and the text to show.
+ */
+export function walkHistory(history, idx, direction) {
+    if (direction === 'up') {
+        if (!history.length)
+            return { idx, value: '' };
+        const next = Math.min(idx + 1, history.length - 1);
+        return { idx: next, value: history[history.length - 1 - next] };
+    }
+    if (idx > 0) {
+        const next = idx - 1;
+        return { idx: next, value: history[history.length - 1 - next] };
+    }
+    if (idx === 0)
+        return { idx: -1, value: '' };
+    return { idx, value: '' };
+}

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
-export declare const VERSION = "0.2.0";
+import { VERSION } from './version.js';
+export { VERSION };

package/dist/index.js

@@ -1,60 +1,93 @@
 #!/usr/bin/env node
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { render, Box, Text } from 'ink';
-import { AlmytyClient, resolveCredentialsOrExit, getOrgSlugFromToken } from '@almyty/client';
+import { AlmytyClient, resolveCredentials, getOrgSlugFromToken } from '@almyty/client';
 import { AgentSelector } from './components.js';
 import { ChatApp, exitMessage } from './app.js';
-export const VERSION = '0.2.0';
+import { helpText, isNonInteractive, parseArgs, resolveRef, splitRef, useColor } from './args.js';
+import { explainError, DEFAULT_APP_URL } from './errors.js';
+import { EXIT, exitCodeForError } from './exit-codes.js';
+import { readStdin, runHeadless } from './headless.js';
+import { VERSION } from './version.js';
+export { VERSION };
+function limitsFrom(args) {
+    if (args.maxSteps === undefined && args.maxCostCents === undefined)
+        return undefined;
+    return {
+        ...(args.maxSteps !== undefined ? { maxSteps: args.maxSteps } : {}),
+        ...(args.maxCostCents !== undefined ? { maxCostCents: args.maxCostCents } : {}),
+    };
+}
 // ── Entry point ─────────────────────────────────────────────────
 async function main() {
-    const argv = process.argv.slice(2);
-    if (argv.includes('--version') || argv.includes('-v')) {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.error) {
+        console.error(args.error);
+        process.exit(EXIT.USAGE);
+    }
+    if (args.version) {
         console.log(VERSION);
         return;
     }
-    if (argv.includes('--help') || argv.includes('-h')) {
-        console.log(`almyty chat v${VERSION}\n\nUsage:\n  npx @almyty/chat <org>/<agent-slug>\n  npx @almyty/chat <org>/<agent-slug> --resume <conversation-id>\n\nExamples:\n  npx @almyty/chat acme/support-bot\n  npx @almyty/chat myorg/my-agent --resume 60d93c85-...\n\nCommands:\n  /help /agents /clear /quit\n\nAuth:\n  npx @almyty/auth login`);
+    if (args.help) {
+        console.log(helpText(VERSION));
         return;
     }
-    const creds = resolveCredentialsOrExit();
-    const client = new AlmytyClient(creds.url, creds.token);
-    let resumeId;
-    const ri = Math.max(argv.indexOf('--resume'), argv.indexOf('-resume'));
-    if (ri !== -1) {
-        resumeId = argv[ri + 1];
-        if (!resumeId || resumeId.startsWith('-')) {
-            console.error('--resume requires a conversation id');
-            process.exit(1);
-        }
+    const creds = resolveCredentials();
+    if (!creds) {
+        // Said once, in full, rather than as a 401 three calls later.
+        console.error('Not authenticated. Run one of:');
+        console.error('  npx @almyty/auth login');
+        console.error('  export ALMYTY_TOKEN=<your-token>');
+        process.exit(EXIT.AUTH);
     }
-    const ref = argv.find(arg => !arg.startsWith('-') && arg !== resumeId);
-    // Resolve org slug — from ref (org/slug) or JWT token
+    const client = new AlmytyClient(creds.url, creds.token);
+    const appUrl = process.env.ALMYTY_APP_URL || creds.frontendUrl || DEFAULT_APP_URL;
+    const headless = isNonInteractive(args, {
+        stdinTty: process.stdin.isTTY === true,
+        stdoutTty: process.stdout.isTTY === true,
+    });
+    const ref = resolveRef(args);
     const defaultOrg = getOrgSlugFromToken(creds.token);
     let orgSlug;
     let agentSlug;
-    if (ref && ref.includes('/')) {
-        [orgSlug, agentSlug] = ref.split('/', 2);
-    }
-    else if (ref) {
-        // Bare slug — use org from JWT
-        if (!defaultOrg) {
-            console.error('Cannot determine org. Use org/agent-slug format or log in: npx @almyty/auth login');
-            process.exit(1);
+    if (ref) {
+        const parts = splitRef(ref);
+        if (parts.orgSlug) {
+            orgSlug = parts.orgSlug;
+            agentSlug = parts.agentSlug;
+        }
+        else {
+            if (!defaultOrg) {
+                console.error('Cannot tell which organization to use. Pass <org>/<agent-slug>, or log in again: npx @almyty/auth login');
+                process.exit(EXIT.USAGE);
+            }
+            orgSlug = defaultOrg;
+            agentSlug = parts.agentSlug;
         }
-        orgSlug = defaultOrg;
-        agentSlug = ref;
+    }
+    else if (headless) {
+        // There is nobody to answer a picker on a pipe.
+        console.error('No agent given. Pass <org>/<agent-slug>, or set ALMYTY_AGENT.');
+        process.exit(EXIT.USAGE);
     }
     else {
-        // No arg — interactive picker
         if (!defaultOrg) {
-            console.error('Usage: npx @almyty/chat <org>/<agent-slug>');
-            process.exit(1);
+            console.error('Usage: almyty chat <org>/<agent-slug>');
+            process.exit(EXIT.USAGE);
         }
         orgSlug = defaultOrg;
-        const agents = await client.listAgents();
+        let agents;
+        try {
+            agents = await client.listAgents();
+        }
+        catch (err) {
+            console.error(explainError(err, { apiUrl: creds.url, appUrl }));
+            process.exit(exitCodeForError(err));
+        }
         if (!agents.length) {
-            console.error('No agents found. Create one at https://app.almyty.com/agents');
-            process.exit(1);
+            console.error(`No agents in this organization yet. Create one at ${appUrl}/agents`);
+            process.exit(EXIT.NOT_FOUND);
         }
         if (agents.length === 1) {
             agentSlug = agents[0].slug || agents[0].name.toLowerCase().replace(/\s+/g, '-');
@@ -69,21 +102,60 @@ async function main() {
         }
     }
     const gw = client.gateway(orgSlug, agentSlug);
+    const errorContext = { agentRef: `${orgSlug}/${agentSlug}`, apiUrl: creds.url, appUrl };
     let agent;
     try {
         agent = await gw.getInfo();
     }
-    catch {
-        console.error(`Agent not found: ${orgSlug}/${agentSlug}`);
-        process.exit(1);
+    catch (err) {
+        // "Agent not found" used to be printed for a bad login, a wrong
+        // org, a draft agent and an unreachable API alike.
+        console.error(explainError(err, { ...errorContext, what: 'info' }));
+        process.exit(exitCodeForError(err));
+    }
+    if (headless) {
+        const message = args.message ?? (await readStdin(process.stdin));
+        if (!message) {
+            console.error('Nothing to ask. Pass --message "<question>", or pipe it in.');
+            process.exit(EXIT.USAGE);
+        }
+        // Ctrl-C on a pipe cancels the run rather than orphaning it.
+        const ac = new AbortController();
+        const onSigint = () => ac.abort();
+        process.on('SIGINT', onSigint);
+        const code = await runHeadless({
+            message,
+            agent,
+            target: gw,
+            json: args.json,
+            stream: args.stream && !args.json,
+            conversationId: args.resume,
+            limits: limitsFrom(args),
+            signal: ac.signal,
+            errorContext,
+            io: {
+                out: (text) => process.stdout.write(text),
+                err: (text) => process.stderr.write(text),
+            },
+        });
+        process.off('SIGINT', onSigint);
+        process.exit(code);
+    }
+    // Colour is decided once, here, so NO_COLOR reaches ink's own
+    // detection rather than being re-derived per component.
+    if (!useColor(args, process.env, process.stdout.isTTY === true)) {
+        process.env.FORCE_COLOR = '0';
     }
-    const { waitUntilExit } = render(_jsx(ChatApp, { client: client, initialAgent: agent, gw: gw, resumeConversationId: resumeId }), { exitOnCtrlC: true });
+    const { waitUntilExit } = render(_jsx(ChatApp, { client: client, initialAgent: agent, gw: gw, resumeConversationId: args.resume, errorContext: errorContext }), 
+    // Ctrl-C is handled inside the app: the first press cancels the
+    // run server-side, and only then does a second one exit.
+    { exitOnCtrlC: false });
     await waitUntilExit();
     if (exitMessage) {
         process.stdout.write(exitMessage);
     }
 }
 main().catch(err => {
-    console.error(err.message);
-    process.exit(1);
+    console.error(explainError(err));
+    process.exit(exitCodeForError(err));
 });