@lifeaitools/clauth 1.5.45 → 1.5.47

package/cli/commands/serve.js

@@ -5149,154 +5149,108 @@ function stopTerminalSession(session_id) {
   return { stopped: true, session_id };
 }
 
-// ── 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.
+// ── ClaudeAItoCLI — realtime collab between claude.ai and a running Claude Code terminal ──
 //
-// Session dirs: <root>/.rdc/relay/sessions/<session_id>/inbox/ + outbox/
+// Flow:
+//   claude.ai calls chitchat_start(name)
+//     → clauth creates session, spawns a visible Windows Terminal running:
+//         claude /rdc:collab --session <id>
+//     → clauth queues a greeting to outbox so claude.ai gets an immediate reply
+//   claude.ai calls chitchat_send(id, msg)   → pushes to in-memory inbox queue
+//   Claude Code calls chitchat_poll(id)       → shifts from inbox queue
+//   Claude Code calls chitchat_reply(id, msg) → pushes to in-memory outbox queue
+//   claude.ai calls chitchat_recv(id)         → shifts from outbox queue
 //
-// 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.
+// Pure in-memory. No files. No CLI spawning on send/recv.
 
-const CHITCHAT_FALLBACK_CWD = 'C:/Dev/regen-root';
+const CHITCHAT_CWD = 'C:/Dev/regen-root';
 
-async function resolveChitchatRoot(vault) {
-  try {
-    const { mounts } = await getFileserverMounts(vault);
-    if (mounts && mounts.length > 0) return mounts[0].path;
-  } catch {}
-  return CHITCHAT_FALLBACK_CWD;
-}
-
-function chitchatSessionDir(rootPath, session_id) {
-  return path.join(rootPath, '.rdc', 'relay', 'sessions', session_id);
-}
-
-async function startChitchatSession(name, vault) {
-  const rootPath = await resolveChitchatRoot(vault);
+async function startChitchatSession(name) {
   const session_id = generateSessionId();
-  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,
-    status: 'waiting',   // waiting = CLI not yet connected
+    status: 'ready',
     started_at: new Date().toISOString(),
     is_chitchat: true,
-    cwd: rootPath,
-    sessionDir,
     turn: 0,
-    lastResponse: undefined,
-    lastResponseAt: undefined,
+    inbox: [],   // claude.ai → Claude Code
+    outbox: [],  // Claude Code → claude.ai
   };
   terminalSessions.set(session_id, session);
-  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'),
-  };
+  // Spawn a visible Windows Terminal running /rdc:collab --session <id>
+  const binary = findClaudeBinary();
+  if (binary) {
+    try {
+      const cmd = `start cmd /k "cd /d ${CHITCHAT_CWD} && ${binary} /rdc:collab --session ${session_id}"`;
+      require('child_process').exec(cmd, { shell: true });
+      console.log(`[ClaudeAItoCLI] spawned terminal for session ${session_id}`);
+    } catch (err) {
+      console.warn(`[ClaudeAItoCLI] could not spawn terminal: ${err.message}`);
+    }
+  } else {
+    console.warn(`[ClaudeAItoCLI] claude CLI not found — terminal not spawned. Run /rdc:collab --session ${session_id} manually.`);
+  }
+
+  // Queue greeting so claude.ai gets an immediate response on first chitchat_recv
+  session.outbox.push({
+    turn: 0,
+    message: `Hey! Claude Code is live — session ${session_id} ready. What's up?`,
+    sent_at: new Date().toISOString(),
+  });
+
+  console.log(`[ClaudeAItoCLI] started session ${session_id} name=${name}`);
+  return { session_id, status: 'ready', name };
 }
 
+// claude.ai → inbox (Claude Code reads via chitchat_poll)
 function sendChitchatMessage(session_id, message) {
   const session = terminalSessions.get(session_id);
-  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) return { error: 'not_found', message: `Session ${session_id} not found` };
+  if (!session.is_chitchat) return { error: 'wrong_type', message: 'Not a ClaudeAItoCLI session' };
   if (session.status === 'stopped') return { error: 'stopped', message: 'Session is stopped' };
 
-  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';
-  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 turn = session.turn;
+  session.inbox.push({ turn, message, sent_at: new Date().toISOString() });
+  console.log(`[ClaudeAItoCLI] session ${session_id} turn=${turn} message queued`);
+  return { queued: true, session_id, turn };
 }
 
+// claude.ai ← outbox (drains all pending replies in one call)
 function recvChitchatResponse(session_id) {
   const session = terminalSessions.get(session_id);
-  if (!session) return { error: 'not_found', message: `Chitchat session ${session_id} not found` };
+  if (!session) return { error: 'not_found', message: `Session ${session_id} not found` };
 
-  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?' };
-  }
+  const messages = session.outbox.splice(0);
+  if (!messages.length) return { session_id, status: 'busy', count: 0, messages: [] };
 
-  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' };
-  }
+  console.log(`[ClaudeAItoCLI] session ${session_id} dequeued ${messages.length} response(s)`);
+  return { session_id, status: 'ready', count: messages.length, messages };
+}
 
-  // 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}` };
-  }
+// Claude Code reads all pending messages from claude.ai in one call
+function pollChitchatMessage(session_id) {
+  const session = terminalSessions.get(session_id);
+  if (!session) return { error: 'not_found', message: `Session ${session_id} not found` };
 
-  // Strip frontmatter, return body
-  const body = raw.replace(/^---[\s\S]*?---\n?/, '').trim();
-  const respondedAt = new Date().toISOString();
+  const messages = session.inbox.splice(0);
+  if (!messages.length) return { session_id, status: 'idle', count: 0, messages: [] };
 
-  // Archive the file so next recv doesn't return it again
-  const archivePath = responsePath + '.processed';
-  try { fs.renameSync(responsePath, archivePath); } catch {}
+  console.log(`[ClaudeAItoCLI] session ${session_id} dequeued ${messages.length} message(s)`);
+  return { session_id, status: 'ready', count: messages.length, messages };
+}
 
-  session.status = 'ready';
-  session.lastResponse = body;
-  session.lastResponseAt = respondedAt;
-  console.log(`[chitchat] session ${session_id} response received from outbox file=${latest}`);
+// Claude Code sends response back to claude.ai
+function replyChitchatMessage(session_id, message) {
+  const session = terminalSessions.get(session_id);
+  if (!session) return { error: 'not_found', message: `Session ${session_id} not found` };
+  if (!session.is_chitchat) return { error: 'wrong_type', message: 'Not a ClaudeAItoCLI session' };
 
-  return { session_id, status: 'ready', turn: session.turn || 0, response: body, responded_at: respondedAt };
+  session.outbox.push({ turn: session.turn, message, sent_at: new Date().toISOString() });
+  console.log(`[ClaudeAItoCLI] session ${session_id} reply queued turn=${session.turn}`);
+  return { queued: true, session_id, turn: session.turn };
 }
 
 function listChitchatSessions() {
@@ -5320,25 +5274,11 @@ 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 {}
+  // Push a stop signal into the inbox so the running /rdc:collab loop knows to exit on its next poll
+  session.inbox.push({ turn: session.turn, type: 'stop', message: 'Session ended by claude.ai.', sent_at: new Date().toISOString() });
 
   terminalSessions.delete(session_id);
-  console.log(`[chitchat] stopped session ${session_id}`);
+  console.log(`[ClaudeAItoCLI] stopped session ${session_id}`);
   return { stopped: true, session_id };
 }
 
@@ -5635,6 +5575,31 @@ const MCP_TOOLS = [
       additionalProperties: false,
     },
   },
+  {
+    name: "chitchat_poll",
+    description: "Claude Code calls this to read the next pending message from claude.ai. Returns { status: 'idle' } if nothing queued, { status: 'ready', message: '...' } when a message is waiting.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID from chitchat_start" },
+      },
+      required: ["session_id"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "chitchat_reply",
+    description: "Claude Code calls this to send its response back to claude.ai. claude.ai retrieves it via chitchat_recv.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID from chitchat_start" },
+        message:    { type: "string", description: "Response text from Claude Code" },
+      },
+      required: ["session_id", "message"],
+      additionalProperties: false,
+    },
+  },
 
   // ── Google Workspace (gws CLI) ──────────────────────────────────────────
   {
@@ -6426,6 +6391,22 @@ async function handleMcpTool(vault, name, args) {
       return mcpResult(JSON.stringify(result));
     }
 
+    case "chitchat_poll": {
+      const { session_id } = args;
+      if (!session_id) return mcpError("session_id required");
+      const result = pollChitchatMessage(session_id);
+      if (result.error) return mcpError(`${result.error}: ${result.message}`);
+      return mcpResult(JSON.stringify(result));
+    }
+
+    case "chitchat_reply": {
+      const { session_id, message } = args;
+      if (!session_id || !message) return mcpError("session_id and message required");
+      const result = replyChitchatMessage(session_id, message);
+      if (result.error) return mcpError(`${result.error}: ${result.message}`);
+      return mcpResult(JSON.stringify(result));
+    }
+
     default:
       return mcpError(`Unknown tool: ${name}`);
   }

package/package.json

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