mixdog 0.9.76 → 0.9.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.76",
+  "version": "0.9.79",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -33,6 +33,7 @@
     "!scripts/smoke-loop*.mjs",
     "!scripts/*-bench.mjs",
     "!scripts/*bench-*.mjs",
+    "!scripts/verify-embedding-runtime.mjs",
     "!scripts/*.ps1",
     "!scripts/*.jsx",
     "src/",
@@ -40,6 +41,7 @@
     "vendor/"
   ],
   "scripts": {
+    "postinstall": "node scripts/prune-embedding-runtime.mjs",
     "prepack": "npm run build:tui",
     "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run npm run release:patch');process.exit(1)}\"",
     "start": "node src/cli.mjs",
@@ -71,7 +73,10 @@
     "test:anthropic-oauth-race": "node --test scripts/anthropic-oauth-refresh-race-test.mjs",
     "test:grok-oauth-race": "node --test scripts/grok-oauth-refresh-race-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
-    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/maintenance-default-routes-test.mjs scripts/embedding-worker-exit-test.mjs",
+    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/maintenance-default-routes-test.mjs scripts/embedding-worker-exit-test.mjs scripts/embedding-runtime-prune-test.mjs",
+    "test:embedding-runtime": "node --test scripts/embedding-runtime-prune-test.mjs scripts/memory-pg-recovery-test.mjs && node scripts/verify-embedding-runtime.mjs",
+    "test:embedding-runtime:core": "node --test scripts/embedding-runtime-prune-test.mjs scripts/memory-pg-recovery-test.mjs && node scripts/verify-embedding-runtime.mjs --core",
+    "test:embedding-runtime:warmup": "node scripts/verify-embedding-runtime.mjs --warmup",
     "test:code-graph-dispatch": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:code-graph-clean-cache": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs scripts/execution-pending-resume-kick-test.mjs scripts/execution-resume-esc-integration-test.mjs",
@@ -79,7 +84,7 @@
     "test:tui-streaming-window": "node --test scripts/streaming-tail-window-test.mjs",
     "test:tui-ambiguous-width": "node --test scripts/tui-ambiguous-width-test.mjs",
     "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/verify-release-assets-test.mjs && node --test scripts/verify-release-assets-test.mjs",
-    "test:release-focused": "npm run test:release-assets && npm run test:tool-contracts && npm run test:placeholder && npm run smoke:patch && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-root-federation-test.mjs scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && npm run test:session && npm run test:workflow-editor && node --test scripts/tui-transcript-perf-test.mjs",
+    "test:release-focused": "npm run test:release-assets && npm run test:tool-contracts && npm run test:placeholder && npm run smoke:patch && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-root-federation-test.mjs scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && npm run test:session && npm run test:workflow-editor && npm run test:embedding-runtime && node --test scripts/tui-transcript-perf-test.mjs",
     "test:native-edit-wire": "node --test scripts/native-edit-wire-test.mjs",
     "test:patch-binary-cache": "node --test scripts/patch-binary-cache-test.mjs",
     "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs scripts/session-heartbeat-lifecycle-test.mjs scripts/remote-transition-order-test.mjs",

package/scripts/prune-embedding-runtime.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+import { access, readdir, readFile, rm } from 'node:fs/promises'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const SUPPORTED_TARGETS = new Map([
+  ['win32', new Set(['x64', 'arm64'])],
+  ['darwin', new Set(['x64', 'arm64'])],
+  ['linux', new Set(['x64', 'arm64'])],
+])
+
+async function exists(path) {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function removeChildrenExcept(directory, keep) {
+  let entries
+  try {
+    entries = await readdir(directory, { withFileTypes: true })
+  } catch (error) {
+    if (error?.code === 'ENOENT') return
+    throw error
+  }
+  await Promise.all(entries
+    .filter((entry) => !keep.has(entry.name))
+    .map((entry) => rm(join(directory, entry.name), { recursive: true, force: true })))
+}
+
+async function packageName(directory) {
+  try {
+    return JSON.parse(await readFile(join(directory, 'package.json'), 'utf8')).name
+  } catch {
+    return ''
+  }
+}
+
+async function findPackageRoot(entry, expectedName) {
+  let current = dirname(entry)
+  for (;;) {
+    if (await packageName(current) === expectedName) return current
+    const parent = dirname(current)
+    if (parent === current) break
+    current = parent
+  }
+  throw new Error(`Unable to locate ${expectedName} from ${entry}`)
+}
+
+export function embeddingRuntimeTarget(options = {}) {
+  const platform = String(
+    options.platform
+      || process.env.MIXDOG_EMBED_TARGET_PLATFORM
+      || process.platform,
+  ).trim()
+  const arch = String(
+    options.arch
+      || process.env.MIXDOG_EMBED_TARGET_ARCH
+      || process.arch,
+  ).trim()
+  if (!SUPPORTED_TARGETS.get(platform)?.has(arch)) {
+    throw new Error(`Unsupported embedding runtime target: ${platform}-${arch}`)
+  }
+  return { platform, arch, key: `${platform}-${arch}` }
+}
+
+export async function pruneEmbeddingRuntime(packageRoot, options = {}) {
+  const root = resolve(packageRoot)
+  const target = embeddingRuntimeTarget(options)
+  const nodeModules = join(root, 'node_modules')
+  const transformerRoot = join(nodeModules, '@huggingface', 'transformers')
+  const transformerPackage = join(transformerRoot, 'package.json')
+  if (!(await exists(transformerPackage))) {
+    throw new Error(`Embedding runtime is incomplete: missing ${transformerPackage}`)
+  }
+
+  const transformerEntry = join(transformerRoot, 'dist', 'transformers.node.cjs')
+  const transformerImport = join(transformerRoot, 'dist', 'transformers.node.mjs')
+  for (const required of [transformerEntry, transformerImport]) {
+    if (!(await exists(required))) {
+      throw new Error(`Embedding runtime is incomplete: missing ${required}`)
+    }
+  }
+
+  const ortCandidates = [
+    join(transformerRoot, 'node_modules', 'onnxruntime-node'),
+    join(nodeModules, 'onnxruntime-node'),
+  ]
+  const ortRoot = (await Promise.all(ortCandidates.map(async (candidate) => (
+    await exists(join(candidate, 'package.json')) ? candidate : null
+  )))).find(Boolean)
+  if (!ortRoot) throw new Error('Embedding runtime is incomplete: onnxruntime-node is unavailable')
+
+  const targetBinaryDir = join(ortRoot, 'bin', 'napi-v3', target.platform, target.arch)
+  if (!(await exists(join(targetBinaryDir, 'onnxruntime_binding.node')))) {
+    throw new Error(`Embedding runtime is incomplete: missing ${target.key} ONNX binding`)
+  }
+
+  // Transformers' Node conditional export bundles all JS implementation code.
+  // Browser bundles, WASM, maps, source and types are not runtime inputs.
+  await removeChildrenExcept(transformerRoot, new Set([
+    'package.json',
+    'LICENSE',
+    'dist',
+    'node_modules',
+  ]))
+  await removeChildrenExcept(join(transformerRoot, 'dist'), new Set([
+    'transformers.node.cjs',
+    'transformers.node.mjs',
+  ]))
+
+  // onnxruntime-node resolves exactly:
+  // bin/napi-v3/${process.platform}/${process.arch}/onnxruntime_binding.node.
+  // Keep one native payload and remove every foreign OS/architecture.
+  const napiRoot = join(ortRoot, 'bin', 'napi-v3')
+  await removeChildrenExcept(napiRoot, new Set([target.platform]))
+  await removeChildrenExcept(join(napiRoot, target.platform), new Set([target.arch]))
+  await removeChildrenExcept(ortRoot, new Set([
+    'package.json',
+    'dist',
+    'bin',
+    'node_modules',
+  ]))
+
+  // The Node bundle marks onnxruntime-web as an ignored webpack external. Keep
+  // only its manifest so npm's dependency inventory remains coherent.
+  for (const webRoot of [
+    join(nodeModules, 'onnxruntime-web'),
+    join(transformerRoot, 'node_modules', 'onnxruntime-web'),
+  ]) {
+    if (await exists(join(webRoot, 'package.json'))) {
+      await removeChildrenExcept(webRoot, new Set(['package.json', 'LICENSE']))
+    }
+  }
+
+  return {
+    ...target,
+    transformerRoot,
+    ortRoot,
+    targetBinaryDir,
+  }
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : ''
+if (invokedPath === import.meta.url) {
+  const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+  pruneEmbeddingRuntime(packageRoot)
+    .then(({ key }) => {
+      process.stdout.write(`Embedding runtime pruned for ${key}.\n`)
+    })
+    .catch((error) => {
+      process.stderr.write(`Embedding runtime prune failed: ${error?.message || error}\n`)
+      process.exitCode = 1
+    })
+}

package/src/runtime/memory/lib/embedding-provider.mjs

@@ -306,3 +306,17 @@ export async function embedTexts(texts) {
     return cached ? [...cached] : []
   })
 }
+
+export async function shutdownEmbeddingProvider() {
+  const activeWorker = worker
+  worker = null
+  _warmupPromise = null
+  _modelReady = false
+  cachedDims = null
+  queryEmbeddingCache.clear()
+  if (!activeWorker) return
+  const shutdownError = new Error('embedding provider shut down')
+  for (const [, pending] of _pending) pending.reject(shutdownError)
+  _pending.clear()
+  await activeWorker.terminate()
+}

package/src/runtime/memory/lib/pg/process.mjs

@@ -77,18 +77,11 @@ function readPostmasterInfo(pgdataDir) {
   }
 }
 
-function pgIsReady(runtimeDir, env, port) {
-  const probe = spawnSync(pgBin(runtimeDir, 'pg_isready'), ['-h', '127.0.0.1', '-p', String(port)], {
-    env, stdio: 'pipe', timeout: 3_000, windowsHide: true,
-  })
-  return probe.status === 0
-}
-
 async function awaitExistingPostmaster({ runtimeDir, pgdataDir, env, waitMs }) {
   const deadline = Date.now() + Math.max(0, Number(waitMs) || 0)
   let info = readPostmasterInfo(pgdataDir)
   while (info.pid && info.port) {
-    if (pgIsReady(runtimeDir, env, info.port)) return { state: 'ready', ...info }
+    if (await healthcheckPg({ port: info.port })) return { state: 'ready', ...info }
     if (!isPidAlive(info.pid)) return { state: 'dead', ...info }
     if (Date.now() >= deadline) return { state: 'alive-not-ready', ...info }
     await delay(250)
@@ -185,10 +178,6 @@ export async function startPg({
 }) {
   mkdirSync(pgdataDir, { recursive: true })
 
-  if (process.platform === 'darwin') {
-    try { writeFileSync(join(pgdataDir, '.metadata_never_index'), '') } catch {}
-  }
-
   // Idempotent v2 conf reconcile — runs before attach/init. Returns true if
   // the block was just appended (so the attach path can trigger pg_ctl reload).
   // Fresh-init path falls through to confAppend below which already includes v2.
@@ -282,6 +271,12 @@ export async function startPg({
       )
     }
   }
+  // PostgreSQL requires a completely empty target on first init. Creating the
+  // Spotlight marker before initdb makes every fresh macOS cluster fail with
+  // "directory exists but is not empty"; add it only after initialization.
+  if (process.platform === 'darwin') {
+    try { writeFileSync(join(pgdataDir, '.metadata_never_index'), '') } catch {}
+  }
 
   // Choose a free port (guards against stale postmaster from prior crash).
   const port    = await findFreePort(preferredPort)
@@ -350,7 +345,7 @@ export async function startPg({
     const deadline = Date.now() + 30_000
     // eslint-disable-next-line no-constant-condition
     while (true) {
-      if (pgIsReady(runtimeDir, env, port)) {
+      if (await healthcheckPg({ port })) {
         const pid = await confirmPid()
         // pid confirmed with matching port → ready. Otherwise keep polling until
         // the cap (postmaster.pid not yet written or port mismatch).