@lifeaitools/clauth 1.5.41 → 1.5.43

package/cli/commands/serve.js

@@ -2921,7 +2921,7 @@ function createServer(initPassword, whitelist, port, tunnelHostnameInit = null,
     }
 
     // ── Hosts that bypass OAuth (fresh domains for claude.ai compatibility) ──
-    const NOAUTH_HOSTS = ["fs.regendevcorp.com", "clauth.regendevcorp.com"];
+    const NOAUTH_HOSTS = ["fs.regendevcorp.com", "clauth.regendevcorp.com", "chitchat.regendevcorp.com"];
     const requestHost = (req.headers.host || "").split(":")[0].toLowerCase();
     const noAuthHost = NOAUTH_HOSTS.includes(requestHost);
 
@@ -3115,18 +3115,20 @@ function createServer(initPassword, whitelist, port, tunnelHostnameInit = null,
     }
 
     // ── MCP path helpers ──
-    const MCP_PATHS = ["/mcp", "/gws", "/clauth", "/fs"];
+    const MCP_PATHS = ["/mcp", "/gws", "/clauth", "/fs", "/chitchat"];
     const isMcpPath = MCP_PATHS.includes(reqPath);
     function toolsForPath(p) {
-      if (p === "/gws")    return MCP_TOOLS.filter(t => t.name.startsWith("gws_"));
-      if (p === "/clauth") return MCP_TOOLS.filter(t => t.name.startsWith("clauth_") || t.name === "monkey_dispatch" || t.name.startsWith("terminal_"));
-      if (p === "/fs")     return MCP_TOOLS.filter(t => t.name.startsWith("fs_"));
+      if (p === "/gws")      return MCP_TOOLS.filter(t => t.name.startsWith("gws_"));
+      if (p === "/clauth")   return MCP_TOOLS.filter(t => t.name.startsWith("clauth_") || t.name === "monkey_dispatch" || t.name.startsWith("terminal_"));
+      if (p === "/fs")       return MCP_TOOLS.filter(t => t.name.startsWith("fs_"));
+      if (p === "/chitchat") return MCP_TOOLS.filter(t => t.name.startsWith("chitchat_"));
       return MCP_TOOLS; // /mcp — all tools
     }
     function serverNameForPath(p) {
-      if (p === "/gws")    return "gws";
-      if (p === "/clauth") return "clauth";
-      if (p === "/fs")     return "fs";
+      if (p === "/gws")      return "gws";
+      if (p === "/clauth")   return "clauth";
+      if (p === "/fs")       return "fs";
+      if (p === "/chitchat") return "chitchat";
       return "clauth";
     }
 
@@ -4917,7 +4919,7 @@ function findClaudeBinary() {
 let activeCliWorkers = 0;
 const MAX_CLI_WORKERS = 2;
 
-function spawnClaudeTask(prompt, jobId) {
+function spawnClaudeTask(prompt, jobId, cwd) {
   if (activeCliWorkers >= MAX_CLI_WORKERS) {
     return { error: 'concurrency_limit', message: `Max ${MAX_CLI_WORKERS} CLI workers active` };
   }
@@ -4928,7 +4930,7 @@ function spawnClaudeTask(prompt, jobId) {
 
   activeCliWorkers++;
   const proc = spawnProc(binary, ['-p', prompt, '--dangerously-skip-permissions'], {
-    cwd: 'C:/Dev/regen-root',
+    cwd: cwd || CHITCHAT_FALLBACK_CWD,
     env: process.env,
     stdio: ['ignore', 'pipe', 'pipe'],
     shell: true,
@@ -4953,7 +4955,7 @@ function generateSessionId() {
   return crypto.randomUUID();
 }
 
-function startTerminalSession(name, knowledge_tier, context_md) {
+function startTerminalSession(name, knowledge_tier, context_md, cwd) {
   const binary = findClaudeBinary();
   if (!binary) {
     return { error: 'binary_not_found', message: 'claude CLI not found in PATH or AppData/npm' };
@@ -4971,9 +4973,10 @@ function startTerminalSession(name, knowledge_tier, context_md) {
     started_at: new Date().toISOString(),
     context: initialContext,
     activeProc: null,
+    cwd: cwd || CHITCHAT_FALLBACK_CWD,
   };
   terminalSessions.set(session_id, session);
-  console.log(`[terminal] started session ${session_id} name=${name}`);
+  console.log(`[terminal] started session ${session_id} name=${name} cwd=${session.cwd}`);
   return { session_id, status: 'ready' };
 }
 
@@ -4990,7 +4993,7 @@ function sendTerminalMessage(session_id, message) {
   const fullPrompt = `${session.context}\n\n---\nUser: ${message}`;
 
   const proc = spawnProc(binary, ['-p', fullPrompt, '--dangerously-skip-permissions'], {
-    cwd: 'C:/Dev/regen-root',
+    cwd: session.cwd || CHITCHAT_FALLBACK_CWD,
     env: process.env,
     stdio: ['ignore', 'pipe', 'pipe'],
     shell: true,
@@ -5071,6 +5074,113 @@ 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);
+  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,
+  };
+  terminalSessions.set(session_id, session);
+  console.log(`[chitchat] started session ${session_id} name=${name} cwd=${rootPath}`);
+  return { session_id, status: 'ready', name, cwd: rootPath };
+}
+
+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.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.status = 'busy';
+  const fullPrompt = `${session.context}\n\n---\nFrom claude.ai: ${message}`;
+
+  const proc = spawnProc(binary, ['-p', fullPrompt, '--dangerously-skip-permissions'], {
+    cwd: session.cwd,
+    env: process.env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: true,
+  });
+  session.activeProc = proc;
+
+  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}`);
+    }
+  });
+
+  return { queued: true, session_id };
+}
+
+function listChitchatSessions() {
+  const sessions = [];
+  for (const [, s] of terminalSessions) {
+    if (s.is_chitchat) {
+      sessions.push({
+        session_id: s.session_id,
+        name: s.name,
+        status: s.status,
+        started_at: s.started_at,
+        turn: s.turn || 0,
+        cwd: s.cwd,
+      });
+    }
+  }
+  return sessions;
+}
+
 const ENV_MAP = {
   "github":           "GITHUB_TOKEN",
   "supabase-anon":    "NEXT_PUBLIC_SUPABASE_ANON_KEY",
@@ -5309,6 +5419,62 @@ const MCP_TOOLS = [
     },
   },
 
+  // ── Chitchat — regen-root collab sessions (claude.ai ↔ Claude Code) ────
+  {
+    name: "chitchat_start",
+    description: "Start a collab session with Claude Code at C:/Dev/regen-root. Auto-injects agent-bootstrap.md as corpus context. Returns session_id for subsequent calls.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Session name slug, e.g. 'collab-sidebar-tabs'" },
+      },
+      required: ["name"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "chitchat_send",
+    description: "Send a message to an active chitchat session. Claude Code runs async — call chitchat_recv to get the response. Returns immediately with { queued: true }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID from chitchat_start" },
+        message:    { type: "string", description: "Message or task to send to Claude Code" },
+      },
+      required: ["session_id", "message"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "chitchat_recv",
+    description: "Poll for Claude Code's response. Returns { status: 'busy' } while processing, { status: 'ready', response: '...' } when done. Poll every 5 seconds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID from chitchat_start" },
+      },
+      required: ["session_id"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "chitchat_list",
+    description: "List all active chitchat sessions with their status and start time.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  },
+  {
+    name: "chitchat_stop",
+    description: "End a chitchat session and free its memory. Always call this when the collab task is done.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID to stop" },
+      },
+      required: ["session_id"],
+      additionalProperties: false,
+    },
+  },
+
   // ── Google Workspace (gws CLI) ──────────────────────────────────────────
   {
     name: "gws_run",
@@ -6020,7 +6186,8 @@ async function handleMcpTool(vault, name, args) {
     case "monkey_dispatch": {
       const { prompt, job_id } = args;
       if (!prompt) return mcpError("prompt required");
-      const result = spawnClaudeTask(prompt, job_id || "untracked");
+      const cwd = await resolveChitchatRoot(vault);
+      const result = spawnClaudeTask(prompt, job_id || "untracked", cwd);
       if (result.error) return mcpError(`${result.error}: ${result.message}`);
       return mcpResult(JSON.stringify(result));
     }
@@ -6028,7 +6195,8 @@ async function handleMcpTool(vault, name, args) {
     case "terminal_start": {
       const { name, knowledge_tier, context_md } = args;
       if (!name) return mcpError("name required");
-      const result = startTerminalSession(name, knowledge_tier || 'db_only', context_md || null);
+      const cwd = await resolveChitchatRoot(vault);
+      const result = startTerminalSession(name, knowledge_tier || 'db_only', context_md || null, cwd);
       if (result.error) return mcpError(`${result.error}: ${result.message}`);
       return mcpResult(JSON.stringify(result));
     }
@@ -6061,6 +6229,42 @@ async function handleMcpTool(vault, name, args) {
       return mcpResult(JSON.stringify(result));
     }
 
+    case "chitchat_start": {
+      const { name } = args;
+      if (!name) return mcpError("name required");
+      const result = await startChitchatSession(name, vault);
+      if (result.error) return mcpError(`${result.error}: ${result.message}`);
+      return mcpResult(JSON.stringify(result));
+    }
+
+    case "chitchat_send": {
+      const { session_id, message } = args;
+      if (!session_id || !message) return mcpError("session_id and message required");
+      const result = sendChitchatMessage(session_id, message);
+      if (result.error) return mcpError(`${result.error}: ${result.message}`);
+      return mcpResult(JSON.stringify(result));
+    }
+
+    case "chitchat_recv": {
+      const { session_id } = args;
+      if (!session_id) return mcpError("session_id required");
+      const result = recvTerminalResponse(session_id);
+      if (result.error) return mcpError(`${result.error}: ${result.message}`);
+      return mcpResult(JSON.stringify(result));
+    }
+
+    case "chitchat_list": {
+      return mcpResult(JSON.stringify(listChitchatSessions()));
+    }
+
+    case "chitchat_stop": {
+      const { session_id } = args;
+      if (!session_id) return mcpError("session_id required");
+      const result = stopTerminalSession(session_id);
+      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.41",
+  "version": "1.5.43",
   "description": "Hardware-bound credential vault for the LIFEAI infrastructure stack",
   "type": "module",
   "bin": {