npm - @lifeaitools/clauth - Versions diffs - 1.5.43 → 1.5.45 - Mend

@lifeaitools/clauth 1.5.43 → 1.5.45

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/cli/commands/serve.js +214 -53
package/package.json +1 -1

package/cli/commands/serve.js CHANGED Viewed

@@ -3382,6 +3382,81 @@ function createServer(initPassword, whitelist, port, tunnelHostnameInit = null,
       });
     }
+    // GET /debug/sessions — live view of all terminal/chitchat sessions
+    if (method === "GET" && reqPath === "/debug/sessions") {
+      const now = Date.now();
+      const sessions = [];
+      for (const [, s] of terminalSessions) {
+        const startedMs = new Date(s.started_at).getTime();
+        sessions.push({
+          session_id: s.session_id,
+          name: s.name,
+          type: s.is_chitchat ? "chitchat" : "terminal",
+          status: s.status,
+          turn: s.turn || 0,
+          cwd: s.cwd || null,
+          knowledge_tier: s.knowledge_tier,
+          started_at: s.started_at,
+          age_seconds: Math.round((now - startedMs) / 1000),
+          last_response_at: s.lastResponseAt || null,
+          last_response_preview: s.lastResponse
+            ? s.lastResponse.slice(0, 300) + (s.lastResponse.length > 300 ? "…" : "")
+            : null,
+          context_chars: s.context ? s.context.length : 0,
+          active_pid: s.activeProc ? s.activeProc.pid : null,
+        });
+      }
+      const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="refresh" content="3">
+  <title>clauth sessions</title>
+  <style>
+    body { font-family: monospace; background: #0d1117; color: #c9d1d9; padding: 20px; }
+    h1 { color: #58a6ff; font-size: 16px; margin-bottom: 4px; }
+    .meta { color: #6e7681; font-size: 12px; margin-bottom: 20px; }
+    .empty { color: #6e7681; }
+    .session { border: 1px solid #30363d; border-radius: 6px; padding: 16px; margin-bottom: 16px; }
+    .session.busy { border-color: #f0883e; }
+    .session.ready { border-color: #3fb950; }
+    .session.stopped { border-color: #6e7681; opacity: 0.6; }
+    .label { color: #6e7681; font-size: 11px; text-transform: uppercase; }
+    .value { color: #e6edf3; font-size: 13px; margin-bottom: 8px; }
+    .badge { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 11px; font-weight: bold; }
+    .badge.chitchat { background: #1f4068; color: #58a6ff; }
+    .badge.terminal { background: #2d1f3d; color: #bc8cff; }
+    .badge.busy { background: #3d2400; color: #f0883e; }
+    .badge.ready { background: #0f2a0f; color: #3fb950; }
+    .preview { background: #161b22; border-radius: 4px; padding: 10px; font-size: 12px; color: #8b949e; white-space: pre-wrap; word-break: break-word; max-height: 120px; overflow: auto; }
+  </style>
+</head>
+<body>
+  <h1>clauth · live sessions</h1>
+  <div class="meta">v${VERSION} · ${sessions.length} session${sessions.length !== 1 ? "s" : ""} · auto-refresh 3s · ${new Date().toISOString()}</div>
+  ${sessions.length === 0
+    ? '<div class="empty">No active sessions.</div>'
+    : sessions.map(s => `
+  <div class="session ${s.status}">
+    <span class="badge ${s.type}">${s.type}</span>
+    <span class="badge ${s.status}" style="margin-left:6px">${s.status}${s.status === "busy" ? " ⟳" : ""}</span>
+    <div style="margin-top:10px">
+      <div class="label">name</div><div class="value">${s.name}</div>
+      <div class="label">session_id</div><div class="value" style="color:#6e7681;font-size:11px">${s.session_id}</div>
+      <div class="label">turn / age / context</div>
+      <div class="value">turn ${s.turn} · ${s.age_seconds}s old · ${s.context_chars} chars context${s.active_pid ? ` · pid ${s.active_pid}` : ""}</div>
+      <div class="label">cwd</div><div class="value" style="color:#6e7681">${s.cwd || "(not set)"}</div>
+      ${s.last_response_preview ? `
+      <div class="label">last response ${s.last_response_at ? "· " + s.last_response_at : ""}</div>
+      <div class="preview">${s.last_response_preview.replace(/</g, "&lt;").replace(/>/g, "&gt;")}</div>` : ""}
+    </div>
+  </div>`).join("")}
+</body>
+</html>`;
+      res.writeHead(200, { "Content-Type": "text/html", ...CORS });
+      return res.end(html);
+    }
     // GET /builds — CI build status (no auth required, same as /ping)
     if (method === "GET" && reqPath === "/builds") {
       return ok(res, buildStatus);
@@ -5074,11 +5149,16 @@ function stopTerminalSession(session_id) {
   return { stopped: true, session_id };
 }
-// ── Chitchat helpers ──────────────────────────────────────────────────────
-// Wrappers around terminal session logic, pre-configured for regen-root collab.
-// cwd + bootstrap path are read from the vault's first fileserver mount at
-// call time — no hardcoded paths. Falls back to C:/Dev/regen-root if vault
-// is locked or no fileserver mount is configured.
+// ── Chitchat helpers — file-relay transport ───────────────────────────────
+// claude.ai sends messages by writing to inbox files. A running /rdc:collab
+// CLI session watches inbox, acts, writes responses to outbox. clauth reads
+// outbox and returns them to claude.ai via chitchat_recv. Dave can watch the
+// terminal, interject, and see exactly what Claude Code is doing.
+//
+// Session dirs: <root>/.rdc/relay/sessions/<session_id>/inbox/ + outbox/
+//
+// cwd is resolved from the vault's first fileserver mount at call time.
+// Falls back to C:/Dev/regen-root if vault is locked or no mount configured.
 const CHITCHAT_FALLBACK_CWD = 'C:/Dev/regen-root';
@@ -5090,34 +5170,52 @@ async function resolveChitchatRoot(vault) {
   return CHITCHAT_FALLBACK_CWD;
 }
-async function readBootstrapContext(rootPath) {
-  const bootstrapPath = path.join(rootPath, '.rdc', 'guides', 'agent-bootstrap.md');
-  try {
-    return fs.readFileSync(bootstrapPath, 'utf-8');
-  } catch {
-    return `# agent-bootstrap.md not found at ${bootstrapPath} — proceeding without corpus context\n`;
-  }
+function chitchatSessionDir(rootPath, session_id) {
+  return path.join(rootPath, '.rdc', 'relay', 'sessions', session_id);
 }
 async function startChitchatSession(name, vault) {
   const rootPath = await resolveChitchatRoot(vault);
-  const corpus = await readBootstrapContext(rootPath);
   const session_id = generateSessionId();
-  const preamble = `${corpus}\n\n---\nCollab session: ${name} | cwd: ${rootPath}\nRead the bootstrap above. Ready to receive tasks from claude.ai.`;
+  const sessionDir = chitchatSessionDir(rootPath, session_id);
+  // Create inbox + outbox dirs
+  fs.mkdirSync(path.join(sessionDir, 'inbox'), { recursive: true });
+  fs.mkdirSync(path.join(sessionDir, 'outbox'), { recursive: true });
+  // Write session metadata
+  fs.writeFileSync(path.join(sessionDir, 'status.json'), JSON.stringify({
+    session_id,
+    name,
+    status: 'waiting',
+    started_at: new Date().toISOString(),
+    cwd: rootPath,
+  }, null, 2));
   const session = {
     session_id,
     name,
-    knowledge_tier: 'corpus',
-    status: 'ready',
+    status: 'waiting',   // waiting = CLI not yet connected
     started_at: new Date().toISOString(),
-    context: preamble,
-    activeProc: null,
     is_chitchat: true,
     cwd: rootPath,
+    sessionDir,
+    turn: 0,
+    lastResponse: undefined,
+    lastResponseAt: undefined,
   };
   terminalSessions.set(session_id, session);
-  console.log(`[chitchat] started session ${session_id} name=${name} cwd=${rootPath}`);
-  return { session_id, status: 'ready', name, cwd: rootPath };
+  console.log(`[chitchat] started session ${session_id} name=${name} dir=${sessionDir}`);
+  return {
+    session_id,
+    status: 'waiting',
+    name,
+    cwd: rootPath,
+    next_step: `Open a terminal and run: /rdc:collab --session ${session_id}`,
+    inbox: path.join(sessionDir, 'inbox'),
+    outbox: path.join(sessionDir, 'outbox'),
+  };
 }
 function sendChitchatMessage(session_id, message) {
@@ -5125,43 +5223,80 @@ function sendChitchatMessage(session_id, message) {
   if (!session) return { error: 'not_found', message: `Chitchat session ${session_id} not found` };
   if (!session.is_chitchat) return { error: 'wrong_type', message: 'Use terminal_send for non-chitchat sessions' };
   if (session.status === 'stopped') return { error: 'stopped', message: 'Session is stopped' };
-  if (session.status === 'busy') return { error: 'session_busy', message: 'Session is busy — try again shortly' };
-  const binary = findClaudeBinary();
-  if (!binary) return { error: 'binary_not_found', message: 'claude CLI not found in PATH or AppData/npm' };
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  session.turn = (session.turn || 0) + 1;
+  const filename = `${ts}-turn${session.turn}.md`;
+  const inboxPath = path.join(session.sessionDir, 'inbox', filename);
+  const content = [
+    '---',
+    `from: claude-ai`,
+    `to: claude-code`,
+    `session_id: ${session_id}`,
+    `turn: ${session.turn}`,
+    `sent_at: ${new Date().toISOString()}`,
+    `status: pending`,
+    '---',
+    '',
+    message,
+  ].join('\n');
+  try {
+    fs.writeFileSync(inboxPath, content, 'utf-8');
+  } catch (err) {
+    return { error: 'write_failed', message: `Could not write to inbox: ${err.message}` };
+  }
   session.status = 'busy';
-  const fullPrompt = `${session.context}\n\n---\nFrom claude.ai: ${message}`;
+  console.log(`[chitchat] session ${session_id} turn=${session.turn} message written to inbox`);
+  return { queued: true, session_id, turn: session.turn, inbox_file: filename };
+}
-  const proc = spawnProc(binary, ['-p', fullPrompt, '--dangerously-skip-permissions'], {
-    cwd: session.cwd,
-    env: process.env,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    shell: true,
-  });
-  session.activeProc = proc;
+function recvChitchatResponse(session_id) {
+  const session = terminalSessions.get(session_id);
+  if (!session) return { error: 'not_found', message: `Chitchat session ${session_id} not found` };
-  let stdout = '';
-  let stderr = '';
-  proc.stdout.on('data', d => { stdout += d; });
-  proc.stderr.on('data', d => { stderr += d; });
-  proc.on('close', (code) => {
-    if (terminalSessions.has(session_id)) {
-      const s = terminalSessions.get(session_id);
-      const response = stdout.trim() || stderr.trim() || '(no output)';
-      const turn = `\n\nFrom claude.ai: ${message}\nClaude Code: ${response}`;
-      const combined = s.context + turn;
-      s.context = combined.length > 8000 ? combined.slice(combined.length - 8000) : combined;
-      s.lastResponse = response;
-      s.lastResponseAt = new Date().toISOString();
-      s.turn = (s.turn || 0) + 1;
-      s.status = 'ready';
-      s.activeProc = null;
-      console.log(`[chitchat] session ${session_id} turn=${s.turn} complete code=${code}`);
-    }
-  });
+  const outboxDir = path.join(session.sessionDir, 'outbox');
+  let files;
+  try {
+    files = fs.readdirSync(outboxDir).filter(f => f.endsWith('.md')).sort();
+  } catch {
+    return { session_id, status: session.status, turn: session.turn || 0, response: null,
+      message: 'Outbox not readable — is /rdc:collab running?' };
+  }
-  return { queued: true, session_id };
+  if (files.length === 0) {
+    return { session_id, status: 'busy', turn: session.turn || 0, response: null,
+      message: session.status === 'waiting'
+        ? 'Waiting for /rdc:collab to connect — open your terminal and run it'
+        : 'Claude Code is working — poll again in a few seconds' };
+  }
+  // Read the latest response file
+  const latest = files[files.length - 1];
+  const responsePath = path.join(outboxDir, latest);
+  let raw;
+  try {
+    raw = fs.readFileSync(responsePath, 'utf-8');
+  } catch (err) {
+    return { error: 'read_failed', message: `Could not read outbox: ${err.message}` };
+  }
+  // Strip frontmatter, return body
+  const body = raw.replace(/^---[\s\S]*?---\n?/, '').trim();
+  const respondedAt = new Date().toISOString();
+  // Archive the file so next recv doesn't return it again
+  const archivePath = responsePath + '.processed';
+  try { fs.renameSync(responsePath, archivePath); } catch {}
+  session.status = 'ready';
+  session.lastResponse = body;
+  session.lastResponseAt = respondedAt;
+  console.log(`[chitchat] session ${session_id} response received from outbox file=${latest}`);
+  return { session_id, status: 'ready', turn: session.turn || 0, response: body, responded_at: respondedAt };
 }
 function listChitchatSessions() {
@@ -5181,6 +5316,32 @@ function listChitchatSessions() {
   return sessions;
 }
+function stopChitchatSession(session_id) {
+  const session = terminalSessions.get(session_id);
+  if (!session) return { error: 'not_found', message: `Session ${session_id} not found` };
+  // Write a stop signal to inbox so the running /rdc:collab loop knows to exit
+  try {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    const stopFile = path.join(session.sessionDir, 'inbox', `${ts}-stop.md`);
+    fs.writeFileSync(stopFile, [
+      '---',
+      'from: claude-ai',
+      'to: claude-code',
+      `session_id: ${session_id}`,
+      'type: stop',
+      `sent_at: ${new Date().toISOString()}`,
+      '---',
+      '',
+      'Session ended by claude.ai. Write final summary and exit.',
+    ].join('\n'));
+  } catch {}
+  terminalSessions.delete(session_id);
+  console.log(`[chitchat] stopped session ${session_id}`);
+  return { stopped: true, session_id };
+}
 const ENV_MAP = {
   "github":           "GITHUB_TOKEN",
   "supabase-anon":    "NEXT_PUBLIC_SUPABASE_ANON_KEY",
@@ -6248,7 +6409,7 @@ async function handleMcpTool(vault, name, args) {
     case "chitchat_recv": {
       const { session_id } = args;
       if (!session_id) return mcpError("session_id required");
-      const result = recvTerminalResponse(session_id);
+      const result = recvChitchatResponse(session_id);
       if (result.error) return mcpError(`${result.error}: ${result.message}`);
       return mcpResult(JSON.stringify(result));
     }
@@ -6260,7 +6421,7 @@ async function handleMcpTool(vault, name, args) {
     case "chitchat_stop": {
       const { session_id } = args;
       if (!session_id) return mcpError("session_id required");
-      const result = stopTerminalSession(session_id);
+      const result = stopChitchatSession(session_id);
       if (result.error) return mcpError(`${result.error}: ${result.message}`);
       return mcpResult(JSON.stringify(result));
     }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/clauth",
-  "version": "1.5.43",
+  "version": "1.5.45",
   "description": "Hardware-bound credential vault for the LIFEAI infrastructure stack",
   "type": "module",
   "bin": {