mixdog 0.7.18 → 0.8.1

package/scripts/ensure-deps.mjs

@@ -1,259 +0,0 @@
-/**
- * ensure-deps.mjs — install or seed runtime deps into <dataDir>/.deps and stamp.
- */
-import { createHash } from 'crypto';
-import { spawnSync } from 'child_process';
-import * as fs from 'fs';
-import * as os from 'os';
-import { dirname, join } from 'path';
-import { assertSafeOwnedDir } from '../src/shared/user-data-guard.mjs';
-
-export const RENAME_RETRY_CODES = new Set(['EPERM', 'EACCES', 'EBUSY', 'EEXIST']);
-const RENAME_BACKOFFS_MS = Object.freeze([25, 50, 100, 200, 400, 800, 1200, 1600]);
-
-export function sleepSync(ms) {
-  try {
-    const buf = new SharedArrayBuffer(4);
-    Atomics.wait(new Int32Array(buf), 0, 0, Math.max(1, Number(ms) || 1));
-  } catch {}
-}
-
-export function renameWithRetrySync(src, dst) {
-  let lastErr = null;
-  for (let attempt = 0; attempt <= RENAME_BACKOFFS_MS.length; attempt++) {
-    try {
-      fs.renameSync(src, dst);
-      return true;
-    } catch (err) {
-      lastErr = err;
-      if (!RENAME_RETRY_CODES.has(err?.code) || attempt >= RENAME_BACKOFFS_MS.length) break;
-      sleepSync(RENAME_BACKOFFS_MS[attempt] + Math.floor(Math.random() * 50));
-    }
-  }
-  throw lastErr;
-}
-
-const requiredDepNames = [
-  ['@modelcontextprotocol', 'sdk', 'package.json'],
-  ['zod', 'package.json'],
-  ['zod-to-json-schema', 'package.json'],
-  ['openai', 'package.json'],
-];
-
-export function hasRequiredDeps(nmDir) {
-  return requiredDepNames.every((parts) => fs.existsSync(join(nmDir, ...parts)));
-}
-
-/** Find hoisted node_modules (npx) that satisfies hasRequiredDeps. */
-export function resolveNmWithRequiredDeps(pluginRoot) {
-  let dir = pluginRoot;
-  for (let depth = 0; depth < 16; depth++) {
-    const nm = join(dir, 'node_modules');
-    if (hasRequiredDeps(nm)) return nm;
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-
-const LOCK_POLL_MS = 250;
-const LOCK_MAX_MS = 15 * 60 * 1000;
-const LOCK_XHOST_MS = 10 * 60 * 1000;
-
-function acquireLock(lockFile) {
-  const start = Date.now();
-  while (Date.now() - start < LOCK_MAX_MS) {
-    try {
-      const body = JSON.stringify({
-        pid: process.pid,
-        hostname: os.hostname(),
-        startedAt: Date.now(),
-      });
-      fs.writeFileSync(lockFile, body, { flag: 'wx' });
-      return;
-    } catch (e) {
-      if (e.code !== 'EEXIST') throw e;
-      try {
-        const raw = fs.readFileSync(lockFile, 'utf8');
-        const body = JSON.parse(raw);
-        const st = fs.statSync(lockFile);
-        const sameHost = body.hostname === os.hostname();
-        let dead = false;
-        if (sameHost) {
-          try { process.kill(body.pid, 0); }
-          catch (ke) { if (ke.code === 'ESRCH') dead = true; }
-        } else if (Date.now() - st.mtimeMs > LOCK_XHOST_MS) {
-          dead = true;
-        }
-        if (dead) fs.unlinkSync(lockFile);
-      } catch { /* lock may have been released — retry */ }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_POLL_MS);
-    }
-  }
-  throw new Error(
-    `timed out waiting for dependency install lock after ${LOCK_MAX_MS / 60000} minutes`,
-  );
-}
-
-function releaseLock(lockFile) {
-  try { fs.unlinkSync(lockFile); } catch {}
-}
-
-function sha256(buf) {
-  return createHash('sha256').update(buf).digest('hex');
-}
-
-export function computeDepHash(pkgJsonPath, pkgLockPath) {
-  if (fs.existsSync(pkgLockPath)) {
-    return sha256(fs.readFileSync(pkgLockPath));
-  }
-  const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
-  const depKeys = ['dependencies', 'optionalDependencies', 'peerDependencies'];
-  const depObj = {};
-  for (const k of depKeys) {
-    if (pkg[k]) {
-      depObj[k] = Object.fromEntries(
-        Object.entries(pkg[k]).sort(([a], [b]) => a.localeCompare(b)),
-      );
-    }
-  }
-  return sha256(Buffer.from(JSON.stringify(depObj)));
-}
-
-const INSTALL_TIMEOUT_MS = 180_000;
-
-function resolveBunExec(bunPath) {
-  for (const p of [bunPath, process.env.BUN_EXEC_PATH]) {
-    if (p && typeof p === 'string' && fs.existsSync(p)) return p;
-  }
-  return null;
-}
-
-function depsAlreadySatisfied(stampPath, sharedNm, currentHash) {
-  let storedHash = '';
-  try { storedHash = fs.readFileSync(stampPath, 'utf8').trim(); } catch {}
-  return currentHash === storedHash && hasRequiredDeps(sharedNm);
-}
-
-function runFrozenLockfileInstall(bunExec, depsDir, stdio = 'inherit') {
-  return spawnSync(bunExec, ['install', '--frozen-lockfile'], {
-    cwd: depsDir,
-    stdio,
-    timeout: INSTALL_TIMEOUT_MS,
-    windowsHide: true,
-    encoding: stdio === 'pipe' ? 'utf8' : undefined,
-  });
-}
-
-/**
- * @returns {{ satisfied: boolean, skipped?: boolean, method?: 'seed'|'install', reason?: string }}
- */
-export function ensureRuntimeDeps({
-  dataDir,
-  pluginRoot,
-  bunPath,
-  seedNm,
-  logPrefix = '[run-mcp]',
-  /** @type {'inherit' | 'pipe' | 'ignore'} */
-  installStdio = 'inherit',
-}) {
-  const pluginPkg = join(pluginRoot, 'package.json');
-  const pluginLock = join(pluginRoot, 'bun.lock');
-
-  const depsDir = join(dataDir, '.deps');
-  const sharedPkg = join(depsDir, 'package.json');
-  const sharedLock = join(depsDir, 'bun.lock');
-  const sharedNm = join(depsDir, 'node_modules');
-  const stamp = join(depsDir, '.deps-stamp');
-  const stampTmp = join(depsDir, '.deps-stamp.tmp');
-  const lockFile = join(depsDir, '.install.lock');
-
-  const currentHash = computeDepHash(pluginPkg, pluginLock);
-  if (depsAlreadySatisfied(stamp, sharedNm, currentHash)) {
-    return { satisfied: true, skipped: true };
-  }
-
-  assertSafeOwnedDir(depsDir, dataDir, 'bun install');
-  fs.mkdirSync(depsDir, { recursive: true });
-  acquireLock(lockFile);
-  try {
-    if (depsAlreadySatisfied(stamp, sharedNm, currentHash)) {
-      return { satisfied: true, skipped: true };
-    }
-
-    fs.copyFileSync(pluginPkg, sharedPkg);
-    if (fs.existsSync(pluginLock)) fs.copyFileSync(pluginLock, sharedLock);
-
-    const bunExec = resolveBunExec(bunPath);
-
-    const canSeed = seedNm && hasRequiredDeps(seedNm);
-    if (canSeed) {
-      process.stderr.write(
-        `${logPrefix} seeding shared deps from ${seedNm} (skipping bun install)\n`,
-      );
-      fs.cpSync(seedNm, sharedNm, { recursive: true, force: true });
-      if (!bunExec) {
-        process.stderr.write(
-          `${logPrefix} bun not available — cannot validate seeded tree against lock\n`,
-        );
-        return { satisfied: false, reason: 'bun unavailable' };
-      }
-      process.stderr.write(
-        `${logPrefix} validating seeded deps: bun install --frozen-lockfile\n`,
-      );
-      const validate = runFrozenLockfileInstall(bunExec, depsDir, installStdio);
-      if (validate.status !== 0) {
-        const detail = validate.status ?? validate.signal ?? 'unknown';
-        process.stderr.write(
-          `${logPrefix} WARN: seeded tree failed frozen-lockfile (${detail}) — ` +
-          'not stamping (runtime will install normally)\n',
-        );
-        return { satisfied: false, reason: 'frozen-lockfile validation failed' };
-      }
-      fs.writeFileSync(stampTmp, currentHash);
-      renameWithRetrySync(stampTmp, stamp);
-      return { satisfied: true, method: 'seed' };
-    } else {
-      if (!bunExec) {
-        process.stderr.write(
-          `${logPrefix} bun not available — skipping install (will retry on launch)\n`,
-        );
-        return { satisfied: false, reason: 'bun unavailable' };
-      }
-      const args = fs.existsSync(sharedLock)
-        ? ['install', '--frozen-lockfile']
-        : ['install'];
-      process.stderr.write(`${logPrefix} installing shared deps: bun ${args.join(' ')}\n`);
-
-      const result = spawnSync(bunExec, args, {
-        cwd: depsDir,
-        stdio: installStdio,
-        timeout: INSTALL_TIMEOUT_MS,
-        windowsHide: true,
-        encoding: installStdio === 'pipe' ? 'utf8' : undefined,
-      });
-      if (result.error?.code === 'ETIMEDOUT' || result.signal === 'SIGTERM') {
-        process.stderr.write(
-          `${logPrefix} WARN: bun install timed out after ${INSTALL_TIMEOUT_MS}ms — ` +
-          'continuing with existing node_modules (stale lock removed)\n',
-        );
-        try { fs.unlinkSync(lockFile); } catch {}
-        return { satisfied: false, reason: 'install timed out' };
-      } else if (result.status !== 0) {
-        const detail = result.status ?? result.signal ?? 'unknown';
-        process.stderr.write(
-          `${logPrefix} WARN: bun install exited with status ${detail} — ` +
-          'continuing with existing node_modules if available\n',
-        );
-        return { satisfied: false, reason: 'install failed' };
-      } else {
-        fs.writeFileSync(stampTmp, currentHash);
-        renameWithRetrySync(stampTmp, stamp);
-        return { satisfied: true, method: 'install' };
-      }
-    }
-  } finally {
-    releaseLock(lockFile);
-  }
-}

package/scripts/fuzzy-e2e.mjs

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-// fuzzy-e2e.mjs — end-to-end check of `list` fuzzy mode against the real repo:
-// a partial name should surface the matching file via rg --files + ranking.
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-
-const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-process.env.CLAUDE_PLUGIN_ROOT ||= ROOT;
-
-const { executeListTool } = await import(
-  pathToFileURL(join(ROOT, 'src/agent/orchestrator/tools/builtin/list-tool.mjs')).href
-);
-
-let fail = 0;
-const check = (name, cond, detail) => {
-  console.log(`${cond ? 'ok  ' : 'FAIL'} ${name}${cond ? '' : ' :: ' + detail}`);
-  if (!cond) fail++;
-};
-
-const out = await executeListTool({ fuzzy: 'edeng', path: 'src' }, ROOT);
-console.log('--- top results ---\n' + String(out).split('\n').slice(0, 5).join('\n') + '\n---');
-check('edeng surfaces edit-engine.mjs', typeof out === 'string' && out.includes('edit-engine.mjs'), String(out).slice(0, 120));
-
-const miss = await executeListTool({ fuzzy: 'zzqqxx', path: 'src' }, ROOT);
-check('no-match returns a clean message', typeof miss === 'string' && /no fuzzy match/.test(miss), String(miss).slice(0, 120));
-
-console.log(fail === 0 ? '\nfuzzy-e2e: PASS' : `\nfuzzy-e2e: FAIL (${fail})`);
-process.exit(fail === 0 ? 0 : 1);

package/scripts/fuzzy-smoke.mjs

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-// fuzzy-smoke.mjs — unit check for the fuzzy filename scorer.
-import { fuzzyScore, fuzzyRank } from '../src/agent/orchestrator/tools/builtin/fuzzy-match.mjs';
-
-let fail = 0;
-const check = (name, cond) => { console.log(`${cond ? 'ok  ' : 'FAIL'} ${name}`); if (!cond) fail++; };
-
-const items = [
-  { path: 'src/agent/orchestrator/tools/builtin/edit-engine.mjs' },
-  { path: 'src/agent/orchestrator/tools/builtin/edit-normalize.mjs' },
-  { path: 'docs/readme.md' },
-  { path: 'src/agent/index.mjs' },
-];
-
-const ranked = fuzzyRank('edeng', items);
-check('edeng -> edit-engine ranks first', ranked.length > 0 && ranked[0].item.path.includes('edit-engine.mjs'));
-
-const idx = fuzzyRank('agidx', items);
-check('agidx -> agent/index ranks first', idx.length > 0 && idx[0].item.path.endsWith('agent/index.mjs'));
-
-check('non-subsequence returns null', fuzzyScore('zzz', 'abc') === null);
-check('empty query scores 0', fuzzyScore('', 'whatever') === 0);
-check('basename beats dir match', fuzzyScore('readme', 'docs/readme.md') > fuzzyScore('readme', 'readme/other.txt'));
-
-console.log(fail === 0 ? '\nfuzzy-smoke: PASS' : `\nfuzzy-smoke: FAIL (${fail})`);
-process.exit(fail === 0 ? 0 : 1);