@lifeaitools/clauth 1.5.44 → 1.5.45

package/cli/commands/serve.js

@@ -5149,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';
 
@@ -5165,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) {
@@ -5200,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() {
@@ -5256,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",
@@ -6323,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));
     }
@@ -6335,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

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