tokenmaw 0.3.0 → 0.4.0

package/dist/runtime/file-lock.js

@@ -0,0 +1,256 @@
+import { homedir } from 'node:os';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+const execFileAsync = promisify(execFile);
+const LOCK_FORMAT_VERSION = 1;
+const DEFAULT_TIMEOUT_MS = 30_000;
+const POLL_INTERVAL_MS = 50;
+export class LockConflictError extends Error {
+    holder;
+    constructor(message, holder) {
+        super(message);
+        this.name = 'LockConflictError';
+        this.holder = holder;
+    }
+}
+export function defaultLockDir() {
+    const base = process.env.CODER_DATA_HOME?.trim() || resolve(homedir(), '.coder');
+    return resolve(base, 'runtime', 'locks');
+}
+function lockKey(target) {
+    return resolve(target);
+}
+function lockFileName(target) {
+    return `${createHash('sha1').update(lockKey(target)).digest('hex')}.lock`;
+}
+// ── Process liveness ─────────────────────────────────────────────────────────
+let cachedSelfStart;
+/** Epoch ms this Node process started (second precision, like `ps lstart`). */
+export function selfStartedAt() {
+    if (cachedSelfStart === undefined) {
+        cachedSelfStart = Math.floor((Date.now() - process.uptime() * 1000) / 1000) * 1000;
+    }
+    return cachedSelfStart;
+}
+const startTimeCache = new Map();
+async function processStartTime(pid) {
+    if (pid === process.pid)
+        return selfStartedAt();
+    if (startTimeCache.has(pid))
+        return startTimeCache.get(pid);
+    let value;
+    try {
+        if (process.platform !== 'win32') {
+            const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'lstart='], { timeout: 5_000 });
+            const parsed = Date.parse(stdout.trim());
+            if (Number.isFinite(parsed))
+                value = parsed;
+        }
+    }
+    catch {
+        value = undefined;
+    }
+    startTimeCache.set(pid, value);
+    return value;
+}
+function processAlive(pid) {
+    if (pid === process.pid)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+/** True when the recorded holder still owns the lock: process alive and, when
+ * verifiable, its start time matches the recorded one (defeats pid reuse). */
+async function holderIsLive(info) {
+    if (!processAlive(info.pid))
+        return false;
+    const actual = await processStartTime(info.pid);
+    if (actual === undefined)
+        return true;
+    return Math.abs(actual - info.startedAt) < 1_500;
+}
+// ── Manager ──────────────────────────────────────────────────────────────────
+/** Nonces of locks currently held by this process, keyed by resolved target.
+ * Process-wide (not per-manager) so two managers in one process — e.g. two
+ * AgentRuntimes — still recognize each other's live locks instead of stealing
+ * them as "same-pid leaks". */
+const processHeldNonces = new Map();
+function processHolds(key) {
+    const set = processHeldNonces.get(key);
+    return Boolean(set && set.size > 0);
+}
+function trackHeld(key, nonce) {
+    const set = processHeldNonces.get(key) ?? new Set();
+    set.add(nonce);
+    processHeldNonces.set(key, set);
+}
+function untrackHeld(key, nonce) {
+    const set = processHeldNonces.get(key);
+    if (!set)
+        return;
+    set.delete(nonce);
+    if (set.size === 0)
+        processHeldNonces.delete(key);
+}
+async function readLockFile(path) {
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        return { corrupt: false, missing: error.code === 'ENOENT' };
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.v !== LOCK_FORMAT_VERSION || typeof parsed.pid !== 'number' || typeof parsed.nonce !== 'string') {
+            return { corrupt: true, missing: false };
+        }
+        return { info: parsed, corrupt: false, missing: false };
+    }
+    catch {
+        return { corrupt: true, missing: false };
+    }
+}
+export class CrossProcessLockManager {
+    dir;
+    constructor(lockDir = defaultLockDir()) {
+        this.dir = resolve(lockDir);
+    }
+    lockPath(target) {
+        return resolve(this.dir, lockFileName(target));
+    }
+    /** Current holder metadata for diagnostics, if any lock file exists. */
+    async holder(target) {
+        const path = this.lockPath(target);
+        const read = await readLockFile(path);
+        if (!read.info)
+            return undefined;
+        return { ...read.info, live: await holderIsLive(read.info) };
+    }
+    async acquire(target, options = {}) {
+        const key = lockKey(target);
+        const timeoutMs = Math.max(100, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        const deadline = Date.now() + timeoutMs;
+        const info = {
+            pid: process.pid,
+            startedAt: selfStartedAt(),
+            nonce: randomUUID(),
+            purpose: options.purpose ?? 'file',
+            target: key,
+            acquiredAt: new Date().toISOString(),
+            ...(options.session ? { session: options.session } : {}),
+        };
+        const payload = `${JSON.stringify({ v: LOCK_FORMAT_VERSION, ...info }, null, 2)}\n`;
+        await mkdir(this.dir, { recursive: true });
+        let lastHolder;
+        let stealAttempts = 0;
+        for (;;) {
+            if (processHolds(key)) {
+                // Another manager instance in this process holds the lock; the
+                // in-process layer above must serialize. Reaching here means a
+                // leaked handle or a second runtime in the same process.
+                throw new LockConflictError(`write lock for ${key} is held by this process (pid ${process.pid}); a previous acquisition was never released`, { ...(await this.holderOrSelf(key, info)), live: true });
+            }
+            const path = this.lockPath(key);
+            let handle;
+            try {
+                handle = await open(path, 'wx');
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                const read = await readLockFile(path);
+                if (read.info) {
+                    const sameProcessLeak = read.info.pid === process.pid && !processHolds(key);
+                    const live = sameProcessLeak ? false : await holderIsLive(read.info);
+                    lastHolder = { ...read.info, live: !sameProcessLeak && live };
+                    if (live) {
+                        if (Date.now() >= deadline) {
+                            throw this.conflict(key, lastHolder);
+                        }
+                        await sleep(POLL_INTERVAL_MS);
+                        continue;
+                    }
+                    // Stale lock: holder process is gone, the pid was reused, or the
+                    // same process leaked an unreleased lock — steal it.
+                    stealAttempts += 1;
+                    if (stealAttempts > 10)
+                        throw this.conflict(key, lastHolder);
+                    await rm(path, { force: true }).catch(() => undefined);
+                    continue;
+                }
+                if (read.corrupt) {
+                    // Unparseable lock file is stale by definition.
+                    stealAttempts += 1;
+                    if (stealAttempts > 10)
+                        throw this.conflict(key, lastHolder);
+                    await rm(path, { force: true }).catch(() => undefined);
+                    continue;
+                }
+                // missing: someone removed it between EEXIST and read — retry immediately.
+                continue;
+            }
+            try {
+                await handle.writeFile(payload, 'utf8');
+                await handle.close();
+            }
+            catch (error) {
+                await handle.close().catch(() => undefined);
+                await rm(path, { force: true }).catch(() => undefined);
+                throw error;
+            }
+            trackHeld(key, info.nonce);
+            let released = false;
+            return {
+                nonce: info.nonce,
+                path,
+                release: async () => {
+                    if (released)
+                        return;
+                    released = true;
+                    untrackHeld(key, info.nonce);
+                    const current = await readLockFile(path);
+                    if (current.info?.nonce === info.nonce) {
+                        await rm(path, { force: true }).catch(() => undefined);
+                    }
+                },
+            };
+        }
+    }
+    async holderOrSelf(key, fallback) {
+        const found = await this.holder(key);
+        return found ?? { ...fallback, target: key };
+    }
+    conflict(key, holder) {
+        if (!holder) {
+            return new LockConflictError(`write lock for ${key} could not be acquired before timeout`);
+        }
+        const who = holder.session ? `session ${holder.session}` : holder.purpose;
+        const state = holder.live ? 'active' : 'possibly stale';
+        return new LockConflictError(`write lock for ${key} is held by another process (pid ${holder.pid}, ${who}, ${state}, acquired ${holder.acquiredAt}). ` +
+            `Wait for it to finish${holder.live ? ', or terminate pid ' + holder.pid + ' if it is wedged' : ''}.`, holder);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolveWait) => setTimeout(resolveWait, ms));
+}
+/** Atomic file replace used by instance heartbeat files etc. */
+export async function atomicReplaceFile(path, content) {
+    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(temp, content, 'utf8');
+    try {
+        await rename(temp, path);
+    }
+    catch (error) {
+        await rm(temp, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}

package/dist/runtime/locks.js

@@ -1,46 +1,66 @@
 import { resolve } from 'node:path';
+import { CrossProcessLockManager, } from './file-lock.js';
+export { LockConflictError } from './file-lock.js';
+/**
+ * Per-path write lock that is safe both within one process (concurrent agent
+ * instances) and across processes (multiple runtimes on the same workspace).
+ *
+ * In-process: a FIFO promise chain per resolved path serializes concurrent
+ * acquirers. Cross-process: an O_EXCL lock file under the runtime lock dir.
+ * The returned release function is bound to the acquisition token and is
+ * idempotent — calling it twice can never hand the lock to another waiter
+ * while the original holder is still inside its critical section.
+ */
 export class FileLockManager {
-    active = new Set();
-    waiters = new Map();
-    async acquire(path, timeoutMs = 30_000) {
+    cross;
+    chains = new Map();
+    constructor(lockDir) {
+        this.cross = new CrossProcessLockManager(lockDir);
+    }
+    /** Diagnostics: who (if anyone) currently holds the cross-process lock. */
+    async holder(path) {
+        return this.cross.holder(resolve(path));
+    }
+    async acquire(path, timeoutMs = 30_000, options = {}) {
         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);
+        const previous = this.chains.get(key) ?? Promise.resolve();
+        let openGate;
+        const gate = new Promise((releaseTurn) => {
+            openGate = releaseTurn;
         });
-        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();
+        const chain = previous.then(() => gate);
+        this.chains.set(key, chain);
+        // Wait for the in-process turn. In-process holders always release (the
+        // release path cannot throw past its finally), so no timeout is needed here.
+        await previous;
+        let handle;
+        try {
+            handle = await this.cross.acquire(key, {
+                timeoutMs: Math.max(100, timeoutMs),
+                ...options,
+            });
         }
-        else {
-            this.active.delete(key);
+        catch (error) {
+            openGate();
+            this.dropChain(key, chain);
+            throw error;
         }
+        let released = false;
+        return async () => {
+            if (released)
+                return; // idempotent second release
+            released = true;
+            try {
+                await handle.release();
+            }
+            finally {
+                openGate();
+                this.dropChain(key, chain);
+            }
+        };
+    }
+    dropChain(key, chain) {
+        if (this.chains.get(key) === chain)
+            this.chains.delete(key);
     }
 }

package/dist/runtime/session-timeline.js

@@ -16,9 +16,29 @@ function runningIndex(session, entries) {
     return index;
 }
 function finish(entries, predicate, status = 'completed') {
+    const endedAt = Date.now();
+    // Freeze endedAt only on the transition to a terminal status so a repeated
+    // finish pass never re-extends a duration that was already frozen.
     for (const entry of entries)
-        if (predicate(entry))
+        if (predicate(entry) && !entry.endedAt && entry.status !== status) {
             entry.status = status;
+            entry.endedAt = endedAt;
+        }
+}
+/** Record a user-typed `!command` run as a transcript entry. Shell entries
+ * stream inline in the conversation but never reach the model context; the
+ * caller mutates `content`/`status` as output arrives and the process exits. */
+export function recordShellRun(session, command) {
+    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 entry = {
+        id: randomUUID(), kind: 'shell', turnId: undefined, tool: 'shell',
+        input: command, content: '', status: 'running', startedAt: Date.now(),
+    };
+    entries.push(entry);
+    return entry;
 }
 /** Record display order at event time, not grouped retrospectively by turn. */
 export function recordTimeline(session, event) {
@@ -35,6 +55,14 @@ export function recordTimeline(session, event) {
             });
         return;
     }
+    if (event.type === 'system_message') {
+        if (!entries.some(entry => entry.id === event.message.messageId))
+            entries.push({
+                id: event.message.messageId, kind: 'message', role: 'system', content: event.message.content,
+                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) ?? [];
@@ -53,7 +81,7 @@ export function recordTimeline(session, event) {
         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' };
+                role: 'assistant', content: '', status: 'running', startedAt: Date.now() };
             entries.push(entry);
             index.set(event.instanceId, [...active.filter(previous => previous.status === 'running'), entry]);
         }
@@ -72,7 +100,7 @@ export function recordTimeline(session, event) {
         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' };
+            turnId: event.turnId, tool: event.tool, input: event.input, content: '', status: 'running', startedAt: Date.now() };
         entries.push(entry);
         index.set(event.instanceId, [...active.filter(previous => previous.status === 'running'), entry]);
     }
@@ -82,6 +110,7 @@ export function recordTimeline(session, event) {
         if (entry) {
             entry.content = event.output;
             entry.status = /^(?:\w*Error:|Error\b)|"ok"\s*:\s*false/.test(event.output) ? 'failed' : 'completed';
+            entry.endedAt = Date.now();
             const remaining = active.filter(previous => previous.status === 'running');
             if (remaining.length)
                 index.set(event.instanceId, remaining);

package/dist/runtime/workspace-instances.js

@@ -0,0 +1,109 @@
+import { homedir } from 'node:os';
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rm, stat, utimes, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { atomicReplaceFile, selfStartedAt } from './file-lock.js';
+const HEARTBEAT_INTERVAL_MS = 5_000;
+const STALE_AFTER_MS = 30_000;
+function instancesDir() {
+    const base = process.env.CODER_DATA_HOME?.trim() || resolve(homedir(), '.coder');
+    return { dir: resolve(base, 'runtime', 'instances') };
+}
+function instanceFile(workspaceRoot, pid) {
+    const key = createHash('sha1').update(resolve(workspaceRoot)).digest('hex').slice(0, 16);
+    return join(instancesDir().dir, `${key}.${pid}.json`);
+}
+function processAlive(pid) {
+    if (pid === process.pid)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+async function heartbeatFile(path, info) {
+    info.heartbeatAt = new Date().toISOString();
+    await mkdir(instancesDir().dir, { recursive: true });
+    await atomicReplaceFile(path, `${JSON.stringify(info, null, 2)}\n`);
+}
+/**
+ * Registers this process as an active instance of `workspaceRoot` and starts a
+ * heartbeat. Returns a cleanup function that removes the registration (also
+ * installed on process exit). Other instances whose pid is dead or whose
+ * heartbeat is older than the stale window are ignored by `otherInstances`.
+ */
+export async function registerWorkspaceInstance(workspaceRoot, session) {
+    const info = {
+        pid: process.pid,
+        startedAt: selfStartedAt(),
+        workspace: resolve(workspaceRoot),
+        ...(session ? { session } : {}),
+        nonce: randomUUID(),
+        heartbeatAt: new Date().toISOString(),
+    };
+    const path = instanceFile(workspaceRoot, info.pid);
+    await mkdir(instancesDir().dir, { recursive: true });
+    await atomicReplaceFile(path, `${JSON.stringify(info, null, 2)}\n`);
+    const timer = setInterval(() => {
+        void heartbeatFile(path, info).catch(() => undefined);
+    }, HEARTBEAT_INTERVAL_MS);
+    timer.unref?.();
+    let cleaned = false;
+    const cleanup = async () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        clearInterval(timer);
+        await rm(path, { force: true }).catch(() => undefined);
+    };
+    process.once('exit', () => { void cleanup(); });
+    return cleanup;
+}
+function isLive(info, mtimeMs) {
+    if (!processAlive(info.pid))
+        return false;
+    if (mtimeMs > 0 && Date.now() - mtimeMs > STALE_AFTER_MS)
+        return false;
+    return true;
+}
+/** Live instances of the same workspace other than this process. */
+export async function otherWorkspaceInstances(workspaceRoot) {
+    const dir = instancesDir().dir;
+    const key = createHash('sha1').update(resolve(workspaceRoot)).digest('hex').slice(0, 16);
+    let files = [];
+    try {
+        files = (await readdir(dir)).filter((name) => name.startsWith(`${key}.`) && name.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    const others = [];
+    for (const file of files) {
+        const path = join(dir, file);
+        try {
+            const [raw, info] = await Promise.all([readFile(path, 'utf8'), stat(path)]);
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.pid !== 'number')
+                continue;
+            if (parsed.pid === process.pid)
+                continue;
+            if (isLive(parsed, info.mtimeMs))
+                others.push(parsed);
+        }
+        catch {
+            continue;
+        }
+    }
+    return others.sort((a, b) => a.pid - b.pid);
+}
+/** Touch helper exposed for tests. */
+export async function touchInstanceFile(workspaceRoot, pid) {
+    const path = instanceFile(workspaceRoot, pid);
+    const now = new Date();
+    await utimes(path, now, now).catch(async () => {
+        await writeFile(path, '').catch(() => undefined);
+    });
+}