@lifeaitools/clauth 1.5.44 → 1.5.46

package/cli/commands/serve.js

@@ -5149,94 +5149,108 @@ 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.
-
-const CHITCHAT_FALLBACK_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;
-}
-
-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`;
-  }
-}
-
-async function startChitchatSession(name, vault) {
-  const rootPath = await resolveChitchatRoot(vault);
-  const corpus = await readBootstrapContext(rootPath);
+// ── ClaudeAItoCLI — realtime collab between claude.ai and a running Claude Code terminal ──
+//
+// 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
+//
+// Pure in-memory. No files. No CLI spawning on send/recv.
+
+const CHITCHAT_CWD = 'C:/Dev/regen-root';
+
+async function startChitchatSession(name) {
   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 session = {
     session_id,
     name,
-    knowledge_tier: 'corpus',
     status: 'ready',
     started_at: new Date().toISOString(),
-    context: preamble,
-    activeProc: null,
     is_chitchat: true,
-    cwd: rootPath,
+    turn: 0,
+    inbox: [],   // claude.ai → Claude Code
+    outbox: [],  // Claude Code → claude.ai
   };
   terminalSessions.set(session_id, session);
-  console.log(`[chitchat] started session ${session_id} name=${name} cwd=${rootPath}`);
-  return { session_id, status: 'ready', name, cwd: rootPath };
+
+  // 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' };
-  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' };
+  session.turn = (session.turn || 0) + 1;
+  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 };
+}
 
-  session.status = 'busy';
-  const fullPrompt = `${session.context}\n\n---\nFrom claude.ai: ${message}`;
+// claude.ai ← outbox (Claude Code writes via chitchat_reply)
+function recvChitchatResponse(session_id) {
+  const session = terminalSessions.get(session_id);
+  if (!session) return { error: 'not_found', message: `Session ${session_id} not found` };
 
-  const proc = spawnProc(binary, ['-p', fullPrompt, '--dangerously-skip-permissions'], {
-    cwd: session.cwd,
-    env: process.env,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    shell: true,
-  });
-  session.activeProc = proc;
+  const msg = session.outbox.shift();
+  if (!msg) return { session_id, status: 'busy', turn: session.turn || 0, response: null, message: 'Claude Code is working — poll again shortly' };
 
-  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}`);
-    }
-  });
+  console.log(`[ClaudeAItoCLI] session ${session_id} response dequeued turn=${msg.turn}`);
+  return { session_id, status: 'ready', turn: msg.turn, response: msg.message, responded_at: msg.sent_at };
+}
 
-  return { queued: true, session_id };
+// Claude Code reads next message from claude.ai
+function pollChitchatMessage(session_id) {
+  const session = terminalSessions.get(session_id);
+  if (!session) return { error: 'not_found', message: `Session ${session_id} not found` };
+
+  const msg = session.inbox.shift();
+  if (!msg) return { session_id, status: 'idle', turn: session.turn || 0, message: null };
+
+  console.log(`[ClaudeAItoCLI] session ${session_id} message dequeued turn=${msg.turn}`);
+  return { session_id, status: 'ready', turn: msg.turn, message: msg.message, sent_at: msg.sent_at };
+}
+
+// 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' };
+
+  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() {
@@ -5256,6 +5270,18 @@ 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` };
+
+  // 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(`[ClaudeAItoCLI] stopped session ${session_id}`);
+  return { stopped: true, session_id };
+}
+
 const ENV_MAP = {
   "github":           "GITHUB_TOKEN",
   "supabase-anon":    "NEXT_PUBLIC_SUPABASE_ANON_KEY",
@@ -5549,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) ──────────────────────────────────────────
   {
@@ -6323,7 +6374,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 +6386,23 @@ 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));
+    }
+
+    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));
     }

package/package.json

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