@zenera/cli 1.1.16 → 1.1.18

package/dist/meta.js

@@ -0,0 +1,695 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { createWriteStream, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import { invokedAs } from "./args.js";
+import { paths, readJson, writeJson } from "./home.js";
+import { envOf } from "./keys.js";
+import { credentialError, cut, cyan, dim, note, pad, plain, red, styled, usageError, write, yellow, } from "./term.js";
+import { answerWidth, segmentsOf, wrap } from "./tui/wrap.js";
+export const PROMPT_DIR = '.github/prompts';
+const PROMPT_SUFFIX = '.prompt.md';
+// ---------------------------------------------------------------------------
+// The model
+// ---------------------------------------------------------------------------
+/** The variable a project's `.env` names it with — a zen ref, not a wire id. */
+export const MODEL_ENV = 'ZENERA_META_MODEL';
+/** Where the answer is looked for, best first. */
+export const ORDER = [
+    'flag',
+    'shell',
+    'env',
+    'store',
+    'project',
+    'default',
+];
+export function chooseModel(sources) {
+    const at = {
+        flag: sources.flag,
+        // `.env` only fills gaps, so an answer that survived it came from the shell
+        shell: sources.shell,
+        env: sources.shell ? undefined : sources.env,
+        store: sources.stored,
+        project: sources.project,
+        default: sources.fallback,
+    };
+    for (const from of ORDER) {
+        const ref = at[from]?.trim();
+        if (ref) {
+            return { ref, from };
+        }
+    }
+    return undefined;
+}
+export const SOURCE_LABELS = {
+    flag: '--model',
+    shell: `${MODEL_ENV} (shell)`,
+    env: `${MODEL_ENV} (.env)`,
+    store: 'zen meta model',
+    project: 'agents.yaml model:',
+    default: 'recommended',
+};
+// ---------------------------------------------------------------------------
+// What to run when nobody said
+//
+// A first `zen meta` should work on a machine that has a key and nothing else,
+// so the last resort is the best model the keys on hand can buy rather than an
+// error. Deep tier deliberately: this agent is pointed at the project itself,
+// and a cheap model reading a specification is a false economy.
+// ---------------------------------------------------------------------------
+/** First of each row is the default; the rest are what `--pick` offers beside it. */
+export const RECOMMENDED = {
+    openai: ['gpt-5.6-sol', 'gpt-5.6-terra'],
+    anthropic: ['claude-opus-5', 'claude-sonnet-5'],
+    vertex: ['gemini-3.8-flash', 'gemini-3.5-flash-lite'],
+    google: ['gemini-3.8-flash', 'gemini-3.5-flash-lite'],
+    openrouter: ['anthropic/claude-opus-5', 'openai/gpt-5.6-sol'],
+};
+/** Which provider is tried first when several are held. */
+const PREFERENCE = ['anthropic', 'openai', 'vertex', 'google', 'openrouter'];
+/** The recommended ref for the first provider with a key, or for `only`. */
+export function defaultRef(store, only) {
+    for (const provider of only ? [only] : PREFERENCE) {
+        const id = RECOMMENDED[provider]?.[0];
+        if (id && store.active(provider)) {
+            return `${provider}/${id}`;
+        }
+    }
+    return undefined;
+}
+const EMPTY = { version: 1 };
+export const readMeta = () => readJson(paths.meta(), EMPTY);
+export function writeMeta(file) {
+    writeJson(paths.meta(), file);
+}
+// ---------------------------------------------------------------------------
+// Refs
+// ---------------------------------------------------------------------------
+const PROVIDER_NAMES = new Set(['openai', 'anthropic', 'google', 'vertex', 'openrouter']);
+/**
+ * `vertex/gemini-3.8-flash` splits; `gpt-5.6-sol` does not. Only a known provider
+ * counts as a prefix, because `google/gemini-3.8-flash` is also a perfectly good
+ * bare id on an endpoint that speaks publisher names.
+ *
+ * The colon form is the library's own — `openai:gpt-5.6-sol`, and with an api
+ * selector `openai/responses:gpt-5.6-sol` — which is what arrives when the ref
+ * came from `agents.yaml`.
+ */
+export function splitRef(ref) {
+    const colon = ref.indexOf(':');
+    if (colon > 0) {
+        const head = ref.slice(0, colon).split('/')[0];
+        if (PROVIDER_NAMES.has(head)) {
+            return { provider: head, id: ref.slice(colon + 1) };
+        }
+    }
+    const slash = ref.indexOf('/');
+    if (slash < 0) {
+        return { id: ref };
+    }
+    const head = ref.slice(0, slash);
+    return PROVIDER_NAMES.has(head)
+        ? { provider: head, id: ref.slice(slash + 1) }
+        : { id: ref };
+}
+/**
+ * The provider a misspelt prefix was reaching for, if that is what it is.
+ *
+ * `vertes/gemini-3.8-flash` is shaped exactly like the OpenRouter id
+ * `meta-llama/llama-4`, so an unknown prefix cannot be an error on its own —
+ * only one close enough to a real provider name to be a slip of the hand.
+ */
+export function misspelledProvider(ref) {
+    const slash = ref.indexOf('/');
+    if (slash <= 0) {
+        return undefined;
+    }
+    const head = ref.slice(0, slash).toLowerCase();
+    if (PROVIDER_NAMES.has(head)) {
+        return undefined;
+    }
+    for (const name of PROVIDER_NAMES) {
+        // Two, so that a transposition — which Levenshtein counts twice — reads
+        // as the typo it is. No provider name is short enough for that to be loose.
+        if (distance(head, name) <= 2) {
+            return name;
+        }
+    }
+    return undefined;
+}
+/** Levenshtein, one row at a time. Both operands are a word long. */
+function distance(a, b) {
+    if (Math.abs(a.length - b.length) > 2) {
+        return 3;
+    }
+    let row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const next = [i];
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            next[j] = Math.min(next[j - 1] + 1, row[j] + 1, row[j - 1] + cost);
+        }
+        row = next;
+    }
+    return row[b.length];
+}
+// ---------------------------------------------------------------------------
+// Wiring
+// ---------------------------------------------------------------------------
+const TYPES = {
+    openai: 'openai',
+    anthropic: 'anthropic',
+    google: 'openai',
+    vertex: 'openai',
+    openrouter: 'openai',
+};
+const BASE_URLS = {
+    openai: 'https://api.openai.com/v1',
+    anthropic: 'https://api.anthropic.com',
+    google: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+    openrouter: 'https://openrouter.ai/api/v1',
+};
+/**
+ * Copilot offers its tools as OpenAI *custom* tools, which the completions API
+ * rejects outright — `400 Invalid value: 'custom'`. Only the responses API
+ * takes them, and only the reasoning models serve it, so the wire API follows
+ * the model rather than being a flag nobody would know to set.
+ */
+export function wireApi(provider, id) {
+    return provider === 'openai' && /^(gpt-5|o[34])/.test(id) ? 'responses' : undefined;
+}
+/**
+ * Turns a zen key entry and a model id into copilot's environment.
+ *
+ * `COPILOT_PROVIDER_BASE_URL` is what activates BYOK at all, so every provider
+ * gets one — including OpenAI, whose url copilot would otherwise have reached
+ * through a GitHub account we are deliberately not using.
+ */
+export function wire(store, entry, id) {
+    const provider = entry.provider;
+    const env = {};
+    const secret = [];
+    const warnings = [];
+    env.COPILOT_PROVIDER_TYPE = TYPES[provider];
+    env.COPILOT_MODEL = id;
+    if (provider === 'vertex') {
+        const project = store.projectOf(entry)?.id;
+        if (!project) {
+            throw credentialError(`no GCP project on ${entry.provider}/${entry.name}`, 'set one: zen key add vertex --project <id>');
+        }
+        const location = entry.location?.trim() || 'global';
+        if (location === 'global') {
+            warnings.push('location `global` adds about ten seconds of cold start');
+        }
+        env.COPILOT_PROVIDER_BASE_URL = `https://aiplatform.googleapis.com/v1/projects/${project}/locations/${location}/endpoints/openapi`;
+        // Vertex speaks publisher names on the wire and knows nothing of zen's
+        // provider prefix; the bare id stays as the model *id* so copilot can
+        // still match its catalogue for token limits and tool support.
+        env.COPILOT_PROVIDER_WIRE_MODEL = id.includes('/') ? id : `google/${id}`;
+        env.COPILOT_PROVIDER_MODEL_ID = id.includes('/') ? id.slice(id.indexOf('/') + 1) : id;
+    }
+    else {
+        const url = BASE_URLS[provider];
+        if (!url) {
+            throw credentialError(`no BYOK endpoint known for ${provider}`);
+        }
+        env.COPILOT_PROVIDER_BASE_URL = url;
+    }
+    const api = wireApi(provider, id);
+    if (api) {
+        env.COPILOT_PROVIDER_WIRE_API = api;
+    }
+    if (entry.holds === 'file') {
+        // A Google access token is good for an hour and a session is not, so
+        // copilot is told how to mint one rather than handed one that will be
+        // stale by the time it matters.
+        env.COPILOT_PROVIDER_API_KEY_COMMAND = `${invokedAs('zen')} key token ${entry.provider}`;
+        env[envOf(entry)] = store.fileOf(entry);
+    }
+    else {
+        env.COPILOT_PROVIDER_API_KEY = store.reveal(entry);
+        secret.push('COPILOT_PROVIDER_API_KEY');
+    }
+    return { provider, model: env.COPILOT_PROVIDER_WIRE_MODEL ?? id, env, secret, warnings };
+}
+/** Values a `--dry-run` may print. A key is four characters and an apology. */
+export function masked(env, secret) {
+    return Object.entries(env)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, value]) => `${name}=${secret.includes(name) ? '••••' : value}`);
+}
+// ---------------------------------------------------------------------------
+// Stored prompts
+//
+// Copilot reads `AGENTS.md`, `.github/skills/` and `.github/agents/`, but it
+// has no notion of `.github/prompts/*.prompt.md` — the files an editor offers
+// as slash commands. Reading one and handing over its body is the whole of
+// `zen meta run`, and it is why that subcommand exists.
+// ---------------------------------------------------------------------------
+/** `/project-review`, `project-review`, `project-review.prompt.md` or a path. */
+export function promptPath(dir, name) {
+    const bare = name.replace(/^\//, '');
+    if (bare.includes('/') || bare.endsWith('.md')) {
+        return `${dir}/${bare}`;
+    }
+    return `${dir}/${PROMPT_DIR}/${bare}${PROMPT_SUFFIX}`;
+}
+/**
+ * Frontmatter is the editor's business — `mode`, `tools`, `description` — and
+ * none of it means anything to copilot, so only the body is sent. `description`
+ * is kept for the one line of narration that says which prompt is running.
+ */
+export function readPrompt(path, name, text) {
+    let body = text;
+    let description;
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    if (match) {
+        body = text.slice(match[0].length);
+        const found = /^description:\s*(.+)$/m.exec(match[1]);
+        description = found?.[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+    return { name, path, description, body: body.trim() };
+}
+export async function loadPrompt(dir, name) {
+    const path = promptPath(dir, name);
+    if (!existsSync(path)) {
+        const known = await listPrompts(dir);
+        throw usageError(`no prompt named ${name.replace(/^\//, '')}`, known.length > 0
+            ? `try: ${known.map((p) => `/${p}`).join(', ')}`
+            : `put one in ${PROMPT_DIR}/`);
+    }
+    return readPrompt(path, name.replace(/^\//, ''), await readFile(path, 'utf8'));
+}
+export async function listPrompts(dir) {
+    const { readdir } = await import('node:fs/promises');
+    try {
+        const names = await readdir(`${dir}/${PROMPT_DIR}`);
+        return names
+            .filter((n) => n.endsWith(PROMPT_SUFFIX))
+            .map((n) => n.slice(0, -PROMPT_SUFFIX.length))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * A `copilot` already installed is used as it is; otherwise `npx` fetches one.
+ * Note that finding the name on `PATH` is not the same as finding the CLI —
+ * an editor may have put a shim there that installs it on first run — so this
+ * only decides how to launch, never whether it will work.
+ */
+export function locate(has = (cmd) => onPath(cmd)) {
+    return has('copilot')
+        ? { command: 'copilot', args: [], from: 'path' }
+        : { command: 'npx', args: ['--yes', '@github/copilot'], from: 'npx' };
+}
+function onPath(cmd) {
+    const dirs = (process.env.PATH ?? '').split(':').filter(Boolean);
+    return dirs.some((d) => existsSync(`${d}/${cmd}`));
+}
+export const terminalSink = {
+    answer: (text) => write(text),
+    narrate: (line) => note(line),
+    warn: (line) => note(red(line)),
+};
+/** Rows of narration the window keeps on screen. */
+export const WINDOW_ROWS = 8;
+const BOX = { tl: '╭', tr: '╮', bl: '╰', br: '╯', h: '─', v: '│' };
+/** How often the border is redrawn — the wave's frame, not the clock's. */
+export const FRAME_MS = 80;
+// Dimmest first, crest last. Written as escapes rather than `styleText` because
+// a named colour has no ramp, which is also why `styled()` has to be asked.
+const WAVE = [
+    '\u001b[0;38;5;24m',
+    '\u001b[0;38;5;31m',
+    '\u001b[0;38;5;38m',
+    '\u001b[0;38;5;45m',
+    '\u001b[0;38;5;51m',
+    '\u001b[1;38;5;159m',
+    '\u001b[1;38;5;231m',
+];
+const RESET = '\u001b[0m';
+/** Cells each tone of the tail covers, so the crest reads as a band, not a dot. */
+const WAVE_TAIL = 2;
+/** Cells the crest travels per frame — a lap of a wide window in a few seconds. */
+export const WAVE_STEP = 3;
+/**
+ * How brightly one cell of the border is lit, given where the crest has got to.
+ *
+ * `position` counts clockwise from the top left corner, so one index walks the
+ * whole ring and the wave rounds the corners without a seam. Everything the
+ * tail has passed sits at the dimmest tone, which is the border's resting
+ * colour: the ring is always drawn, only the crest moves.
+ */
+export function toneAt(position, head, span) {
+    const behind = (((head - position) % span) + span) % span;
+    const step = Math.floor(behind / WAVE_TAIL);
+    return step < WAVE.length ? WAVE.length - 1 - step : 0;
+}
+/**
+ * A run of border cells, coloured by the wave and emitting an escape only where
+ * the tone changes — a frame of the whole ring is a handful of them.
+ *
+ * `from` is the ring position of the first cell and `step` which way round the
+ * ring the cells run, because the bottom rule is printed left to right while
+ * the ring travels it right to left.
+ */
+function lit(cells, from, step, head, span) {
+    let out = '';
+    let tone = -1;
+    for (let i = 0; i < cells.length; i++) {
+        const next = toneAt(from + i * step, head, span);
+        if (next !== tone) {
+            out += WAVE[next];
+            tone = next;
+        }
+        out += cells[i];
+    }
+    return `${out}${RESET}`;
+}
+/**
+ * The bottom rule as cells, with the status label set into it near the left.
+ *
+ * Waiting belongs to the frame rather than to the narration: a row of its own
+ * costs a step of what the agent is doing every time, and it settles just
+ * under the last line, which is where the eye already is. Near the left, where
+ * reading starts, and not so near that it displaces the corner.
+ */
+export function footerCells(label, width) {
+    const room = width - 6;
+    const text = label && room > 0 ? [...label].slice(0, room) : [];
+    const cells = text.length > 0 ? [BOX.bl, BOX.h, ' ', ...text, ' '] : [BOX.bl];
+    while (cells.length < width - 1) {
+        cells.push(BOX.h);
+    }
+    return [...cells, BOX.br];
+}
+/**
+ * Narration held to a fixed number of rows that rewrite themselves in place.
+ *
+ * A long run is hundreds of tool calls, and printing each as its own line
+ * scrolls the question, the model line and every warning off the top of the
+ * screen — by the end the terminal holds a transcript nobody asked for and the
+ * answer is somewhere in the middle of it. Only the last few steps say what it
+ * is doing now, which is the only thing narration is for; the rest is in the
+ * session copilot recorded.
+ *
+ * Warnings are not narration: they leave the window and stay on the screen.
+ *
+ * Without a terminal there is nothing to rewrite over, so every line is its
+ * own — which is what a CI log wants anyway.
+ */
+export function windowSink(rows = WINDOW_ROWS) {
+    if (!process.stderr.isTTY) {
+        return terminalSink;
+    }
+    const kept = [];
+    const colour = styled();
+    let label = '';
+    let head = 0;
+    let painted = 0;
+    // The frame must stay under the viewport: a block taller than the screen
+    // scrolls its own top away, and then the cursor-up erase falls short and
+    // strands a copy of every repaint. The two border rows count towards it.
+    const height = () => Math.max(1, Math.min(rows, (process.stderr.rows ?? 24) - 4));
+    const columns = () => Math.max(20, (process.stderr.columns ?? 80) - 1);
+    const innerOf = () => columns() - 4;
+    const erase = () => {
+        if (painted > 0) {
+            process.stderr.write(`\u001b[${painted}A\u001b[0J`);
+            painted = 0;
+        }
+    };
+    /** The whole frame, border lit by the wave, every row exactly one row. */
+    const frameOf = (show, inner) => {
+        const width = inner + 4;
+        // Clockwise from the top left: across the top, down the right, back
+        // along the bottom, up the left. One ring, so one index addresses it.
+        const span = 2 * width + 2 * show.length;
+        const top = [BOX.tl, ...Array(width - 2).fill(BOX.h), BOX.tr];
+        const bottom = footerCells(label, width);
+        const edge = (position) => colour ? lit([BOX.v], position, 1, head, span) : cyan(BOX.v);
+        return [
+            colour ? lit(top, 0, 1, head, span) : cyan(top.join('')),
+            ...show.map((line, r) => `${edge(span - 1 - r)} ${pad(cut(line, inner), inner)} ${edge(width + r)}`),
+            colour
+                ? lit(bottom, 2 * width + show.length - 1, -1, head, span)
+                : cyan(bottom.join('')),
+        ];
+    };
+    const paint = () => {
+        const show = kept.slice(-height());
+        if (show.length === 0 && label === '') {
+            erase();
+            return;
+        }
+        // The wave wants a frame to run round before there is anything to say.
+        const lines = frameOf(show.length > 0 ? show : [''], innerOf());
+        if (painted === lines.length) {
+            // Erasing before a repaint is what flickers; overwriting in place
+            // does not, and at frame rate the whole border has to be redrawn.
+            process.stderr.write(`\u001b[${painted}A${lines.map((l) => `\r${l}\u001b[0K\n`).join('')}`);
+            return;
+        }
+        erase();
+        process.stderr.write(lines.map((l) => `${l}\n`).join(''));
+        painted = lines.length;
+    };
+    return {
+        answer: (text) => {
+            erase();
+            write(text);
+        },
+        narrate: (line) => {
+            kept.push(...line.split('\n'));
+            if (kept.length > height() * 4) {
+                kept.splice(0, kept.length - height());
+            }
+            paint();
+        },
+        warn: (line) => {
+            erase();
+            note(red(line));
+            paint();
+        },
+        status: (line) => {
+            label = line;
+            head += WAVE_STEP;
+            paint();
+        },
+        close: erase,
+    };
+}
+/**
+ * The answer in the same box `zen run` draws it in: bounded width, rounded
+ * rule, fenced blocks kept as they were written.
+ *
+ * Redirected output gets the text and nothing else — `zen meta run ... > out.md`
+ * is meant to produce a file you can read, not one with a border down its side.
+ */
+export function answerBox(text, columns = process.stdout.columns ?? 80) {
+    if (!process.stdout.isTTY) {
+        return text.split('\n');
+    }
+    const outer = answerWidth(columns);
+    const inner = outer - 4;
+    const body = [];
+    for (const segment of segmentsOf(text)) {
+        if (segment.code) {
+            // Indentation is the meaning of a fenced block, so it is cut rather
+            // than reflowed.
+            body.push(dim(`\u250c\u2500${segment.title ? ` ${segment.title}` : ''}`));
+            body.push(...segment.lines.map((l) => `${dim('\u2502')} ${cut(l, inner - 2)}`));
+            body.push(dim('\u2514\u2500'));
+        }
+        else {
+            body.push(...wrap(segment.lines.join('\n'), inner));
+        }
+    }
+    const rule = BOX.h.repeat(outer - 2);
+    return [
+        '',
+        dim(`${BOX.tl}${rule}${BOX.tr}`),
+        ...body.map((l) => `${dim(BOX.v)} ${pad(l, inner)} ${dim(BOX.v)}`),
+        dim(`${BOX.bl}${rule}${BOX.br}`),
+        '',
+    ];
+}
+/** `<project>/.tmp/logs/meta.<when>.log`, opened for append. */
+export function openLog(dir, now = new Date()) {
+    const two = (n) => String(n).padStart(2, '0');
+    const stamp = `${now.getFullYear()}${two(now.getMonth() + 1)}${two(now.getDate())}` +
+        `${two(now.getHours())}${two(now.getMinutes())}${two(now.getSeconds())}`;
+    const folder = `${dir}/.tmp/logs`;
+    mkdirSync(folder, { recursive: true });
+    const path = `${folder}/meta.${stamp}.log`;
+    const answerPath = `${folder}/meta.${stamp}.md`;
+    const file = createWriteStream(path, { flags: 'a' });
+    return {
+        path,
+        answerPath,
+        line: (text) => {
+            file.write(`${plain(text)}\n`);
+        },
+        saveAnswer: (text) => {
+            writeFileSync(answerPath, text.endsWith('\n') ? text : `${text}\n`);
+        },
+        close: () => {
+            file.end();
+        },
+    };
+}
+/** Everything the sink is told, kept by the log too — and the detail only there. */
+function tee(sink, log) {
+    return {
+        answer: (text) => sink.answer(text),
+        narrate: (line) => {
+            log.line(line);
+            sink.narrate(line);
+        },
+        detail: (line) => log.line(line),
+        warn: (line) => {
+            log.line(line);
+            sink.warn(line);
+        },
+        status: (line) => sink.status?.(line),
+        close: () => sink.close?.(),
+    };
+}
+/**
+ * Folds one event into the outcome and says what, if anything, to show for it.
+ *
+ * `assistant.message` carries both the running commentary and the final word;
+ * what separates them is `toolRequests`, so the last message that asked for no
+ * tool is the answer and the rest are narration.
+ */
+export function absorb(event, out, sink, width) {
+    const data = (event.data ?? {});
+    switch (event.type) {
+        case 'assistant.message': {
+            const content = String(data.content ?? '').trim();
+            const requests = Array.isArray(data.toolRequests) ? data.toolRequests : [];
+            if (requests.length === 0) {
+                out.answer = content;
+            }
+            else if (content) {
+                sink.narrate(cut(content.replace(/\s+/g, ' '), width));
+            }
+            break;
+        }
+        case 'tool.execution_start': {
+            const args = (data.arguments ?? {});
+            const what = String(args.command ?? args.description ?? data.toolName ?? '').trim();
+            // Step-by-step belongs in the log: on screen it is a wall of `$`
+            // saying less than the one line of commentary above it.
+            sink.detail?.(`$ ${what.replace(/\s+/g, ' ')}`);
+            break;
+        }
+        case 'tool.execution_complete': {
+            if (data.success === false) {
+                sink.detail?.(`  ${String(data.toolName ?? 'the tool')} failed`);
+            }
+            break;
+        }
+        case 'session.tools_updated': {
+            if (data.model) {
+                sink.detail?.(`model ${String(data.model)}`);
+            }
+            break;
+        }
+        case 'session.error': {
+            sink.warn(String(data.message ?? 'the session failed'));
+            break;
+        }
+        case 'model.call_failure': {
+            const status = data.statusCode ? ` (${String(data.statusCode)})` : '';
+            sink.warn(`${cut(String(data.errorMessage ?? 'the model call failed'), width)}${status}`);
+            break;
+        }
+        case 'result': {
+            out.exitCode = Number(event.exitCode ?? 0);
+            out.sessionId = event.sessionId;
+            out.usage = event.usage;
+            break;
+        }
+        default:
+            break;
+    }
+    out.events.push(event);
+}
+export async function launch(opts) {
+    const shown = opts.sink ?? windowSink();
+    const sink = opts.log ? tee(shown, opts.log) : shown;
+    const width = opts.width ?? Math.max(40, (process.stderr.columns ?? 100) - 4);
+    const start = opts.spawn ?? nodeSpawn;
+    const out = { answer: '', exitCode: 0, events: [] };
+    const child = start(opts.binary.command, [...opts.binary.args, ...opts.args], {
+        cwd: opts.cwd,
+        env: { ...process.env, ...opts.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: false,
+    });
+    const stop = (signal) => () => {
+        child.kill(signal);
+    };
+    const onInt = stop('SIGINT');
+    const onTerm = stop('SIGTERM');
+    process.on('SIGINT', onInt);
+    process.on('SIGTERM', onTerm);
+    // The first model call says nothing for as long as it takes, and silence
+    // after the model line is indistinguishable from a hang.
+    const began = Date.now();
+    const beat = setInterval(() => {
+        const seconds = Math.round((Date.now() - began) / 1000);
+        sink.status?.(`working: ${seconds}s`);
+    }, FRAME_MS);
+    beat.unref();
+    child.stderr?.on('data', (chunk) => {
+        const text = chunk.toString().trimEnd();
+        if (text) {
+            sink.narrate(dim(text));
+        }
+    });
+    try {
+        const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        for await (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                // Not ours to interpret, but losing it is worse than showing it.
+                sink.narrate(line);
+                continue;
+            }
+            absorb(event, out, sink, width);
+        }
+        const code = await new Promise((resolve) => {
+            child.on('close', (value) => resolve(value ?? 0));
+        });
+        if (out.exitCode === 0 && code !== 0) {
+            out.exitCode = code;
+        }
+    }
+    finally {
+        clearInterval(beat);
+        process.off('SIGINT', onInt);
+        process.off('SIGTERM', onTerm);
+        // The answer is written by the caller, so the window has to be gone first.
+        sink.close?.();
+    }
+    return out;
+}
+/** Non-fatal, said once, because a competing file is a silent override. */
+export function providersWarning() {
+    const configured = process.env.COPILOT_PROVIDERS_CONFIG;
+    const path = configured ?? `${process.env.HOME ?? ''}/.copilot/providers.json`;
+    return existsSync(path)
+        ? yellow(`${path} may override the provider zen just wired`)
+        : undefined;
+}
+//# sourceMappingURL=meta.js.map