gm-hermes 2.0.1074 → 2.0.1076

package/hermes-skill.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1074",
+  "version": "2.0.1076",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "homepage": "https://github.com/AnEntrypoint/gm",

package/index.html

@@ -74,7 +74,7 @@ body { display: flex; flex-direction: column; min-height: 100vh; }
 <section>
   <div class="gm-section-label"><span class="slash">//</span>status</div>
   <div class="panel">
-    <div class="panel-head"><span>release · v2.0.1074</span><span>probably emerging</span></div>
+    <div class="panel-head"><span>release · v2.0.1076</span><span>probably emerging</span></div>
     <div class="panel-body">
       <div class="row">
         <span class="code"><span style="color:var(--panel-accent)">●</span></span>

package/lib/browser-spool-handler.js

@@ -0,0 +1,130 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  createSession,
+  sendCommand,
+  getScreenshot,
+  closeSession,
+  isBrowserAvailable,
+} = require('./browser');
+
+const LOG_DIR = path.join(os.homedir(), '.claude', 'gm-log');
+
+function emitHandlerEvent(severity, message, details) {
+  try {
+    const date = new Date().toISOString().split('T')[0];
+    const logDir = path.join(LOG_DIR, date);
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    const logFile = path.join(logDir, 'browser-handler.jsonl');
+    const entry = {
+      ts: new Date().toISOString(),
+      severity,
+      message,
+      ...details,
+    };
+    fs.appendFileSync(logFile, JSON.stringify(entry) + '\n');
+  } catch (e) {
+    console.error(`[browser-handler] Failed to emit event: ${e.message}`);
+  }
+}
+
+async function handleBrowserVerb(body, sessionId) {
+  const lines = body.trim().split('\n');
+  const action = lines[0]?.trim();
+  const args = lines.slice(1).join('\n').trim();
+
+  try {
+    emitHandlerEvent('info', 'Browser verb dispatched', {
+      sessionId,
+      action,
+      argsLength: args.length,
+    });
+
+    const available = await isBrowserAvailable();
+    if (!available) {
+      throw new Error(
+        'Browser API unavailable at 127.0.0.1:5000. Ensure rs-exec is running with browser support enabled.'
+      );
+    }
+
+    switch (action) {
+      case 'start': {
+        const result = await createSession(sessionId);
+        console.log(JSON.stringify(result));
+        return result;
+      }
+
+      case 'stop': {
+        const result = await closeSession(sessionId);
+        console.log(JSON.stringify(result));
+        return result;
+      }
+
+      case 'screenshot': {
+        const result = await getScreenshot(sessionId);
+        console.log(JSON.stringify({
+          ok: result.ok,
+          mimeType: result.mimeType,
+          screenshotLength: result.screenshot?.length || 0,
+          screenshot: result.screenshot,
+        }));
+        return result;
+      }
+
+      case 'click':
+      case 'type':
+      case 'navigate':
+      case 'execute': {
+        let commandArgs = {};
+        if (args) {
+          try {
+            commandArgs = JSON.parse(args);
+          } catch (e) {
+            commandArgs = { value: args };
+          }
+        }
+
+        const result = await sendCommand(sessionId, action, commandArgs);
+        console.log(JSON.stringify(result));
+        return result;
+      }
+
+      default: {
+        let commandArgs = {};
+        if (args) {
+          try {
+            commandArgs = JSON.parse(args);
+          } catch (e) {
+            commandArgs = { value: args };
+          }
+        }
+        const result = await sendCommand(sessionId, action, commandArgs);
+        console.log(JSON.stringify(result));
+        return result;
+      }
+    }
+  } catch (e) {
+    emitHandlerEvent('error', 'Browser verb failed', {
+      sessionId,
+      action,
+      error: e.message,
+    });
+
+    const errorResponse = {
+      ok: false,
+      error: e.message,
+      action,
+      sessionId,
+    };
+
+    console.log(JSON.stringify(errorResponse));
+    throw e;
+  }
+}
+
+module.exports = {
+  handleBrowserVerb,
+};

package/lib/browser.js

@@ -0,0 +1,131 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const spool = require('./spool.js');
+
+const LOG_DIR = path.join(os.homedir(), '.claude', 'gm-log');
+const SESSION_STATE_DIR = path.join(os.homedir(), '.gm', 'browser-sessions');
+
+function emitBrowserEvent(severity, message, details) {
+  try {
+    const date = new Date().toISOString().split('T')[0];
+    const logDir = path.join(LOG_DIR, date);
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(path.join(logDir, 'browser.jsonl'), JSON.stringify({ ts: new Date().toISOString(), severity, message, ...details }) + '\n');
+  } catch (e) {
+    console.error(`[browser] Failed to emit event: ${e.message}`);
+  }
+}
+
+function loadSessionState(sessionId) {
+  try {
+    fs.mkdirSync(SESSION_STATE_DIR, { recursive: true });
+    const stateFile = path.join(SESSION_STATE_DIR, `${sessionId}.json`);
+    if (fs.existsSync(stateFile)) return JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+  } catch (e) {
+    emitBrowserEvent('warn', 'Failed to load session state', { sessionId, error: e.message });
+  }
+  return { sessionId, createdAt: new Date().toISOString(), commands: [] };
+}
+
+function saveSessionState(sessionId, state) {
+  try {
+    fs.mkdirSync(SESSION_STATE_DIR, { recursive: true });
+    fs.writeFileSync(path.join(SESSION_STATE_DIR, `${sessionId}.json`), JSON.stringify(state, null, 2));
+  } catch (e) {
+    emitBrowserEvent('warn', 'Failed to save session state', { sessionId, error: e.message });
+  }
+}
+
+function parseJsonFromStdout(stdout) {
+  const trimmed = (stdout || '').trim();
+  if (!trimmed) return null;
+  const lines = trimmed.split(/\r?\n/).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      return JSON.parse(lines[i]);
+    } catch (e) {}
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch (e) {
+    return null;
+  }
+}
+
+async function runBrowserVerb(action, args, sessionId, timeoutMs = 30000) {
+  const payload = args && Object.keys(args).length > 0 ? `${action}\n${JSON.stringify(args)}` : action;
+  const result = await spool.execSpool(payload, 'browser', { timeoutMs, sessionId });
+  if (!result.ok) throw new Error(result.stderr || result.stdout || `browser verb failed: ${action}`);
+  const parsed = parseJsonFromStdout(result.stdout);
+  return parsed || { ok: true };
+}
+
+async function isBrowserAvailable(sessionId = process.env.CLAUDE_SESSION_ID || 'unknown') {
+  try {
+    const result = await spool.execSpool('health', 'health', { timeoutMs: 1000, sessionId });
+    return !!(result && result.ok);
+  } catch (e) {
+    return false;
+  }
+}
+
+async function createSession(sessionId) {
+  if (!sessionId) throw new Error('sessionId is required');
+  const result = await runBrowserVerb('start', {}, sessionId, 30000);
+  const state = loadSessionState(sessionId);
+  state.browserSessionId = result.browserSessionId || result.sessionId || sessionId;
+  state.status = 'active';
+  state.createdAt = new Date().toISOString();
+  saveSessionState(sessionId, state);
+  return { ok: true, sessionId, browserSessionId: state.browserSessionId };
+}
+
+async function sendCommand(sessionId, commandType, args) {
+  if (!sessionId) throw new Error('sessionId is required');
+  const result = await runBrowserVerb(commandType, args || {}, sessionId, 30000);
+  const state = loadSessionState(sessionId);
+  state.commands = state.commands || [];
+  state.commands.push({ type: commandType, args: args || {}, timestamp: new Date().toISOString() });
+  if (state.commands.length > 1000) state.commands = state.commands.slice(-500);
+  saveSessionState(sessionId, state);
+  return { ok: true, result: result.result || result.data || result };
+}
+
+async function executeScript(sessionId, code, options = {}) {
+  if (!sessionId) throw new Error('sessionId is required');
+  if (!code || typeof code !== 'string') throw new Error('code must be a non-empty string');
+  const payload = { code, ...options };
+  return sendCommand(sessionId, 'execute', payload);
+}
+
+async function getScreenshot(sessionId) {
+  if (!sessionId) throw new Error('sessionId is required');
+  const result = await runBrowserVerb('screenshot', {}, sessionId, 30000);
+  let screenshotData = result.screenshot || result.data || '';
+  if (screenshotData && !screenshotData.startsWith('data:image')) screenshotData = `data:image/png;base64,${screenshotData}`;
+  return { ok: true, screenshot: screenshotData, mimeType: 'image/png' };
+}
+
+async function closeSession(sessionId) {
+  if (!sessionId) throw new Error('sessionId is required');
+  try { await runBrowserVerb('stop', {}, sessionId, 10000); } catch (e) {}
+  const stateFile = path.join(SESSION_STATE_DIR, `${sessionId}.json`);
+  if (fs.existsSync(stateFile)) fs.unlinkSync(stateFile);
+  return { ok: true, sessionId };
+}
+
+async function closeAllSessions(excludeSessionId = null) {
+  if (!fs.existsSync(SESSION_STATE_DIR)) return { ok: true, closed: 0 };
+  const files = fs.readdirSync(SESSION_STATE_DIR);
+  let closed = 0;
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+    const sessionId = file.replace('.json', '');
+    if (excludeSessionId && sessionId === excludeSessionId) continue;
+    try { await closeSession(sessionId); closed++; } catch (e) {}
+  }
+  return { ok: true, closed };
+}
+
+module.exports = { createSession, sendCommand, executeScript, getScreenshot, closeSession, closeAllSessions, isBrowserAvailable, loadSessionState, saveSessionState };

package/lib/codeinsight.js

@@ -0,0 +1,109 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const spool = require('./spool.js');
+
+const CODEINSIGHT_HOST = '127.0.0.1';
+const CODEINSIGHT_PORT = 4802;
+const REQUEST_TIMEOUT_MS = 30000;
+
+function emitEvent(severity, message, details = {}) {
+  try {
+    const date = new Date().toISOString().split('T')[0];
+    const logDir = path.join(os.homedir(), '.claude', 'gm-log', date);
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    const entry = { ts: new Date().toISOString(), severity, message, ...details };
+    fs.appendFileSync(path.join(logDir, 'codeinsight.jsonl'), JSON.stringify(entry) + '\n');
+  } catch (e) {
+    console.error(`[codeinsight] emit failed: ${e.message}`);
+  }
+}
+
+async function checkSocketReachable(host = CODEINSIGHT_HOST, port = CODEINSIGHT_PORT, timeoutMs = 1000) {
+  try {
+    const result = await spool.execSpool('health', 'health', { timeoutMs });
+    return !!(result && result.ok);
+  } catch (e) {
+    return false;
+  }
+}
+
+async function sendRequest(request, sessionId = 'unknown') {
+  const startTime = Date.now();
+  const reachable = await checkSocketReachable();
+
+  if (!reachable) {
+    emitEvent('warn', 'Codeinsight socket unreachable', {
+      host: CODEINSIGHT_HOST,
+      port: CODEINSIGHT_PORT,
+      sessionId,
+      durationMs: Date.now() - startTime,
+    });
+    return { ok: false, error: `Codeinsight daemon unavailable at ${CODEINSIGHT_HOST}:${CODEINSIGHT_PORT}`, durationMs: Date.now() - startTime };
+  }
+
+  try {
+    if (request.action === 'search') {
+      const q = request.discipline && request.discipline !== 'default' ? `@${request.discipline} ${request.query}` : request.query;
+      const result = await spool.execCodesearch(q, { timeoutMs: REQUEST_TIMEOUT_MS, sessionId });
+      if (!result.ok) return { ok: false, error: result.stderr || result.stdout || 'codesearch failed', durationMs: Date.now() - startTime };
+      return { ok: true, raw: result.stdout || '', durationMs: Date.now() - startTime };
+    }
+    return { ok: false, error: `Unsupported action via spool: ${request.action}`, durationMs: Date.now() - startTime };
+  } catch (err) {
+    return { ok: false, error: err.message, durationMs: Date.now() - startTime };
+  }
+}
+
+async function searchCode(query, discipline = 'default', sessionId = 'unknown') {
+  if (!query || typeof query !== 'string' || query.trim().length === 0) {
+    return { ok: false, error: 'Query must be a non-empty string' };
+  }
+  const result = await sendRequest({ action: 'search', query: query.trim(), discipline, sessionId }, sessionId);
+  if (result.ok) {
+    emitEvent('info', 'Search completed', { query: query.trim(), discipline, resultCount: (result.results || []).length, sessionId, durationMs: result.durationMs });
+  }
+  return result;
+}
+
+async function indexProject(projectPath, discipline = 'default', sessionId = 'unknown') {
+  if (!projectPath || typeof projectPath !== 'string') {
+    return { ok: false, error: 'Project path must be a non-empty string' };
+  }
+  if (!fs.existsSync(projectPath)) {
+    emitEvent('warn', 'Project path does not exist', { projectPath, discipline, sessionId });
+    return { ok: false, error: `Project path does not exist: ${projectPath}` };
+  }
+  const result = await sendRequest({ action: 'index', projectPath: path.resolve(projectPath), discipline, sessionId }, sessionId);
+  if (result.ok) {
+    emitEvent('info', 'Index completed', { projectPath: path.resolve(projectPath), discipline, filesIndexed: result.filesIndexed, sessionId, durationMs: result.durationMs });
+  }
+  return result;
+}
+
+async function getDiagnostics(projectPath = null, discipline = 'default', sessionId = 'unknown') {
+  if (projectPath && !fs.existsSync(projectPath)) {
+    return { ok: false, error: `Project path does not exist: ${projectPath}` };
+  }
+  const result = await sendRequest({ action: 'diagnostics', projectPath: projectPath ? path.resolve(projectPath) : null, discipline, sessionId }, sessionId);
+  if (result.ok) {
+    emitEvent('info', 'Diagnostics retrieved', { projectPath: projectPath ? path.resolve(projectPath) : 'system-wide', discipline, diagnosticCount: (result.diagnostics || []).length, sessionId, durationMs: result.durationMs });
+  }
+  return result;
+}
+
+async function getIndexStatus(discipline = 'default', sessionId = 'unknown') {
+  const result = await sendRequest({ action: 'status', discipline, sessionId }, sessionId);
+  if (result.ok) {
+    emitEvent('info', 'Index status retrieved', { discipline, indexed: result.indexed, sessionId, durationMs: result.durationMs });
+  }
+  return result;
+}
+
+module.exports = {
+  searchCode,
+  indexProject,
+  getDiagnostics,
+  getIndexStatus,
+  checkSocketReachable,
+};