workoffdesk 0.0.0-stage → 1.0.1

package/dist/server/agents/claude/hooks/hooks.js

@@ -0,0 +1,114 @@
+import { readFileSync, rmSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { writeJsonAtomic } from '../../../system/paths.js';
+import { HOOK_EVENTS } from './status.js';
+const shq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+const hookCommand = (sockPath) => `curl -s -o /dev/null --max-time 2 --unix-socket ${shq(sockPath)} ` +
+    `-H "x-workoffdesk-session: $WORKOFFDESK_SESSION" --data-binary @- http://localhost/hook || true`;
+// How long a permission prompt's hook waits for the phone. The dialog is on the Mac's screen meanwhile.
+const PERMISSION_HOLD_S = 3600;
+// Prints what the server answers, which is the hook's decision; nothing when it cannot be reached.
+const permissionCommand = (sockPath) => `curl -s --max-time ${PERMISSION_HOLD_S} --unix-socket ${shq(sockPath)} ` +
+    `-H "x-workoffdesk-session: $WORKOFFDESK_SESSION" --data-binary @- http://localhost/permission || true`;
+const QUOTED = /^'(?:[^']|'\\'')*'$/;
+const OWN = [hookCommand, permissionCommand].map((make) => make('\0').split(shq('\0')));
+// Whether a hook command is one workoffdesk installs, for a service home anywhere.
+export function isOwnHookCommand(command) {
+    return OWN.some(([head, tail]) => command.startsWith(head) && command.endsWith(tail) && QUOTED.test(command.slice(head.length, command.length - tail.length)));
+}
+const statusPost = (sockPath) => `curl -s -o /dev/null --max-time 2 --unix-socket ${shq(sockPath)} ` +
+    `-H "x-workoffdesk-session: $WORKOFFDESK_SESSION" --data-binary @- http://localhost/status`;
+// The status line the user set for Claude Code themselves, which keeps drawing the terminal's.
+export function userStatusLine(settingsPath) {
+    try {
+        const s = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        const l = s.statusLine;
+        if (l?.type !== 'command' || typeof l.command !== 'string' || !l.command)
+            return undefined;
+        return typeof l.padding === 'number' ? { type: 'command', command: l.command, padding: l.padding } : { type: 'command', command: l.command };
+    }
+    catch {
+        return undefined;
+    }
+}
+// What the status line is given goes to workoffdesk too, and the user's own status line still draws it.
+export function statusLineCommand(sockPath, own) {
+    const post = statusPost(sockPath);
+    if (!own)
+        return `${post} >/dev/null 2>&1 || true`;
+    return `input=$(cat); { printf '%s' "$input" | ${post} >/dev/null 2>&1 & } ; printf '%s' "$input" | { ${own}
+}`;
+}
+export function writeClaudeSettings(path, sockPath, own) {
+    const command = hookCommand(sockPath);
+    const hooks = {
+        ...Object.fromEntries(HOOK_EVENTS.map((event) => [event, [{ hooks: [{ type: 'command', command, timeout: 5 }] }]])),
+        PermissionRequest: [{ hooks: [{ type: 'command', command: permissionCommand(sockPath), timeout: PERMISSION_HOLD_S }] }],
+    };
+    const statusLine = { type: 'command', command: statusLineCommand(sockPath, own?.command) };
+    if (own?.padding !== undefined)
+        statusLine.padding = own.padding;
+    // Agent view moves a conversation out of its window, on quitting or by /background, into a session the
+    // phone cannot follow; what is typed afterwards starts new ones.
+    writeJsonAtomic(path, { hooks, statusLine, disableAgentView: true });
+}
+const MAX_BODY = 1 << 20;
+export async function startHookServer(sockPath, onEvent, onStatus = () => { }, 
+// A permission prompt, held open until `hook` is answered.
+onPermission = (_id, _p, hook) => hook.reply(null)) {
+    const server = createServer((req, res) => {
+        const termId = req.headers['x-workoffdesk-session'];
+        let size = 0;
+        const chunks = [];
+        req.on('data', (c) => {
+            size += c.length;
+            if (size > MAX_BODY)
+                req.destroy();
+            else
+                chunks.push(c);
+        });
+        req.on('end', () => {
+            const held = req.url === '/permission';
+            if (!held)
+                res.end();
+            let payload;
+            try {
+                payload = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            }
+            catch {
+                payload = null;
+            }
+            if (typeof termId !== 'string' || !termId || !payload || typeof payload !== 'object') {
+                if (held)
+                    res.end();
+                return;
+            }
+            if (held) {
+                onPermission(termId, payload, {
+                    reply: (output) => res.writableEnded || res.end(output ? JSON.stringify(output) : ''),
+                    onGone: (cb) => res.on('close', () => res.writableEnded || cb()),
+                });
+            }
+            else if (req.url === '/status')
+                onStatus(termId, payload);
+            else
+                onEvent(termId, payload);
+        });
+    });
+    return listenOwnerOnly(server, sockPath);
+}
+// The umask makes the socket owner-only from the moment it exists.
+export async function listenOwnerOnly(server, sockPath) {
+    rmSync(sockPath, { force: true });
+    const oldMask = process.umask(0o177);
+    try {
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(sockPath, () => resolve());
+        });
+    }
+    finally {
+        process.umask(oldMask);
+    }
+    return server;
+}

package/dist/server/agents/claude/hooks/status.js

@@ -0,0 +1,34 @@
+const TRANSITIONS = {
+    UserPromptSubmit: 'working',
+    PostToolUse: 'working',
+    PostToolUseFailure: 'working',
+    Notification: 'waiting',
+    Stop: 'idle',
+    // A turn ended by an API error, a rate limit or an overload.
+    StopFailure: 'idle',
+};
+// SessionStart says which transcript Claude writes from now on, and that a new one is at its prompt. A compaction's status
+// depends on what came before it, so the machine keeps it. SessionEnd comes on /clear too, while Claude goes on: whether
+// Claude ended is read off its process (machine.ts), which the hook only has looked at sooner.
+export const HOOK_EVENTS = [...Object.keys(TRANSITIONS), 'SessionStart', 'SessionEnd', 'PreCompact', 'PostCompact'];
+// Notifications that wait on the user: a permission prompt (which is also how a question from Claude
+// shows) and an MCP server asking for input. Claude also notifies when idle at its prompt for a minute,
+// which is not a wait; one without a type comes from a version that predates the types.
+const ASKS = new Set(['permission_prompt', 'elicitation_dialog']);
+export function nextStatus(prev, event, notificationType) {
+    if (event === 'Notification' && notificationType !== undefined && !ASKS.has(notificationType))
+        return prev;
+    // Asked something before it started (trust this folder?), it starts once that is answered.
+    if (event === 'SessionStart')
+        return prev === 'starting' || prev === 'waiting' ? 'idle' : prev;
+    return TRANSITIONS[event] ?? prev;
+}
+export function notificationFor(prev, next, title) {
+    if (!next || prev === next)
+        return null;
+    if (next === 'waiting')
+        return { title, event: 'waiting' };
+    if (next === 'idle' && prev === 'working')
+        return { title, event: 'idle' };
+    return null;
+}

package/dist/server/agents/claude/hooks/tracker.js

@@ -0,0 +1,79 @@
+import { askedOf, leftToScreen } from './asks.js';
+import { heldInTranscript, lastTurn, transcriptTail } from '../transcript/turn.js';
+import { nextStatus, notificationFor } from './status.js';
+import { shownTitle } from '../../../system/store.js';
+// How long a turn that ended with a message still in Claude's own queue waits for Claude to start the turn
+// that message makes, before it is taken as over after all.
+export const HELD_WAIT_MS = 5000;
+// Hook events after which no permission prompt of the session is still open, and those that say its tool ran.
+const ASKS_OVER = new Set(['UserPromptSubmit', 'Stop', 'StopFailure', 'SessionEnd']);
+const TOOL_DONE = new Set(['PostToolUse', 'PostToolUseFailure']);
+function mover(machine, notifier) {
+    return (termId, event, type, said = '') => {
+        const meta = machine.sessionMeta(termId);
+        if (!meta)
+            return;
+        const prev = machine.getStatus(termId);
+        const next = nextStatus(prev, event, type);
+        if (!next || next === prev)
+            return;
+        machine.setStatus(termId, next);
+        const n = notificationFor(prev, next, shownTitle(meta));
+        if (n)
+            void notifier.notify(termId, n.title, n.event, said).catch(() => { });
+    };
+}
+// A permission prompt is a wait from the moment its hook comes, seconds before Claude Code's notification,
+// which says only that one is open.
+export function createPermissionHandler(machine, notifier) {
+    const move = mover(machine, notifier);
+    return (termId, payload, hook) => {
+        if (machine.holdPermission(termId, payload, hook) || leftToScreen(payload))
+            move(termId, 'Notification', 'permission_prompt', askedOf(payload));
+    };
+}
+// What a hook's event was about, in Claude's words: the reply a turn ended with, or what an MCP server asks.
+// Claude Code's own notification of a prompt names no more than that one is open.
+function saidIn(payload, event) {
+    const said = event === 'Notification' ? (payload.notification_type === 'elicitation_dialog' ? payload.message : '') : payload.last_assistant_message;
+    return typeof said === 'string' ? said : '';
+}
+export function createHookHandler(machine, notifier) {
+    const held = new Map();
+    const move = mover(machine, notifier);
+    return (termId, payload) => {
+        if (!machine.sessionMeta(termId))
+            return;
+        if (typeof payload.session_id === 'string')
+            machine.setClaudeSessionId(termId, payload.session_id);
+        void machine.ingest(termId);
+        const event = String(payload.hook_event_name ?? '');
+        if (TOOL_DONE.has(event))
+            machine.asks.toolDone(termId, payload.tool_name, payload.tool_input);
+        if (ASKS_OVER.has(event))
+            machine.asks.endAll(termId);
+        clearTimeout(held.get(termId));
+        held.delete(termId);
+        if (event === 'SessionEnd')
+            return machine.claudeMayHaveQuit(termId);
+        if (event === 'PreCompact')
+            return machine.compactStarted(termId);
+        if (event === 'PostCompact')
+            return machine.compactEnded(termId, payload.trigger === 'manual');
+        // Claude goes on at once with what was typed into its own queue while it worked (a message sent now,
+        // out of its turn), however the turn ended: it is not over, and what waits here waits for the next.
+        const ended = event === 'Stop' || event === 'StopFailure';
+        if (ended && typeof payload.transcript_path === 'string' && heldInTranscript(payload.transcript_path).length > 0) {
+            held.set(termId, setTimeout(() => {
+                held.delete(termId);
+                // Started with no hook to say so: the next Stop ends it.
+                const lines = transcriptTail(payload.transcript_path);
+                if (lines && lastTurn(lines)?.over === false)
+                    return;
+                move(termId, event, undefined, saidIn(payload, event));
+            }, HELD_WAIT_MS));
+            return;
+        }
+        move(termId, event, typeof payload.notification_type === 'string' ? payload.notification_type : undefined, saidIn(payload, event));
+    };
+}

package/dist/server/agents/claude/offers/commands.js

@@ -0,0 +1,219 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { initialized } from './initialize.js';
+// Claude Code's own commands live in its binary, not in files, so these are written down here, for when
+// Claude Code cannot be asked for its list (initialize.ts).
+const BUILTIN = [
+    ['agents', 'Manage subagents'],
+    ['clear', 'Clear the conversation and start over'],
+    ['compact', 'Compact the conversation to free up context'],
+    ['config', 'Open settings'],
+    ['context', 'Show how much context is used'],
+    ['cost', 'Show what this session has cost'],
+    ['doctor', 'Check the Claude Code installation'],
+    ['export', 'Export the conversation'],
+    ['help', 'Help'],
+    ['hooks', 'Manage hooks'],
+    ['init', 'Write a CLAUDE.md for the project'],
+    ['mcp', 'Manage MCP servers'],
+    ['memory', 'Edit memory files'],
+    ['model', 'Switch the model'],
+    ['permissions', 'Manage permissions'],
+    ['plugin', 'Manage plugins'],
+    ['resume', 'Resume an earlier conversation'],
+    ['review', 'Review a pull request'],
+    ['rewind', 'Go back to an earlier point'],
+    ['status', 'Show version, account and connections'],
+    ['todos', 'Show the todo list'],
+    ['usage', 'Show how much of the plan is used'],
+];
+const DESCRIPTION_MAX = 120;
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+async function readJson(path) {
+    const text = await readText(path);
+    if (text === null)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+async function entries(dir) {
+    try {
+        return (await readdir(dir, { withFileTypes: true })).filter((e) => !e.name.startsWith('.'));
+    }
+    catch {
+        return [];
+    }
+}
+const unquote = (v) => (/^(["']).*\1$/.test(v) ? v.slice(1, -1) : v);
+// The simple keys of a markdown file's front matter, and the text after it. A value of `>` or `|` runs
+// on over the indented lines below it.
+function frontMatter(text) {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    if (!m)
+        return { fields: {}, body: text };
+    const fields = {};
+    const lines = m[1].split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const kv = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(lines[i]);
+        if (!kv)
+            continue;
+        let value = kv[2].trim();
+        if (value === '' || /^[>|][+-]?$/.test(value)) {
+            const more = [];
+            while (i + 1 < lines.length && /^\s+\S/.test(lines[i + 1]))
+                more.push(lines[++i].trim());
+            value = more.join(' ');
+        }
+        fields[kv[1]] = unquote(value);
+    }
+    return { fields, body: text.slice(m[0].length) };
+}
+function oneLine(text) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length <= DESCRIPTION_MAX ? flat : `${flat.slice(0, DESCRIPTION_MAX - 1).trimEnd()}…`;
+}
+const firstLine = (body) => body.split(/\r?\n/).map((l) => l.replace(/^#+\s*/, '').trim()).find((l) => l) ?? '';
+function describe(text, fallbackName) {
+    const { fields, body } = frontMatter(text);
+    const lines = body.split(/\r?\n/).filter((l) => l.trim() && !l.trim().startsWith('#'));
+    return {
+        name: fields.name || fallbackName,
+        description: oneLine(fields.description || lines[0] || firstLine(body)),
+        hidden: fields['user-invocable'] === 'false',
+    };
+}
+// <dir>/<folder>/SKILL.md, named by its front matter, else by its folder.
+async function skillsIn(dir) {
+    const found = [];
+    for (const e of await entries(dir)) {
+        if (!e.isDirectory() && !e.isSymbolicLink())
+            continue;
+        const text = await readText(join(dir, e.name, 'SKILL.md'));
+        if (text === null)
+            continue;
+        const s = describe(text, e.name);
+        if (!s.hidden)
+            found.push({ name: s.name, description: s.description });
+    }
+    return found;
+}
+// <dir>/**/<name>.md, a folder becoming `folder:` in front of the name.
+async function commandsIn(dir, prefix = '') {
+    const found = [];
+    for (const e of await entries(dir)) {
+        const path = join(dir, e.name);
+        if (e.isDirectory())
+            found.push(...(await commandsIn(path, `${prefix}${e.name}:`)));
+        else if (e.name.endsWith('.md')) {
+            const text = await readText(path);
+            if (text !== null)
+                found.push({ name: prefix + e.name.slice(0, -3), description: describe(text, '').description });
+        }
+    }
+    return found;
+}
+const both = async (root) => [...(await skillsIn(join(root, 'skills'))), ...(await commandsIn(join(root, 'commands')))];
+const record = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+// The plugins switched on for a session in `cwd`: the user's settings, then the project's, then its local ones.
+async function enabledPlugins(claudeDir, cwd) {
+    const on = new Map();
+    for (const path of [join(claudeDir, 'settings.json'), join(cwd, '.claude', 'settings.json'), join(cwd, '.claude', 'settings.local.json')]) {
+        for (const [key, value] of Object.entries(record(record(await readJson(path)).enabledPlugins)))
+            on.set(key, value === true);
+    }
+    return new Set([...on].filter(([, v]) => v).map(([k]) => k));
+}
+async function pluginCommands(claudeDir, cwd) {
+    const enabled = await enabledPlugins(claudeDir, cwd);
+    const installed = record(record(await readJson(join(claudeDir, 'plugins', 'installed_plugins.json'))).plugins);
+    const found = [];
+    for (const [key, installs] of Object.entries(installed)) {
+        if (!enabled.has(key) || !Array.isArray(installs))
+            continue;
+        const install = installs.map(record).find((i) => i.scope === 'user' || i.projectPath === cwd);
+        if (typeof install?.installPath !== 'string')
+            continue;
+        const plugin = key.split('@')[0];
+        for (const c of await both(install.installPath))
+            found.push({ ...c, name: `${plugin}:${c.name}` });
+    }
+    return found;
+}
+// Commands Claude Code takes only in its terminal, which it leaves out of the list it gives a program.
+const TERMINAL_ONLY = [
+    ['add-dir', 'Add a new working directory'],
+    ['btw', 'Ask a quick side question without interrupting the main conversation'],
+    ['export', 'Export the current conversation to a file or clipboard'],
+    ['help', 'Show help and available commands'],
+    ['hooks', 'Manage hooks'],
+    ['memory', 'Edit CLAUDE.md files and memory settings'],
+    ['permissions', 'Manage permissions'],
+    ['plugin', 'Manage plugins'],
+    ['resume', 'Resume a previous conversation'],
+    ['rewind', 'Restore the code and/or conversation to a previous point'],
+    ['status', 'Show Claude Code status including version, model, account, API connectivity, and tool statuses'],
+    ['tasks', 'View and manage everything running in the background'],
+];
+// Claude Code says where a command of the user's or the project's comes from after its description, and a
+// plugin's before it.
+function fromTold(c) {
+    // `__` marks one of its own, which its menu does not show.
+    if (typeof c.name !== 'string' || !c.name || c.name.startsWith('__'))
+        return null;
+    const said = typeof c.description === 'string' ? c.description : '';
+    const source = c.builtin === true ? 'builtin' : c.name.includes(':') ? 'plugin' : /\(project\)\s*$/.test(said) ? 'project' : 'user';
+    const unsourced = said.replace(/\s*\((user|project)\)\s*$/, '');
+    const description = source === 'plugin' ? unsourced.replace(/^\([^)]*\)\s*/, '') : unsourced;
+    return { name: c.name, description: oneLine(description), source };
+}
+const byNameOrder = (a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+// What can follow a `/` in a Claude session started in `cwd`: Claude Code's own list when `claudeBin` can be
+// asked for it, else read from the same files Claude Code reads.
+export async function listCommands(o) {
+    if (o.claudeBin && o.cwd) {
+        const told = await initialized(o.claudeBin, o.cwd).catch(() => null);
+        const list = Array.isArray(told?.commands) ? told.commands : null;
+        if (list) {
+            const byName = new Map();
+            for (const c of list.map(fromTold))
+                if (c && !byName.has(c.name))
+                    byName.set(c.name, c);
+            for (const [name, description] of TERMINAL_ONLY)
+                if (!byName.has(name))
+                    byName.set(name, { name, description, source: 'builtin' });
+            return [...byName.values()].sort(byNameOrder);
+        }
+    }
+    return filesListed(o);
+}
+// Read from the same files Claude Code reads. Where two share a name, the earlier source wins: built-in,
+// then the project, the user, a plugin.
+async function filesListed(o) {
+    const [project, user, plugin] = await Promise.all([
+        o.cwd ? both(join(o.cwd, '.claude')) : [],
+        both(o.claudeDir),
+        pluginCommands(o.claudeDir, o.cwd),
+    ]);
+    const byName = new Map();
+    const add = (source, list) => {
+        for (const c of list)
+            if (c.name && !byName.has(c.name))
+                byName.set(c.name, { ...c, source });
+    };
+    add('builtin', BUILTIN.map(([name, description]) => ({ name, description })));
+    add('project', project);
+    add('user', user);
+    add('plugin', plugin);
+    return [...byName.values()].sort(byNameOrder);
+}

package/dist/server/agents/claude/offers/files.js

@@ -0,0 +1,51 @@
+import { execFile } from 'node:child_process';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+// How many paths are offered at most, how deep a folder that is not a git repository is walked, and for how
+// long a listing is reused.
+const MAX_FILES = 5000;
+const MAX_DEPTH = 3;
+const GIT_TIMEOUT_MS = 3000;
+const KEPT_MS = 30_000;
+const SKIPPED = new Set(['node_modules', 'dist', 'build', 'target', 'vendor', '__pycache__']);
+const kept = new Map();
+// The files under cwd an `@` can name, relative to it: what git tracks or would (ignored ones left out);
+// outside a repository, a shallow walk past dot folders and dependency folders.
+export function listFiles(cwd, now = Date.now()) {
+    const hit = kept.get(cwd);
+    if (hit && now - hit.at < KEPT_MS)
+        return hit.files;
+    const files = gitFiles(cwd).catch(() => walk(cwd));
+    kept.set(cwd, { at: now, files });
+    files.catch(() => kept.delete(cwd));
+    return files;
+}
+async function gitFiles(cwd) {
+    const { stdout } = await run('git', ['ls-files', '-co', '--exclude-standard'], { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: 32 * 1024 * 1024 });
+    return stdout.split('\n').filter(Boolean).slice(0, MAX_FILES);
+}
+async function walk(cwd) {
+    const files = [];
+    const visit = async (rel, depth) => {
+        if (files.length >= MAX_FILES)
+            return;
+        const entries = await readdir(join(cwd, rel), { withFileTypes: true }).catch(() => []);
+        for (const e of entries) {
+            if (files.length >= MAX_FILES)
+                return;
+            if (e.name.startsWith('.') || SKIPPED.has(e.name))
+                continue;
+            const path = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+                if (depth < MAX_DEPTH)
+                    await visit(path, depth + 1);
+            }
+            else if (e.isFile())
+                files.push(path);
+        }
+    };
+    await visit('', 1);
+    return files;
+}

package/dist/server/agents/claude/offers/initialize.js

@@ -0,0 +1,59 @@
+import { spawn } from 'node:child_process';
+const ASK_MS = 15_000;
+const KEPT_MS = 5 * 60_000;
+const told = new Map();
+// Claude Code's answer in `cwd`, kept a while: it changes only with its settings, plugins and account.
+export function initialized(bin, cwd) {
+    const key = `${bin}\n${cwd}`;
+    const kept = told.get(key);
+    if (kept && Date.now() - kept.at < KEPT_MS)
+        return kept.answer;
+    const answer = askClaude(bin, cwd);
+    told.set(key, { at: Date.now(), answer });
+    answer.catch(() => told.get(key)?.answer === answer && told.delete(key));
+    return answer;
+}
+// Asked as a program asks it (`-p`, stream-json) before any turn, so nothing goes to the model; without hooks
+// or a transcript, so it leaves no trace.
+function askClaude(bin, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--no-session-persistence', '--settings', JSON.stringify({ disableAllHooks: true })], { cwd, stdio: ['pipe', 'pipe', 'ignore'] });
+        let done = false;
+        const finish = (error, answer = {}) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(answer);
+        };
+        const timer = setTimeout(() => finish(new Error('claude did not answer initialize')), ASK_MS);
+        child.on('error', finish);
+        child.on('exit', () => finish(new Error('claude ended before answering initialize')));
+        let out = '';
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            out += chunk;
+            for (let end = out.indexOf('\n'); end >= 0; end = out.indexOf('\n')) {
+                const line = out.slice(0, end);
+                out = out.slice(end + 1);
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (msg?.type !== 'control_response')
+                    continue;
+                const answer = msg.response?.response;
+                return answer && typeof answer === 'object' ? finish(null, answer) : finish(new Error('claude answered initialize with nothing'));
+            }
+        });
+        child.stdin.on('error', () => { });
+        child.stdin.end(`${JSON.stringify({ type: 'control_request', request_id: 'initialize', request: { subtype: 'initialize' } })}\n`);
+    });
+}

package/dist/server/agents/claude/offers/models.js

@@ -0,0 +1,20 @@
+import { initialized } from './initialize.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+// What /model is given is typed at the prompt: a name, an id, `opus[1m]`, never anything else.
+const VALUE = /^[\w.:[\]-]{1,40}$/;
+// The models Claude Code offers in `cwd`, in its own order; empty when it cannot be asked.
+export async function listModels(bin, cwd) {
+    const told = await initialized(bin, cwd).catch(() => null);
+    if (!Array.isArray(told?.models))
+        return [];
+    return told.models.flatMap((m) => {
+        if (!m || typeof m !== 'object')
+            return [];
+        const r = m;
+        const value = str(r.value);
+        if (!VALUE.test(value))
+            return [];
+        const efforts = r.supportsEffort === true && Array.isArray(r.supportedEffortLevels) ? r.supportedEffortLevels.filter((l) => typeof l === 'string') : [];
+        return [{ value, name: str(r.displayName) || value, about: str(r.description), efforts }];
+    });
+}