dsh-graft-plugin 0.3.3 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-graft-plugin",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Shows which graft index a dsh session is serving and whether it still matches the code, and gives the model graft_ask, graft_grep, graft_callers, graft_skeleton and graft_map as native tools.",
   "icon": "assets/icon.png",
   "type": "module",

package/scripts/test-autosync.mjs

@@ -1,4 +1,4 @@
-import { join } from 'node:path'
+import { delimiter, join } from 'node:path'
 import { resolveGraftCommand, savedTokensIn } from '../src/graft-tools.js'
 import { createAutoSync } from '../src/auto-sync.js'
 import { totalSaved } from '../src/index.js'
@@ -178,5 +178,40 @@ check('or via USERPROFILE/.bun on Windows', viaUserprofile.prefix[0] === join('C
 const bare = resolveGraftCommand({ PATH: '', HOME: '/home/x' }, fakeExists(new Set()))
 check('nothing installed falls back to the bare command', bare.command === 'graft' && bare.prefix.length === 0)
 
+// The dsh DESKTOP app runs on Electron, where process.execPath is
+// "DeepSeek Harness.exe". Spawning that still RUNS the script — but the child
+// keeps process.versions.electron, and commander 15 then reads argv from 1
+// instead of 2, so graft's own cli.js path is taken as the subcommand:
+//   error: unknown command '<...>\graft\dist\cli.js'
+// which is what Build and every query tool returned there. The npm shim's own
+// rule — the node beside the shims — is the interpreter to use instead.
+const NODE_EXE = process.platform === 'win32' ? 'node.exe' : 'node'
+const npmDir = join('C:\\Users\\x', 'AppData', 'Local', 'hermes', 'node')
+const npmCli = join(npmDir, 'node_modules', '@nanonets', 'graft', 'dist', 'cli.js')
+const appExe = join('C:\\Application', 'DeepSeek Harness', 'DeepSeek Harness.exe')
+const onElectron = resolveGraftCommand({ PATH: npmDir }, fakeExists(new Set([npmCli, join(npmDir, NODE_EXE)])), appExe, true)
+check('an Electron host runs graft with the node beside it, not the app binary', onElectron.command === join(npmDir, NODE_EXE) && onElectron.shell === false, onElectron.command)
+// A graft whose prefix has no node of its own (bun, a hand-made layout): the
+// PATH search is the fallback, so the Electron binary is still not used.
+const elsewhere = join('C:\\Program Files', 'nodejs')
+const viaPath = resolveGraftCommand({ PATH: [npmDir, elsewhere].join(delimiter) }, fakeExists(new Set([npmCli, join(elsewhere, NODE_EXE)])), appExe, true)
+check('a node elsewhere on PATH is preferred over the app binary', viaPath.command === join(elsewhere, NODE_EXE), viaPath.command)
+const noNode = resolveGraftCommand({ PATH: npmDir }, fakeExists(new Set([npmCli])), appExe, true)
+check('with no node anywhere it still returns the cli, not nothing', noNode.prefix[0] === npmCli && noNode.command === appExe, noNode.command)
+// A plain Node host is untouched by all of this: its execPath IS the runtime.
+const onNode = resolveGraftCommand({ PATH: npmDir }, fakeExists(new Set([npmCli])), join('C:\\node', 'node.exe'), false)
+check('a Node host keeps using its own process.execPath', onNode.command === join('C:\\node', 'node.exe'), onNode.command)
+
+// And the rebuild must be handed that interpreter, because sync-run rebuilds
+// through execFileSync(process.execPath, ...) — the grandchild inherits whatever
+// binary started sync-run.
+spawned = []
+state.stats = { dirty: true }
+state.lock = true
+now += 60_000
+const withNode = make({ nodePath: 'C:/fake/node.exe' })
+check('the rebuild spawns sync-run', (await withNode.rebuild('C:/interp')) === 'started')
+check('with the resolved interpreter, not process.execPath', spawned.at(-1)?.[0] === 'C:/fake/node.exe', String(spawned.at(-1)?.[0]))
+
 console.log(failures === 0 ? '\nALL CHECKS PASSED' : `\n${failures} CHECK(S) FAILED`)
 process.exit(failures === 0 ? 0 : 1)

package/src/auto-sync.js

@@ -92,6 +92,7 @@ async function loadGraftState(cliPath) {
 
 /**
  * @param deps.cliPath - graft's `dist/cli.js`, from which its `claude/` dir is found.
+ * @param deps.nodePath - the interpreter to run it with; defaults to execPath.
  * @param deps.minIntervalMs - floor between rebuilds of the same repo.
  */
 export function createAutoSync(deps = {}) {
@@ -108,6 +109,20 @@ export function createAutoSync(deps = {}) {
    */
   const minIntervalMs = Number.isInteger(deps.minIntervalMs) ? deps.minIntervalMs : 5_000
   const spawnFn = deps.spawn ?? spawn
+  /**
+   * The interpreter for sync-run.js — the one the plugin resolved for graft's
+   * CLI, which is NOT necessarily `process.execPath`.
+   *
+   * sync-run rebuilds through `execFileSync(process.execPath, [cli, 'build',
+   * '.'])`, i.e. it re-spawns whatever binary started it. So handing it the
+   * plugin's node is enough to fix the grandchild as well, and spawning this
+   * host's execPath is not: in the dsh DESKTOP app that is
+   * `DeepSeek Harness.exe`, and Electron's `process.versions.electron` makes
+   * graft's commander read the cli.js path as the subcommand. That failure is
+   * invisible from here — sync-run's build call discards stdio, so the rebuild
+   * simply reported success over an unchanged graph.
+   */
+  const nodePath = deps.nodePath ?? process.execPath
   const now = deps.now ?? (() => Date.now())
 
   /**
@@ -271,7 +286,7 @@ export function createAutoSync(deps = {}) {
          * and `sync-run` clears `syncing` and releases the lock on its own way
          * out either way.
          */
-        const child = spawnFn(process.execPath, [g.syncRun, root], {
+        const child = spawnFn(nodePath, [g.syncRun, root], {
           stdio: 'ignore',
           windowsHide: true,
         })

package/src/graft-tools.js

@@ -73,21 +73,68 @@ const MAX_CHARS = 60_000
  *
  * The bare-name fallback keeps a differently-installed graft working; it is
  * only reached when the entry point cannot be found.
+ *
+ * WHY THE INTERPRETER IS NOT ALWAYS `process.execPath`
+ *
+ * execPath is Node only when the host is Node. The dsh DESKTOP app is Electron
+ * (`DeepSeek Harness.exe`) running with ELECTRON_RUN_AS_NODE=1, so execPath is
+ * that app binary: the script still starts, and the breakage happens one layer
+ * in, inside graft's own argument parsing. The child keeps
+ * `process.versions.electron`, and commander 15 picks its `electron` argv
+ * convention from exactly that (`if (process.versions?.electron) from =
+ * 'electron'`). That branch then keys on `process.defaultApp`, which is
+ * undefined when the JS arrived as a script path rather than an app directory,
+ * and slices argv from 1 instead of 2 — so the cli.js path lands where the
+ * subcommand should be:
+ *
+ *     error: unknown command '<...>\@nanonets\graft\dist\cli.js'
+ *
+ * which is what the Build button and all five query tools used to return in the
+ * desktop app. A real node avoids the Electron binary altogether.
  */
-export function resolveGraftCommand(env = process.env, exists = existsSync, execPath = process.execPath) {
-  const path = String(env.PATH ?? env.Path ?? '')
-  for (const dir of path.split(delimiter)) {
-    if (dir === '') continue
+const NODE_EXE = process.platform === 'win32' ? 'node.exe' : 'node'
+
+/**
+ * Which binary to run graft's cli.js with.
+ *
+ * The npm shim's own rule is the first choice — `%dp0%\node.exe`, the node that
+ * was installed beside the shims — so this agrees with what typing `graft` in a
+ * terminal would do. Only an Electron host needs the PATH search after it,
+ * because `graft` and its node need not share a prefix. A Node host keeps using
+ * its own execPath, unchanged from before.
+ */
+function interpreterFor(installDir, dirs, exists, execPath, electron) {
+  const beside = join(installDir, NODE_EXE)
+  if (exists(beside)) return beside
+  if (!electron) return execPath
+  for (const dir of dirs) {
+    const candidate = join(dir, NODE_EXE)
+    if (exists(candidate)) return candidate
+  }
+  // Nothing better to hand: execPath at least runs the script, and graft's own
+  // stderr says what happened — the same answer as before this existed.
+  return execPath
+}
+
+export function resolveGraftCommand(
+  env = process.env,
+  exists = existsSync,
+  execPath = process.execPath,
+  electron = process.versions?.electron !== undefined,
+) {
+  const dirs = String(env.PATH ?? env.Path ?? '').split(delimiter).filter((dir) => dir !== '')
+  for (const dir of dirs) {
     const cli = join(dir, 'node_modules', '@nanonets', 'graft', 'dist', 'cli.js')
-    if (exists(cli)) return { command: execPath, prefix: [cli], shell: false }
+    if (exists(cli)) return { command: interpreterFor(dir, dirs, exists, execPath, electron), prefix: [cli], shell: false }
   }
   // A bun global install puts only the shim on PATH; the package lives under
   // $BUN_INSTALL/install/global. Missing it left prefix empty, which auto-sync
   // used to turn into a fatal dirname(undefined).
   const bunRoot = env.BUN_INSTALL ?? join(env.HOME ?? env.USERPROFILE ?? '.', '.bun')
   if (typeof bunRoot === 'string' && bunRoot !== '') {
-    const bunCli = join(bunRoot, 'install', 'global', 'node_modules', '@nanonets', 'graft', 'dist', 'cli.js')
-    if (exists(bunCli)) return { command: execPath, prefix: [bunCli], shell: false }
+    const bunInstall = join(bunRoot, 'install', 'global')
+    const bunCli = join(bunInstall, 'node_modules', '@nanonets', 'graft', 'dist', 'cli.js')
+    if (exists(bunCli)) return { command: interpreterFor(bunInstall, dirs, exists, execPath, electron), prefix: [bunCli], shell: false }
   }
   return { command: 'graft', prefix: [], shell: process.platform === 'win32' }
 }

package/src/index.js

@@ -561,8 +561,12 @@ export function apply(ctx, config = {}) {
    * Build button. Hoisted out of the `autoBuild` block on purpose: the button
    * must rebuild even in a profile that turned the automatic hooks off.
    */
+  // Resolved once: the rebuild needs graft's cli.js AND the interpreter that
+  // may run it, and re-resolving per call could pick a different node mid-session.
+  const graftCommand = resolveGraftCommand()
   const autoSync = createAutoSync({
-    cliPath: resolveGraftCommand().prefix[0],
+    cliPath: graftCommand.prefix[0],
+    nodePath: graftCommand.command,
     minIntervalMs: config.autoBuildMinIntervalMs,
     writeTools: config.autoBuildTools,
   })