gm-skill 0.1.2 → 2.0.1080

package/lib/daemon-bootstrap.js

@@ -1,14 +1,14 @@
 const fs = require('fs');
 const path = require('path');
-const net = require('net');
 const crypto = require('crypto');
 const { spawn, execSync } = require('child_process');
 const os = require('os');
+const spool = require('./spool.js');
 
 const LOG_DIR = path.join(os.homedir(), '.claude', 'gm-log');
 const GM_STATE_DIR = path.join(os.homedir(), '.gm');
 
-function emitEvent(daemon, severity, message, details = {}) {
+function emitDaemonEvent(daemon, severity, message, details) {
   try {
     const date = new Date().toISOString().split('T')[0];
     const logDir = path.join(LOG_DIR, date);
@@ -25,7 +25,7 @@ function emitEvent(daemon, severity, message, details = {}) {
     };
     fs.appendFileSync(logFile, JSON.stringify(entry) + '\n');
   } catch (e) {
-    console.error(`[daemon-bootstrap] emit failed: ${e.message}`);
+    console.error(`[daemon-bootstrap] Failed to emit event: ${e.message}`);
   }
 }
 
@@ -65,92 +65,202 @@ function isDaemonRunning(daemonName) {
 }
 
 function checkPortReachable(host, port, timeoutMs = 500) {
-  return new Promise((resolve) => {
-    const socket = new net.Socket();
-    const timeoutHandle = setTimeout(() => {
-      socket.destroy();
-      resolve(false);
-    }, timeoutMs);
-
-    socket.connect(port, host, () => {
-      clearTimeout(timeoutHandle);
-      socket.destroy();
-      resolve(true);
-    });
+  return spool.execSpool('health', 'health', { timeoutMs, sessionId: getSessionId() })
+    .then((r) => !!(r && r.ok))
+    .catch(() => false);
+}
 
-    socket.on('error', () => {
-      clearTimeout(timeoutHandle);
-      resolve(false);
-    });
-  });
+function computeIndexDigest(cwd = process.cwd()) {
+  try {
+    let mtimeSum = 0;
+    const walkDir = (dir) => {
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+              walkDir(path.join(dir, entry.name));
+            }
+          } else {
+            const fullPath = path.join(dir, entry.name);
+            const stat = fs.statSync(fullPath);
+            mtimeSum += stat.mtimeMs;
+          }
+        }
+      } catch (e) {
+        return;
+      }
+    };
+
+    walkDir(cwd);
+
+    let gitHead = '';
+    try {
+      gitHead = execSync('git rev-parse HEAD', { cwd, encoding: 'utf8' }).trim();
+    } catch {
+      gitHead = 'unknown';
+    }
+
+    let dirtyStatus = 'clean';
+    try {
+      const porcelain = execSync('git status --porcelain', { cwd, encoding: 'utf8' }).trim();
+      if (porcelain.length > 0) {
+        dirtyStatus = 'dirty';
+      }
+    } catch {
+      dirtyStatus = 'unknown';
+    }
+
+    const digestInput = `${mtimeSum}:${gitHead}:${dirtyStatus}`;
+    const digest = crypto.createHash('sha256').update(digestInput).digest('hex');
+    return `v1:${digest}:files=${mtimeSum}`;
+  } catch (e) {
+    emitDaemonEvent('digest', 'error', 'Failed to compute digest', { error: e.message });
+    return '';
+  }
 }
 
-function writeStatusFile(daemonName, status, details = {}) {
+function writeStatusFile(daemonName, status, sessionId) {
   try {
     fs.mkdirSync(GM_STATE_DIR, { recursive: true });
     const statusFile = path.join(GM_STATE_DIR, `${daemonName}-status.json`);
     const payload = {
       daemon: daemonName,
       status,
-      sessionId: getSessionId(),
+      sessionId,
       timestamp: new Date().toISOString(),
       pid: process.pid,
-      ...details,
     };
     fs.writeFileSync(statusFile, JSON.stringify(payload, null, 2));
-    emitEvent(daemonName, 'info', 'Status written', { file: statusFile });
+    emitDaemonEvent(daemonName, 'info', 'Status written', { file: statusFile });
   } catch (e) {
-    emitEvent(daemonName, 'warn', 'Failed to write status file', { error: e.message });
+    emitDaemonEvent(daemonName, 'warn', 'Failed to write status file', { error: e.message });
   }
 }
 
-async function checkState(daemonName) {
+async function ensureRsLearningDaemonRunning() {
+  const daemonName = 'rs-learn';
   const sessionId = getSessionId();
   const startTime = Date.now();
 
   try {
-    emitEvent(daemonName, 'info', 'checkState initiated', { sessionId });
+    emitDaemonEvent(daemonName, 'info', 'Daemon startup check initiated', { sessionId });
 
-    const running = isDaemonRunning(daemonName);
-    if (!running) {
-      emitEvent(daemonName, 'info', 'Daemon not running', { sessionId });
-      writeStatusFile(daemonName, 'not_running', { sessionId });
-      return { ok: true, running: false, durationMs: Date.now() - startTime };
+    if (isDaemonRunning(daemonName)) {
+      emitDaemonEvent(daemonName, 'info', 'Daemon already running', { sessionId });
+      writeStatusFile(daemonName, 'running', sessionId);
+      return { ok: true, already_running: true };
     }
 
-    emitEvent(daemonName, 'info', 'Daemon running', { sessionId });
-    writeStatusFile(daemonName, 'running', { sessionId });
-    return { ok: true, running: true, durationMs: Date.now() - startTime };
+    emitDaemonEvent(daemonName, 'info', 'Spawning daemon', { sessionId });
+
+    const env = Object.assign({}, process.env, {
+      CLAUDE_SESSION_ID: sessionId,
+    });
+
+    const proc = spawn('bun', ['x', 'rs-learn@latest'], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      env,
+    });
+
+    const pid = proc.pid;
+    proc.unref();
+
+    emitDaemonEvent(daemonName, 'info', 'Daemon spawned successfully', { pid, sessionId });
+    writeStatusFile(daemonName, 'started', sessionId);
+
+    return {
+      ok: true,
+      pid,
+      sessionId,
+      durationMs: Date.now() - startTime,
+    };
   } catch (e) {
-    emitEvent(daemonName, 'error', 'checkState failed', {
+    emitDaemonEvent(daemonName, 'error', 'Daemon spawn failed', {
       error: e.message,
       sessionId,
       durationMs: Date.now() - startTime,
     });
-    return { ok: false, error: e.message, durationMs: Date.now() - startTime };
+    writeStatusFile(daemonName, 'error', sessionId);
+    throw e;
   }
 }
 
-async function spawnDaemon(daemonName, cmd) {
+async function ensureAcptoapiRunning() {
+  const sessionId = getSessionId();
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const statusPath = path.join(projectDir, '.gm', 'acptoapi-status.json');
+
+  const host = '127.0.0.1';
+  const port = 4800;
+
+  try {
+    const reachable = await checkPortReachable(host, port);
+
+    if (reachable) {
+      emitDaemonEvent('acptoapi', 'info', 'Already running', { port, sessionId });
+      writeStatusFile('acptoapi', 'running', sessionId);
+      return { ok: true, message: 'acptoapi already running' };
+    }
+
+    emitDaemonEvent('acptoapi', 'info', 'Spawning daemon', { port, sessionId });
+
+    const env = Object.assign({}, process.env, {
+      CLAUDE_SESSION_ID: sessionId,
+    });
+
+    try {
+      const child = spawn('bun', ['x', 'acptoapi@latest'], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        env,
+      });
+      child.unref();
+      emitDaemonEvent('acptoapi', 'info', 'Daemon spawned', { pid: child.pid, port, sessionId });
+      writeStatusFile('acptoapi', 'spawned', sessionId);
+      return { ok: true, message: 'acptoapi spawned', pid: child.pid };
+    } catch (spawnErr) {
+      emitDaemonEvent('acptoapi', 'warn', 'Spawn failed, fallback to SDK', {
+        error: spawnErr.message,
+        sessionId,
+      });
+      writeStatusFile('acptoapi', 'spawn_failed', sessionId);
+      return { ok: false, message: 'acptoapi spawn failed, fallback to Anthropic SDK', error: spawnErr.message };
+    }
+  } catch (err) {
+    emitDaemonEvent('acptoapi', 'error', 'Check failed', {
+      error: err.message,
+      sessionId,
+    });
+    writeStatusFile('acptoapi', 'check_error', sessionId);
+    return { ok: false, message: 'acptoapi check failed, fallback to Anthropic SDK', error: err.message };
+  }
+}
+
+async function ensureRsCodeinsightDaemonRunning() {
+  const daemonName = 'rs-codeinsight';
   const sessionId = getSessionId();
   const startTime = Date.now();
 
   try {
-    emitEvent(daemonName, 'info', 'spawn initiated', { cmd, sessionId });
+    emitDaemonEvent(daemonName, 'info', 'Daemon startup check initiated', { sessionId });
 
     if (isDaemonRunning(daemonName)) {
-      emitEvent(daemonName, 'info', 'Already running, skipping spawn', { sessionId });
-      writeStatusFile(daemonName, 'running', { sessionId });
-      return { ok: true, already_running: true, durationMs: Date.now() - startTime };
+      emitDaemonEvent(daemonName, 'info', 'Daemon already running', { sessionId });
+      writeStatusFile(daemonName, 'running', sessionId);
+      return { ok: true, already_running: true };
     }
 
-    emitEvent(daemonName, 'info', 'Spawning daemon', { cmd, sessionId });
+    emitDaemonEvent(daemonName, 'info', 'Spawning daemon', { sessionId });
 
     const env = Object.assign({}, process.env, {
       CLAUDE_SESSION_ID: sessionId,
     });
 
-    const proc = spawn('bun', ['x', cmd], {
+    const proc = spawn('bun', ['x', 'rs-codeinsight@latest'], {
       detached: true,
       stdio: 'ignore',
       windowsHide: true,
@@ -160,155 +270,166 @@ async function spawnDaemon(daemonName, cmd) {
     const pid = proc.pid;
     proc.unref();
 
-    emitEvent(daemonName, 'info', 'Daemon spawned', { pid, cmd, sessionId });
-    writeStatusFile(daemonName, 'spawned', { pid, sessionId });
+    emitDaemonEvent(daemonName, 'info', 'Daemon spawned successfully', { pid, sessionId });
+    writeStatusFile(daemonName, 'started', sessionId);
 
-    return {
-      ok: true,
-      pid,
-      cmd,
-      sessionId,
-      durationMs: Date.now() - startTime,
-    };
+    return { ok: true, pid, sessionId, durationMs: Date.now() - startTime };
   } catch (e) {
-    emitEvent(daemonName, 'error', 'spawn failed', {
+    emitDaemonEvent(daemonName, 'error', 'Daemon spawn failed', {
       error: e.message,
-      cmd,
       sessionId,
       durationMs: Date.now() - startTime,
     });
-    writeStatusFile(daemonName, 'spawn_error', { error: e.message, sessionId });
-    return { ok: false, error: e.message, durationMs: Date.now() - startTime };
+    writeStatusFile(daemonName, 'error', sessionId);
+    throw e;
   }
 }
 
-async function waitForReady(daemonName, host, port, timeoutMs = 30000) {
+async function ensureRsSearchDaemonRunning() {
+  const daemonName = 'rs-search';
   const sessionId = getSessionId();
   const startTime = Date.now();
 
   try {
-    emitEvent(daemonName, 'info', 'waitForReady initiated', {
-      host,
-      port,
-      timeoutMs,
+    emitDaemonEvent(daemonName, 'info', 'Daemon startup check initiated', { sessionId });
+
+    if (isDaemonRunning(daemonName)) {
+      emitDaemonEvent(daemonName, 'info', 'Daemon already running', { sessionId });
+      writeStatusFile(daemonName, 'running', sessionId);
+      return { ok: true, already_running: true };
+    }
+
+    emitDaemonEvent(daemonName, 'info', 'Spawning daemon', { sessionId });
+
+    const env = Object.assign({}, process.env, {
+      CLAUDE_SESSION_ID: sessionId,
+    });
+
+    const proc = spawn('bun', ['x', 'rs-search@latest'], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      env,
+    });
+
+    const pid = proc.pid;
+    proc.unref();
+
+    emitDaemonEvent(daemonName, 'info', 'Daemon spawned successfully', { pid, sessionId });
+    writeStatusFile(daemonName, 'started', sessionId);
+
+    return { ok: true, pid, sessionId, durationMs: Date.now() - startTime };
+  } catch (e) {
+    emitDaemonEvent(daemonName, 'error', 'Daemon spawn failed', {
+      error: e.message,
       sessionId,
+      durationMs: Date.now() - startTime,
     });
+    writeStatusFile(daemonName, 'error', sessionId);
+    throw e;
+  }
+}
+
+async function ensureRsCodeinsightReady(sessionId = getSessionId()) {
+  const startTime = Date.now();
+  const daemonName = 'rs-codeinsight';
+  const host = '127.0.0.1';
+  const port = 4802;
 
-    const deadline = startTime + timeoutMs;
+  try {
+    emitDaemonEvent(daemonName, 'info', 'Ensuring daemon readiness', { sessionId, host, port });
+
+    await ensureRsCodeinsightDaemonRunning();
+
+    const maxWaitMs = 30000;
     const pollIntervalMs = 500;
+    const deadline = Date.now() + maxWaitMs;
 
     while (Date.now() < deadline) {
       const reachable = await checkPortReachable(host, port, 1000);
       if (reachable) {
-        emitEvent(daemonName, 'info', 'Ready', {
+        emitDaemonEvent(daemonName, 'info', 'Daemon ready', {
           host,
           port,
           elapsedMs: Date.now() - startTime,
           sessionId,
         });
-        writeStatusFile(daemonName, 'ready', { host, port, sessionId });
-        return { ok: true, host, port, elapsedMs: Date.now() - startTime };
+        writeStatusFile(daemonName, 'ready', sessionId);
+        return { ok: true, host, port, sessionId, durationMs: Date.now() - startTime };
       }
 
       await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
     }
 
-    emitEvent(daemonName, 'warn', 'Timeout waiting for readiness', {
+    emitDaemonEvent(daemonName, 'warn', 'Timeout waiting for readiness', {
       host,
       port,
-      timeoutMs,
+      maxWaitMs,
       sessionId,
       elapsedMs: Date.now() - startTime,
     });
-    writeStatusFile(daemonName, 'timeout', { host, port, timeoutMs, sessionId });
-    return { ok: false, error: 'Timeout', timeoutMs, elapsedMs: Date.now() - startTime };
+    writeStatusFile(daemonName, 'timeout', sessionId);
+    return { ok: false, error: 'Timeout waiting for codeinsight daemon', durationMs: Date.now() - startTime };
   } catch (e) {
-    emitEvent(daemonName, 'error', 'waitForReady failed', {
+    emitDaemonEvent(daemonName, 'error', 'Failed to ensure readiness', {
       error: e.message,
-      host,
-      port,
       sessionId,
-      elapsedMs: Date.now() - startTime,
-    });
-    return { ok: false, error: e.message, elapsedMs: Date.now() - startTime };
-  }
-}
-
-async function getSocket(daemonName) {
-  try {
-    emitEvent(daemonName, 'info', 'getSocket initiated', { sessionId: getSessionId() });
-
-    const statusFile = path.join(GM_STATE_DIR, `${daemonName}-status.json`);
-    if (!fs.existsSync(statusFile)) {
-      emitEvent(daemonName, 'warn', 'No status file found', { statusFile });
-      return { ok: false, error: 'No status file found' };
-    }
-
-    const status = JSON.parse(fs.readFileSync(statusFile, 'utf8'));
-    const socket = `${status.host || '127.0.0.1'}:${status.port || 'unknown'}`;
-
-    emitEvent(daemonName, 'info', 'Socket retrieved', { socket });
-    return { ok: true, socket, ...status };
-  } catch (e) {
-    emitEvent(daemonName, 'error', 'getSocket failed', {
-      error: e.message,
-      sessionId: getSessionId(),
+      durationMs: Date.now() - startTime,
     });
-    return { ok: false, error: e.message };
+    writeStatusFile(daemonName, 'error', sessionId);
+    return { ok: false, error: e.message, durationMs: Date.now() - startTime };
   }
 }
 
-async function shutdown(daemonName) {
-  const sessionId = getSessionId();
+async function ensureBrowserReady(sessionId = getSessionId()) {
   const startTime = Date.now();
+  const host = '127.0.0.1';
+  const port = 5000;
 
   try {
-    emitEvent(daemonName, 'info', 'shutdown initiated', { sessionId });
+    emitDaemonEvent('browser', 'info', 'Checking browser readiness', { sessionId, host, port });
 
-    const plat = getPlatformKey();
-    let killed = false;
+    const maxWaitMs = 10000;
+    const pollIntervalMs = 250;
+    const deadline = Date.now() + maxWaitMs;
 
-    if (plat === 'win32') {
-      try {
-        execSync(`taskkill /F /IM ${daemonName}* /T`, { stdio: 'ignore' });
-        killed = true;
-      } catch {
-        killed = false;
-      }
-    } else {
-      try {
-        execSync(`pkill -9 -f "${daemonName}"`, { stdio: 'ignore' });
-        killed = true;
-      } catch {
-        killed = false;
+    while (Date.now() < deadline) {
+      const reachable = await checkPortReachable(host, port, 1000);
+      if (reachable) {
+        emitDaemonEvent('browser', 'info', 'Browser ready', {
+          host,
+          port,
+          elapsedMs: Date.now() - startTime,
+          sessionId,
+        });
+        return { ok: true, host, port, sessionId, durationMs: Date.now() - startTime };
       }
+
+      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
     }
 
-    emitEvent(daemonName, 'info', 'shutdown completed', {
-      killed,
+    emitDaemonEvent('browser', 'warn', 'Browser not available', {
+      host,
+      port,
+      maxWaitMs,
       sessionId,
-      durationMs: Date.now() - startTime,
     });
-    writeStatusFile(daemonName, 'shutdown', { killed, sessionId });
-
-    return { ok: true, killed, durationMs: Date.now() - startTime };
+    return { ok: false, error: 'Browser API not available at 127.0.0.1:5000', durationMs: Date.now() - startTime };
   } catch (e) {
-    emitEvent(daemonName, 'error', 'shutdown failed', {
+    emitDaemonEvent('browser', 'error', 'Failed to check browser', {
       error: e.message,
       sessionId,
-      durationMs: Date.now() - startTime,
     });
     return { ok: false, error: e.message, durationMs: Date.now() - startTime };
   }
 }
 
 module.exports = {
-  checkState,
-  spawnDaemon,
-  waitForReady,
-  getSocket,
-  shutdown,
-  emitEvent,
-  isDaemonRunning,
+  ensureAcptoapiRunning,
+  ensureRsCodeinsightDaemonRunning,
+  ensureRsCodeinsightReady,
+  ensureRsSearchDaemonRunning,
+  ensureRsLearningDaemonRunning,
+  ensureBrowserReady,
   checkPortReachable,
 };

package/lib/git.js

@@ -1,4 +1,3 @@
-const net = require('net');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');