tokenmaw 0.3.0

package/dist/runtime/agent-store.js

@@ -0,0 +1,152 @@
+import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+const writes = new Map();
+function validSessionId(sessionId) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,119}$/.test(sessionId)) {
+        throw new Error('Invalid session id. Use letters, numbers, dot, underscore, or dash.');
+    }
+}
+async function replaceFile(temp, target) {
+    let lastError;
+    for (let attempt = 0; attempt < 6; attempt += 1) {
+        try {
+            await rename(temp, target);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            const code = error.code;
+            if (!['EPERM', 'EEXIST', 'EACCES'].includes(code ?? ''))
+                throw error;
+            await rm(target, { force: true }).catch(() => undefined);
+            await new Promise((resolveWait) => setTimeout(resolveWait, (attempt + 1) * 5));
+        }
+    }
+    throw lastError;
+}
+export class AgentRuntimeStore {
+    dir;
+    constructor(baseDir = process.env.CODER_DATA_HOME?.trim() || resolve(homedir(), '.coder')) {
+        this.dir = resolve(baseDir, 'runtime');
+    }
+    async init() {
+        await mkdir(this.dir, { recursive: true });
+    }
+    path(sessionId) {
+        validSessionId(sessionId);
+        return resolve(this.dir, `${sessionId}.json`);
+    }
+    async save(snapshot) {
+        const path = this.path(snapshot.session.sessionId);
+        const payload = `${JSON.stringify(snapshot, null, 2)}\n`;
+        const key = path.toLowerCase();
+        const previous = writes.get(key) ?? Promise.resolve();
+        const next = previous.catch(() => undefined).then(async () => {
+            await mkdir(this.dir, { recursive: true });
+            const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+            try {
+                await writeFile(temp, payload, 'utf8');
+                await replaceFile(temp, path);
+            }
+            catch (error) {
+                await rm(temp, { force: true }).catch(() => undefined);
+                throw error;
+            }
+        });
+        writes.set(key, next);
+        try {
+            await next;
+        }
+        finally {
+            if (writes.get(key) === next)
+                writes.delete(key);
+        }
+    }
+    async load(sessionId) {
+        const path = this.path(sessionId);
+        await writes.get(path.toLowerCase())?.catch(() => undefined);
+        try {
+            const parsed = JSON.parse(await readFile(path, 'utf8'));
+            return parsed.version === 1 ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async list() {
+        await Promise.all([...writes.values()].map((write) => write.catch(() => undefined)));
+        let files = [];
+        try {
+            files = await readdir(this.dir);
+        }
+        catch {
+            return [];
+        }
+        const sessions = [];
+        for (const file of files.filter((name) => name.endsWith('.json'))) {
+            try {
+                const parsed = JSON.parse(await readFile(resolve(this.dir, file), 'utf8'));
+                if (parsed.version !== 1)
+                    continue;
+                sessions.push({
+                    sessionId: parsed.session.sessionId,
+                    messages: parsed.session.messages.length,
+                    updatedAt: parsed.session.updatedAt,
+                });
+            }
+            catch { /* skip invalid snapshots */ }
+        }
+        return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    async remove(sessionId) {
+        const path = this.path(sessionId);
+        await writes.get(path.toLowerCase())?.catch(() => undefined);
+        await rm(path, { force: true }).catch(() => undefined);
+        await this.removeArchives(sessionId);
+    }
+    // ── Compaction archives ─────────────────────────────────────────────────────
+    archivesDir(sessionId) {
+        validSessionId(sessionId);
+        return resolve(this.dir, 'archives', sessionId);
+    }
+    /** Persist the messages removed by compaction so agents can search them later. */
+    async saveArchive(sessionId, instanceId, seq, messages) {
+        const dir = this.archivesDir(sessionId);
+        const path = resolve(dir, `${instanceId}.${String(seq).padStart(4, '0')}.json`);
+        const payload = `${JSON.stringify({ version: 1, instanceId, seq, messages }, null, 2)}\n`;
+        await mkdir(dir, { recursive: true });
+        await writeFile(path, payload, 'utf8');
+    }
+    /** Load archived messages for one instance (or all instances of a session). */
+    async loadArchives(sessionId, instanceId) {
+        const dir = this.archivesDir(sessionId);
+        let files = [];
+        try {
+            files = await readdir(dir);
+        }
+        catch {
+            return [];
+        }
+        const archives = [];
+        for (const file of files.filter((name) => name.endsWith('.json')).sort()) {
+            if (instanceId && !file.startsWith(`${instanceId}.`))
+                continue;
+            try {
+                const parsed = JSON.parse(await readFile(resolve(dir, file), 'utf8'));
+                if (parsed.version !== 1 || !Array.isArray(parsed.messages))
+                    continue;
+                archives.push({ instanceId: parsed.instanceId, seq: parsed.seq, messages: parsed.messages });
+            }
+            catch { /* skip invalid archives */ }
+        }
+        return archives;
+    }
+    async removeArchives(sessionId) {
+        await rm(this.archivesDir(sessionId), { recursive: true, force: true }).catch(() => undefined);
+    }
+    async flush() {
+        await Promise.all([...writes.values()].map((write) => write.catch(() => undefined)));
+    }
+}

package/dist/runtime/locks.js

@@ -0,0 +1,46 @@
+import { resolve } from 'node:path';
+export class FileLockManager {
+    active = new Set();
+    waiters = new Map();
+    async acquire(path, timeoutMs = 30_000) {
+        const key = resolve(path);
+        if (!this.active.has(key)) {
+            this.active.add(key);
+            return () => this.release(key);
+        }
+        await new Promise((resolveWait, reject) => {
+            const queue = this.waiters.get(key) ?? [];
+            const waiter = {
+                resume: resolveWait,
+                reject,
+                timer: setTimeout(() => {
+                    const current = this.waiters.get(key);
+                    const index = current?.indexOf(waiter) ?? -1;
+                    if (index >= 0)
+                        current.splice(index, 1);
+                    if (current?.length === 0)
+                        this.waiters.delete(key);
+                    reject(new Error(`Timed out waiting for write lock: ${key}`));
+                }, Math.max(100, timeoutMs)),
+            };
+            queue.push(waiter);
+            this.waiters.set(key, queue);
+        });
+        this.active.add(key);
+        return () => this.release(key);
+    }
+    release(key) {
+        const queue = this.waiters.get(key);
+        const next = queue?.shift();
+        if (!queue || queue.length === 0) {
+            this.waiters.delete(key);
+        }
+        if (next) {
+            clearTimeout(next.timer);
+            next.resume();
+        }
+        else {
+            this.active.delete(key);
+        }
+    }
+}

package/dist/runtime/session-timeline.js

@@ -0,0 +1,92 @@
+import { randomUUID } from 'node:crypto';
+const runningEntries = new WeakMap();
+function runningIndex(session, entries) {
+    const cached = runningEntries.get(session);
+    if (cached?.entries === entries)
+        return cached.index;
+    const index = new Map();
+    for (const entry of entries) {
+        if (!entry.instanceId || entry.status !== 'running')
+            continue;
+        const active = index.get(entry.instanceId) ?? [];
+        active.push(entry);
+        index.set(entry.instanceId, active);
+    }
+    runningEntries.set(session, { entries, index });
+    return index;
+}
+function finish(entries, predicate, status = 'completed') {
+    for (const entry of entries)
+        if (predicate(entry))
+            entry.status = status;
+}
+/** Record display order at event time, not grouped retrospectively by turn. */
+export function recordTimeline(session, event) {
+    const entries = session.timeline ??= session.messages.map(message => ({
+        id: message.messageId, kind: 'message', role: message.role,
+        turnId: message.turnId, content: message.content, status: 'completed',
+    }));
+    const index = runningIndex(session, entries);
+    if (event.type === 'user_message') {
+        if (!entries.some(entry => entry.id === event.message.messageId))
+            entries.push({
+                id: event.message.messageId, kind: 'message', role: 'user', content: event.message.content,
+                turnId: event.message.turnId, status: 'completed',
+            });
+        return;
+    }
+    if (!('instanceId' in event) || !event.instanceId) {
+        if (event.type === 'instance_updated' && ['idle', 'failed', 'cancelled', 'queued'].includes(event.instance.status)) {
+            const active = index.get(event.instance.instanceId) ?? [];
+            const status = event.instance.status === 'failed' ? 'failed' : event.instance.status === 'cancelled' || event.instance.status === 'queued' ? 'cancelled' : 'completed';
+            finish(active, () => true, status);
+            index.delete(event.instance.instanceId);
+        }
+        return;
+    }
+    const instanceId = event.instanceId;
+    const own = () => index.get(instanceId) ?? [];
+    if (event.type === 'thinking_delta' || event.type === 'assistant_delta') {
+        const kind = event.type === 'thinking_delta' ? 'thinking' : 'message';
+        const active = own();
+        let entry = active.at(-1);
+        if (!entry || entry.kind !== kind || entry.turnId !== event.turnId) {
+            finish(active, previous => previous.kind !== 'tool');
+            entry = { id: randomUUID(), kind, instanceId: event.instanceId, turnId: event.turnId,
+                role: 'assistant', content: '', status: 'running' };
+            entries.push(entry);
+            index.set(event.instanceId, [...active.filter(previous => previous.status === 'running'), entry]);
+        }
+        entry.content += event.text;
+    }
+    else if (event.type === 'assistant_message') {
+        const active = own();
+        finish(active, entry => entry.kind !== 'tool');
+        const remaining = active.filter(entry => entry.status === 'running');
+        if (remaining.length)
+            index.set(event.instanceId, remaining);
+        else
+            index.delete(event.instanceId);
+    }
+    else if (event.type === 'tool_started') {
+        const active = own();
+        finish(active, entry => entry.kind !== 'tool');
+        const entry = { id: randomUUID(), kind: 'tool', instanceId: event.instanceId,
+            turnId: event.turnId, tool: event.tool, input: event.input, content: '', status: 'running' };
+        entries.push(entry);
+        index.set(event.instanceId, [...active.filter(previous => previous.status === 'running'), entry]);
+    }
+    else if (event.type === 'tool_finished') {
+        const active = own();
+        const entry = active.find(entry => entry.kind === 'tool' && entry.tool === event.tool && entry.turnId === event.turnId);
+        if (entry) {
+            entry.content = event.output;
+            entry.status = /^(?:\w*Error:|Error\b)|"ok"\s*:\s*false/.test(event.output) ? 'failed' : 'completed';
+            const remaining = active.filter(previous => previous.status === 'running');
+            if (remaining.length)
+                index.set(event.instanceId, remaining);
+            else
+                index.delete(event.instanceId);
+        }
+    }
+}

package/dist/tools/index.js

@@ -0,0 +1,4 @@
+export { ToolRegistry } from './registry.js';
+// Built-ins are exposed through this package boundary for embedding. The
+// legacy infra path remains as a compatibility import for the coordinator.
+export { executeTool, getToolPolicy, listTools, setToolPolicy, toolRegistry, TOOLS, WORKER_TOOLS, } from '../infra/tools.js';

package/dist/tools/registry.js

@@ -0,0 +1,51 @@
+/** Small, provider-neutral registry suitable for embedding outside the agent. */
+export class ToolRegistry {
+    #tools = new Map();
+    register(tool) {
+        const name = tool.definition.function.name.trim();
+        if (!name)
+            throw new Error('Tool name cannot be empty');
+        if (this.#tools.has(name))
+            throw new Error(`Tool already registered: ${name}`);
+        if (tool.definition.function.parameters.type !== 'object') {
+            throw new Error(`Tool parameters must be an object schema: ${name}`);
+        }
+        this.#tools.set(name, tool);
+        return this;
+    }
+    has(name) {
+        return this.#tools.has(name);
+    }
+    get(name) {
+        return this.#tools.get(name);
+    }
+    definitions(options = {}) {
+        return [...this.#tools.values()]
+            .filter((tool) => options.includeHidden || !tool.metadata.hidden)
+            .map((tool) => tool.definition);
+    }
+    describe(options = {}) {
+        return [...this.#tools.values()]
+            .filter((tool) => options.includeHidden || !tool.metadata.hidden)
+            .map((tool) => ({
+            name: tool.definition.function.name,
+            description: tool.definition.function.description,
+            metadata: { ...tool.metadata },
+        }));
+    }
+    async execute(name, args, context) {
+        const tool = this.#tools.get(name);
+        if (!tool)
+            return `Error: unknown tool "${name}"`;
+        if (context?.signal?.aborted)
+            return 'Error: tool execution aborted';
+        try {
+            return await tool.execute(args, context);
+        }
+        catch (error) {
+            if (context?.signal?.aborted)
+                return 'Error: tool execution aborted';
+            return `Error executing ${name}: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+}

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/clipboard.js

@@ -0,0 +1,24 @@
+import { spawn } from 'node:child_process';
+/** Clipboard payload travels over stdin, never through shell interpolation. */
+export function copyText(text) {
+    const command = process.platform === 'win32' ? 'powershell.exe' : process.platform === 'darwin' ? 'pbcopy' : process.env.WAYLAND_DISPLAY ? 'wl-copy' : 'xclip';
+    const args = process.platform === 'win32'
+        ? ['-NoProfile', '-NonInteractive', '-Command', '[Console]::InputEncoding = [System.Text.UTF8Encoding]::new(); Set-Clipboard -Value ([Console]::In.ReadToEnd())']
+        : command === 'xclip' ? ['-selection', 'clipboard'] : [];
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { windowsHide: true, stdio: ['pipe', 'ignore', 'pipe'] });
+        let error = '';
+        const timer = setTimeout(() => { child.kill(); reject(new Error('Clipboard operation timed out')); }, 5000);
+        child.stderr.on('data', (chunk) => { error += chunk.toString(); });
+        child.on('error', (cause) => { clearTimeout(timer); reject(cause); });
+        child.stdin.on('error', () => { });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(error.trim() || 'Clipboard unavailable'));
+        });
+        child.stdin.end(text, 'utf8');
+    });
+}

package/dist/ui/commands.js

@@ -0,0 +1,20 @@
+export const SLASH_COMMANDS = [
+    { name: '/provider', description: 'Manage providers' },
+    { name: '/model', description: 'Choose a model' },
+    { name: '/agents', description: 'Inspect agent specs' },
+    { name: '/sessions', description: 'Open a saved conversation' },
+    { name: '/new', description: 'Start a conversation' },
+    { name: '/clear', description: 'Clear this conversation' },
+    { name: '/compact', description: 'Summarize and archive older context' },
+    { name: '/cancel', description: 'Stop current work' },
+    { name: '/select', description: 'Native terminal selection' },
+    { name: '/mouse', description: 'Toggle app mouse interaction' },
+    { name: '/help', description: 'Open command palette' },
+    { name: '/exit', description: 'Exit TokenMaw' },
+    { name: '/quit', description: 'Exit TokenMaw' },
+];
+export function commandMatches(input) {
+    if (!/^\/[^\s]*$/.test(input))
+        return [];
+    return SLASH_COMMANDS.filter((command) => command.name.startsWith(input.toLowerCase()));
+}

package/dist/ui/composer-layout.js

@@ -0,0 +1,31 @@
+/** Map code-point cursor positions to terminal cells, including wrapped CJK text. */
+export function layoutComposer(value, cursor, width, measure) {
+    const chars = Array.from(value);
+    const rows = [''];
+    const positions = [];
+    let row = 0;
+    let column = 0;
+    width = Math.max(2, width);
+    for (let index = 0; index <= chars.length; index++) {
+        const char = chars[index];
+        const cells = char && char !== '\n' ? measure(char) : 0;
+        if (column >= width || (cells > 0 && column + cells > width)) {
+            rows.push('');
+            row++;
+            column = 0;
+        }
+        positions.push({ row, column });
+        if (char === undefined)
+            break;
+        if (char === '\n') {
+            rows.push('');
+            row++;
+            column = 0;
+        }
+        else {
+            rows[row] += char;
+            column += cells;
+        }
+    }
+    return { rows, cursor: positions[Math.max(0, Math.min(cursor, chars.length))] };
+}