claude-simple 0.2.24 → 0.2.26

package/src/collab.js

@@ -0,0 +1,267 @@
+import { promises as fs } from 'fs';
+import crypto from 'crypto';
+import path from 'path';
+import os from 'os';
+import http from 'http';
+
+const DEFAULT_TTL_MS = 60_000;
+const AUTO_CLAIM_MS = 30_000;
+const RANK = { viewer: 1, editor: 2, admin: 3, owner: 4 };
+
+export function roleAtLeast(have, need) {
+  return (RANK[have] || 0) >= (RANK[need] || 0);
+}
+
+export function createCollab({ filePath }) {
+  let data = { users: [], locks: {}, routes: {} };
+  let loaded = false;
+  let chain = Promise.resolve();
+  function withMutex(fn) {
+    const run = chain.then(fn, fn);
+    chain = run.then(() => undefined, () => undefined);
+    return run;
+  }
+
+  async function load() {
+    if (loaded) return data;
+    try {
+      data = JSON.parse(await fs.readFile(filePath, 'utf8'));
+      data.locks ||= {};
+      data.routes ||= {};
+      data.users ||= [];
+    } catch {
+      data = { users: [], locks: {}, routes: {} };
+    }
+    loaded = true;
+    return data;
+  }
+
+  async function save() {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tmp = filePath + '.tmp';
+    await fs.writeFile(tmp, JSON.stringify(data, null, 2));
+    await fs.rename(tmp, filePath);
+  }
+
+  function now() { return Date.now(); }
+
+  function purgeLocks() {
+    const t = now();
+    for (const [k, l] of Object.entries(data.locks)) {
+      if (l.expiresAt < t) delete data.locks[k];
+    }
+  }
+
+  function token() { return crypto.randomBytes(16).toString('hex'); }
+
+  async function acquire({ key, kind, holder, holderRole, lockToken, ttlMs, exclusive = true }) {
+    return withMutex(async () => {
+      await load();
+      purgeLocks();
+      if (!roleAtLeast(holderRole, 'editor')) {
+        return { code: 403, error: 'viewers cannot take exclusive locks' };
+      }
+      if (!key) return { code: 400, error: 'key required' };
+      ttlMs = Math.min(Math.max(ttlMs || DEFAULT_TTL_MS, 5_000), 5 * 60_000);
+      const cur = data.locks[key];
+      if (!cur) {
+        const l = {
+          key, kind, holder, holderRole,
+          token: lockToken || token(),
+          exclusive, acquiredAt: now(), expiresAt: now() + ttlMs, version: 1,
+        };
+        data.locks[key] = l;
+        await save();
+        return { code: 200, lock: { ...l } };
+      }
+      // Same principal always reclaims. Never rotate the token on a token-less
+      // refresh: rotating locked the holder's other tabs out of their own session.
+      if (cur.holder === holder) {
+        cur.expiresAt = now() + ttlMs;
+        cur.holderRole = holderRole || cur.holderRole;
+        await save();
+        return { code: 200, lock: { ...cur } };
+      }
+      const pub = { ...cur, token: undefined };
+      return { code: 423, error: 'locked', lock: pub };
+    });
+  }
+
+  async function heartbeat({ key, holder, lockToken, ttlMs }) {
+    return withMutex(async () => {
+      await load();
+      purgeLocks();
+      const cur = data.locks[key];
+      if (!cur) return { code: 404, error: 'no lock' };
+      if (cur.holder !== holder || cur.token !== lockToken) {
+        return { code: 409, error: 'token mismatch' };
+      }
+      cur.expiresAt = now() + (ttlMs || DEFAULT_TTL_MS);
+      await save();
+      return { code: 200, lock: { ...cur } };
+    });
+  }
+
+  async function release({ key, holder, lockToken, force }) {
+    return withMutex(async () => {
+      await load();
+      const cur = data.locks[key];
+      if (!cur) return { code: 200 };
+      // Holder can drop their own lease without presenting the token (Flutter
+      // lock list has no stored token). Anyone else needs force-break.
+      if (!force && cur.holder !== holder) {
+        return { code: 409, error: 'token mismatch' };
+      }
+      delete data.locks[key];
+      await save();
+      return { code: 200 };
+    });
+  }
+
+  async function requireLock({ key, lockToken, writer, writerRole }) {
+    return withMutex(async () => {
+      await load();
+      purgeLocks();
+      if (!roleAtLeast(writerRole, 'editor')) {
+        return { code: 403, error: 'forbidden' };
+      }
+      let cur = data.locks[key];
+      if (!cur) {
+        const l = {
+          key, kind: 'auto', holder: writer, holderRole: writerRole,
+          token: lockToken || token(), exclusive: true,
+          acquiredAt: now(), expiresAt: now() + AUTO_CLAIM_MS, version: 1,
+        };
+        data.locks[key] = l;
+        await save();
+        return { code: 200, lock: { ...l } };
+      }
+      // Same holder may omit or present a stale token; they already own the lease.
+      if (cur.holder === writer) {
+        cur.expiresAt = now() + DEFAULT_TTL_MS;
+        await save();
+        return { code: 200, lock: { ...cur } };
+      }
+      return { code: 423, error: 'locked', lock: { ...cur, token: undefined } };
+    });
+  }
+
+  async function listLocks() {
+    await load();
+    purgeLocks();
+    return Object.values(data.locks).map(l => ({ ...l, token: undefined }));
+  }
+
+  const slugRe = /^[a-z0-9][a-z0-9-]{1,47}$/;
+
+  async function putRoute(actor, actorRole, route) {
+    await load();
+    if (!roleAtLeast(actorRole, 'editor')) return { code: 403, error: 'forbidden' };
+    const slug = String(route.slug || '').toLowerCase().trim();
+    if (!slugRe.test(slug)) return { code: 400, error: 'invalid slug' };
+    const port = Number(route.targetPort);
+    if (!route.machineId || !Number.isInteger(port) || port < 1 || port > 65535) {
+      return { code: 400, error: 'machineId and targetPort required' };
+    }
+    const host = route.targetHost || '127.0.0.1';
+    const existing = data.routes[slug];
+    if (existing && existing.owner !== actor && !roleAtLeast(actorRole, 'admin')) {
+      return { code: 403, error: 'forbidden' };
+    }
+    const enabled = route.enabled !== false;
+    for (const [s, o] of Object.entries(data.routes)) {
+      if (s === slug || !o.enabled || !enabled) continue;
+      if (o.machineId === route.machineId && (o.targetHost || '127.0.0.1') === host && o.targetPort === port) {
+        return { code: 409, error: `port already mapped as ${s}` };
+      }
+    }
+    const nowMs = now();
+    const next = {
+      slug,
+      machineId: route.machineId,
+      targetHost: host,
+      targetPort: port,
+      owner: existing?.owner || actor,
+      public: !!route.public,
+      enabled,
+      createdAt: existing?.createdAt || nowMs,
+      updatedAt: nowMs,
+    };
+    data.routes[slug] = next;
+    await save();
+    return { code: 200, route: next };
+  }
+
+  async function deleteRoute(actor, actorRole, slug) {
+    await load();
+    const r = data.routes[slug];
+    if (!r) return { code: 404, error: 'not found' };
+    if (r.owner !== actor && !roleAtLeast(actorRole, 'admin')) return { code: 403, error: 'forbidden' };
+    delete data.routes[slug];
+    await save();
+    return { code: 200 };
+  }
+
+  async function listRoutes(viewer, role) {
+    await load();
+    return Object.values(data.routes).filter(r => r.public || r.owner === viewer || roleAtLeast(role, 'admin'));
+  }
+
+  async function getRoute(slug) {
+    await load();
+    return data.routes[slug] || null;
+  }
+
+  return {
+    acquire, heartbeat, release, requireLock, listLocks,
+    putRoute, deleteRoute, listRoutes, getRoute, load,
+  };
+}
+
+export function isLoopbackHost(host) {
+  const h = String(host || '').toLowerCase();
+  return h === '127.0.0.1' || h === 'localhost' || h === '::1' || h === '0.0.0.0';
+}
+
+export function proxyToLocalPort({ host, port, reqPath, method, headers, body, allowRemote }) {
+  return new Promise((resolve, reject) => {
+    const h = host || '127.0.0.1';
+    if (!allowRemote && !isLoopbackHost(h)) {
+      reject(Object.assign(new Error('remote hosts not allowed'), { status: 403 }));
+      return;
+    }
+    const p = Number(port);
+    if (!Number.isInteger(p) || p < 1 || p > 65535) {
+      reject(Object.assign(new Error('invalid port'), { status: 400 }));
+      return;
+    }
+    const lib = http;
+    const hdrs = { ...headers };
+    delete hdrs.host;
+    delete hdrs.authorization;
+    delete hdrs['x-hub-token'];
+    const r = lib.request({
+      hostname: h,
+      port: p,
+      path: reqPath || '/',
+      method: method || 'GET',
+      headers: hdrs,
+      timeout: 30_000,
+    }, (res) => {
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => resolve({
+        status: res.statusCode,
+        headers: res.headers,
+        body: Buffer.concat(chunks),
+      }));
+    });
+    r.on('error', reject);
+    if (body && body.length) r.write(body);
+    r.end();
+  });
+}
+
+export function machineId() {
+  return process.env.MACHINE_ID || os.hostname();
+}

package/src/runtime/external-session-sync.js

@@ -0,0 +1,106 @@
+/**
+ * Read-only mirror for agent sessions started outside this UI.
+ *
+ * Native CLIs persist their conversations as JSONL while they run.  This
+ * service samples only sessions that a browser has explicitly subscribed to,
+ * usually when their native JSONL changes (with a low-frequency fallback),
+ * compares the normalized transcript, and asks the server to notify viewers
+ * when it changes. It never writes to, interrupts, or otherwise controls the
+ * external CLI process.
+ */
+
+function transcriptFingerprint(bundle) {
+  const messages = Array.isArray(bundle?.messages) ? bundle.messages : [];
+  // Message parsing already normalizes the native formats. JSON preserves a
+  // change to an in-progress/rewritten final message as well as append-only
+  // turns, which a length-only cursor would miss.
+  return JSON.stringify({ agent: bundle?.agent || '', context: bundle?.context || null, messages });
+}
+
+export function createExternalSessionMirror({ readSession, emit, intervalMs = 750, clock = globalThis } = {}) {
+  if (typeof readSession !== 'function') throw new TypeError('readSession is required');
+  if (typeof emit !== 'function') throw new TypeError('emit is required');
+
+  const entries = new Map();
+  let timer = null;
+
+  const entryKey = (sessionId, agent) => `${agent || ''}:${sessionId}`;
+
+  function stopTimerWhenIdle() {
+    if (entries.size || !timer) return;
+    clock.clearInterval(timer);
+    timer = null;
+  }
+
+  function ensureTimer() {
+    if (timer || !entries.size) return;
+    timer = clock.setInterval(() => {
+      for (const entry of entries.values()) sync(entry).catch(() => {});
+    }, intervalMs);
+  }
+
+  async function sync(entry, { announce = false } = {}) {
+    if (entry.loading || !entries.has(entry.key)) return;
+    entry.loading = true;
+    try {
+      const bundle = await readSession(entry.sessionId, entry.agent || null);
+      if (!bundle || !entries.has(entry.key)) return;
+      const fingerprint = transcriptFingerprint(bundle);
+      const changed = fingerprint !== entry.fingerprint;
+      entry.fingerprint = fingerprint;
+      if (changed || announce) {
+        emit(entry.sessionId, {
+          type: 'external-session-updated',
+          sessionId: entry.sessionId,
+          agent: bundle.agent || entry.agent || null,
+          initial: !!announce,
+          updatedAt: Date.now(),
+        });
+      }
+    } finally {
+      entry.loading = false;
+    }
+  }
+
+  function unsubscribe(client) {
+    const key = client?.externalMirrorKey;
+    if (!key) return;
+    const entry = entries.get(key);
+    if (entry) {
+      entry.clients.delete(client);
+      if (!entry.clients.size) entries.delete(key);
+    }
+    client.externalMirrorKey = null;
+    stopTimerWhenIdle();
+  }
+
+  function subscribe(client, { sessionId, agent = null } = {}) {
+    if (!client || !sessionId) return;
+    const key = entryKey(sessionId, agent);
+    if (client.externalMirrorKey !== key) unsubscribe(client);
+
+    let entry = entries.get(key);
+    if (!entry) {
+      entry = { key, sessionId, agent, clients: new Set(), fingerprint: null, loading: false };
+      entries.set(key, entry);
+    }
+    entry.clients.add(client);
+    client.externalMirrorKey = key;
+    ensureTimer();
+    // Announce the initial snapshot too: the browser may have loaded history
+    // just before this subscription reached the server.
+    sync(entry, { announce: true }).catch(() => {});
+  }
+
+  function close() {
+    if (timer) clock.clearInterval(timer);
+    timer = null;
+    entries.clear();
+  }
+
+  async function refresh() {
+    await Promise.all([...entries.values()].map(entry => sync(entry)));
+  }
+
+  return { subscribe, unsubscribe, close, refresh, size: () => entries.size };
+}

package/src/runtime/protocol.js

@@ -27,6 +27,9 @@ export function normalizeCommand(msg) {
       requestId: msg.requestId || null,
       allow: msg.allow,
       always: msg.always,
+      // An immediate replacement turn keeps any server-side follow-ups. This
+      // is opt-in; the legacy Stop action continues to discard them.
+      preserveQueue: msg.preserveQueue === true,
       cwd: msg.cwd || msg.options?.cwd || null,
     };
   }
@@ -42,6 +45,7 @@ export function normalizeCommand(msg) {
       requestId: null,
       allow: undefined,
       always: false,
+      preserveQueue: false,
       cwd: msg.options?.cwd || null,
     };
   }
@@ -57,6 +61,7 @@ export function normalizeCommand(msg) {
       requestId: null,
       allow: undefined,
       always: false,
+      preserveQueue: false,
       cwd: null,
     };
   }
@@ -72,6 +77,7 @@ export function normalizeCommand(msg) {
       requestId: msg.requestId || msg.request_id,
       allow: msg.allow !== false && msg.allow !== 0 && msg.allow !== '0',
       always: !!msg.always,
+      preserveQueue: false,
       cwd: null,
     };
   }
@@ -87,6 +93,7 @@ export function normalizeCommand(msg) {
       requestId: null,
       allow: undefined,
       always: false,
+      preserveQueue: false,
       cwd: msg.cwd || null,
     };
   }
@@ -95,13 +102,14 @@ export function normalizeCommand(msg) {
     return {
       cmd: 'session.subscribe',
       id: msg.id || null,
-      agent: null,
+      agent: msg.agent || null,
       command: '',
       options: {},
       sessionId: msg.sessionId || null,
       requestId: null,
       allow: undefined,
       always: false,
+      preserveQueue: false,
       cwd: null,
     };
   }
@@ -129,6 +137,7 @@ export const UI_EVENT = {
   SHELL_OUTPUT: 'shell-output',
   SHELL_EXIT: 'shell-exit',
   RUN_STATUS: 'run-status',
+  GROK_QUEUE_STATUS: 'grok-queue-status',
   ABORT_RESULT: 'abort-result',
   BATCH: 'batch',
   PING: 'ping',
@@ -165,7 +174,7 @@ export function mapAgentEmit(data, { agent, compactTools = true } = {}) {
     'session-created', 'assistant', 'assistant_stream_start', 'assistant_delta',
     'assistant_stream_end', 'thought_stream_start', 'thought_delta', 'thought_stream_end',
     'result', 'complete', 'error', 'status', 'permission_request', 'permission_resolved',
-    'shell-start', 'shell-output', 'shell-exit', 'run-status', 'abort-result',
+    'shell-start', 'shell-output', 'shell-exit', 'run-status', 'grok-queue-status', 'abort-result',
   ]);
   if (known.has(t)) {
     const out = { ...data };