dsh-code 1.0.6 → 1.2.0

package/bin/deepseek.mjs

@@ -8,7 +8,8 @@ import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
 const packageRequire = createRequire(import.meta.url)
-const packageVersion = packageRequire('../package.json').version
+/** This launcher's release version (exported for probes and tests). */
+export const packageVersion = packageRequire('../package.json').version
 
 /** Arguments required to boot DSH-Code's conventional profile. */
 export const profileArgs = (args = []) => ['--profile', 'cli', ...args]
@@ -115,6 +116,97 @@ export function harnessLineFromPeers(peers) {
   return undefined
 }
 
+/**
+ * The exact global install that pairs with this launcher: the harness line
+ * its own package declares in peers, and its own release. The guidance a
+ * missing host prints must not send the user to an unpinned `dsh-code`,
+ * which could mount a newer bundle beside this older wrapper.
+ */
+export function selfInstallHint(options = {}) {
+  const version = options.version ?? packageVersion
+  // An explicitly passed peers value — including undefined, the "no peers
+  // were readable" case — must win over this launcher's own manifest, which
+  // a destructuring default would conflate with the argument being absent.
+  const peers = 'peers' in options ? options.peers : packageRequire('../package.json').peerDependencies
+  const line = harnessLineFromPeers(peers)
+  return `npm install -g @deepseek-ai/dsh${line === undefined ? '' : `@${line}`} dsh-code@${version}`
+}
+
+/**
+ * Refusal line when npm's latest dsh-code is OLDER than this running
+ * launcher — a registry rollback, or a launcher installed from a GitHub
+ * release that sits ahead of the registry — and applying would downgrade
+ * the bundle back over the user's profile. Undefined when the upgrade may
+ * proceed.
+ */
+export function bundleDowngradeRefusal(latest, running = packageVersion) {
+  return latest !== undefined && compareHarnessLines(latest, running) < 0
+    ? `dsh-code: npm latest is dsh-code@${latest}, older than this launcher (dsh-code@${running}); refusing to downgrade the bundle`
+    : undefined
+}
+
+/**
+ * Refusal reason when a local-checkout profile would pair an older local
+ * build with the newer global host this upgrade installs, or undefined when
+ * the upgrade may proceed (no checkout mounted, or the checkout already
+ * matches the release). The caller prints the lines verbatim.
+ */
+export function localCheckoutRefusal(mounted, latestCode, codeSpec) {
+  if (mounted === latestCode) return undefined
+  if (mounted === undefined) {
+    return [
+      'dsh-code: the cli profile mounts a local checkout, but its version could not be read',
+      'dsh-code: refusing to upgrade the global host beside an unread checkout',
+      'dsh-code: update the checkout first (git pull, pnpm install, pnpm build), or switch the profile to the published package:',
+      `dsh-code:   dsh plugin --profile cli remove dsh-code && dsh plugin --profile cli add ${codeSpec}`,
+    ]
+  }
+  return [
+    `dsh-code: the cli profile mounts a local checkout of dsh-code ${mounted}, while this upgrade would install ${latestCode} globally`,
+    'dsh-code: upgrading the host beside an older local checkout pairs incompatible code; refusing to install',
+    'dsh-code: update the checkout first (git pull, pnpm install, pnpm build), or switch the profile to the published package:',
+    `dsh-code:   dsh plugin --profile cli remove dsh-code && dsh plugin --profile cli add ${codeSpec}`,
+  ]
+}
+
+/** Version after the last @ in an npm spec (`dsh-code@1.0.8`). */
+export function specVersion(spec) {
+  if (typeof spec !== 'string') return undefined
+  const at = spec.lastIndexOf('@')
+  if (at <= 0 || at === spec.length - 1) return undefined
+  return spec.slice(at + 1)
+}
+
+/**
+ * Exact install plan passed to `update --apply` after a probe. Missing
+ * `--code` means apply should query npm itself (CLI one-shot).
+ */
+export function parsePinnedPlan(args) {
+  let dshSpec
+  let codeSpec
+  const pluginSpecs = []
+  for (let index = 0; index < args.length; index += 1) {
+    const flag = args[index]
+    const value = args[index + 1]
+    if (flag === '--dsh' && value !== undefined) {
+      dshSpec = value
+      index += 1
+      continue
+    }
+    if (flag === '--code' && value !== undefined) {
+      codeSpec = value
+      index += 1
+      continue
+    }
+    if (flag === '--plugin' && value !== undefined) {
+      pluginSpecs.push(value)
+      index += 1
+    }
+  }
+  if (codeSpec === undefined || dshSpec === undefined) return undefined
+  return { dshSpec, codeSpec, pluginSpecs }
+}
+
 /**
  * Decide what `update --apply` installs. The global DSH launcher is pinned
  * to the harness line the target dsh-code release declares in its peers,
@@ -138,6 +230,56 @@ export function updatePlan({ latestCode, peers, profileSpec, profilePlugins = []
   }
 }
 
+/**
+ * The concrete steps `update --apply` runs. The host install and the
+ * dsh-code mount are fatal: a failure there strands the global host and the
+ * profile bundle on different release lines, so the sequence stops. The
+ * companion plugin carries are best-effort — one plugin without a build on
+ * the target line must not strand the rest of the upgrade, so each reports
+ * its manual retry command and lets the sequence finish. Unresolvable dsh
+ * commands come back as blockers: they are enforced before any step runs,
+ * because starting the host install without a working profile step is
+ * exactly the half-updated state the fatal marking exists to prevent.
+ */
+export function updateSteps({ plan, npm = npmInvocation(), resolveCommand = rawDshCommand }) {
+  const steps = [{
+    command: npm.command,
+    args: [...npm.args, 'install', '-g', plan.dshSpec, plan.codeSpec],
+    label: 'npm install',
+    fatal: true,
+    remedy: `npm install -g ${plan.dshSpec} ${plan.codeSpec}`,
+  }]
+  if (!plan.profileStep) return { steps, blockers: [] }
+  const blockers = []
+  const codeCommand = resolveCommand(['plugin', '--profile', 'cli', 'add', plan.codeSpec])
+  if (codeCommand === undefined) {
+    blockers.push('dsh-code: could not resolve the dsh command for the profile update')
+  } else {
+    steps.push({
+      command: codeCommand.command,
+      args: codeCommand.args,
+      label: 'dsh plugin add',
+      fatal: true,
+      remedy: `dsh plugin --profile cli add ${plan.codeSpec}`,
+    })
+  }
+  for (const pluginSpec of plan.pluginSpecs) {
+    const pluginCommand = resolveCommand(['plugin', '--profile', 'cli', 'add', pluginSpec])
+    if (pluginCommand === undefined) {
+      blockers.push(`dsh-code: could not resolve the dsh command for ${pluginSpec}`)
+      continue
+    }
+    steps.push({
+      command: pluginCommand.command,
+      args: pluginCommand.args,
+      label: `dsh plugin add ${pluginSpec}`,
+      fatal: false,
+      remedy: `dsh plugin --profile cli add ${pluginSpec}`,
+    })
+  }
+  return { steps, blockers }
+}
+
 /**
  * Compare two @deepseek-ai/dsh release-line versions (`0.1.x`, `0.1.x-rc.N`,
  * `0.1.x-alpha.N`). Positive when `left` is newer, negative when older, and 0
@@ -184,23 +326,37 @@ export function installedGlobalDshVersion(roots = globalDshRoots(), fileExists =
   return undefined
 }
 
-/** Run wrapper-owned child steps in order, stopping at the first failure. */
+/**
+ * Run wrapper-owned child steps in order. A step marked fatal stops the
+ * sequence at its failure (the default: the next step depends on this one);
+ * a `fatal: false` step is best-effort — its failure is reported with the
+ * step's manual retry command, the sequence continues, and the resolved
+ * code stays non-zero so the caller still sees the incomplete pass.
+ */
 export function runSequence(steps, spawnProcess = spawn) {
   return new Promise(resolve => {
+    const failures = []
     const run = index => {
       const step = steps[index]
       if (step === undefined) {
-        resolve(0)
+        resolve(failures.length === 0 ? 0 : failures[failures.length - 1])
         return
       }
       const needsShell = process.platform === 'win32' && /\.(cmd|bat)$/iu.test(step.command)
       const child = spawnProcess(step.command, step.args, { stdio: 'inherit', ...(needsShell ? { shell: true } : {}) })
+      const report = code => {
+        if (step.remedy !== undefined) console.error(`dsh-code: to retry ${step.label} manually: ${step.remedy}`)
+        failures.push(code ?? 1)
+        run(index + 1)
+      }
       child.once('error', error => {
         console.error(`dsh-code: ${step.label} failed: ${error.message}`)
-        resolve(1)
+        if (step.fatal === false) report(undefined)
+        else resolve(1)
       })
-      child.once('exit', (code, signal) => {
+      child.once('exit', code => {
         if (code === 0) run(index + 1)
+        else if (step.fatal === false) report(code)
         else resolve(code ?? 1)
       })
     }
@@ -384,6 +540,62 @@ function printUpdateStatus() {
   console.log('Run `deepseek update --apply` to upgrade the global packages and the cli profile together.')
 }
 
+/**
+ * The structured form of the update status for machine consumers
+ * (`update --json`, consumed by the TUI /update panel): what is running,
+ * what npm serves, the exact steps `update --apply` would run, and every
+ * refusal that would stop it. One JSON object on stdout; `null` marks an
+ * unreadable value so the payload shape stays constant.
+ */
+export function buildUpdateStatus({
+  view = viewJson,
+  installedDsh = installedDshVersion,
+  readSpec = profileDependencySpec,
+  readMounted = profileMountedVersion,
+  readPlugins = profilePluginDependencies,
+} = {}) {
+  const codeLatest = view(['dsh-code', 'version'])
+  const installed = installedDsh()
+  const spec = readSpec()
+  const mounted = readMounted()
+  const peers = codeLatest === undefined ? undefined : view([`dsh-code@${codeLatest}`, 'peerDependencies'])
+  const plan = updatePlan({
+    latestCode: codeLatest ?? 'unknown',
+    peers,
+    profileSpec: spec,
+    profilePlugins: readPlugins(),
+  })
+  const registry = codeLatest === undefined ? 'could not read the latest dsh-code version from npm' : undefined
+  // The same refusals applyUpdate enforces, precomputed so a caller can
+  // show them BEFORE any confirmation instead of failing mid-flight.
+  const downgrade = plan.line !== undefined && installed !== undefined && compareHarnessLines(plan.line, installed) < 0
+  const localCheckout = plan.profileStep ? undefined : localCheckoutRefusal(mounted, codeLatest, plan.codeSpec)
+  const hostOnLine = installed !== undefined && (plan.line === undefined || compareHarnessLines(installed, plan.line) === 0)
+  // A launcher ahead of the registry (a GitHub-release install) has nothing
+  // npm can offer: the registry's older latest must not present as a pending
+  // update, and applyUpdate refuses it anyway.
+  const bundleAhead = codeLatest !== undefined && compareHarnessLines(codeLatest, packageVersion) < 0
+  const upToDate = bundleAhead || (registry === undefined
+    && codeLatest === packageVersion
+    && !downgrade
+    && localCheckout === undefined
+    && hostOnLine
+    && plan.pluginSpecs.length === 0
+    && (mounted === undefined || mounted === codeLatest))
+  return {
+    code: { running: packageVersion, latest: codeLatest ?? null },
+    host: { installed: installed ?? null, targetLine: plan.line ?? null },
+    profile: { spec: spec ?? null, mounted: mounted ?? null, localCheckout: !plan.profileStep },
+    plan: { dshSpec: plan.dshSpec, codeSpec: plan.codeSpec, pluginSpecs: plan.pluginSpecs },
+    // JSON.stringify drops undefined members; every unreadable value must
+    // serialize as an explicit null so machine consumers never see a missing
+    // key drift into a truthy comparison.
+    blockers: { registry: registry ?? null, downgrade, localCheckout: localCheckout ?? null },
+    upToDate,
+    aheadOfRegistry: bundleAhead,
+  }
+}
+
 /**
  * Upgrade the global launcher and the cli profile plugin together. The
  * global install is pinned to the harness line the new dsh-code release
@@ -394,21 +606,53 @@ async function applyUpdate({
   view = viewJson,
   resolveCommand = rawDshCommand,
   spawnProcess = spawn,
+  pinned,
 } = {}) {
   const npm = npmInvocation()
-  const latestCode = view(['dsh-code', 'version'], undefined, npm)
-  if (latestCode === undefined) {
-    console.error('dsh-code: could not read the latest dsh-code version from npm')
+  const profileSpec = profileDependencySpec()
+  const profilePlugins = profilePluginDependencies()
+  let latestCode
+  let plan
+  if (pinned !== undefined) {
+    latestCode = specVersion(pinned.codeSpec)
+    if (latestCode === undefined) {
+      console.error(`dsh-code: could not read a version from ${pinned.codeSpec}`)
+      process.exitCode = 1
+      return
+    }
+    const line = specVersion(pinned.dshSpec)
+    plan = {
+      dshSpec: pinned.dshSpec,
+      line,
+      lineLocked: line !== undefined,
+      codeSpec: pinned.codeSpec,
+      profileStep: !(typeof profileSpec === 'string' && /^(link|file):/iu.test(profileSpec)),
+      pluginSpecs: pinned.pluginSpecs,
+    }
+  } else {
+    latestCode = view(['dsh-code', 'version'], undefined, npm)
+    if (latestCode === undefined) {
+      console.error('dsh-code: could not read the latest dsh-code version from npm')
+      process.exitCode = 1
+      return
+    }
+    const peers = view([`dsh-code@${latestCode}`, 'peerDependencies'], undefined, npm)
+    plan = updatePlan({
+      latestCode,
+      peers,
+      profileSpec,
+      profilePlugins,
+    })
+  }
+  // A launcher installed from a GitHub release (or any source ahead of the
+  // registry) must not be walked back by an apply targeting npm's older
+  // latest - the downgrade guard below only covers the host line.
+  const bundleRefusal = bundleDowngradeRefusal(latestCode)
+  if (bundleRefusal !== undefined) {
+    console.error(bundleRefusal)
     process.exitCode = 1
     return
   }
-  const peers = view([`dsh-code@${latestCode}`, 'peerDependencies'], undefined, npm)
-  const plan = updatePlan({
-    latestCode,
-    peers,
-    profileSpec: profileDependencySpec(),
-    profilePlugins: profilePluginDependencies(),
-  })
   if (!plan.lineLocked) {
     console.log('dsh-code: could not read the compatible harness line; installing @deepseek-ai/dsh@latest')
   }
@@ -424,26 +668,26 @@ async function applyUpdate({
     process.exitCode = 1
     return
   }
-  const steps = [{ command: npm.command, args: [...npm.args, 'install', '-g', plan.dshSpec, plan.codeSpec], label: 'npm install' }]
-  if (plan.profileStep) {
-    const command = resolveCommand(['plugin', '--profile', 'cli', 'add', plan.codeSpec])
-    if (command === undefined) {
-      console.error('dsh-code: could not resolve the dsh command for the profile update')
+  // Local-checkout guard: a link/file-mounted profile runs the checkout's
+  // own build, and this command would upgrade the global host beside it.
+  // When the checkout is older than the release being installed, upgrading
+  // pairs a new host with old local code — the terminal breaks on the next
+  // launch. Refuse until the checkout is updated or unmounted.
+  if (!plan.profileStep) {
+    const refusal = localCheckoutRefusal(profileMountedVersion(), latestCode, plan.codeSpec)
+    if (refusal !== undefined) {
+      for (const line of refusal) console.error(line)
       process.exitCode = 1
       return
     }
-    steps.push({ command: command.command, args: command.args, label: 'dsh plugin add' })
-    // Companion plugins ride the same line: without this, `dsh plugin add`-ed
-    // extras stay pinned to the old harness line after an upgrade.
-    for (const pluginSpec of plan.pluginSpecs) {
-      const pluginCommand = resolveCommand(['plugin', '--profile', 'cli', 'add', pluginSpec])
-      if (pluginCommand === undefined) {
-        console.error(`dsh-code: could not resolve the dsh command for ${pluginSpec}`)
-        process.exitCode = 1
-        return
-      }
-      steps.push({ command: pluginCommand.command, args: pluginCommand.args, label: `dsh plugin add ${pluginSpec}` })
-    }
+  }
+  const { steps, blockers } = updateSteps({ plan, npm, resolveCommand })
+  if (blockers.length > 0) {
+    for (const line of blockers) console.error(line)
+    process.exitCode = 1
+    return
+  }
+  if (plan.profileStep) {
     if (plan.pluginSpecs.length > 0) {
       console.log(`carrying ${plan.pluginSpecs.length} profile plugin${plan.pluginSpecs.length === 1 ? '' : 's'} to the same line: ${plan.pluginSpecs.join(', ')}`)
     }
@@ -483,15 +727,19 @@ export function launchOperation(args = process.argv.slice(2)) {
     // Setup must mount the exact globally installed release on launch day.
     const command = rawDshCommand(['plugin', '--profile', 'cli', 'add', setupBundle(args)])
     if (command === undefined) {
-      console.error('dsh-code: @deepseek-ai/dsh is not installed; run: npm install -g @deepseek-ai/dsh dsh-code')
+      console.error(`dsh-code: @deepseek-ai/dsh is not installed; run: ${selfInstallHint()}`)
       process.exitCode = 1
       return true
     }
     return launchChild(command.command, command.args)
   }
   if (operation === 'update') {
+    if (args.includes('--json')) {
+      console.log(JSON.stringify(buildUpdateStatus()))
+      return true
+    }
     if (args.includes('--apply')) {
-      void applyUpdate()
+      void applyUpdate({ pinned: parsePinnedPlan(args) })
       return true
     }
     printUpdateStatus()
@@ -522,7 +770,7 @@ export function launchDsh(
   }
   const command = resolveCommand(args)
   if (command === undefined) {
-    console.error('dsh-code: @deepseek-ai/dsh must be installed globally beside dsh-code; run: npm install -g @deepseek-ai/dsh dsh-code')
+    console.error(`dsh-code: @deepseek-ai/dsh must be installed globally beside dsh-code; run: ${selfInstallHint()}`)
     process.exitCode = 1
     return undefined
   }

package/cordis.patch.yml

@@ -24,6 +24,17 @@
   config:
     mode: !!js process.env.DSH_TOOLS_MODE
 
+# The base row keeps full-text search off entirely (openAt: never) so nothing
+# imports node:sqlite at boot; the terminal replaces it with the bundle's
+# skip-tolerant subclass below. An override row cannot retarget a row's
+# MODULE (name is only honored on inserts), so the base row is disabled and
+# an equivalent row mounts the subclass: the derived index opens lazily on
+# the first search (no startup cost, no Node 22 experimental warning), and
+# one unreadable source (a pre-release artifact the frozen codecs reject)
+# is skipped with a warning instead of failing every cross-session search.
+- id: session-query-sqlite
+  disabled: true
+
 # Agent-plane rows are mounted by the selected preset. Keep this list aligned
 # with the upstream Web bundle so two sessions can use different compositions
 # without leaking model-facing registrations through the host layer.
@@ -132,6 +143,92 @@
     - id: authorization
       name: '@deepseek-ai/dsh-authorization'
 
+    # The bundle's skip-tolerant session-query engine replacing the disabled
+    # base row above: same SQLite FTS5 service, observation loop patched to
+    # skip unreadable sources instead of failing every search.
+    - id: session-query-skip
+      name: 'dsh-code/session-query'
+      config:
+        path: ':memory:'
+        openAt: first-search
+
+    # Model-facing session-log search/trace/read tools over the sessionQuery
+    # service (read-only, workspace-scoped by exact cwd). A host-plane mount
+    # is deployment-global: every preset session sees the five tools. Kept
+    # ENABLED deliberately — read-only search leaks no capability — but note
+    # it does reach minimal-preset sessions too. The host CLI does not bundle
+    # this package, so it ships as a real dependency and resolves from the
+    # profile's own node_modules.
+    - id: tool-session-query
+      name: '@deepseek-ai/dsh-tool-session-query'
+
+    # Durable reminders: the schedule service arms per-root timers, injects
+    # due prompts as plugin-source user messages, and writes schedule/change
+    # events the projection folds into the /schedule panel. time-context
+    # gives the model a clock reading so 'at' times are phrased against the
+    # actual time; the 30s throttle bounds durable snapshot growth.
+    - id: schedule
+      name: '@deepseek-ai/dsh-schedule'
+
+    - id: time-context
+      name: '@deepseek-ai/dsh-time-context'
+      config:
+        refreshIntervalMs: 30000
+
+    # Persistent PTY plumbing: the owner-scoped registry and the one backend
+    # package in both dialects (pwsh is the Windows/ConPTY path, bash covers
+    # POSIX) mount as host SERVICES — no model-facing surface, so they break
+    # no preset boundary. The six terminal_* TOOLS ship DISABLED like LSP:
+    # enabling them at the host plane would hand every preset (including the
+    # shell-restricted minimal one) raw shell capability, the exact leak the
+    # disables above exist to prevent. Flip tool-terminal to disabled: false
+    # in the PROFILE layer to opt the deployment into PTY tools — but install
+    # @deepseek-ai/dsh-tool-terminal into the profile first (the host CLI does
+    # not bundle it; an enabled row over a missing package fails the boot):
+    #   dsh plugin --profile cli add @deepseek-ai/dsh-tool-terminal
+    - id: pty
+      name: '@deepseek-ai/dsh-terminal'
+
+    - id: terminal-pwsh
+      name: '@deepseek-ai/dsh-terminal-bash'
+      disabled: !!js process.platform !== 'win32'
+      config:
+        shellDialect: pwsh
+
+    - id: terminal-bash
+      name: '@deepseek-ai/dsh-terminal-bash'
+      disabled: !!js process.platform === 'win32'
+
+    - id: tool-terminal
+      name: '@deepseek-ai/dsh-tool-terminal'
+      disabled: true
+
+    # LSP navigation ships DISABLED: lsp-stdio resolves every server command
+    # at mount and a missing binary would fail the whole composition boot.
+    # Enable in the PROFILE layer with real servers, e.g.:
+    #   lsp / lsp-stdio / tool-lsp rows with disabled: false and
+    #   lsp-stdio config.servers mapping extensions to server commands.
+    # The three packages are also not bundled by the host CLI: install them
+    # into the profile first or the enabled rows fail the boot.
+    - id: lsp
+      name: '@deepseek-ai/dsh-lsp'
+      disabled: true
+
+    - id: lsp-stdio
+      name: '@deepseek-ai/dsh-lsp-stdio'
+      disabled: true
+
+    - id: tool-lsp
+      name: '@deepseek-ai/dsh-tool-lsp'
+      disabled: true
+
+    # MCP servers (dsh-mcp-client) and hooks bridges (dsh-hooks-claude-code /
+    # -codex) take per-instance config (server transports, hooks.json paths),
+    # so they mount as rows in the USER profile layer, not here; the host CLI
+    # bundles these peers, so those rows resolve. README documents the row
+    # shapes, and rows over packages the host does not bundle need the package
+    # added to the profile first.
+
     - id: tui-startup
       name: 'dsh-code/startup'