@venturewild/workspace 0.4.2 → 0.5.0

package/server/src/index.mjs

@@ -46,7 +46,7 @@ import {
   MAX_TIER,
   MAX_GRANT_MINUTES,
 } from './support-consent.mjs';
-import { ClaudeLoginSession } from './agent-login.mjs';
+import { ClaudeLoginSession, defaultPtyLoader } from './agent-login.mjs';
 import { ErrorReporter } from './error-reporter.mjs';
 import { DaemonBridge } from './daemon.mjs';
 import { DaemonSupervisor } from './daemon-supervisor.mjs';
@@ -77,7 +77,7 @@ import { TURN_SYSTEM_PROMPT, writeTurnMcpConfig } from './turn-mcp.mjs';
 import { loadAccount } from './account.mjs';
 import { getOperatorToken } from './operator.mjs';
 import { runDoctor } from './doctor.mjs';
-import { appendLine, tailFile, logFile, TAILABLE, globalDir } from './logpaths.mjs';
+import { appendLine, tailFile, logFile, listLogs, TAILABLE, globalDir } from './logpaths.mjs';
 import { SessionReporter } from './session-reporter.mjs';
 import { TranscriptRecorder } from './transcript.mjs';
 import { loadObservabilityConsent, setObservabilityConsent } from './observability.mjs';
@@ -109,24 +109,34 @@ function log(tag, ...args) {
 // The conversation's claude session id, stored in the workspace's gitignored
 // .wild-workspace/ dir. Persisting it means a browser reload — or a server
 // restart — doesn't wipe the agent's memory of the conversation.
-function chatSessionPath(dataDir) {
-  return path.join(dataDir, 'chat-session.json');
+// A chat THREAD id (C3 — independent chats on the canvas) becomes a filename
+// segment, so harden it against traversal / illegal chars (`:` is illegal on
+// Windows — never use it in the path). Null → the PRIMARY thread, which keeps the
+// legacy un-suffixed files for upgrade-safe continuity.
+function sanitizeThreadId(threadId) {
+  if (!threadId) return null;
+  const s = String(threadId).replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 64);
+  return s && s !== '.' && s !== '..' ? s : null;
 }
-function loadChatSessionId(dataDir) {
+function chatSessionPath(dataDir, threadId) {
+  const safe = sanitizeThreadId(threadId);
+  return path.join(dataDir, safe ? `chat-session-${safe}.json` : 'chat-session.json');
+}
+function loadChatSessionId(dataDir, threadId) {
   try {
-    const parsed = JSON.parse(readFileSync(chatSessionPath(dataDir), 'utf8'));
+    const parsed = JSON.parse(readFileSync(chatSessionPath(dataDir, threadId), 'utf8'));
     return typeof parsed.sessionId === 'string' ? parsed.sessionId : null;
   } catch {
     return null;
   }
 }
-function saveChatSessionId(dataDir, sessionId) {
+function saveChatSessionId(dataDir, threadId, sessionId) {
   try {
     // A freshly-created workspace has no .wild-workspace/ dir yet — make it so the
     // per-workspace conversation persists from the very first turn (lobby M1).
     mkdirSync(dataDir, { recursive: true });
     writeFileSync(
-      chatSessionPath(dataDir),
+      chatSessionPath(dataDir, threadId),
       JSON.stringify({ sessionId: sessionId || null }, null, 2),
     );
   } catch {
@@ -431,10 +441,18 @@ export async function createServer(overrides = {}) {
   // (full-context turn in this repo, 2026-06-13), so 3 concurrent ≈ 1 GB — safe
   // headroom on any modern machine, while the cap stops an unbounded fan-out from
   // OOMing a laptop. Raise/lower via WILD_WORKSPACE_MAX_CONCURRENT_TURNS.
-  const currentTurns = new Map(); // workspace.id → { session, messageId, workspaceId }
+  // Keyed by a TURN KEY = `${workspace.id}:${threadId}` (C3 — independent chats on
+  // the canvas). A null/primary thread keys by bare workspace.id, so the primary
+  // chat behaves byte-for-byte as before. Each chat block on the canvas is its own
+  // thread with its own in-flight turn; the MAX_CONCURRENT_TURNS cap stays GLOBAL.
+  const currentTurns = new Map(); // turnKey → { session, messageId, workspaceId, threadId }
   const MAX_CONCURRENT_TURNS =
     overrides.maxConcurrentTurns ??
     Math.max(1, Number(process.env.WILD_WORKSPACE_MAX_CONCURRENT_TURNS) || 3);
+  function turnKey(workspaceId, threadId) {
+    const safe = sanitizeThreadId(threadId);
+    return safe ? `${workspaceId}:${safe}` : workspaceId;
+  }
   // Drop a workspace's turn entry ONLY if it still points at THIS session. A
   // superseded turn's `end` fires a tick AFTER its proc is killed (the 'close'
   // event), by which point the replacement turn may already own the slot — so an
@@ -461,11 +479,20 @@ export async function createServer(overrides = {}) {
   // that workspace receive it — so a tab viewing workspace B never renders a turn
   // that belongs to A (lobby M1: per-workspace conversations over one WS pool).
   // Frames with no workspaceId (e.g. the usage gauge, bazaar meter) go to all.
-  function broadcastChat(obj, workspaceId) {
-    const data = JSON.stringify(obj);
+  function broadcastChat(obj, workspaceId, threadId) {
+    const safe = sanitizeThreadId(threadId);
+    // Tag chat-turn frames with their thread so the client can double-filter
+    // (defense in depth on top of the per-socket scoping below).
+    const data = JSON.stringify(safe ? { ...obj, threadId: safe } : obj);
     for (const ws of chatClients) {
       if (ws.readyState !== ws.OPEN) continue;
-      if (workspaceId && ws._wsWorkspaceId !== workspaceId) continue;
+      if (workspaceId) {
+        // A workspace-scoped frame goes only to sockets on that workspace AND bound
+        // to the same thread (C3): a frame for thread T must not render in another
+        // chat block, and the primary (null) thread must not leak into a secondary.
+        if (ws._wsWorkspaceId !== workspaceId) continue;
+        if ((ws._wsThreadId || null) !== (safe || null)) continue;
+      }
       ws.send(data);
     }
   }
@@ -479,27 +506,28 @@ export async function createServer(overrides = {}) {
    *     and retries once if the run fails (PRD §13 A8).
    * Returns false if the turn could not start (an auto turn while busy).
    */
-  function runChatTurn({ prompt, mode, messageId, userText, note, auto = false, workspace = defaultWorkspace }) {
+  function runChatTurn({ prompt, mode, messageId, userText, note, auto = false, workspace = defaultWorkspace, threadId = null }) {
     const id = messageId || nanoid(8);
-    // Supersede only THIS workspace's in-flight turn — a send in B must never kill
-    // a turn still running in A (lobby M2).
-    const live = currentTurns.get(workspace.id);
+    const key = turnKey(workspace.id, threadId);
+    // Supersede only THIS thread's in-flight turn — a send in another chat (or
+    // another workspace) must never kill a turn still running here (lobby M2 / C3).
+    const live = currentTurns.get(key);
     if (live) {
-      if (auto) return false; //          auto-wake yields to a live turn in this workspace
+      if (auto) return false; //          auto-wake yields to a live turn in this thread
       live.session.close(); //            a user send supersedes what's running here
-      currentTurns.delete(workspace.id);
+      currentTurns.delete(key);
     }
-    // Concurrency cap (after the per-workspace supersede, before spawn): too many
-    // OTHER workspaces are already mid-turn. Reject — don't queue — and tell the
+    // Concurrency cap (after the per-thread supersede, before spawn): too many
+    // OTHER turns are already mid-flight. Reject — don't queue — and tell the
     // tab so the user can resend (an auto-wake re-queues itself, so it stays quiet).
     if (currentTurns.size >= MAX_CONCURRENT_TURNS) {
-      log('[chat]', `cap reached (${currentTurns.size}/${MAX_CONCURRENT_TURNS}) — rejecting ${auto ? 'auto' : 'user'} turn in ${workspace.id}`);
+      log('[chat]', `cap reached (${currentTurns.size}/${MAX_CONCURRENT_TURNS}) — rejecting ${auto ? 'auto' : 'user'} turn in ${key}`);
       if (!auto) {
         broadcastChat({
           type: 'error',
           messageId: id,
-          message: `${MAX_CONCURRENT_TURNS} workspaces are already working at once. Wait for one to finish, then resend.`,
-        }, workspace.id);
+          message: `${MAX_CONCURRENT_TURNS} chats are already working at once. Wait for one to finish, then resend.`,
+        }, workspace.id, threadId);
       }
       return false;
     }
@@ -508,11 +536,11 @@ export async function createServer(overrides = {}) {
     // the stored level + the per-message toggle through resolveAutonomyMode, whose
     // guardrail guarantees an unbuilt/unknown level can NEVER become bypassPermissions.
     if (!auto) mode = resolveAutonomyMode(settings.getAutonomyLevel(), mode);
-    // Per-workspace conversation (lobby M1): resume THIS workspace's claude session
-    // from its own dataDir, and tag every frame with the workspace so it streams
-    // only to tabs viewing it.
-    const resumeId = loadChatSessionId(workspace.dataDir);
-    broadcastChat({ type: 'turn-begin', messageId: id, userText, note }, workspace.id);
+    // Per-thread conversation (C3 on top of lobby M1): resume THIS thread's claude
+    // session from the workspace dataDir, and tag every frame with the workspace +
+    // thread so it streams only to the matching chat block.
+    const resumeId = loadChatSessionId(workspace.dataDir, threadId);
+    broadcastChat({ type: 'turn-begin', messageId: id, userText, note }, workspace.id, threadId);
     activityBus.publish({
       type: 'chat-user',
       messageId: id,
@@ -524,7 +552,7 @@ export async function createServer(overrides = {}) {
       const startedAt = Date.now();
       log('[chat]', `turn-begin id=${id} auto=${auto} mode=${mode || 'build'} promptChars=${(prompt || '').length}`);
       const session = new AgentSession(activeAgent);
-      currentTurns.set(workspace.id, { session, messageId: id, workspaceId: workspace.id });
+      currentTurns.set(key, { session, messageId: id, workspaceId: workspace.id, threadId });
       let sawError = false;
       session.on('chunk', (chunk) => {
         // The per-turn context signal (working-memory gauge, §8) feeds the usage
@@ -535,7 +563,7 @@ export async function createServer(overrides = {}) {
           return;
         }
         if (chunk.type === 'error') sawError = true;
-        broadcastChat({ type: 'chunk', messageId: id, chunk }, workspace.id);
+        broadcastChat({ type: 'chunk', messageId: id, chunk }, workspace.id, threadId);
         activityBus.publish({ type: 'chat-stream', messageId: id, chunk });
         // Surface the turn's token/cost totals so the activity bar can show
         // running usage — the ActivityBus accumulates events typed 'usage'.
@@ -546,7 +574,7 @@ export async function createServer(overrides = {}) {
       session.on('stderr', (text) => {
         const trimmed = String(text || '').trim();
         if (trimmed) log('[chat]', `stderr id=${id}: ${trimmed.slice(0, 240)}`);
-        broadcastChat({ type: 'stderr', messageId: id, text }, workspace.id);
+        broadcastChat({ type: 'stderr', messageId: id, text }, workspace.id, threadId);
       });
       session.on('error', (err) => {
         sawError = true;
@@ -562,11 +590,11 @@ export async function createServer(overrides = {}) {
           type: 'error',
           messageId: id,
           message: msg,
-        }, workspace.id);
-        clearTurnIf(workspace.id, session);
+        }, workspace.id, threadId);
+        clearTurnIf(key, session);
       });
       session.on('end', ({ code }) => {
-        clearTurnIf(workspace.id, session);
+        clearTurnIf(key, session);
         const elapsed = Date.now() - startedAt;
         log('[chat]', `turn-end id=${id} code=${code} ms=${elapsed} closed=${session.closed} sawError=${sawError}`);
         // Silent agent crash → telemetry. A non-zero exit (or signal-kill =
@@ -596,10 +624,10 @@ export async function createServer(overrides = {}) {
             return;
           }
           if (session.sessionId) {
-            saveChatSessionId(workspace.dataDir, session.sessionId);
+            saveChatSessionId(workspace.dataDir, threadId, session.sessionId);
           }
         }
-        broadcastChat({ type: 'end', messageId: id, code }, workspace.id);
+        broadcastChat({ type: 'end', messageId: id, code }, workspace.id, threadId);
         activityBus.publish({ type: 'chat-end', messageId: id, code });
       });
       session.send(prompt, {
@@ -615,16 +643,17 @@ export async function createServer(overrides = {}) {
     return true;
   }
 
-  function resetChat(workspace = defaultWorkspace) {
-    // Only stop the live turn if it belongs to THIS workspace — a "new chat" in B
-    // must never kill a turn still running in A (lobby M1/M2).
-    const live = currentTurns.get(workspace.id);
+  function resetChat(workspace = defaultWorkspace, threadId = null) {
+    // Only stop the live turn if it belongs to THIS thread — a "new chat" in
+    // another chat block (or workspace) must never kill a turn running elsewhere.
+    const key = turnKey(workspace.id, threadId);
+    const live = currentTurns.get(key);
     if (live) {
       live.session.close();
-      currentTurns.delete(workspace.id);
+      currentTurns.delete(key);
     }
-    saveChatSessionId(workspace.dataDir, null);
-    broadcastChat({ type: 'reset' }, workspace.id);
+    saveChatSessionId(workspace.dataDir, threadId, null);
+    broadcastChat({ type: 'reset' }, workspace.id, threadId);
   }
 
   // --- auto-wake on import (AR-23) ------------------------------------------
@@ -2276,6 +2305,25 @@ export async function createServer(overrides = {}) {
     }
   });
 
+  // Logs block (C1): tail the user's own machine-global logs (server / daemon / cli /
+  // operator / audit) BY NAME — never an arbitrary path (the TAILABLE allowlist, the
+  // same one the operator channel uses). Owner-only (fileTree): a share-link viewer
+  // must not read the host's system + audit logs. No `name` → the catalogue (which logs
+  // exist + sizes). Absolute on-disk paths are NOT exposed (they'd leak the home dir).
+  app.get('/api/workspace/logs', (c) => {
+    const forbidden = require(c, 'fileTree');
+    if (forbidden) return forbidden;
+    const name = c.req.query('name');
+    if (!name) {
+      return c.json({ logs: listLogs().map(({ file, ...rest }) => rest) });
+    }
+    if (!TAILABLE.includes(name)) {
+      return c.json({ error: 'unknown-log', name, allowed: TAILABLE }, 400);
+    }
+    const lines = Math.min(Number(c.req.query('lines')) || 200, 2000);
+    return c.json({ name, lines, body: tailFile(logFile(name), lines) });
+  });
+
   // --- component inbox ---
   app.get('/api/inbox', async (c) => {
     // Enforce the `inbox` capability (partner-only). It existed in the matrix
@@ -2399,6 +2447,26 @@ export async function createServer(overrides = {}) {
     if (!res.ok) return c.json({ error: res.error }, 404);
     return c.json(res);
   });
+  // Publish the user's CURRENT look as a theme on their Themes shelf — the human
+  // authoring loop ("Publish my look" in the Theme picker). chatWrite-gated (a
+  // read-only viewer can't publish on the owner's behalf). The bundle is hex-only,
+  // re-validated by normalizeTheme inside publishTheme (data, never CSS). Optional
+  // `builtFrom` records a remix's lineage (the shelf theme it was tweaked from).
+  app.post('/api/bazaar/themes/publish', async (c) => {
+    const forbidden = require(c, 'chatWrite');
+    if (forbidden) return forbidden;
+    const body = await c.req.json().catch(() => ({}));
+    const title = String(body.title || '').trim();
+    if (!title) return c.json({ error: 'title-required' }, 400);
+    const res = bazaar.publishTheme({
+      title,
+      pitch: body.pitch ? String(body.pitch).slice(0, 200) : '',
+      tags: Array.isArray(body.tags) ? body.tags.slice(0, 8).map((t) => String(t).slice(0, 24)) : [],
+      theme: body.theme && typeof body.theme === 'object' ? body.theme : {},
+      builtFrom: body.builtFrom && body.builtFrom.id ? { id: body.builtFrom.id, title: body.builtFrom.title } : null,
+    });
+    return c.json(res);
+  });
 
   // --- canvas (agent-made custom blocks — §3.3) -----------------------------
   // The blocks the agent has built for the user. The UI hydrates these on load (so
@@ -2795,10 +2863,13 @@ export async function createServer(overrides = {}) {
   }
 
   // --- websocket bridge ---
+  // The power-user terminal (T1) loads node-pty lazily + optionally — same loader as
+  // in-app sign-in. Overridable so tests can inject a deterministic fake PTY.
+  const ptyLoader = overrides.ptyLoader || defaultPtyLoader;
   const wss = new WebSocketServer({ noServer: true });
   httpServer.on('upgrade', async (req, socket, head) => {
     const reqUrl = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
-    const supported = ['/ws/chat', '/ws/activity'];
+    const supported = ['/ws/chat', '/ws/activity', '/ws/pty'];
     if (!supported.includes(reqUrl.pathname)) {
       socket.destroy();
       return;
@@ -2833,16 +2904,35 @@ export async function createServer(overrides = {}) {
       socket.destroy();
       return;
     }
+    // T1 — the power-user terminal is a real shell with the owner's full privileges,
+    // so it is the MOST sensitive socket. Gate it hard, BEFORE the handshake:
+    //   - PARTNER only (a viewer/client share token can never open a shell), AND
+    //   - in public mode, ONLY a genuine-LOCAL request (host-machine owner over
+    //     loopback) — never the reverse tunnel. loopbackHeaders() returns false the
+    //     moment any x-forwarded-*/x-real-ip header is present, so a relayed visitor
+    //     can't reach it even with a stolen partner token.
+    if (reqUrl.pathname === '/ws/pty') {
+      const genuineLocal = isLocalBind && loopbackHeaders((n) => req.headers[n]);
+      if (role !== ROLES.PARTNER || (config.publicMode && !genuineLocal)) {
+        log('[ws]', `denied /ws/pty (role=${role} publicMode=${config.publicMode} local=${genuineLocal})`);
+        socket.destroy();
+        return;
+      }
+    }
     // The chat WS carries its tab's active workspace as `?workspace=<id>` (lobby
     // M1) — the per-tab channel for the socket, mirroring the X-Workspace-Id header
     // on HTTP. Absent/unknown → the boot default.
     const wsWorkspace = resolveWorkspace(reqUrl.searchParams.get('workspace'));
+    // C3: a chat socket also carries its THREAD (`?thread=<id>`) — one chat block on
+    // the canvas = one thread. Absent → the primary thread (legacy continuity).
+    const wsThreadId = sanitizeThreadId(reqUrl.searchParams.get('thread'));
     wss.handleUpgrade(req, socket, head, (ws) => {
       ws._wsRole = role;
       ws._wsSub = sub;
       ws._wsWorkspace = wsWorkspace;
       ws._wsWorkspaceId = wsWorkspace.id;
-      log('[ws]', `open ${reqUrl.pathname} role=${role} sub=${sub} ws=${wsWorkspace.id}`);
+      ws._wsThreadId = wsThreadId;
+      log('[ws]', `open ${reqUrl.pathname} role=${role} sub=${sub} ws=${wsWorkspace.id}${wsThreadId ? ` thread=${wsThreadId}` : ''}`);
       wss.emit('connection', ws, req, reqUrl.pathname);
     });
   });
@@ -2850,7 +2940,64 @@ export async function createServer(overrides = {}) {
   wss.on('connection', (ws, req, route) => {
     if (route === '/ws/activity') return wireActivityWs(ws);
     if (route === '/ws/chat') return wireChatWs(ws);
-  });
+    if (route === '/ws/pty') return wirePtyWs(ws);
+  });
+
+  // T1 — a real interactive shell over the socket (already auth-gated to a local
+  // partner in the upgrade handler). Spawns the platform shell in the workspace
+  // root via node-pty; pipes pty→ws as {type:'data'} and ws→pty for data/resize;
+  // kills the child on close. If node-pty isn't available on this platform, sends a
+  // single {type:'error'} and closes (the UI shows "terminal not available").
+  async function wirePtyWs(ws) {
+    const pty = await ptyLoader();
+    if (!pty || typeof pty.spawn !== 'function') {
+      try { ws.send(JSON.stringify({ type: 'error', message: 'Terminal is not available on this platform.' })); } catch {}
+      try { ws.close(); } catch {}
+      return;
+    }
+    const shell = process.platform === 'win32'
+      ? (process.env.ComSpec || 'cmd.exe')
+      : (process.env.SHELL || '/bin/bash');
+    let proc;
+    try {
+      proc = pty.spawn(shell, [], {
+        name: 'xterm-color',
+        cols: 80,
+        rows: 24,
+        cwd: config.workspaceDir,
+        env: { ...process.env },
+      });
+    } catch (e) {
+      try { ws.send(JSON.stringify({ type: 'error', message: `couldn't start a shell: ${e?.message || e}` })); } catch {}
+      try { ws.close(); } catch {}
+      return;
+    }
+    log('[ws]', `pty open pid=${proc.pid} shell=${shell} cwd=${config.workspaceDir}`);
+    ws.send(JSON.stringify({ type: 'ready', shell }));
+    proc.onData((d) => {
+      if (ws.readyState === ws.OPEN) ws.send(JSON.stringify({ type: 'data', data: String(d) }));
+    });
+    proc.onExit((ev) => {
+      const code = ev && typeof ev === 'object' ? ev.exitCode : ev;
+      try { if (ws.readyState === ws.OPEN) ws.send(JSON.stringify({ type: 'exit', code })); } catch {}
+      try { ws.close(); } catch {}
+    });
+    ws.on('message', (raw) => {
+      let msg;
+      try { msg = JSON.parse(raw.toString()); } catch { return; }
+      if (msg.type === 'data' && typeof msg.data === 'string') {
+        try { proc.write(msg.data); } catch {}
+      } else if (msg.type === 'resize') {
+        const cols = Math.max(1, Math.min(1000, Number(msg.cols) || 80));
+        const rows = Math.max(1, Math.min(1000, Number(msg.rows) || 24));
+        try { proc.resize(cols, rows); } catch {}
+      }
+    });
+    ws.on('close', () => {
+      try { proc.kill(); } catch {}
+      log('[ws]', `pty close pid=${proc.pid}`);
+    });
+  }
 
   function wireActivityWs(ws) {
     const presence = activityBus.joinPresence({
@@ -2917,25 +3064,27 @@ export async function createServer(overrides = {}) {
           return;
         }
         ws._sendTimes.push(now);
-        // The turn-runner resumes THIS tab's workspace conversation and streams
-        // back only to tabs on the same workspace (lobby M1).
+        // The turn-runner resumes THIS socket's workspace + thread conversation and
+        // streams back only to the matching chat block (lobby M1 + C3).
         runChatTurn({
           prompt: msg.text,
           mode: msg.mode,
           messageId: msg.messageId,
           userText: msg.text,
           workspace: ws._wsWorkspace,
+          threadId: ws._wsThreadId,
         });
       } else if (msg.type === 'cancel') {
-        // Cancel only the turn that belongs to this tab's workspace.
-        const live = currentTurns.get(ws._wsWorkspaceId);
+        // Cancel only the turn that belongs to this socket's thread.
+        const key = turnKey(ws._wsWorkspaceId, ws._wsThreadId);
+        const live = currentTurns.get(key);
         if (live) {
           live.session.close();
-          currentTurns.delete(ws._wsWorkspaceId);
+          currentTurns.delete(key);
         }
       } else if (msg.type === 'reset') {
         // "New chat" — drop the resumed session so the next turn starts fresh.
-        if (cap.chatWrite) resetChat(ws._wsWorkspace);
+        if (cap.chatWrite) resetChat(ws._wsWorkspace, ws._wsThreadId);
       }
     });
     ws.on('close', () => {