gm-skill 2.0.2025 → 2.0.2027

package/gm-plugkit/wrapper/cdp-eval.js

@@ -1,123 +0,0 @@
-import fs from 'fs';
-import http from 'http';
-
-function httpJson(url, timeoutMs) {
-  return new Promise((resolve) => {
-    const req = http.get(url, { timeout: timeoutMs }, (res) => {
-      let body = '';
-      res.on('data', (c) => { body += c; });
-      res.on('end', () => { try { resolve(JSON.parse(body)); } catch (_) { resolve(null); } });
-    });
-    req.on('error', () => resolve(null));
-    req.on('timeout', () => { req.destroy(); resolve(null); });
-  });
-}
-
-async function pickPageTarget(port, startUrl, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const list = await httpJson(`http://127.0.0.1:${port}/json/list`, 2000);
-    if (Array.isArray(list)) {
-      const page = list.find((t) => t.type === 'page' && t.webSocketDebuggerUrl);
-      if (page) return page;
-    }
-    if (startUrl) {
-      const created = await httpJson(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(startUrl)}`, 3000);
-      if (created && created.webSocketDebuggerUrl) return created;
-    }
-    await new Promise((r) => setTimeout(r, 250));
-  }
-  return null;
-}
-
-function cdpSession(wsUrl, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const ws = new WebSocket(wsUrl);
-    let nextId = 1;
-    const pending = new Map();
-    const timer = setTimeout(() => { try { ws.close(); } catch (_) {} reject(new Error('cdp timeout')); }, timeoutMs);
-    ws.addEventListener('open', () => {
-      resolve({
-        send(method, params) {
-          const id = nextId++;
-          return new Promise((res, rej) => {
-            pending.set(id, { res, rej });
-            ws.send(JSON.stringify({ id, method, params: params || {} }));
-          });
-        },
-        close() { clearTimeout(timer); try { ws.close(); } catch (_) {} },
-      });
-    });
-    ws.addEventListener('message', (ev) => {
-      let msg;
-      try { msg = JSON.parse(ev.data); } catch (_) { return; }
-      if (msg.id && pending.has(msg.id)) {
-        const { res, rej } = pending.get(msg.id);
-        pending.delete(msg.id);
-        if (msg.error) rej(new Error(msg.error.message || 'cdp error'));
-        else res(msg.result);
-      }
-    });
-    ws.addEventListener('error', () => { clearTimeout(timer); reject(new Error('cdp websocket error')); });
-  });
-}
-
-// Direct CDP evaluation, replacing the playwriter relay attach+eval that crashes
-// with UV_HANDLE_CLOSING on Windows. Everything up to obtaining Chrome's CDP
-// endpoint is already done by the wrapper (it launches Chrome with
-// --remote-debugging-port and polls /json/version); this drives that endpoint
-// directly over the DevTools websocket, so the crashing relay process is never
-// spawned. Reads {port, startUrl, scriptFile, resultFile, timeoutMs} from argv[2]
-// as JSON, runs the script via Runtime.evaluate (awaitPromise, returnByValue),
-// and writes the returned value to resultFile -- the same result channel the
-// playwriter path used.
-async function main() {
-  const cfg = JSON.parse(process.argv[2]);
-  const { port, startUrl, scriptFile, resultFile, timeoutMs } = cfg;
-  const script = fs.readFileSync(scriptFile, 'utf-8');
-  const target = await pickPageTarget(port, startUrl, Math.min(timeoutMs, 30000));
-  if (!target) {
-    fs.writeFileSync(resultFile, JSON.stringify({ __cdpError: 'no page target on CDP endpoint' }));
-    process.stderr.write('cdp-eval: no page target\n');
-    process.exit(1);
-  }
-  const sess = await cdpSession(target.webSocketDebuggerUrl, timeoutMs);
-  try {
-    await sess.send('Runtime.enable', {});
-    if (startUrl) {
-      await sess.send('Page.enable', {});
-      await sess.send('Page.navigate', { url: startUrl });
-      await new Promise((r) => setTimeout(r, 1200));
-    }
-    // The wrapper's eval body is a function body ending in `return __RET;`.
-    // Wrap it in an async IIFE so Runtime.evaluate resolves the returned value.
-    const wrapped = `(async () => { ${script} })()`;
-    const res = await sess.send('Runtime.evaluate', {
-      expression: wrapped,
-      awaitPromise: true,
-      returnByValue: true,
-      userGesture: true,
-      timeout: timeoutMs,
-    });
-    if (res.exceptionDetails) {
-      const msg = res.exceptionDetails.exception && res.exceptionDetails.exception.description
-        ? res.exceptionDetails.exception.description
-        : (res.exceptionDetails.text || 'evaluate exception');
-      fs.writeFileSync(resultFile, JSON.stringify({ __cdpError: msg }));
-      process.stderr.write(`cdp-eval: exception ${msg}\n`);
-      sess.close();
-      process.exit(1);
-    }
-    const value = res.result && ('value' in res.result) ? res.result.value : null;
-    fs.writeFileSync(resultFile, JSON.stringify(value === undefined ? null : value));
-    sess.close();
-    process.exit(0);
-  } catch (e) {
-    fs.writeFileSync(resultFile, JSON.stringify({ __cdpError: String(e && e.message || e) }));
-    process.stderr.write(`cdp-eval: ${e && e.message || e}\n`);
-    try { sess.close(); } catch (_) {}
-    process.exit(1);
-  }
-}
-
-main();

package/gm-plugkit/wrapper/fs-atomic.js

@@ -1,26 +0,0 @@
-import fs from 'fs';
-
-function atomicWriteRaw(filePath, data) {
-  const tmp = filePath + '.tmp.' + process.pid + '.' + Date.now() + '.' + Math.random().toString(36).slice(2, 8);
-  fs.writeFileSync(tmp, data);
-  try {
-    fs.renameSync(tmp, filePath);
-  } catch (err) {
-    try { fs.unlinkSync(tmp); } catch (_) {}
-    throw err;
-  }
-}
-
-function atomicWriteJson(filePath, obj) {
-  atomicWriteRaw(filePath, JSON.stringify(obj, null, 2));
-}
-
-function readJsonFile(fp, fallback) {
-  try { return JSON.parse(fs.readFileSync(fp, 'utf-8')); } catch (_) { return fallback; }
-}
-
-function writeJsonFile(fp, value) {
-  try { atomicWriteJson(fp, value); } catch (_) {}
-}
-
-export { atomicWriteRaw, atomicWriteJson, readJsonFile, writeJsonFile };

package/gm-plugkit/wrapper/kv-store.js

@@ -1,81 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-function safeName(s) { return String(s).replace(/[^A-Za-z0-9._-]/g, '_'); }
-
-function projectKvDir(ns) {
-  const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  return path.join(projectRoot, '.gm', 'disciplines', safeName(ns));
-}
-
-function makeLegacyKvDir(kvDir) {
-  return function legacyKvDir(ns) {
-    return path.join(kvDir, safeName(ns));
-  };
-}
-
-function makeKvFilePath() {
-  return function kvFilePath(ns, key, ensureDir) {
-    const dir = projectKvDir(ns);
-    if (ensureDir) fs.mkdirSync(dir, { recursive: true });
-    return path.join(dir, safeName(key) + '.json');
-  };
-}
-
-function makeKvReadResolve(legacyKvDir) {
-  const kvFilePath = makeKvFilePath();
-  return function kvReadResolve(ns, key) {
-    const fp = kvFilePath(ns, key);
-    if (fs.existsSync(fp)) return fp;
-    const legacy = path.join(legacyKvDir(ns), safeName(key) + '.json');
-    if (fs.existsSync(legacy)) return legacy;
-    return null;
-  };
-}
-
-function makeKvNamespaceDirs(legacyKvDir) {
-  return function kvNamespaceDirs(ns) {
-    const out = [];
-    const proj = projectKvDir(ns);
-    if (fs.existsSync(proj)) out.push(proj);
-    const legacy = legacyKvDir(ns);
-    if (fs.existsSync(legacy)) out.push(legacy);
-    return out;
-  };
-}
-
-function enabledDisciplineNamespaces(baseNs) {
-  const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  const set = new Set([baseNs]);
-  try {
-    const enabledPath = path.join(projectRoot, '.gm', 'disciplines', 'enabled.txt');
-    if (fs.existsSync(enabledPath)) {
-      const lines = fs.readFileSync(enabledPath, 'utf-8').split(/\r?\n/);
-      for (const ln of lines) {
-        const name = ln.trim();
-        if (name && !name.startsWith('#')) set.add(name);
-      }
-    }
-  } catch (_) {}
-  return Array.from(set);
-}
-
-function jaccardOverlap(a, b) {
-  if (!a || !b) return 0;
-  const tokenize = (s) => new Set(String(s).toLowerCase().split(/[^a-z0-9]+/).filter(t => t.length >= 3));
-  const A = tokenize(a), B = tokenize(b);
-  if (A.size === 0 || B.size === 0) return 0;
-  let inter = 0;
-  for (const t of A) if (B.has(t)) inter++;
-  return inter / (A.size + B.size - inter);
-}
-
-function makeKvHelpers(kvDir) {
-  const legacyKvDir = makeLegacyKvDir(kvDir);
-  const kvFilePath = makeKvFilePath();
-  const kvReadResolve = makeKvReadResolve(legacyKvDir);
-  const kvNamespaceDirs = makeKvNamespaceDirs(legacyKvDir);
-  return { safeName, projectKvDir, legacyKvDir, kvFilePath, kvReadResolve, kvNamespaceDirs, enabledDisciplineNamespaces, jaccardOverlap };
-}
-
-export { safeName, projectKvDir, enabledDisciplineNamespaces, jaccardOverlap, makeKvHelpers };

package/gm-plugkit/wrapper/task-manager.js

@@ -1,272 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-function makeTaskManager({ spawn, spawnSync, logEvent }) {
-  const __tasks = new Map();
-
-  function tasksDir(cwd) {
-    const d = path.join(cwd || process.cwd(), '.gm', 'exec-spool', 'tasks');
-    try { fs.mkdirSync(d, { recursive: true }); } catch (_) {}
-    return d;
-  }
-
-  function taskMetaPath(cwd, id) { return path.join(tasksDir(cwd), `${id}.json`); }
-  function taskOutPath(cwd, id, which) { return path.join(tasksDir(cwd), `${id}.${which}.log`); }
-
-  function writeTaskMeta(cwd, id, meta) {
-    try { fs.writeFileSync(taskMetaPath(cwd, id), JSON.stringify(meta, null, 2)); } catch (_) {}
-  }
-
-  function nextTaskId(cwd) {
-    const counterPath = path.join(tasksDir(cwd), '.counter');
-    let n = 0;
-    try { n = parseInt(fs.readFileSync(counterPath, 'utf-8'), 10) || 0; } catch (_) {}
-    n += 1;
-    try { fs.writeFileSync(counterPath, String(n)); } catch (_) {}
-    return `t${n}`;
-  }
-
-  let _jsRuntimeCmd = null;
-  function resolveJsRuntimeCmd() {
-    if (_jsRuntimeCmd) return _jsRuntimeCmd;
-    if (!/(^|[\\/])node(\.exe)?$/i.test(String(process.execPath || ''))) {
-      _jsRuntimeCmd = process.execPath;
-      return _jsRuntimeCmd;
-    }
-    try {
-      const which = process.platform === 'win32' ? 'where' : 'which';
-      const out = spawnSync(which, ['bun'], { encoding: 'utf-8', windowsHide: true });
-      const first = (out && out.stdout || '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
-      if (first) { _jsRuntimeCmd = first; return _jsRuntimeCmd; }
-    } catch (_) {}
-    _jsRuntimeCmd = process.execPath;
-    return _jsRuntimeCmd;
-  }
-
-  function langToCmd(lang, code) {
-    if (lang === 'nodejs' || lang === 'js' || lang === 'javascript' || lang === 'node') return { cmd: resolveJsRuntimeCmd(), args: ['-e', code], stdinCode: null };
-    if (lang === 'python' || lang === 'py') return { cmd: 'python', args: ['-c', code], stdinCode: null };
-    if (lang === 'bash' || lang === 'sh' || lang === 'shell' || lang === 'zsh') return { cmd: 'bash', args: ['-c', code], stdinCode: null };
-    if (lang === 'powershell' || lang === 'ps1') return { cmd: 'powershell', args: ['-NoProfile', '-NonInteractive', '-Command', code], stdinCode: null };
-    if (lang === 'deno') return { cmd: 'deno', args: ['eval', code], stdinCode: null };
-    return null;
-  }
-
-  const TASK_MAX_TIMEOUT_MS = 10 * 60 * 1000;
-
-  function spawnTask({ cwd, lang, code, timeoutMs }) {
-    const id = nextTaskId(cwd);
-    const built = langToCmd(lang, code);
-    if (!built) return { ok: false, error: `unsupported lang: ${lang}` };
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > TASK_MAX_TIMEOUT_MS) {
-      timeoutMs = TASK_MAX_TIMEOUT_MS;
-    }
-    const outLog = taskOutPath(cwd, id, 'stdout');
-    const errLog = taskOutPath(cwd, id, 'stderr');
-    let outFd = null, errFd = null;
-    try { outFd = fs.openSync(outLog, 'a'); } catch (_) {}
-    try { errFd = fs.openSync(errLog, 'a'); } catch (_) {}
-    const startedMs = Date.now();
-    const isPosix = process.platform !== 'win32';
-    const child = spawn(built.cmd, built.args, {
-      cwd: cwd || process.cwd(),
-      detached: isPosix,
-      stdio: ['ignore', outFd || 'ignore', errFd || 'ignore'],
-      windowsHide: true,
-      env: process.env,
-    });
-    try { if (outFd !== null) fs.closeSync(outFd); } catch (_) {}
-    try { if (errFd !== null) fs.closeSync(errFd); } catch (_) {}
-    const meta = {
-      id,
-      pid: child.pid,
-      pgid: isPosix ? child.pid : null,
-      lang,
-      cmd: built.cmd,
-      cwd: cwd || process.cwd(),
-      started_ms: startedMs,
-      timeout_ms: timeoutMs,
-      deadline_ms: startedMs + timeoutMs,
-      status: 'running',
-      exit_code: null,
-      stdout_log: outLog,
-      stderr_log: errLog,
-    };
-    __tasks.set(id, { child, meta });
-    writeTaskMeta(cwd, id, meta);
-    child.on('exit', (code, signal) => {
-      meta.status = signal ? 'killed' : (code === 0 ? 'completed' : 'failed');
-      meta.exit_code = code;
-      meta.signal = signal;
-      meta.ended_ms = Date.now();
-      writeTaskMeta(meta.cwd, id, meta);
-    });
-    child.on('error', (err) => {
-      meta.status = 'error';
-      meta.error = err.message;
-      meta.ended_ms = Date.now();
-      writeTaskMeta(meta.cwd, id, meta);
-    });
-    logEvent('plugkit', 'task.spawn', { task_id: id, pid: child.pid, lang, timeout_ms: timeoutMs });
-    return { ok: true, task_id: id, pid: child.pid, started_ms: startedMs };
-  }
-
-  function stopTaskById(id) {
-    const entry = __tasks.get(id);
-    if (!entry) {
-      return { ok: false, error: 'unknown task_id', task_id: id };
-    }
-    const { child, meta } = entry;
-    if (meta.status !== 'running') return { ok: true, already: meta.status, task_id: id };
-    const pid = meta.pid;
-    const isPosix = process.platform !== 'win32';
-    try {
-      if (isPosix && meta.pgid) {
-        try { process.kill(-meta.pgid, 'SIGTERM'); } catch (_) {}
-      } else {
-        try { child.kill('SIGTERM'); } catch (_) {}
-      }
-    } catch (_) {}
-    const graceTimer = setTimeout(() => {
-      if (meta.status !== 'running') return;
-      if (isPosix && meta.pgid) {
-        try { process.kill(-meta.pgid, 'SIGKILL'); } catch (_) {}
-      } else if (process.platform === 'win32') {
-        try { spawnSync('taskkill', ['/F', '/T', '/PID', String(pid)], { stdio: 'ignore', timeout: 3000 }); } catch (_) {}
-      } else {
-        try { child.kill('SIGKILL'); } catch (_) {}
-      }
-    }, 2000);
-    graceTimer.unref && graceTimer.unref();
-    logEvent('plugkit', 'task.stop', { task_id: id, pid });
-    return { ok: true, task_id: id, pid };
-  }
-
-  function tailFile(filePath, maxBytes) {
-    try {
-      const stat = fs.statSync(filePath);
-      if (stat.size <= maxBytes) return fs.readFileSync(filePath, 'utf-8');
-      const fd = fs.openSync(filePath, 'r');
-      try {
-        const buf = Buffer.alloc(maxBytes);
-        fs.readSync(fd, buf, 0, maxBytes, stat.size - maxBytes);
-        return buf.toString('utf-8');
-      } finally { try { fs.closeSync(fd); } catch (_) {} }
-    } catch (_) { return ''; }
-  }
-
-  function listTasks(cwd) {
-    const d = tasksDir(cwd);
-    const out = [];
-    try {
-      for (const entry of fs.readdirSync(d)) {
-        if (!entry.endsWith('.json') || entry.startsWith('.')) continue;
-        try {
-          const meta = JSON.parse(fs.readFileSync(path.join(d, entry), 'utf-8'));
-          out.push(meta);
-        } catch (_) {}
-      }
-    } catch (_) {}
-    return out;
-  }
-
-  function reapTimedOutTasks() {
-    const now = Date.now();
-    for (const [id, entry] of __tasks) {
-      const m = entry.meta;
-      if (m.status === 'running' && m.deadline_ms && now > m.deadline_ms) {
-        logEvent('plugkit', 'task.timeout', { task_id: id, pid: m.pid, deadline_ms: m.deadline_ms, now_ms: now });
-        stopTaskById(id);
-      }
-    }
-  }
-
-  function killAllTasks(reason) {
-    let killed = 0;
-    for (const [id, entry] of __tasks) {
-      if (entry.meta.status === 'running') {
-        stopTaskById(id);
-        killed += 1;
-      }
-    }
-    if (killed > 0) logEvent('plugkit', 'task.killAll', { reason, count: killed });
-    return killed;
-  }
-
-  function pidAliveLocal(pid) {
-    if (!Number.isFinite(pid) || pid <= 0) return false;
-    try { process.kill(pid, 0); return true; } catch (_) { return false; }
-  }
-
-  function sweepOrphanedTaskMetaOnBoot(cwd) {
-    let swept = 0;
-    try {
-      const dir = tasksDir(cwd);
-      const now = Date.now();
-      for (const name of fs.readdirSync(dir)) {
-        if (!/^t\d+\.json$/.test(name)) continue;
-        const metaPath = path.join(dir, name);
-        let meta = null;
-        try { meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8')); } catch (_) { continue; }
-        if (!meta || meta.status !== 'running') continue;
-        const stale = !pidAliveLocal(meta.pid) || (meta.deadline_ms && now > meta.deadline_ms);
-        if (!stale) continue;
-        if (pidAliveLocal(meta.pid)) {
-          try {
-            if (process.platform === 'win32') {
-              spawnSync('taskkill', ['/F', '/T', '/PID', String(meta.pid)], { stdio: 'ignore', windowsHide: true, timeout: 3000 });
-            } else {
-              try { process.kill(-meta.pid, 'SIGKILL'); } catch (_) { try { process.kill(meta.pid, 'SIGKILL'); } catch (_) {} }
-            }
-          } catch (_) {}
-        }
-        meta.status = 'reaped-on-boot';
-        meta.ended_ms = now;
-        try { fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2)); } catch (_) {}
-        swept += 1;
-      }
-    } catch (_) {}
-    if (swept > 0) logEvent('plugkit', 'task.bootSweepReaped', { cwd: cwd || process.cwd(), count: swept });
-    return swept;
-  }
-
-  function hostTaskProc(action, params) {
-    switch (action) {
-      case 'spawn': return spawnTask(params);
-      case 'stop': return stopTaskById(params.id || params.task_id);
-      case 'list': return { ok: true, tasks: listTasks(params.cwd) };
-      case 'output': return {
-        ok: true,
-        task_id: params.id || params.task_id,
-        stdout: tailFile(taskOutPath(params.cwd, params.id || params.task_id, 'stdout'), params.max_bytes || 65536),
-        stderr: tailFile(taskOutPath(params.cwd, params.id || params.task_id, 'stderr'), params.max_bytes || 65536),
-      };
-      case 'reap': { reapTimedOutTasks(); return { ok: true }; }
-      case 'killAll': { const n = killAllTasks(params.reason || 'host_task_proc'); return { ok: true, killed: n }; }
-      default: return { ok: false, error: `unknown action: ${action}` };
-    }
-  }
-
-  return {
-    __tasks,
-    tasksDir,
-    taskMetaPath,
-    taskOutPath,
-    writeTaskMeta,
-    nextTaskId,
-    resolveJsRuntimeCmd,
-    langToCmd,
-    TASK_MAX_TIMEOUT_MS,
-    spawnTask,
-    stopTaskById,
-    tailFile,
-    listTasks,
-    reapTimedOutTasks,
-    killAllTasks,
-    pidAliveLocal,
-    sweepOrphanedTaskMetaOnBoot,
-    hostTaskProc,
-  };
-}
-
-export { makeTaskManager };