gm-plugkit 2.0.2208 → 2.0.2209

package/bootstrap.js

@@ -6,8 +6,9 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 const { spawn, spawnSync } = require('child_process');
-const { pidAlive, sha256OfFile, sha256OfFileSync } = require('./gm-process');
+const { sha256OfFile, sha256OfFileSync } = require('./gm-process');
 const shared = require('./bootstrap-shared');
+const core = require('./bootstrap-wasm-core');
 const {
   obsEvent,
   cacheRoot,
@@ -16,49 +17,40 @@ const {
   ensureDir,
   acquireLock,
   releaseLock,
-  isLockStale,
   pruneOldVersions,
   healIfShaMatches,
   daemonVersionSentinel,
   readDaemonVersion,
   writeDaemonVersion,
-  pidCommandLineForKillGuard,
-  pidIsPlugkitProcess,
-  writeKillAttribution,
-  killPid,
   killSpoolWatcherInCwd,
   proactiveKillForNewInstall,
   ensureNextStepWiring: ensureNextStepWiringShared,
-  resolveWindowsExe,
-  resolveNpmCliJs,
 } = shared;
+const {
+  resolveProjectRoot,
+  writeBootstrapError,
+  clearBootstrapError,
+  resolveInstalledWasmPath,
+} = core;
 
-const NPM_PACKAGE = 'plugkit-wasm';
-const ATTEMPT_TIMEOUT_MS = 10 * 60 * 1000;
-const MAX_ATTEMPTS = 3;
-const BACKOFF_MS = [5000, 15000];
 const LOCK_STALE_MS = 30 * 60 * 1000;
 
 const wrapperDir = __dirname;
 
-function log(msg) {
-  try { process.stderr.write(`[gm-plugkit] ${msg}\n`); } catch (_) {}
-}
+const log = core.makeLogger('gm-plugkit');
 
-function writeBootstrapError(spec) {
+function copyWasmToGmTools(wasmPath, version) {
+  core.copyWasmToGmTools(wasmPath, version);
   try {
-    const projectDir = resolveProjectRoot(process.env.CLAUDE_PROJECT_DIR || process.cwd());
-    const spoolDir = path.join(projectDir, '.gm', 'exec-spool');
-    fs.mkdirSync(spoolDir, { recursive: true });
-    fs.writeFileSync(path.join(spoolDir, '.bootstrap-error.json'), JSON.stringify({ ts: new Date().toISOString(), ...spec }, null, 2));
+    const ownPkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf-8'));
+    if (ownPkg && ownPkg.version) {
+      fs.writeFileSync(path.join(gmToolsDir(), 'gm-plugkit.version'), ownPkg.version);
+    }
   } catch (_) {}
 }
 
-function clearBootstrapError() {
-  try {
-    const projectDir = resolveProjectRoot(process.env.CLAUDE_PROJECT_DIR || process.cwd());
-    fs.unlinkSync(path.join(projectDir, '.gm', 'exec-spool', '.bootstrap-error.json'));
-  } catch (_) {}
+function extractNpmPackageWithRetry(destPath, version) {
+  return core.extractNpmPackageWithRetry(destPath, version, { log });
 }
 
 function sha256Hex(buf) {
@@ -179,45 +171,12 @@ function hasNativeEmbedRunner() {
   return names.some(n => { try { return fs.existsSync(path.join(dir, n)); } catch (_) { return false; } });
 }
 
-function resolveProjectRoot(start) {
-  const resolved = path.resolve(start);
-  try {
-    const r = spawnSync('git', ['rev-parse', '--git-common-dir'], { cwd: resolved, encoding: 'utf-8', windowsHide: true, timeout: 1500 });
-    if (r.status === 0 && r.stdout && r.stdout.trim()) {
-      let commonDir = r.stdout.trim();
-      if (!path.isAbsolute(commonDir)) commonDir = path.resolve(resolved, commonDir);
-      if (/(^|[\\/])\.git$/.test(commonDir)) return path.dirname(commonDir);
-    }
-  } catch (_) {}
-  return resolved;
-}
-
 function readVersionFile() {
-  const p = path.join(wrapperDir, 'plugkit.version');
-  if (!fs.existsSync(p)) throw new Error(`plugkit.version not found at ${p}`);
-  return fs.readFileSync(p, 'utf8').trim();
+  return core.readVersionFile(wrapperDir);
 }
 
 function readShaManifest() {
-  const p = path.join(wrapperDir, 'plugkit.sha256');
-  if (!fs.existsSync(p)) return null;
-  const raw = fs.readFileSync(p, 'utf8');
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === 'object') {
-      const out = {};
-      for (const [name, sha] of Object.entries(parsed)) {
-        if (typeof sha === 'string') out[name] = sha.toLowerCase();
-      }
-      return out;
-    }
-  } catch (_) {}
-  const out = {};
-  for (const line of raw.split(/\r?\n/)) {
-    const m = line.match(/^([0-9a-f]{64})\s+(\S+)\s*$/i);
-    if (m) out[m[2]] = m[1].toLowerCase();
-  }
-  return out;
+  return core.readShaManifest(wrapperDir);
 }
 
 async function fetchRemoteSha(version, artifactName) {
@@ -231,54 +190,6 @@ async function fetchRemoteSha(version, artifactName) {
   }
 }
 
-async function extractNpmPackageWasm(destPath, version) {
-  const tempDir = path.join(path.dirname(destPath), '.npm-extract-' + Date.now());
-  try {
-    ensureDir(tempDir);
-    const startMs = Date.now();
-    log(`extracting npm package ${NPM_PACKAGE}@${version} to ${tempDir}`);
-    obsEvent('bootstrap', 'npm.extract.start', { package: NPM_PACKAGE, version });
-
-    fs.writeFileSync(path.join(tempDir, 'package.json'), JSON.stringify({ name: 'plugkit-extract', version: '0.0.0', private: true }));
-
-    const cmd = resolveWindowsExe('npm');
-    const installArgs = ['install', '--no-audit', '--no-fund', '--no-save', NPM_PACKAGE + '@' + version];
-    const isCmdShim = process.platform === 'win32' && /\.(cmd|bat)$/i.test(cmd);
-    const npmCliJs = isCmdShim ? resolveNpmCliJs(cmd) : null;
-
-    const spawnCmd = npmCliJs ? process.execPath : (isCmdShim ? `"${cmd}"` : cmd);
-    const rawArgs = npmCliJs ? [npmCliJs, ...installArgs] : installArgs;
-    const spawnArgs = (isCmdShim && !npmCliJs) ? rawArgs.map(a => /[\s"]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a) : rawArgs;
-
-    const result = spawnSync(spawnCmd, spawnArgs, {
-      cwd: tempDir,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout: ATTEMPT_TIMEOUT_MS,
-      encoding: 'utf8',
-      windowsHide: true,
-      ...((isCmdShim && !npmCliJs) ? { shell: true } : {}),
-    });
-
-    if (result.error) throw result.error;
-    if (result.status !== 0) {
-      const detail = (result.stderr || result.stdout || '').trim().split(/\r?\n/).slice(-5).join(' | ');
-      const sig = result.signal ? ` signal=${result.signal}` : '';
-      throw new Error(`npm install failed status=${result.status}${sig}: ${detail || 'no stderr/stdout captured'}`);
-    }
-
-    const nodeModulesPath = path.join(tempDir, 'node_modules', NPM_PACKAGE, 'plugkit.wasm');
-    if (!fs.existsSync(nodeModulesPath)) {
-      throw new Error(`plugkit.wasm not found in extracted npm package at ${nodeModulesPath}`);
-    }
-
-    fs.copyFileSync(nodeModulesPath, destPath);
-    log(`extracted ${nodeModulesPath} -> ${destPath}`);
-    obsEvent('bootstrap', 'npm.extract.end', { dur_ms: Date.now() - startMs, ok: true });
-  } finally {
-    try { fs.rmSync(tempDir, { recursive: true, force: true, maxRetries: 1, retryDelay: 50 }); } catch (_) {}
-  }
-}
-
 function httpGetBuffer(url, timeoutMs) {
   const https = require('https');
   const idleTimeoutMs = timeoutMs || 30000;
@@ -355,35 +266,6 @@ async function downloadFromGithubReleases(destPath, version, artifactName) {
   log(`gh-releases wrote ${buf.length} bytes to ${destPath} (artifact=${name})`);
 }
 
-async function extractNpmPackageWithRetry(destPath, version) {
-  let lastErr;
-  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-    try {
-      log(`npm extract attempt ${attempt}/${MAX_ATTEMPTS}: ${NPM_PACKAGE}@${version}`);
-      await extractNpmPackageWasm(destPath, version);
-      return;
-    } catch (err) {
-      lastErr = err;
-      log(`attempt ${attempt} failed: ${err.message}`);
-      obsEvent('bootstrap', 'npm.extract.attempt_failed', { package: NPM_PACKAGE, attempt, max: MAX_ATTEMPTS, err: String(err.message || err) });
-      if (err && (err.code === 'ENOENT' || /ENOENT/.test(String(err.message || '')))) {
-        log(`npm binary unresolvable (ENOENT); skipping retries, falling back`);
-        throw err;
-      }
-      if (err && (err.code === 'EINVAL' || /EINVAL/.test(String(err.message || '')))) {
-        log(`spawn EINVAL on npm shim; skipping retries, falling back`);
-        throw err;
-      }
-      if (attempt < MAX_ATTEMPTS) {
-        const wait = BACKOFF_MS[attempt - 1] || 120000;
-        log(`backing off ${wait}ms`);
-        await new Promise(r => setTimeout(r, wait));
-      }
-    }
-  }
-  throw lastErr;
-}
-
 function killStaleDaemonIfVersionChanged() {
   let currentVersion;
   try { currentVersion = readVersionFile(); }
@@ -391,9 +273,9 @@ function killStaleDaemonIfVersionChanged() {
     obsEvent('bootstrap', 'kill-stale-daemon.version-read-failed', { error: e.message });
     return;
   }
-  const cached = resolveCachedBinary({ version: currentVersion });
-  if (cached) {
-    proactiveKillForNewInstall(currentVersion, cached);
+  const cached = resolveInstalledWasmPath();
+  if (cached && fs.existsSync(cached)) {
+    proactiveKillForNewInstall(currentVersion);
     return;
   }
   const recorded = readDaemonVersion();
@@ -553,51 +435,8 @@ async function bootstrap(opts) {
   }
 }
 
-function copyWasmToGmTools(wasmPath, version) {
-  const dst = gmToolsDir();
-  fs.mkdirSync(dst, { recursive: true });
-  const target = path.join(dst, 'plugkit.wasm');
-
-  let wasmFresh = false;
-  if (fs.existsSync(target)) {
-    try {
-      const cur = sha256OfFileSync(target);
-      const src = sha256OfFileSync(wasmPath);
-      if (cur === src) wasmFresh = true;
-    } catch (_) {}
-  }
-  if (!wasmFresh) {
-    const tmp = `${target}.partial-${process.pid}`;
-    fs.copyFileSync(wasmPath, tmp);
-    try { fs.renameSync(tmp, target); }
-    catch (err) {
-      if (err.code === 'EEXIST' || err.code === 'EPERM') {
-        try { fs.unlinkSync(target); } catch (_) {}
-        fs.renameSync(tmp, target);
-      } else {
-        try { fs.unlinkSync(tmp); } catch (_) {}
-        throw err;
-      }
-    }
-  }
-  fs.writeFileSync(path.join(dst, 'plugkit.version'), version);
-
-  try {
-    const ownPkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf-8'));
-    if (ownPkg && ownPkg.version) {
-      fs.writeFileSync(path.join(dst, 'gm-plugkit.version'), ownPkg.version);
-    }
-  } catch (_) {}
-
-}
-
 function getWasmPath() {
-  const home = process.env.USERPROFILE || process.env.HOME || os.homedir();
-  const primary = path.join(home, '.gm-tools', 'plugkit.wasm');
-  const fallback = path.join(home, '.claude', 'gm-tools', 'plugkit.wasm');
-  if (fs.existsSync(primary)) return primary;
-  if (fs.existsSync(fallback)) return fallback;
-  return primary;
+  return resolveInstalledWasmPath();
 }
 
 function isReady() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.2208",
+  "version": "2.0.2209",
   "description": "Bootstrap and daemon-spawn tool for gm plugkit binary. Downloads the correct platform wasm, verifies SHA256, and launches agentplug-runner (the native wasm host) as the spool watcher daemon.",
   "main": "index.js",
   "bin": {

package/plugkit.version

@@ -1 +1 @@
-0.1.1048
+0.1.1049