@tomflow/chatloop-tools 0.0.0-stage → 0.4.0

package/lib/control.mjs

@@ -0,0 +1,98 @@
+import {connect} from 'node:net';
+import {existsSync, lstatSync, mkdirSync, readFileSync, statSync, unlinkSync} from 'node:fs';
+import {homedir} from 'node:os';
+import {join} from 'node:path';
+
+export const CONTRACT = 'chat-loop.local-control.v1';
+export const VERSION = '0.4.0';
+export const ACTIONS = new Set(['start','stop','restart','status']);
+export const directory = () => process.env.CHAT_LOOP_LOCAL_TOOLS_STATE_DIR || join(homedir(), '.chat-loop', 'local-tools');
+export const paths = () => ({dir: directory(), socket: join(directory(), 'control.sock'), lock: join(directory(), 'manager.lock'), log: join(directory(), 'events.jsonl')});
+export function registry() {
+  const tools = [{id: 'desktop-commander', enabled: process.env.CHAT_LOOP_LOCAL_TOOLS_FIXTURES !== '1', kind: 'mcp-child'}];
+  if (['1','both'].includes(process.env.CHAT_LOOP_LOCAL_TOOLS_FIXTURES)) {
+    tools.push({id: 'mock-alpha', enabled: true, kind: 'fixture'});
+    tools.push({id: 'mock-beta', enabled: true, kind: 'fixture'});
+  }
+  return tools;
+}
+export function ensurePrivateDir() {
+  const p = paths().dir;
+  mkdirSync(p, {recursive:true, mode:0o700});
+  const s = lstatSync(p);
+  if (!s.isDirectory() || s.isSymbolicLink() || (process.getuid && s.uid !== process.getuid()) || (s.mode & 0o077))
+    throw Object.assign(new Error('Insecure local-tools state directory'), {code:'INSECURE_STATE_DIR'});
+}
+export function lockPresent() {return existsSync(paths().lock);}
+export function verifyOwner(hello) {
+  const p=paths();
+  const d=lstatSync(p.dir), l=lstatSync(p.lock), s=lstatSync(p.socket);
+  if (!d.isDirectory() || d.isSymbolicLink() || (d.mode&0o077) ||
+      !l.isFile() || l.isSymbolicLink() || (l.mode&0o077) ||
+      !s.isSocket() || (s.mode&0o077) ||
+      (process.getuid && [d,l,s].some(f=>f.uid!==process.getuid())))
+    throw Object.assign(new Error('Untrusted local IPC ownership'),{code:'INSECURE_STATE_DIR'});
+  const owner=JSON.parse(readFileSync(p.lock,'utf8'));
+  if(owner.pid!==hello.managerPid || owner.nonce!==hello.ownerNonce ||
+     owner.version!==VERSION)
+    throw Object.assign(new Error('Manager lock and IPC mismatch'),{code:'MANAGER_UNAVAILABLE'});
+}
+export function safeFallback(action, target, requestId) {
+  const found = registry().filter(t => target ? t.id === target : action === 'status' || t.enabled);
+  const unsure = lockPresent();
+  const results = found.map(t => ({toolId:t.id, enabled:t.enabled, before:t.enabled ? (unsure ? 'UNKNOWN' : 'STOPPED') : 'DISABLED',
+    after:t.enabled ? (unsure ? 'UNKNOWN' : 'STOPPED') : 'DISABLED',
+    outcome:unsure && t.enabled ? 'MANAGER_UNAVAILABLE' : action === 'stop' ? 'ALREADY_STOPPED' : 'OBSERVED',
+    pid:null, evidence:unsure ? 'STALE_MANAGER_LOCK' : 'NO_MANAGER_LOCK', error:unsure && t.enabled ? {code:'UNKNOWN_RESULT'} : null}));
+  return {contract:CONTRACT,requestId,action,scope:target?'tool':'all',target:target || null,
+    status:unsure ? 'UNKNOWN':'OK',results};
+}
+export function send(request, timeout=3000) {
+  return new Promise((resolve,reject)=>{
+    let buf = '', done = false;
+    const socket = connect(paths().socket);
+    const timer = setTimeout(()=>finish(Object.assign(new Error('IPC deadline'),{code:'TIMEOUT'})),timeout);
+    function finish(err,value) {if(done)return; done=true; clearTimeout(timer); socket.destroy(); err?reject(err):resolve(value);}
+    socket.on('connect',()=>socket.write(JSON.stringify(request)+'\n'));
+    socket.on('error',err=>finish(err));
+    socket.on('end',()=>{if(!done)finish(Object.assign(new Error('Empty IPC reply'),{code:'UNKNOWN_RESULT'}));});
+    socket.on('data',chunk=>{
+      buf+=chunk.toString();
+      if(buf.length>8*1024*1024)return finish(Object.assign(new Error('IPC reply too large'),{code:'INVALID_REPLY'}));
+      const n=buf.indexOf('\n'); if(n===-1)return;
+      try{finish(null,JSON.parse(buf.slice(0,n)));}catch{finish(Object.assign(new Error('Malformed IPC reply'),{code:'INVALID_REPLY'}));}
+    });
+  });
+}
+export async function talk(request,timeout=12000){
+  const hello=await send({action:'__ping'},1200);
+  if(hello.contract!==CONTRACT||hello.version!==VERSION||
+      hello.registrySignature!==registry().map(t=>t.id+':'+t.enabled).join('|'))
+    throw Object.assign(new Error('Version or registry mismatch'),{code:'INCOMPATIBLE_VERSION'});
+  verifyOwner(hello);
+  return send(request,timeout);
+}
+export async function recoverStaleLock() {
+  const p=paths();
+  if (!existsSync(p.lock)) return;
+  const contents=readFileSync(p.lock,'utf8');
+  let data; try{data=JSON.parse(contents);}catch{throw Object.assign(new Error('Unrecognized owner lock'),{code:'MANAGER_UNAVAILABLE'});}
+  if (!Number.isSafeInteger(data.pid) || data.pid<2 || !data.nonce) throw Object.assign(new Error('Unverified owner lock'),{code:'MANAGER_UNAVAILABLE'});
+  try { process.kill(data.pid,0); throw Object.assign(new Error('Owner may still be alive'),{code:'MANAGER_UNAVAILABLE'}); }
+  catch(err){ if(err.code!=='ESRCH')throw err; }
+  // Fail closed on a changed lock; never send signals to a PID read from disk.
+  if(readFileSync(p.lock,'utf8')!==contents)throw Object.assign(new Error('Owner changed'),{code:'MANAGER_UNAVAILABLE'});
+  if(existsSync(p.socket)) {
+    const s=lstatSync(p.socket);
+    if(!s.isSocket() || (process.getuid && s.uid!==process.getuid()))throw Object.assign(new Error('Unowned socket'),{code:'MANAGER_UNAVAILABLE'});
+    unlinkSync(p.socket);
+  }
+  unlinkSync(p.lock);
+}
+export function exitCode(reply) {
+  if(reply?.error?.code==='UNKNOWN_TOOL' || reply?.error?.code==='DISABLED_TOOL' || reply?.error?.code==='INVALID_ARGUMENT')return 2;
+  if(reply?.error?.code==='INCOMPATIBLE_VERSION'||reply?.error?.code==='MANAGER_UNAVAILABLE')return 3;
+  if(reply?.status==='OK')return 0;
+  if(reply?.status==='PARTIAL')return 4;
+  return 5;
+}