@lifeaitools/clauth 1.5.39 → 1.5.41

package/cli/commands/serve.js

@@ -3119,7 +3119,7 @@ function createServer(initPassword, whitelist, port, tunnelHostnameInit = null,
     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");
+      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_"));
       return MCP_TOOLS; // /mcp — all tools
     }
@@ -3494,6 +3494,83 @@ function createServer(initPassword, whitelist, port, tunnelHostnameInit = null,
       return;
     }
 
+    // POST /terminal/start — start a named terminal session
+    if (method === "POST" && reqPath === "/terminal/start") {
+      let body = "";
+      req.on("data", d => body += d);
+      req.on("end", () => {
+        try {
+          const { name, knowledge_tier, context_md } = JSON.parse(body);
+          if (!name) {
+            res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+            return res.end(JSON.stringify({ error: "name required" }));
+          }
+          const tier = knowledge_tier || 'db_only';
+          const result = startTerminalSession(name, tier, context_md || null);
+          const status = result.error ? 503 : 200;
+          res.writeHead(status, { "Content-Type": "application/json", ...CORS });
+          res.end(JSON.stringify(result));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+          res.end(JSON.stringify({ error: "invalid JSON" }));
+        }
+      });
+      return;
+    }
+
+    // POST /terminal/send — send a message to a running terminal session
+    if (method === "POST" && reqPath === "/terminal/send") {
+      let body = "";
+      req.on("data", d => body += d);
+      req.on("end", () => {
+        try {
+          const { session_id, message } = JSON.parse(body);
+          if (!session_id || !message) {
+            res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+            return res.end(JSON.stringify({ error: "session_id and message required" }));
+          }
+          const result = sendTerminalMessage(session_id, message);
+          const status = result.error === 'session_busy' ? 409 : result.error ? 404 : 200;
+          res.writeHead(status, { "Content-Type": "application/json", ...CORS });
+          res.end(JSON.stringify(result));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+          res.end(JSON.stringify({ error: "invalid JSON" }));
+        }
+      });
+      return;
+    }
+
+    // GET /terminal/list — list all active terminal sessions
+    if (method === "GET" && reqPath === "/terminal/list") {
+      res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+      res.end(JSON.stringify(listTerminalSessions()));
+      return;
+    }
+
+    // POST /terminal/stop — stop a terminal session
+    if (method === "POST" && reqPath === "/terminal/stop") {
+      let body = "";
+      req.on("data", d => body += d);
+      req.on("end", () => {
+        try {
+          const { session_id } = JSON.parse(body);
+          if (!session_id) {
+            res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+            return res.end(JSON.stringify({ error: "session_id required" }));
+          }
+          const result = stopTerminalSession(session_id);
+          const status = result.error ? 404 : 200;
+          res.writeHead(status, { "Content-Type": "application/json", ...CORS });
+          res.end(JSON.stringify(result));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json", ...CORS });
+          res.end(JSON.stringify({ error: "invalid JSON" }));
+        }
+      });
+      return;
+    }
+
     // GET|POST /shutdown (for daemon stop — programmatic, keeps boot.key)
     // Accept POST as well — older scripts and curl default to POST
     if ((method === "GET" || method === "POST") && reqPath === "/shutdown") {
@@ -4866,6 +4943,134 @@ function spawnClaudeTask(prompt, jobId) {
   return { status: 'spawned', pid: proc.pid, jobId, activeWorkers: activeCliWorkers };
 }
 
+// ── Terminal session manager ─────────────────────────────────────
+// Rolling-context approach: each session stores a context string.
+// /terminal/send spawns a fresh claude -p with [context + message],
+// captures stdout, stores result back in session context.
+const terminalSessions = new Map(); // session_id → SessionState
+
+function generateSessionId() {
+  return crypto.randomUUID();
+}
+
+function startTerminalSession(name, knowledge_tier, context_md) {
+  const binary = findClaudeBinary();
+  if (!binary) {
+    return { error: 'binary_not_found', message: 'claude CLI not found in PATH or AppData/npm' };
+  }
+  const session_id = generateSessionId();
+  const preamble = context_md
+    ? `${context_md}\n\n---\n`
+    : '';
+  const initialContext = `${preamble}Session: ${name} | Tier: ${knowledge_tier}\nReady. Await instructions.`;
+  const session = {
+    session_id,
+    name,
+    knowledge_tier,
+    status: 'ready',
+    started_at: new Date().toISOString(),
+    context: initialContext,
+    activeProc: null,
+  };
+  terminalSessions.set(session_id, session);
+  console.log(`[terminal] started session ${session_id} name=${name}`);
+  return { session_id, status: 'ready' };
+}
+
+function sendTerminalMessage(session_id, message) {
+  const session = terminalSessions.get(session_id);
+  if (!session) return { error: 'not_found', message: `Session ${session_id} not found` };
+  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---\nUser: ${message}`;
+
+  const proc = spawnProc(binary, ['-p', fullPrompt, '--dangerously-skip-permissions'], {
+    cwd: 'C:/Dev/regen-root',
+    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)';
+      // Append turn to rolling context (cap at ~8000 chars to avoid overflow)
+      const turn = `\n\nUser: ${message}\nAssistant: ${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(`[terminal] session ${session_id} turn=${s.turn} complete code=${code}`);
+    }
+  });
+
+  return { queued: true, session_id };
+}
+
+function recvTerminalResponse(session_id, timeout_ms = 30000) {
+  const session = terminalSessions.get(session_id);
+  if (!session) return { error: 'not_found', message: `Session ${session_id} not found` };
+
+  // If already ready with a response, return it immediately
+  if (session.status === 'ready' && session.lastResponse !== undefined) {
+    return {
+      session_id,
+      status: 'ready',
+      turn: session.turn || 0,
+      response: session.lastResponse,
+      responded_at: session.lastResponseAt,
+    };
+  }
+
+  // Session is still busy — caller should poll again
+  return {
+    session_id,
+    status: session.status,
+    turn: session.turn || 0,
+    response: null,
+    message: session.status === 'busy' ? 'Still processing — poll again in a few seconds' : 'No response yet',
+  };
+}
+
+function listTerminalSessions() {
+  const sessions = [];
+  for (const [, s] of terminalSessions) {
+    sessions.push({
+      session_id: s.session_id,
+      name: s.name,
+      status: s.status,
+      knowledge_tier: s.knowledge_tier,
+      started_at: s.started_at,
+    });
+  }
+  return sessions;
+}
+
+function stopTerminalSession(session_id) {
+  const session = terminalSessions.get(session_id);
+  if (!session) return { error: 'not_found', message: `Session ${session_id} not found` };
+  if (session.activeProc) {
+    try { session.activeProc.kill(); } catch {}
+  }
+  terminalSessions.delete(session_id);
+  console.log(`[terminal] stopped session ${session_id}`);
+  return { stopped: true, session_id };
+}
+
 const ENV_MAP = {
   "github":           "GITHUB_TOKEN",
   "supabase-anon":    "NEXT_PUBLIC_SUPABASE_ANON_KEY",
@@ -5046,6 +5251,64 @@ const MCP_TOOLS = [
     },
   },
 
+  // ── Terminal session manager ───────────────────────────────────────────
+  {
+    name: "terminal_start",
+    description: "Start a named persistent Claude session. Sessions maintain rolling context across sends. Returns session_id for subsequent sends.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name:           { type: "string", description: "Human-readable session name (e.g. 'knowledgedude-prt')" },
+        knowledge_tier: { type: "string", enum: ["db_only", "corpus", "project"], description: "Knowledge tier for the session. 'corpus' injects context_md as preamble." },
+        context_md:     { type: "string", description: "Optional markdown preamble injected as session context (used for 'corpus' tier)" },
+      },
+      required: ["name"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "terminal_send",
+    description: "Send a message to a running terminal session. Spawns a Claude worker with rolling context + message. Returns immediately — session processes async.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID returned by terminal_start" },
+        message:    { type: "string", description: "Message to send to the session" },
+      },
+      required: ["session_id", "message"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "terminal_list",
+    description: "List all active terminal sessions with their status (ready/busy/stopped), knowledge tier, and start time.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  },
+  {
+    name: "terminal_recv",
+    description: "Read the last response from a terminal session. Returns response if ready, or status='busy' if still processing. Poll every 3-5 seconds until status='ready'.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID returned by terminal_start" },
+      },
+      required: ["session_id"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "terminal_stop",
+    description: "Stop a terminal session and remove it from memory. Kills any active process.",
+    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",
@@ -5762,6 +6025,42 @@ async function handleMcpTool(vault, name, args) {
       return mcpResult(JSON.stringify(result));
     }
 
+    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);
+      if (result.error) return mcpError(`${result.error}: ${result.message}`);
+      return mcpResult(JSON.stringify(result));
+    }
+
+    case "terminal_send": {
+      const { session_id, message } = args;
+      if (!session_id || !message) return mcpError("session_id and message required");
+      const result = sendTerminalMessage(session_id, message);
+      if (result.error) return mcpError(`${result.error}: ${result.message}`);
+      return mcpResult(JSON.stringify(result));
+    }
+
+    case "terminal_list": {
+      return mcpResult(JSON.stringify(listTerminalSessions()));
+    }
+
+    case "terminal_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 "terminal_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.39",
+  "version": "1.5.41",
   "description": "Hardware-bound credential vault for the LIFEAI infrastructure stack",
   "type": "module",
   "bin": {