@clawchatsai/connector 0.0.69 → 0.0.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawchatsai/connector",
-  "version": "0.0.69",
+  "version": "0.0.71",
   "type": "module",
   "description": "ClawChats OpenClaw plugin — P2P tunnel + local API bridge",
   "main": "dist/index.js",

package/server.js

@@ -277,6 +277,21 @@ const OPENCLAW_SESSIONS_DIR = (() => {
   return fallback;
 })();
 
+// ─── Agent Helpers ───────────────────────────────────────────────────────────
+
+function getSessionsDirForAgent(agentId) {
+  if (!agentId || agentId === 'main') return OPENCLAW_SESSIONS_DIR;
+  return path.join(HOME, '.openclaw', 'agents', agentId, 'sessions');
+}
+
+function validateAgent(agentId) {
+  if (!agentId) return 'main';
+  if (!/^[a-zA-Z0-9_-]+$/.test(agentId)) throw new Error('Invalid agent ID');
+  const agentDir = path.join(HOME, '.openclaw', 'agents', agentId);
+  if (!fs.existsSync(agentDir)) throw new Error(`Agent not found: ${agentId}`);
+  return agentId;
+}
+
 // ─── Workspace Management ───────────────────────────────────────────────────
 
 function ensureDirs() {
@@ -619,13 +634,15 @@ function parseMultipart(req) {
 
 // ─── Context Fill Helper ────────────────────────────────────────────────────
 
-function buildContextPreamble(db, threadId, lastSessionId) {
+function buildContextPreamble(db, threadId, lastSessionId, sessionKey) {
   let summary = null;
   let method = 'raw';
 
   // Try to read old JSONL transcript
   if (lastSessionId) {
-    const jsonlPath = path.join(OPENCLAW_SESSIONS_DIR, `${lastSessionId}.jsonl`);
+    const agentMatch = (sessionKey || '').match(/^agent:([^:]+):/);
+    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
+    const jsonlPath = path.join(sessionsDir, `${lastSessionId}.jsonl`);
     try {
       const content = fs.readFileSync(jsonlPath, 'utf8');
       const lines = content.split('\n').filter(Boolean);
@@ -696,7 +713,9 @@ function buildContextPreamble(db, threadId, lastSessionId) {
 
 function cleanGatewaySession(sessionKey) {
   try {
-    const sessionsPath = path.join(OPENCLAW_SESSIONS_DIR, 'sessions.json');
+    const agentMatch = (sessionKey || '').match(/^agent:([^:]+):/);
+    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
+    const sessionsPath = path.join(sessionsDir, 'sessions.json');
     const raw = fs.readFileSync(sessionsPath, 'utf8');
     const store = JSON.parse(raw);
     const entry = store[sessionKey];
@@ -704,7 +723,7 @@ function cleanGatewaySession(sessionKey) {
 
     // Delete .jsonl transcript
     if (entry.sessionId) {
-      const jsonlPath = path.join(OPENCLAW_SESSIONS_DIR, `${entry.sessionId}.jsonl`);
+      const jsonlPath = path.join(sessionsDir, `${entry.sessionId}.jsonl`);
       try { fs.unlinkSync(jsonlPath); } catch { /* ok */ }
     }
 
@@ -721,7 +740,9 @@ function cleanGatewaySession(sessionKey) {
 
 function cleanGatewaySessionsByPrefix(prefix) {
   try {
-    const sessionsPath = path.join(OPENCLAW_SESSIONS_DIR, 'sessions.json');
+    const agentMatch = (prefix || '').match(/^agent:([^:]+):/);
+    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
+    const sessionsPath = path.join(sessionsDir, 'sessions.json');
     const raw = fs.readFileSync(sessionsPath, 'utf8');
     const store = JSON.parse(raw);
     let cleaned = 0;
@@ -730,7 +751,7 @@ function cleanGatewaySessionsByPrefix(prefix) {
       if (!key.startsWith(prefix)) continue;
       const entry = store[key];
       if (entry?.sessionId) {
-        const jsonlPath = path.join(OPENCLAW_SESSIONS_DIR, `${entry.sessionId}.jsonl`);
+        const jsonlPath = path.join(sessionsDir, `${entry.sessionId}.jsonl`);
         try { fs.unlinkSync(jsonlPath); } catch { /* ok */ }
       }
       delete store[key];
@@ -811,7 +832,9 @@ async function handleCreateWorkspace(req, res) {
   if (ws.workspaces[name]) {
     return sendError(res, 409, 'Workspace already exists');
   }
-  const workspace = { name, label: label || name, color: body.color || null, icon: body.icon || null, createdAt: Date.now() };
+  let agent = 'main';
+  try { agent = validateAgent(body.agent || 'main'); } catch { agent = 'main'; }
+  const workspace = { name, label: label || name, color: body.color || null, icon: body.icon || null, agent, createdAt: Date.now() };
   ws.workspaces[name] = workspace;
   setWorkspaces(ws);
   // Initialize DB
@@ -837,8 +860,38 @@ async function handleUpdateWorkspace(req, res, params) {
   if (body.lastThread !== undefined) {
     ws.workspaces[params.name].lastThread = body.lastThread;
   }
+  let migratedThreads = 0;
+  if (body.agent !== undefined) {
+    let newAgent;
+    try { newAgent = validateAgent(body.agent); } catch (e) { return sendError(res, 400, e.message); }
+    const oldAgent = ws.workspaces[params.name].agent || 'main';
+    if (newAgent !== oldAgent) {
+      const db = getDb(params.name);
+      const threads = db.prepare(
+        `SELECT id, session_key FROM threads WHERE session_key LIKE ?`
+      ).all(`agent:${oldAgent}:${params.name}:chat:%`);
+      db.prepare(`
+        UPDATE threads
+        SET session_key = replace(
+          session_key,
+          'agent:' || ? || ':' || ? || ':chat:',
+          'agent:' || ? || ':' || ? || ':chat:'
+        )
+        WHERE session_key LIKE 'agent:' || ? || ':' || ? || ':chat:%'
+      `).run(oldAgent, params.name, newAgent, params.name, oldAgent, params.name);
+      for (const t of threads) cleanGatewaySession(t.session_key);
+      ws.workspaces[params.name].agent = newAgent;
+      migratedThreads = threads.length;
+      gatewayClient.broadcastToBrowsers(JSON.stringify({
+        type: 'clawchats',
+        event: 'workspace-agent-changed',
+        workspace: params.name,
+        agent: newAgent
+      }));
+    }
+  }
   setWorkspaces(ws);
-  send(res, 200, { workspace: ws.workspaces[params.name] });
+  send(res, 200, { workspace: ws.workspaces[params.name], migratedThreads });
 }
 
 function handleDeleteWorkspace(req, res, params) {
@@ -850,9 +903,6 @@ function handleDeleteWorkspace(req, res, params) {
   if (Object.keys(ws.workspaces).length <= 1) {
     return sendError(res, 400, 'Cannot delete the only workspace');
   }
-  if (ws.active === params.name) {
-    return sendError(res, 400, 'Cannot delete the active workspace');
-  }
   // Close and remove DB
   closeDb(params.name);
   const dbPath = path.join(DATA_DIR, `${params.name}.db`);
@@ -861,12 +911,19 @@ function handleDeleteWorkspace(req, res, params) {
   try { fs.unlinkSync(dbPath + '-shm'); } catch { /* ok */ }
 
   // Clean all gateway sessions for this workspace
-  const cleaned = cleanGatewaySessionsByPrefix(`agent:main:${params.name}:chat:`);
+  const wsAgentForDelete = ws.workspaces[params.name]?.agent || 'main';
+  const cleaned = cleanGatewaySessionsByPrefix(`agent:${wsAgentForDelete}:${params.name}:chat:`);
   if (cleaned > 0) {
     console.log(`Cleaned ${cleaned} gateway sessions for workspace: ${params.name}`);
   }
 
   delete ws.workspaces[params.name];
+
+  // If this was the active workspace, switch active to the first remaining one
+  if (ws.active === params.name) {
+    ws.active = Object.keys(ws.workspaces)[0] || null;
+  }
+
   setWorkspaces(ws);
   send(res, 200, { ok: true });
 }
@@ -1004,7 +1061,8 @@ async function handleCreateThread(req, res) {
   const ws = getWorkspaces();
   const id = body.id || uuid();
   const now = Date.now();
-  const sessionKey = `agent:main:${ws.active}:chat:${id}`;
+  const workspaceAgent = ws.workspaces[ws.active]?.agent || 'main';
+  const sessionKey = `agent:${workspaceAgent}:${ws.active}:chat:${id}`;
 
   try {
     db.prepare(
@@ -1065,9 +1123,11 @@ function handleDeleteThread(req, res, params) {
 
   // Look up sessionId from SQLite or sessions.json as fallback
   let sessionIdToDelete = thread.last_session_id;
+  const threadAgentMatch = (thread.session_key || '').match(/^agent:([^:]+):/);
+  const threadSessionsDir = getSessionsDirForAgent(threadAgentMatch?.[1]);
   if (!sessionIdToDelete) {
     try {
-      const raw = fs.readFileSync(path.join(OPENCLAW_SESSIONS_DIR, 'sessions.json'), 'utf8');
+      const raw = fs.readFileSync(path.join(threadSessionsDir, 'sessions.json'), 'utf8');
       const store = JSON.parse(raw);
       const entry = store[thread.session_key];
       if (entry?.sessionId) sessionIdToDelete = entry.sessionId;
@@ -1079,7 +1139,7 @@ function handleDeleteThread(req, res, params) {
 
   // If cleanGatewaySession didn't find it but we have a sessionId, delete transcript directly
   if (sessionIdToDelete) {
-    const jsonlPath = path.join(OPENCLAW_SESSIONS_DIR, `${sessionIdToDelete}.jsonl`);
+    const jsonlPath = path.join(threadSessionsDir, `${sessionIdToDelete}.jsonl`);
     try { fs.unlinkSync(jsonlPath); } catch { /* ok */ }
   }
 
@@ -1205,7 +1265,7 @@ function handleContextFill(req, res, params) {
   const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
   if (!thread) return sendError(res, 404, 'Thread not found');
 
-  const { preamble, method } = buildContextPreamble(db, params.id, thread.last_session_id);
+  const { preamble, method } = buildContextPreamble(db, params.id, thread.last_session_id, thread.session_key);
   send(res, 200, { preamble, method });
 }
 
@@ -1300,6 +1360,7 @@ async function handleImport(req, res) {
   const importAll = db.transaction(() => {
     for (const t of body.threads) {
       if (!t.id) continue;
+      // TODO: per-project agent — import uses agent:main for now
       const sessionKey = t.session_key || `agent:main:${ws.active}:chat:${t.id}`;
       const result = insertThread.run(
         t.id, sessionKey, t.title || 'Imported chat',
@@ -2409,6 +2470,19 @@ async function _handleRequestImpl(req, res) {
       return await handleTranscribe(req, res);
     }
 
+    // --- Agents ---
+    if (method === 'GET' && urlPath === '/api/agents') {
+      try {
+        const agentsDir = path.join(HOME, '.openclaw', 'agents');
+        const agents = fs.readdirSync(agentsDir, { withFileTypes: true })
+          .filter(e => e.isDirectory())
+          .map(e => e.name);
+        return send(res, 200, { agents });
+      } catch {
+        return send(res, 200, { agents: ['main'] });
+      }
+    }
+
     // --- Workspaces ---
     if (method === 'GET' && urlPath === '/api/workspaces') {
       return handleGetWorkspaces(req, res);
@@ -3199,9 +3273,9 @@ function syncThreadUnreadCount(db, threadId) {
 // Helper: Parse session key
 function parseSessionKey(sessionKey) {
   if (!sessionKey) return null;
-  const match = sessionKey.match(/^agent:main:([^:]+):chat:([^:]+)$/);
+  const match = sessionKey.match(/^agent:([^:]+):([^:]+):chat:([^:]+)$/);
   if (!match) return null; // Non-ClawChats keys — silently ignore
-  return { workspace: match[1], threadId: match[2] };
+  return { agent: match[1], workspace: match[2], threadId: match[3] };
 }
 
 // Helper: Extract content from message
@@ -3541,7 +3615,9 @@ export function createApp(config = {}) {
     }
     const ws = _getWorkspaces();
     if (ws.workspaces[name]) return sendError(res, 409, 'Workspace already exists');
-    const workspace = { name, label: label || name, color: body.color || null, icon: body.icon || null, createdAt: Date.now() };
+    let agent = 'main';
+    try { agent = validateAgent(body.agent || 'main'); } catch { agent = 'main'; }
+    const workspace = { name, label: label || name, color: body.color || null, icon: body.icon || null, agent, createdAt: Date.now() };
     ws.workspaces[name] = workspace;
     _setWorkspaces(ws);
     _getDb(name);
@@ -3556,23 +3632,54 @@ export function createApp(config = {}) {
     if (body.color !== undefined) ws.workspaces[params.name].color = body.color;
     if (body.icon !== undefined) ws.workspaces[params.name].icon = body.icon;
     if (body.lastThread !== undefined) ws.workspaces[params.name].lastThread = body.lastThread;
+    let migratedThreads = 0;
+    if (body.agent !== undefined) {
+      let newAgent;
+      try { newAgent = validateAgent(body.agent); } catch (e) { return sendError(res, 400, e.message); }
+      const oldAgent = ws.workspaces[params.name].agent || 'main';
+      if (newAgent !== oldAgent) {
+        const db = _getDb(params.name);
+        const threads = db.prepare(
+          `SELECT id, session_key FROM threads WHERE session_key LIKE ?`
+        ).all(`agent:${oldAgent}:${params.name}:chat:%`);
+        db.prepare(`
+          UPDATE threads
+          SET session_key = replace(
+            session_key,
+            'agent:' || ? || ':' || ? || ':chat:',
+            'agent:' || ? || ':' || ? || ':chat:'
+          )
+          WHERE session_key LIKE 'agent:' || ? || ':' || ? || ':chat:%'
+        `).run(oldAgent, params.name, newAgent, params.name, oldAgent, params.name);
+        for (const t of threads) cleanGatewaySession(t.session_key);
+        ws.workspaces[params.name].agent = newAgent;
+        migratedThreads = threads.length;
+        _gatewayClient.broadcastToBrowsers(JSON.stringify({
+          type: 'clawchats',
+          event: 'workspace-agent-changed',
+          workspace: params.name,
+          agent: newAgent
+        }));
+      }
+    }
     _setWorkspaces(ws);
-    send(res, 200, { workspace: ws.workspaces[params.name] });
+    send(res, 200, { workspace: ws.workspaces[params.name], migratedThreads });
   }
 
   function _handleDeleteWorkspace(req, res, params) {
     const ws = _getWorkspaces();
     if (!ws.workspaces[params.name]) return sendError(res, 404, 'Workspace not found');
     if (Object.keys(ws.workspaces).length <= 1) return sendError(res, 400, 'Cannot delete the only workspace');
-    if (ws.active === params.name) return sendError(res, 400, 'Cannot delete the active workspace');
     _closeDb(params.name);
     const dbPath = path.join(_DATA_DIR, `${params.name}.db`);
     try { fs.unlinkSync(dbPath); } catch { /* ok */ }
     try { fs.unlinkSync(dbPath + '-wal'); } catch { /* ok */ }
     try { fs.unlinkSync(dbPath + '-shm'); } catch { /* ok */ }
-    const cleaned = cleanGatewaySessionsByPrefix(`agent:main:${params.name}:chat:`);
+    const wsAgentForDelete = ws.workspaces[params.name]?.agent || 'main';
+    const cleaned = cleanGatewaySessionsByPrefix(`agent:${wsAgentForDelete}:${params.name}:chat:`);
     if (cleaned > 0) console.log(`Cleaned ${cleaned} gateway sessions for workspace: ${params.name}`);
     delete ws.workspaces[params.name];
+    if (ws.active === params.name) ws.active = Object.keys(ws.workspaces)[0] || null;
     _setWorkspaces(ws);
     send(res, 200, { ok: true });
   }
@@ -3664,7 +3771,8 @@ export function createApp(config = {}) {
     const ws = _getWorkspaces();
     const id = body.id || uuid();
     const now = Date.now();
-    const sessionKey = `agent:main:${ws.active}:chat:${id}`;
+    const workspaceAgent = ws.workspaces[ws.active]?.agent || 'main';
+    const sessionKey = `agent:${workspaceAgent}:${ws.active}:chat:${id}`;
     try {
       db.prepare('INSERT INTO threads (id, session_key, title, created_at, updated_at) VALUES (?, ?, ?, ?, ?)').run(id, sessionKey, 'New chat', now, now);
     } catch (e) {
@@ -3709,9 +3817,11 @@ export function createApp(config = {}) {
     if (!thread) return sendError(res, 404, 'Thread not found');
     db.prepare('DELETE FROM threads WHERE id = ?').run(params.id);
     let sessionIdToDelete = thread.last_session_id;
+    const tAgentMatch = (thread.session_key || '').match(/^agent:([^:]+):/);
+    const tSessionsDir = getSessionsDirForAgent(tAgentMatch?.[1]);
     if (!sessionIdToDelete) {
       try {
-        const raw = fs.readFileSync(path.join(OPENCLAW_SESSIONS_DIR, 'sessions.json'), 'utf8');
+        const raw = fs.readFileSync(path.join(tSessionsDir, 'sessions.json'), 'utf8');
         const store = JSON.parse(raw);
         const entry = store[thread.session_key];
         if (entry?.sessionId) sessionIdToDelete = entry.sessionId;
@@ -3719,7 +3829,7 @@ export function createApp(config = {}) {
     }
     cleanGatewaySession(thread.session_key);
     if (sessionIdToDelete) {
-      const jsonlPath = path.join(OPENCLAW_SESSIONS_DIR, `${sessionIdToDelete}.jsonl`);
+      const jsonlPath = path.join(tSessionsDir, `${sessionIdToDelete}.jsonl`);
       try { fs.unlinkSync(jsonlPath); } catch { /* ok */ }
     }
     const uploadDir = path.join(_UPLOADS_DIR, params.id);
@@ -3810,7 +3920,7 @@ export function createApp(config = {}) {
     const db = _getActiveDb();
     const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
     if (!thread) return sendError(res, 404, 'Thread not found');
-    const { preamble, method } = buildContextPreamble(db, params.id, thread.last_session_id);
+    const { preamble, method } = buildContextPreamble(db, params.id, thread.last_session_id, thread.session_key);
     send(res, 200, { preamble, method });
   }
 
@@ -3862,6 +3972,7 @@ export function createApp(config = {}) {
     const importAll = db.transaction(() => {
       for (const t of body.threads) {
         if (!t.id) continue;
+        // TODO: per-project agent — import uses agent:main for now
         const sessionKey = t.session_key || `agent:main:${ws.active}:chat:${t.id}`;
         const result = insertThread.run(t.id, sessionKey, t.title || 'Imported chat', t.pinned || 0, t.pin_order || 0, t.model || null, t.last_session_id || null, t.created_at || Date.now(), t.updated_at || Date.now());
         if (result.changes > 0) threadsImported++;
@@ -4612,6 +4723,14 @@ export function createApp(config = {}) {
       if (method === 'GET' && urlPath === '/api/settings') return _handleGetSettings(req, res);
       if (method === 'PUT' && urlPath === '/api/settings') return await _handleSaveSettings(req, res);
       if (method === 'POST' && urlPath === '/api/transcribe') return await handleTranscribe(req, res);
+      if (method === 'GET' && urlPath === '/api/agents') {
+        try {
+          const agentsDir = path.join(HOME, '.openclaw', 'agents');
+          const agents = fs.readdirSync(agentsDir, { withFileTypes: true })
+            .filter(e => e.isDirectory()).map(e => e.name);
+          return send(res, 200, { agents });
+        } catch { return send(res, 200, { agents: ['main'] }); }
+      }
       if (method === 'GET' && urlPath === '/api/workspaces') return _handleGetWorkspaces(req, res);
       if (method === 'POST' && urlPath === '/api/workspaces') return await _handleCreateWorkspace(req, res);
       if ((p = matchRoute(method, urlPath, 'PATCH /api/workspaces/:name'))) return await _handleUpdateWorkspace(req, res, p);