chatbase 0.0.1 → 0.1.1

package/dist/config/store.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { configDir, configFile } from './paths.js';
+export function readUserConfig() {
+    let contents;
+    try {
+        contents = fs.readFileSync(configFile(), 'utf8');
+    }
+    catch {
+        return {};
+    }
+    try {
+        return JSON.parse(contents);
+    }
+    catch {
+        fs.rmSync(configFile(), { force: true });
+        return {};
+    }
+}
+/**
+ * Atomic write: full JSON into a temp file, then rename over config.json.
+ * A crash/Ctrl-C at any line leaves either the complete old file or the
+ * complete new one — never a truncated config holding half an API key.
+ *
+ * Load-bearing details: the temp file MUST live in the destination
+ * directory (rename is only atomic within one filesystem — /tmp may be
+ * another); the PID suffix keeps concurrent CLI processes from clobbering
+ * each other's in-flight writes. Modes: dir 0700 / file 0600, since this
+ * file stores the credential.
+ */
+export function writeUserConfig(config) {
+    fs.mkdirSync(configDir(), { recursive: true, mode: 0o700 });
+    const tmp = path.join(configDir(), `.config.json.tmp-${process.pid}`);
+    fs.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}\n`, {
+        mode: 0o600
+    });
+    fs.renameSync(tmp, configFile());
+}

package/dist/errors/errors.js

@@ -0,0 +1,81 @@
+export class UsageError extends Error {
+}
+export class ApiError extends Error {
+    code;
+    status;
+    requestId;
+    details;
+    remediation;
+    constructor(opts) {
+        super(opts.message);
+        this.code = opts.code;
+        this.status = opts.status;
+        this.requestId = opts.requestId;
+        this.details = opts.details;
+        this.remediation = opts.remediation;
+    }
+}
+/**
+ * Remediation advice appended to API errors, resolved in two tiers:
+ * exact error code first (this map), HTTP status fallback second
+ * (STATUS_REMEDIATIONS). The server's own message always prints; these
+ * only add "here's what to do about it".
+ */
+const REMEDIATIONS = {
+    AUTH_MISSING_API_KEY: 'Run `chatbase auth login`, or set CHATBASE_API_KEY. Keys live in chatbase.co → Workspace Settings → API Keys.',
+    AUTH_INVALID_API_KEY: 'Your key was rejected. Run `chatbase auth login` with a fresh key, or check CHATBASE_API_KEY.',
+    AUTH_EXPIRED_API_KEY: 'This API key has expired. Run `chatbase auth login` to authenticate again.',
+    AUTH_INSUFFICIENT_PERMISSIONS: 'This API key does not have permission for this operation. Check its scopes with `chatbase auth status`, re-pair with broader access via `chatbase auth login`, or ask a workspace admin.',
+    SUBSCRIPTION_API_RESTRICTED_PLAN: 'API access requires the Standard plan or higher — upgrade at chatbase.co.',
+    VALIDATION_INVALID_BODY: 'Fix the fields above and retry.'
+};
+/**
+ * Fallback tier: best-guess advice for error CODES this CLI version doesn't
+ * know (e.g. the API added one after this release), keyed by HTTP status.
+ * No 403 fallback: the API has many distinct 403 codes (AGENT_LIMIT_REACHED,
+ * HELPDESK_NOT_ENABLED, plan gates, ...) whose server messages are already
+ * self-explanatory — a blanket guess was actively misleading for most.
+ */
+const STATUS_REMEDIATIONS = {
+    404: 'Resource not found — check the ID (agent IDs live in your dashboard).',
+    429: 'Rate limited — the CLI already retried; wait for the reset and try again.'
+};
+function isErrorEnvelope(body) {
+    return (typeof body === 'object' &&
+        body !== null &&
+        typeof body.error === 'object' &&
+        typeof body.error?.code === 'string');
+}
+export function parseErrorResponse(status, body, requestId) {
+    if (isErrorEnvelope(body)) {
+        const { code, message, details } = body.error;
+        return new ApiError({
+            code,
+            message,
+            status,
+            requestId,
+            details,
+            remediation: REMEDIATIONS[code] ?? STATUS_REMEDIATIONS[status]
+        });
+    }
+    return new ApiError({
+        code: `HTTP_${status}`,
+        message: `Request failed with status ${status}`,
+        status,
+        requestId,
+        remediation: STATUS_REMEDIATIONS[status]
+    });
+}
+export function formatApiError(err, color) {
+    const lines = [color.red(`✗ ${err.message} (${err.code})`)];
+    if (err.details && typeof err.details === 'object') {
+        for (const [field, problem] of Object.entries(err.details)) {
+            lines.push(`    ${field}  ${String(problem)}`);
+        }
+    }
+    if (err.requestId)
+        lines.push(color.dim(`  request id: ${err.requestId}`));
+    if (err.remediation)
+        lines.push(`  ${err.remediation}`);
+    return lines.join('\n');
+}

package/dist/hooks/chat-message-hint.js

@@ -0,0 +1,21 @@
+/**
+ * `chat` is both a command and a topic (`chat retry`), so oclif resolves
+ * `chatbase chat "hello"` by looking for a subcommand named "hello" and
+ * lands in command_not_found. Without this hook, plugin-not-found prints
+ * a baffling `"chat hello" is not a chatbase command` — catch that one
+ * miss and point at the real input forms instead.
+ */
+const hook = async function (opts) {
+    // oclif joins the attempted command with its internal ':' separator —
+    // `chatbase chat "what are your hours?"` arrives as
+    // { id: 'chat:what are your hours?', argv: [] }.
+    const argv = opts.argv ?? [];
+    const parts = [...(opts.id ?? '').split(':'), ...argv].filter(Boolean);
+    if (parts[0] !== 'chat' || parts.length < 2)
+        return;
+    const attempted = parts.slice(1).join(' ');
+    this.error(`chat takes its message via -m, not as an argument:\n` +
+        `  chatbase chat -m ${JSON.stringify(attempted)}\n` +
+        `You can also pipe stdin, or run \`chatbase chat\` alone for the interactive REPL.`, { exit: 2 });
+};
+export default hook;

package/dist/output/color.js

@@ -0,0 +1,30 @@
+export function colorEnabled(stream, noColorFlag = false) {
+    const force = process.env.FORCE_COLOR;
+    if (force && force.length > 0 && force !== '0')
+        return true;
+    if (noColorFlag)
+        return false;
+    const no = process.env.NO_COLOR;
+    if (no && no.length > 0)
+        return false;
+    if (process.env.TERM === 'dumb')
+        return false;
+    return stream.isTTY === true;
+}
+const wrap = (open) => (s) => `\x1b[${open}m${s}\x1b[0m`;
+const identity = (s) => s;
+export function paint(enabled) {
+    if (!enabled)
+        return {
+            red: identity,
+            green: identity,
+            yellow: identity,
+            dim: identity
+        };
+    return {
+        red: wrap('31'),
+        green: wrap('32'),
+        yellow: wrap('33'),
+        dim: wrap('2')
+    };
+}

package/dist/output/mode.js

@@ -0,0 +1,7 @@
+export function selectMode(flags, stream = process.stdout) {
+    if (flags.json)
+        return 'json';
+    if (flags.plain)
+        return 'plain';
+    return stream.isTTY ? 'pretty' : 'plain';
+}

package/dist/output/spinner.js

@@ -0,0 +1,37 @@
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const CLEAR_LINE = '\r\x1b[2K';
+/**
+ * Transient stderr spinner for operations with dead air (file uploads,
+ * non-streaming chat). Returns a stop() that erases the line. No-op when
+ * stderr isn't a TTY — CI logs and pipes never see spinner frames.
+ * `delayMs` holds the spinner back so sub-second operations never flicker.
+ */
+/** Convenience for the common `<suppress> ? noop : startSpinner(...)`
+ * guard — --quiet (and streaming, where tokens are their own feedback)
+ * suppress the spinner entirely. */
+export function maybeSpinner(suppress, text, delayMs = 0) {
+    return suppress ? () => { } : startSpinner(text, delayMs);
+}
+export function startSpinner(text, delayMs = 0) {
+    if (!process.stderr.isTTY)
+        return () => { };
+    let i = 0;
+    let timer;
+    const delay = setTimeout(() => {
+        process.stderr.write(HIDE_CURSOR);
+        timer = setInterval(() => {
+            process.stderr.write(`\r${FRAMES[i++ % FRAMES.length]} ${text}`);
+        }, 80);
+        timer.unref();
+    }, delayMs);
+    delay.unref();
+    return () => {
+        clearTimeout(delay);
+        if (timer) {
+            clearInterval(timer);
+            process.stderr.write(CLEAR_LINE + SHOW_CURSOR);
+        }
+    };
+}

package/dist/repl/chat-repl.js

@@ -0,0 +1,129 @@
+import readline from 'node:readline';
+const GREETING = 'Type /exit or press Ctrl-D to quit. Ctrl-C cancels a response. /help for commands.';
+const HELP_LINES = [
+    '/exit    Quit the REPL (same as Ctrl-D)',
+    '/new     Start a fresh conversation (clears the current conversation id)',
+    '/retry   Regenerate the last response (replaces it in the conversation)',
+    '/id      Print the current conversation id',
+    '/help    Show this list'
+];
+/** True for the AbortError a cancelled `send`/`retry` call rejects with —
+ * matches the same duck-typed check `classifyError` uses in base-command.ts. */
+function isAbortError(err) {
+    return err?.name === 'AbortError';
+}
+/**
+ * Runs the interactive chat REPL. Dependency-injected (send/retry/input/
+ * output/info) so tests can drive it with fake streams and fake network
+ * calls — the `chat` command wires real stdin/stdout and `sendChat`.
+ *
+ * Ctrl-C semantics: readline is created with `terminal: true` so it parses
+ * Ctrl-C (byte 0x03) itself and emits its own 'SIGINT' event, distinct from
+ * the process-wide SIGINT the rest of the CLI listens for (see
+ * client/signals.ts) — forcing `terminal: true` is what makes this
+ * intercept work even over the plain PassThrough streams used in tests,
+ * not just a real TTY. While a `send`/`retry` call is in flight, that event
+ * aborts *that call's own* AbortController only; at an idle prompt (nothing
+ * in flight) it exits the REPL, same as /exit.
+ */
+export async function runChatRepl(deps) {
+    const { send, retry, input, output, info } = deps;
+    let conversationId = deps.initialConversationId;
+    let currentController;
+    const rl = readline.createInterface({
+        input,
+        output,
+        terminal: true,
+        prompt: '> '
+    });
+    rl.on('SIGINT', () => {
+        if (currentController) {
+            currentController.abort();
+            return;
+        }
+        rl.close();
+    });
+    // Readline closes the moment its input ends (Ctrl-D, or a piped stream
+    // finishing), but the `for await` loop below may still be draining lines
+    // readline buffered before that. prompt() on a closed interface is a
+    // silent no-op on Node 20/22 but throws ERR_USE_AFTER_CLOSE on Node 24+,
+    // so every prompt goes through this close-aware wrapper.
+    let closed = false;
+    rl.once('close', () => {
+        closed = true;
+    });
+    const prompt = () => {
+        if (!closed)
+            rl.prompt();
+    };
+    /** Runs `fn` under a fresh per-call AbortController wired to the
+     * readline-level Ctrl-C above. Swallows the resulting AbortError (and
+     * any other failure) so one bad turn never crashes the whole REPL —
+     * it prints a note via `info` and returns to the prompt either way. */
+    async function cancelable(fn) {
+        const controller = new AbortController();
+        currentController = controller;
+        try {
+            return await fn(controller.signal);
+        }
+        catch (err) {
+            // A cancelled or failed call may have already streamed partial
+            // text straight to `output` with no trailing newline (send/retry
+            // write tokens as they arrive) — start the note on its own line.
+            output.write('\n');
+            if (isAbortError(err)) {
+                info('[cancelled — response was interrupted]');
+            }
+            else {
+                info(`✗ ${err?.message ?? err}`);
+            }
+            return undefined;
+        }
+        finally {
+            currentController = undefined;
+        }
+    }
+    info(GREETING);
+    prompt();
+    for await (const rawLine of rl) {
+        const line = rawLine.trim();
+        if (line === '') {
+            prompt();
+            continue;
+        }
+        if (line.startsWith('/')) {
+            const cmd = line.split(/\s+/, 1)[0];
+            if (cmd === '/exit')
+                break;
+            if (cmd === '/new') {
+                conversationId = undefined;
+            }
+            else if (cmd === '/retry') {
+                if (!conversationId) {
+                    info('No conversation yet — send a message first.');
+                }
+                else {
+                    await cancelable((signal) => retry(conversationId, signal));
+                }
+            }
+            else if (cmd === '/id') {
+                info(conversationId ?? 'none');
+            }
+            else if (cmd === '/help') {
+                for (const helpLine of HELP_LINES)
+                    info(helpLine);
+            }
+            else {
+                info(`Unknown command: ${cmd} — type /help for a list.`);
+            }
+            prompt();
+            continue;
+        }
+        const result = await cancelable((signal) => send(line, conversationId, signal));
+        if (result?.conversationId)
+            conversationId = result.conversationId;
+        prompt();
+    }
+    rl.close();
+    return { conversationId };
+}

package/dist/version.js

@@ -0,0 +1,3 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+export const VERSION = require('../package.json').version;