gm-skill 0.1.2 → 2.0.1080

package/gm-plugkit/cli.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+'use strict';
+
+const { ensureReady, startSpoolDaemon, getBinaryPath, isReady } = require('./bootstrap');
+
+const usage = `gm-plugkit — Bootstrap and daemon-spawn for gm plugkit binary.
+
+Usage:
+  bun x gm-plugkit@latest          Bootstrap + start spool daemon
+  bun x gm-plugkit@latest --daemon  Same as default
+  bun x gm-plugkit@latest --binary  Print binary path only
+  bun x gm-plugkit@latest --status  JSON status check
+  bun x gm-plugkit@latest --help    Show this help
+`;
+
+(async () => {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(usage);
+    process.exit(0);
+  }
+
+  try {
+    const result = await ensureReady();
+    if (!result.ok) {
+      console.error('Bootstrap failed:', result.error);
+      process.exit(1);
+    }
+
+    const daemon = startSpoolDaemon();
+    if (!daemon.ok) {
+      console.error('Daemon start failed:', daemon.error);
+      process.exit(1);
+    }
+
+    console.log(JSON.stringify({
+      ok: true,
+      binary: result.binaryPath,
+      daemon: daemon,
+      message: 'plugkit ready, spool watcher running'
+    }));
+    process.exit(0);
+  } catch (err) {
+    console.error('gm-plugkit failed:', err.message);
+    process.exit(1);
+  }
+})();

package/gm-plugkit/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+'use strict';
+
+const { ensureReady, startSpoolDaemon, getBinaryPath, isReady, bootstrap } = require('./bootstrap');
+
+module.exports = {
+  ensureReady,
+  startSpoolDaemon,
+  getBinaryPath,
+  isReady,
+  bootstrap,
+};

package/gm-plugkit/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "gm-plugkit",
+  "version": "0.1.0",
+  "description": "Bootstrap and daemon-spawn tool for gm plugkit binary. Downloads the correct platform binary, verifies SHA256, and starts the spool watcher daemon. Includes plugkit-wasm-wrapper for WASM-based spool watching.",
+  "main": "index.js",
+  "bin": {
+    "gm-plugkit": "./cli.js",
+    "plugkit-wasm-wrapper": "./plugkit-wasm-wrapper.js"
+  },
+  "files": [
+    "cli.js",
+    "index.js",
+    "bootstrap.js",
+    "plugkit-wasm-wrapper.js",
+    "plugkit.version",
+    "plugkit.sha256"
+  ],
+  "keywords": ["gm", "plugkit", "bootstrap", "daemon", "spool", "wasm"],
+  "author": "AnEntrypoint",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AnEntrypoint/gm.git",
+    "directory": "gm-starter/gm-plugkit"
+  }
+}

package/gm-plugkit/plugkit-wasm-wrapper.js

@@ -0,0 +1,190 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { watch } from 'fs';
+
+function createWasiShim() {
+  const shim = new Proxy({}, {
+    get(target, prop) {
+      if (prop === 'proc_exit') return (code) => process.exit(code);
+      return () => 0;
+    }
+  });
+  return shim;
+}
+
+function memWriteStr(memory, ptr, len, str) {
+  const bytes = new TextEncoder().encode(str);
+  const buf = new Uint8Array(memory.buffer, ptr, len);
+  buf.set(bytes.slice(0, len));
+  return Math.min(bytes.length, len);
+}
+
+function memReadStr(memory, ptr, len) {
+  const buf = new Uint8Array(memory.buffer, ptr, len);
+  return new TextDecoder().decode(buf);
+}
+
+let nextMemPtr = 0x10000;
+function allocInMemory(memory, data) {
+  const ptr = nextMemPtr;
+  const buf = new Uint8Array(memory.buffer, ptr, data.length);
+  buf.set(data);
+  nextMemPtr += data.length;
+  if (nextMemPtr > memory.buffer.byteLength - 4096) nextMemPtr = 0x10000;
+  return { ptr, len: data.length };
+}
+
+function packResult(str) {
+  const bytes = new TextEncoder().encode(str);
+  const ptr = Math.random() * 0x100000 | 0;
+  const len = bytes.length;
+  return (BigInt(ptr) & 0xffffffffn) | (BigInt(len) << 32n);
+}
+
+async function runSpoolWatcher(instance, spoolDir) {
+  const inDir = path.join(spoolDir, 'in');
+  const outDir = path.join(spoolDir, 'out');
+  fs.mkdirSync(inDir, { recursive: true });
+  fs.mkdirSync(outDir, { recursive: true });
+
+  console.log(`[plugkit-wasm] watching ${inDir}`);
+
+  const processed = new Set();
+  const dispatch = instance.exports.dispatch_verb;
+  if (!dispatch) throw new Error('dispatch_verb not exported');
+
+  const processFile = async (filePath) => {
+    const key = path.relative(inDir, filePath);
+    if (processed.has(key)) return;
+    processed.add(key);
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const relPath = path.relative(inDir, filePath);
+      const dir = path.dirname(relPath);
+      const verb = dir === '.' ? path.basename(filePath, path.extname(filePath)) : dir;
+      const body = content.trim() || '{}';
+
+      const verbBytes = new TextEncoder().encode(verb);
+      const bodyBytes = new TextEncoder().encode(body);
+
+      const { ptr: verbPtr, len: verbLen } = allocInMemory(instance.exports.memory, verbBytes);
+      const { ptr: bodyPtr, len: bodyLen } = allocInMemory(instance.exports.memory, bodyBytes);
+
+      const result = dispatch(verbPtr, verbLen, bodyPtr, bodyLen);
+
+      const ptr = Number(result & 0xffffffffn);
+      const len = Number(result >> 32n);
+      const resultStr = memReadStr(instance.exports.memory, ptr, len);
+
+      const taskId = Math.random().toString(36).slice(2);
+      fs.writeFileSync(path.join(outDir, `${taskId}.json`), resultStr);
+
+      fs.unlinkSync(filePath);
+      processed.delete(key);
+    } catch (e) {
+      console.error(`[plugkit-wasm] error processing ${key}: ${e.message}`);
+      try { fs.unlinkSync(filePath); } catch (_) {}
+      processed.delete(key);
+    }
+  };
+
+  function walkDir(dir) {
+    const files = [];
+    try {
+      for (const entry of fs.readdirSync(dir)) {
+        const fullPath = path.join(dir, entry);
+        const stat = fs.statSync(fullPath);
+        if (stat.isFile()) {
+          files.push(fullPath);
+        } else if (stat.isDirectory()) {
+          files.push(...walkDir(fullPath));
+        }
+      }
+    } catch (e) {
+      console.error(`[plugkit-wasm] error walking ${dir}: ${e.message}`);
+    }
+    return files;
+  }
+
+  const existing = walkDir(inDir);
+  for (const fullPath of existing) {
+    await processFile(fullPath);
+  }
+
+  let debounce = {};
+  watch(inDir, { recursive: true }, (eventType, filename) => {
+    if (!filename) return;
+    const fullPath = path.join(inDir, filename);
+
+    clearTimeout(debounce[fullPath]);
+    debounce[fullPath] = setTimeout(async () => {
+      try {
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+          await processFile(fullPath);
+        }
+      } catch (_) {}
+      delete debounce[fullPath];
+    }, 50);
+  });
+
+  console.log('[plugkit-wasm] spool watcher running');
+  await new Promise(() => {});
+}
+
+(async () => {
+  try {
+    const wasmPath = path.join(os.homedir(), '.claude', 'gm-tools', 'plugkit.wasm');
+    const wasmBuffer = fs.readFileSync(wasmPath);
+    const wasmModule = new WebAssembly.Module(wasmBuffer);
+
+    const memory = new WebAssembly.Memory({ initial: 256, maximum: 512 });
+
+    const hostFunctions = {
+      host_fs_read: () => 0,
+      host_fs_write: () => 0,
+      host_fs_readdir: () => 0,
+      host_fs_stat: () => 0,
+      host_kv_get: () => 0,
+      host_kv_put: () => 0,
+      host_kv_query: () => 0,
+      host_fetch: () => 0,
+      host_vec_search: () => 0,
+      host_vec_embed: () => 0,
+      host_browser_spawn: () => 0,
+      host_browser_eval: () => 0,
+      host_browser_close: () => 0,
+      host_exec_js: () => 0,
+      host_log: (ptr, len) => { console.log('[host_log]'); return 0; },
+      host_now_ms: () => BigInt(Date.now()),
+      host_env_get: () => 0,
+    };
+
+    const importObject = {
+      env: { memory, ...hostFunctions },
+      wasi_snapshot_preview1: createWasiShim(),
+    };
+
+    const instance = new WebAssembly.Instance(wasmModule, importObject);
+
+    const args = process.argv.slice(2);
+    if (args.includes('--version')) {
+      console.log('plugkit v0.1.366 (wasm)');
+      process.exit(0);
+    }
+
+    if (args[0] === 'spool') {
+      const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+      const spoolDir = path.join(projectDir, '.gm', 'exec-spool');
+      await runSpoolWatcher(instance, spoolDir);
+    } else {
+      console.log('[plugkit-wasm] args:', args.join(' '));
+      process.exit(0);
+    }
+  } catch (e) {
+    console.error('[plugkit-wasm] fatal:', e.message);
+    if (process.env.DEBUG) console.error(e.stack);
+    process.exit(1);
+  }
+})();

package/gm-plugkit/plugkit.sha256

@@ -0,0 +1,6 @@
+e5569efe81e4ef06c8349678253ca2845571495e619babb0a79be9268ea83c2a  plugkit-win32-x64.exe
+ce2f09f8ea0dd522345a9d9c3e5b04ba44bc37b2046d311d7ff1737f1b3fbf1a  plugkit-win32-arm64.exe
+a1a1d376986551828e5a39e4ae931accf66f00663aceac1439b2778cb4fffd27  plugkit-darwin-x64
+7c36d730edab5cddf678211146ca670c9ce1def17d8b454234ce4bc04a4d7e85  plugkit-darwin-arm64
+c9db60a399caf53c490dc08705713c7d83a1f62db057585a3950d64ab8fa449a  plugkit-linux-x64
+b9ebabaace995b1768d1d96ae13ca18a6dc5e2ca65b774fcdd457f069a7d115c  plugkit-linux-arm64

package/gm-plugkit/plugkit.version

@@ -0,0 +1 @@
+0.1.366

package/gm.json

@@ -0,0 +1,27 @@
+{
+  "name": "gm",
+  "version": "2.0.1080",
+  "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
+  "author": "AnEntrypoint",
+  "license": "MIT",
+  "keywords": [
+    "claude-code",
+    "claude-plugin",
+    "wfgy",
+    "automation"
+  ],
+  "homepage": "https://github.com/AnEntrypoint/gm",
+  "agents": [
+    {
+      "name": "gm",
+      "description": "Agent (not skill) - immutable programming state machine. Always invoke for all work coordination."
+    }
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "plugkitVersion": "0.1.366"
+}

package/lang/browser.js

@@ -0,0 +1,45 @@
+'use strict';
+const path = require('path');
+const os = require('os');
+const { spawnSync, execSync } = require('child_process');
+const fsSync = require('fs');
+
+function findPlugkit() {
+  if (process.env.PLUGKIT_BIN && fsSync.existsSync(process.env.PLUGKIT_BIN)) return process.env.PLUGKIT_BIN;
+  const home = os.homedir();
+  const isWin = process.platform === 'win32';
+  const exe = isWin ? 'plugkit.exe' : 'plugkit';
+  const candidates = [
+    path.join(home, '.claude', 'gm-tools', exe),
+    path.join(home, '.local', 'bin', exe),
+    path.join(home, '.claude', 'plugins', 'marketplaces', 'gm-cc', 'bin', exe),
+  ];
+  if (process.env.CLAUDE_PLUGIN_ROOT) {
+    candidates.push(path.join(process.env.CLAUDE_PLUGIN_ROOT, 'bin', exe));
+  }
+  for (const p of candidates) {
+    if (fsSync.existsSync(p)) return p;
+  }
+  try { execSync('plugkit --version', { encoding: 'utf-8', timeout: 3000 }); return 'plugkit'; } catch (_) {}
+  return 'plugkit';
+}
+
+module.exports = {
+  id: 'browser',
+  exec: {
+    run(code, cwd) {
+      const tmp = path.join(os.tmpdir(), 'gm-browser-' + Date.now() + '.js');
+      try {
+        fsSync.writeFileSync(tmp, code, 'utf-8');
+        const plugkit = findPlugkit();
+        const opts = { encoding: 'utf-8', timeout: 120000, windowsHide: true, ...(cwd && { cwd }) };
+        const r = spawnSync(plugkit, ['exec', '--lang', 'browser', '--file', tmp], opts);
+        const out = (r.stdout || '').trimEnd();
+        const err = (r.stderr || '').trimEnd();
+        return out && err ? out + '\n[stderr]\n' + err : out || err || '(no output)';
+      } finally {
+        try { fsSync.unlinkSync(tmp); } catch (_) {}
+      }
+    }
+  }
+};

package/lang/ssh.js

@@ -0,0 +1,166 @@
+'use strict';
+const path = require('path');
+const os = require('os');
+const fsSync = require('fs');
+const http = require('http');
+
+function loadTarget(targetName) {
+  const cfgPath = path.join(os.homedir(), '.claude', 'ssh-targets.json');
+  if (!fsSync.existsSync(cfgPath)) throw new Error('No ssh-targets.json found at ' + cfgPath);
+  const cfg = JSON.parse(fsSync.readFileSync(cfgPath, 'utf8'));
+  const name = targetName || 'default';
+  if (!cfg[name]) throw new Error('No target \'' + name + '\' in ssh-targets.json. Available: ' + Object.keys(cfg).join(', '));
+  return cfg[name];
+}
+
+function parseCommand(code) {
+  const lines = code.trim().split('\n');
+  let target = 'default';
+  let cmd = code.trim();
+  if (lines[0].trim().startsWith('@')) {
+    target = lines[0].trim().slice(1);
+    cmd = lines.slice(1).join('\n').trim();
+  }
+  return { target, cmd };
+}
+
+function resolveSsh2() {
+  const candidates = [
+    path.join(os.homedir(), '.claude', 'gm-tools', 'node_modules', 'ssh2'),
+    path.join(os.homedir(), '.claude', 'plugins', 'node_modules', 'ssh2'),
+    'ssh2',
+  ];
+  for (const p of candidates) {
+    try { return require(p); } catch (_) {}
+  }
+  throw new Error('ssh2 not found. Run: cd ~/.claude/gm-tools && npm install ssh2');
+}
+
+function getRunnerPort() {
+  const portFile = path.join(os.tmpdir(), 'glootie-runner.port');
+  try { return parseInt(fsSync.readFileSync(portFile, 'utf8').trim(), 10); } catch { return null; }
+}
+
+function rpcCall(port, method, params) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ method, params });
+    const req = http.request(
+      { hostname: '127.0.0.1', port, path: '/rpc', method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) } },
+      (res) => {
+        let data = '';
+        res.on('data', c => { data += c; });
+        res.on('end', () => {
+          try {
+            const p = JSON.parse(data);
+            if (p.error) return reject(new Error(p.error.message || String(p.error)));
+            resolve(p.result);
+          } catch { reject(new Error('RPC parse error: ' + data)); }
+        });
+      }
+    );
+    req.setTimeout(5000, () => { req.destroy(); reject(new Error('RPC timeout')); });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function runSsh(target, cmd, onData) {
+  return new Promise((resolve, reject) => {
+    const { Client } = resolveSsh2();
+    const ssh = new Client();
+    let out = '';
+    let done = false;
+
+    const finish = (text) => {
+      if (!done) { done = true; ssh.end(); resolve(text != null ? text : out.trimEnd()); }
+    };
+
+    const timeout = setTimeout(() => {
+      if (!done) { done = true; try { ssh.end(); } catch (_) {} resolve(out.trimEnd() || '[timeout after 55s]'); }
+    }, 55000);
+
+    ssh.on('ready', () => {
+      ssh.exec(cmd, { pty: false }, (err, stream) => {
+        if (err) { clearTimeout(timeout); ssh.end(); reject(err); return; }
+        stream.on('data', d => {
+          const s = d.toString();
+          out += s;
+          if (onData) onData(s, 'stdout');
+        });
+        stream.stderr.on('data', d => {
+          const s = d.toString();
+          out += s;
+          if (onData) onData(s, 'stderr');
+        });
+        stream.on('close', () => { clearTimeout(timeout); finish(); });
+      });
+    });
+
+    ssh.on('error', err => { clearTimeout(timeout); if (!done) { done = true; reject(err); } });
+
+    const connOpts = { host: target.host, port: target.port || 22, username: target.username, readyTimeout: 15000 };
+    if (target.password) connOpts.password = target.password;
+    if (target.keyPath) connOpts.privateKey = fsSync.readFileSync(target.keyPath);
+    if (target.passphrase) connOpts.passphrase = target.passphrase;
+    ssh.connect(connOpts);
+  });
+}
+
+async function runBackground(target, cmd) {
+  const port = getRunnerPort();
+  if (!port) return null;
+
+  let taskId;
+  try {
+    const r = await rpcCall(port, 'createTask', { code: '', runtime: 'ssh', workingDirectory: process.cwd() });
+    taskId = r?.taskId ?? r;
+    await rpcCall(port, 'startTask', { taskId });
+  } catch { return null; }
+
+  const onData = (data, type) => {
+    rpcCall(port, 'appendOutput', { taskId, type, data }).catch(() => {});
+  };
+
+  runSsh(target, cmd, onData).then(out => {
+    rpcCall(port, 'completeTask', { taskId, result: { success: true, exitCode: 0, stdout: out, stderr: '', error: null } }).catch(() => {});
+  }).catch(err => {
+    rpcCall(port, 'completeTask', { taskId, result: { success: false, exitCode: 1, stdout: '', stderr: err.message, error: err.message } }).catch(() => {});
+  });
+
+  return taskId;
+}
+
+module.exports = {
+  id: 'ssh',
+  exec: {
+    match: /^exec:ssh/,
+    async run(code) {
+      const { target: targetName, cmd } = parseCommand(code);
+      if (!cmd) return '[no command provided]';
+      const target = loadTarget(targetName);
+
+      // Detect background-only commands (fire-and-forget: ends with & or uses nohup/systemd-run)
+      const isBackground = /(&\s*$|^\s*(nohup|systemd-run|setsid)\s)/m.test(cmd);
+
+      if (isBackground) {
+        const taskId = await runBackground(target, cmd);
+        if (taskId != null) {
+          return 'Backgrounded on remote host. Local task_' + taskId + ' streams output.\n\n' +
+            '  exec:sleep\n  task_' + taskId + '\n\n' +
+            '  exec:status\n  task_' + taskId + '\n\n' +
+            '  exec:close\n  task_' + taskId;
+        }
+      }
+
+      return await runSsh(target, cmd, null);
+    }
+  },
+  context: `=== exec:ssh ===
+exec:ssh
+[@target]
+<shell command>
+
+Runs shell command on remote SSH host. Target from ~/.claude/ssh-targets.json ("default" if no @name). Supports multi-line scripts. Password or key auth. Returns combined stdout+stderr. Commands ending with & or using nohup/systemd-run are backgrounded — use exec:sleep/status/close to follow.`
+};

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,
+};