claude-simple 0.2.24 → 0.2.25

package/src/collab.js

@@ -0,0 +1,248 @@
+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;
+
+  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 }) {
+    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 } };
+    }
+    if (cur.holder === holder && (!lockToken || lockToken === cur.token)) {
+      cur.expiresAt = now() + ttlMs;
+      if (!lockToken) {
+        cur.token = token();
+        cur.version += 1;
+      }
+      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 }) {
+    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 }) {
+    await load();
+    const cur = data.locks[key];
+    if (!cur) return { code: 200 };
+    if (!force && (cur.holder !== holder || cur.token !== lockToken)) {
+      return { code: 409, error: 'token mismatch' };
+    }
+    delete data.locks[key];
+    await save();
+    return { code: 200 };
+  }
+
+  async function requireLock({ key, lockToken, writer, writerRole }) {
+    await load();
+    purgeLocks();
+    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 } };
+    }
+    if (cur.holder !== writer || (lockToken && lockToken !== cur.token)) {
+      return { code: 423, error: 'locked', lock: { ...cur, token: undefined } };
+    }
+    cur.expiresAt = now() + DEFAULT_TTL_MS;
+    await save();
+    return { code: 200, lock: { ...cur } };
+  }
+
+  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

@@ -95,7 +95,7 @@ export function normalizeCommand(msg) {
     return {
       cmd: 'session.subscribe',
       id: msg.id || null,
-      agent: null,
+      agent: msg.agent || null,
       command: '',
       options: {},
       sessionId: msg.sessionId || null,
@@ -129,6 +129,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 +166,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 };