@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.33

package/plugins/tui-tools/update.mjs

@@ -0,0 +1,111 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, appendFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// DSCODE update surface for the TUI: the `/update` command schedules this module as a
+// detached helper, which waits for the interactive session to exit and then runs the
+// same `dscode update` entry the CLI uses (npm/Hub launcher or tar/source self-update).
+
+export const LAUNCHER_PACKAGE = '@toddzheng024/dscode';
+export const REGISTRY_URL = `https://registry.npmjs.org/${LAUNCHER_PACKAGE}/latest`;
+export const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[\w.-]+)?$/;
+
+/** Whether `candidate` is newer than `current`; a prerelease sorts below its release. */
+export function newerVersion(candidate, current) {
+  const split = value => {
+    const text = String(value);
+    const at = text.indexOf('-');
+    return { core: (at === -1 ? text : text.slice(0, at)).split('.').map(Number), pre: at === -1 ? '' : text.slice(at + 1) };
+  };
+  const left = split(candidate), right = split(current);
+  for (let index = 0; index < Math.max(left.core.length, right.core.length); index++) {
+    const x = left.core[index] ?? 0, y = right.core[index] ?? 0;
+    if (x !== y) return x > y;
+  }
+  if (left.pre === right.pre) return false;
+  if (left.pre === '') return true;
+  if (right.pre === '') return false;
+  return false;
+}
+
+/** Newest launcher version on npm, or undefined when the registry cannot be read. */
+export async function fetchLatestVersion({ fetchImpl = fetch, timeoutMs = 8000 } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    // Plain JSON: the registry answers 406 for the abbreviated metadata type on the
+    // `/latest` dist-tag endpoint.
+    const response = await fetchImpl(REGISTRY_URL, { headers: { accept: 'application/json' }, signal: controller.signal });
+    if (!response.ok) return undefined;
+    const version = (await response.json())?.version;
+    return typeof version === 'string' && VERSION_PATTERN.test(version) ? version : undefined;
+  } catch { return undefined; }
+  finally { clearTimeout(timer); }
+}
+
+/** State directory shared by every install shape, matching the launcher's own default. */
+export function stateHome(env = process.env, home = process.env.HOME) {
+  return resolve(env.DSH_HOME || env.DSCODE_HOME || join(home ?? '.', '.local/share/dscode-hub'));
+}
+
+/**
+ * The command that upgrades this installation once no session is running: a sibling
+ * `bin/dscode.mjs` for tar and source trees, otherwise the npm launcher from PATH.
+ */
+export function planUpdate({ moduleUrl, version = 'latest', execPath = process.execPath } = {}) {
+  const root = resolve(dirname(fileURLToPath(moduleUrl)), '..', '..');
+  const entry = join(root, 'bin/dscode.mjs');
+  if (existsSync(entry)) return { label: `tar/source ${root}`, command: execPath, args: [entry, 'update', version] };
+  if (existsSync(join(root, 'node_modules', LAUNCHER_PACKAGE, 'cli.mjs'))) return { label: 'npm launcher (bundle tree)', command: execPath, args: [join(root, 'node_modules', LAUNCHER_PACKAGE, 'cli.mjs'), 'update', version] };
+  return { label: 'npm/Hub launcher from PATH', command: 'dscode', args: ['update', version] };
+}
+
+/** Start the detached helper that finishes the update once `pid` (the TUI) exits. */
+export function scheduleUpdate({ helperModuleUrl, pid, version = 'latest', env = process.env, spawnImpl = spawn, execPath = process.execPath }) {
+  const helper = fileURLToPath(helperModuleUrl);
+  const child = spawnImpl(execPath, [helper, String(pid), version], { detached: true, stdio: 'ignore', env });
+  child.unref();
+  return { helper, log: logPath(stateHome(env)) };
+}
+
+export function logPath(home) {
+  return join(home, 'update.log');
+}
+
+function append(log, text) {
+  mkdirSync(dirname(log), { recursive: true, mode: 0o700 });
+  appendFileSync(log, text.endsWith('\n') ? text : `${text}\n`, { mode: 0o600 });
+}
+
+export async function runUpdateAfterExit({ pid, version = 'latest', home, moduleUrl = import.meta.url, spawnImpl, now = Date.now, sleep = ms => new Promise(resolvePromise => setTimeout(resolvePromise, ms)), maxWaitMs = 12 * 3600000 } = {}) {
+  const log = logPath(home);
+  const started = now();
+  append(log, `${new Date(started).toISOString()} scheduled: pid ${pid} exit, then ${version}`);
+  while (now() - started < maxWaitMs) {
+    let alive = true;
+    try { process.kill(pid, 0); } catch { alive = false; }
+    if (!alive) break;
+    await sleep(1000);
+  }
+  await sleep(1500);
+  const plan = planUpdate({ moduleUrl, version });
+  append(log, `${new Date().toISOString()} running: ${plan.command} ${plan.args.join(' ')} (${plan.label})`);
+  const result = await spawnImpl(plan.command, plan.args, { stdio: ['ignore', 'pipe', 'pipe'], env: process.env });
+  const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
+  if (output) append(log, output);
+  const ok = result.status === 0;
+  append(log, `${new Date().toISOString()} ${ok ? 'finished' : `failed with ${result.status ?? result.signal}`}`);
+  writeFileSync(join(home, 'update-result.json'), `${JSON.stringify({ version, status: ok ? 'done' : 'failed', code: result.status ?? null, at: new Date().toISOString(), log }, null, 2)}\n`, { mode: 0o600 });
+  return { status: ok ? 'done' : 'failed', log };
+}
+
+async function main(argv) {
+  const [pid, version = 'latest'] = argv;
+  const home = stateHome();
+  await runUpdateAfterExit({ pid: Number(pid), version, home, moduleUrl: import.meta.url,
+    spawnImpl: (command, args, options) => spawnSync(command, args, { ...options, encoding: 'utf8' }) });
+}
+
+const isEntry = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isEntry) main(process.argv.slice(2)).catch(error => { try { append(logPath(stateHome()), `${new Date().toISOString()} helper failed: ${error.message}`); } catch { /* best effort */ } });

package/plugins/tui-tools/workspace-discovery.mjs

@@ -0,0 +1,129 @@
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
+
+// Discovery above the project root, bounded at the home directory rather than the
+// filesystem root: a shared workspace directory such as ~/Workspace can contribute
+// skills and instructions to every project below it, while nothing outside the
+// operator's own tree can.
+export const ancestorSkillRoots = Object.freeze(['.dsh/skills', '.agents/skills', '.claude/skills']);
+export const instructionFileCandidates = Object.freeze(['AGENTS.md', 'CLAUDE.md']);
+export const projectRootMarkers = Object.freeze(['.git']);
+
+export const ENABLED_VALUES = Object.freeze(['1', 'true', 'on', 'yes']);
+// Fail closed: only the documented enable spellings read as on, so an operator
+// writing "no", "none" or "disable" cannot accidentally arm a feature that reads
+// untrusted project content.
+export const enabledFlag = (value) => ENABLED_VALUES.includes(String(value ?? '').trim().toLowerCase());
+// Ancestor skill discovery defaults to on, so its switch is the inverse: only an
+// explicit off spelling disables it and an unrecognised value keeps the default.
+export const DISABLED_VALUES = Object.freeze(['0', 'false', 'off', 'no', 'none', 'disable']);
+export const disabledFlag = (value) => DISABLED_VALUES.includes(String(value ?? '').trim().toLowerCase());
+export const skillAncestorsEnabled = (env = process.env) => !disabledFlag(env.DSCODE_SKILL_ANCESTORS);
+
+// A symlinked $HOME (or a /Volumes mount) must not break the boundary test: the
+// launcher passes an already-resolved session directory while os.homedir() returns
+// whatever $HOME says, so the comparison canonicalizes both sides. The chain itself
+// keeps the caller's logical paths, which is what the skill and instruction probes
+// then stat.
+const canonical = path => { try { return realpathSync(path); } catch { return resolve(path); } };
+
+// Every directory from the working directory up to home, nearest first. An empty
+// list means home is not an ancestor, and the mode then contributes nothing.
+export function ancestorChain({ cwd, home }) {
+  const start = resolve(cwd);
+  const stop = resolve(home);
+  const canonicalStop = canonical(stop);
+  const canonicalStart = canonical(start);
+  if (canonicalStart !== canonicalStop && !canonicalStart.startsWith(canonicalStop + sep)) return [];
+  const chain = [];
+  for (let current = start; ;) {
+    chain.push(current);
+    if (canonical(current) === canonicalStop) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return chain;
+}
+
+export function projectRootOf({ cwd, markers = projectRootMarkers }) {
+  const start = resolve(cwd);
+  for (let current = start; ;) {
+    if (markers.some(marker => existsSync(join(current, marker)))) return current;
+    const parent = dirname(current);
+    if (parent === current) return start;
+    current = parent;
+  }
+}
+
+// Nearest first, which is also precedence: the provider scans `customSkillDirs` in
+// order and the first definition of a duplicate name wins. The provider's own rank
+// 100/200 roots at the project root still outrank everything registered here.
+export function ancestorSkillDirs({ cwd, home, env = process.env }) {
+  if (!skillAncestorsEnabled(env)) return [];
+  const projectRoot = projectRootOf({ cwd });
+  const dirs = [];
+  for (const dir of ancestorChain({ cwd, home })) {
+    for (const root of ancestorSkillRoots) {
+      // The provider already scans these two at rank 100/200 for the owning project.
+      if (dir === projectRoot && (root === '.dsh/skills' || root === '.agents/skills')) continue;
+      const path = join(dir, root);
+      if (existsSync(path) && !dirs.includes(path)) dirs.push(path);
+    }
+  }
+  return dirs;
+}
+
+// Instruction files strictly above the project root, farthest first so the chain
+// still reads broad to specific. The project chain itself stays upstream's job.
+export function ancestorInstructionFiles({ cwd, home }) {
+  const chain = ancestorChain({ cwd, home });
+  // The chain runs from the working directory outward, so everything after the
+  // project root is above it; reversing restores broad-to-specific order.
+  const stop = chain.indexOf(projectRootOf({ cwd }));
+  const above = (stop === -1 ? chain : chain.slice(stop + 1)).reverse();
+  const files = [];
+  for (const dir of above) {
+    for (const name of instructionFileCandidates) {
+      const path = join(dir, name);
+      if (existsSync(path)) files.push(path);
+    }
+  }
+  return files;
+}
+
+// The provider ignores a source file that cannot fit its render budget, and the
+// aggregate below occupies the broadest (user-global) slot: without a bound, one
+// oversized ancestor file would take the user-global instructions down with it.
+// Stay under the preset's 64 KiB maxBytes with headroom.
+export const AGGREGATE_BUDGET_BYTES = 60 * 1024;
+
+// The upstream provider owns exactly one user-global instruction file, so ancestor
+// files are folded in behind it. With no ancestor file this writes nothing and
+// changes nothing: the provider keeps reading $DSH_HOME/AGENTS.md where it always did.
+// The user-global file is always written: dropping it in favour of its descendants
+// would silently replace what the user wrote with what the project wrote. Ancestors
+// are then added nearest-first while the budget allows, and a source that would
+// overflow is skipped whole rather than truncated mid-file.
+export function writeWorkspaceInstructions({ cwd, home, stateDir, outputDir = join(stateDir, 'workspace-instructions') }) {
+  const files = ancestorInstructionFiles({ cwd, home });
+  if (!files.length) return undefined;
+  const userGlobal = join(stateDir, 'AGENTS.md');
+  const texts = new Map();
+  if (existsSync(userGlobal)) texts.set(userGlobal, readFileSync(userGlobal, 'utf8').trim());
+  for (const file of files) texts.set(file, readFileSync(file, 'utf8').trim());
+  const written = [...texts.keys()];
+  const priority = written[0] === userGlobal ? [userGlobal, ...written.slice(1).reverse()] : [...written].reverse();
+  const kept = new Set();
+  let bytes = 0;
+  for (const source of priority) {
+    const size = Buffer.byteLength(texts.get(source), 'utf8') + 2;
+    if (kept.size > 0 && bytes + size > AGGREGATE_BUDGET_BYTES) continue;
+    kept.add(source);
+    bytes += size;
+  }
+  const directory = outputDir;
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(join(directory, 'AGENTS.md'), written.filter(source => kept.has(source)).map(source => texts.get(source)).join('\n\n') + '\n', { mode: 0o600 });
+  return directory;
+}

package/plugins/ultra/policy.mjs

@@ -0,0 +1,42 @@
+export const ULTRA_POLICY = `DSCODE ULTRA — max reasoning with task-proportional execution.
+Use the depth needed to resolve actual uncertainty. Ultra is capability available on demand, not a requirement to maximize investigation, planning, delegation or verification. Briefly choose the smallest sufficient approach, then act. Do not repeatedly reassess a decision without new evidence.
+For a bounded task such as adding a unit test, a small bug fix or a local edit: work directly in the parent. Read the target implementation, applicable instructions and a nearby relevant example; make the requested change; run the focused test and required project checks; fix observed failures; then report the result and stop. Do not scan the whole repository, add a formal plan, launch reviewers, broaden coverage or refactor unrelated code unless concrete evidence makes it necessary. Once acceptance criteria and required checks pass, do not invent additional work or rerun passing checks without a relevant change. If the task turns out to involve an unclear contract, a broad regression or a shared interface, expand only to resolve that specific uncertainty.
+When delegating, explicitly choose reasoning_effort for each child instead of automatically propagating ultra. Prefer low for bounded implementation, unit tests and factual lookup; high for nontrivial debugging or review; max for exceptional uncertainty or complex design. These are guidelines, not a substitute for judging the task. Use only efforts supported by the child model. Omission inherits the parent; choosing a child effort never changes the parent effort. Both subagent and subagent_fork support effort-only selection.
+For substantial tasks, delegate only independent work that is likely to shorten completion or resolve meaningful uncertainty. Before delegating, identify the independent boundary, concrete wall-clock benefit, and useful work you will do while the child runs. Give each child a bounded objective, relevant context, file ownership and acceptance criteria. Give each child a unique name (1-10 characters, letters, digits and underscores, starting and ending with a letter, such as read_code) and address it as /name in send_message and interrupt_agent; a child addresses you as /. Prefer subagent_fork when established conversation history is relevant; use fresh subagent for self-contained work that does not benefit from that history. Fork excludes the current unfinished turn, so always give a self-contained assignment. Keep useful work for yourself while children run. For read-only work or tasks needing the parent's uncommitted files, omit worktree and assign disjoint files if writing. For independent parallel edits on a clean repository, set worktree: true; the child starts at HEAD in an isolated checkout. Never have multiple agents edit the same files in a shared workspace. Inspect and integrate worktree changes before removing the checkout.
+In ultra use subagent/subagent_fork and send_message for delegation, not workflow or ralph. Use at most twenty child agents concurrently across this root session; start only as many as have genuinely independent work. Children complete their assigned work themselves and cannot delegate again; do not duplicate investigations across agents. The parent owns integration, verifies child claims, resolves conflicts and runs appropriate checks. Seek independent review of substantial changes when useful; do not add a review round merely because ultra is enabled. Parent/child messages are available; sibling direct messaging is not. Preserve the user's permission policy: ultra grants no extra authority. Reuse findings and stop delegating when coordination costs outweigh value. If progress stalls, name the concrete blocker and take the next diagnostic step rather than silently extending deliberation.`;
+
+export const FLASH_POLICY = `DSCODE DeepSeek Flash — use task-proportional effort. For a simple question, answer directly. For a bounded coding change, read the relevant code, make the change, run the focused check, and stop when it passes. Avoid repeated planning, broad repository scans, speculative edge cases, extra review rounds, or repeated tests unless a concrete failure or uncertainty calls for them. Keep explanations concise while reporting the result and any real limitation.`;
+
+export function flashRequest(options, messages) {
+  if (options.model !== 'deepseek-flash' || options.purpose || !options.sessionId) return messages;
+  const copy = messages.map(m => ({ ...m }));
+  const system = copy.findLast(m => m.role === 'system' && typeof m.content === 'string');
+  if (system) system.content += '\n\n' + FLASH_POLICY;
+  else copy.unshift({ role: 'system', content: FLASH_POLICY });
+  return copy;
+}
+
+export function ultraRequest(options, messages) {
+  if (options.reasoningEffort !== 'ultra' || options.purpose || !options.tools?.some(t => t.name === 'subagent' || t.name === 'subagent_fork')) return messages;
+  const copy = messages.map(m => ({ ...m }));
+  const system = copy.findLast(m => m.role === 'system' && typeof m.content === 'string');
+  if (system) system.content += '\n\n' + ULTRA_POLICY;
+  else copy.unshift({ role: 'system', content: ULTRA_POLICY });
+  return copy;
+}
+
+/**
+ * DSH 0.1.7 rewrote the DeepSeek adapter onto the Messages API, where the system
+ * prompt is a request field rather than a leading message. These two carry the same
+ * gates as the message-shaped pair above, which the OpenRouter, Grok and OpenCode Go adapters
+ * still use, and stay self-contained: `patch-runtime` embeds them by `toString()`.
+ */
+export function ultraSystem(options, system) {
+  if (options.reasoningEffort !== 'ultra' || options.purpose || !options.tools?.some(t => t.name === 'subagent' || t.name === 'subagent_fork')) return system;
+  return system.length === 0 ? ULTRA_POLICY : system + '\n\n' + ULTRA_POLICY;
+}
+
+export function flashSystem(options, system) {
+  if (options.model !== 'deepseek-flash' || options.purpose || !options.sessionId) return system;
+  return system.length === 0 ? FLASH_POLICY : system + '\n\n' + FLASH_POLICY;
+}

package/plugins/worktree-subagent/worktree.mjs

@@ -0,0 +1,56 @@
+import { randomUUID } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+async function git(cwd, args, signal, timeout = 60000) {
+  try {
+    const { stdout } = await execFileAsync('git', ['-C', cwd, ...args], { encoding: 'utf8', maxBuffer: 1024 * 1024, timeout, signal });
+    return stdout.trim();
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    throw new Error((error.stderr || error.stdout || error.message).trim(), { cause: error });
+  }
+}
+
+/** The parent's Git root, once it can host child worktrees: an absolute, clean repository root. */
+export async function worktreeBase(parentCwd, signal) {
+  if (typeof parentCwd !== 'string' || !isAbsolute(parentCwd)) throw new Error('Subagent worktree requires an absolute parent workspace.');
+  const root = realpathSync(await git(parentCwd, ['rev-parse', '--show-toplevel'], signal));
+  if (root !== realpathSync(parentCwd)) throw new Error('Subagent worktree requires the parent session to start at its Git repository root.');
+  const status = await git(root, ['status', '--porcelain=v1', '--untracked-files=all'], signal);
+  if (status) throw new Error('Subagent worktree starts at HEAD, but the parent workspace has uncommitted changes. Use the shared workspace for work that needs those changes, or commit/stash them first.');
+  return root;
+}
+
+export async function createChildWorktree(parentCwd, signal) {
+  const root = await worktreeBase(parentCwd, signal);
+  const directory = join(root, '.dscode-worktrees');
+  if (await git(root, ['ls-files', '--', '.dscode-worktrees'], signal)) throw new Error('The repository tracks .dscode-worktrees; choose a different workspace before delegating.');
+  if (lstatSync(directory, { throwIfNoEntry: false })?.isSymbolicLink()) throw new Error('Refusing a symlinked .dscode-worktrees directory.');
+  const excludePath = resolve(root, await git(root, ['rev-parse', '--git-path', 'info/exclude'], signal));
+  const exclude = existsSync(excludePath) ? readFileSync(excludePath, 'utf8') : '';
+  if (!exclude.split(/\r?\n/).includes('/.dscode-worktrees/')) {
+    mkdirSync(resolve(excludePath, '..'), { recursive: true });
+    appendFileSync(excludePath, `${exclude && !exclude.endsWith('\n') ? '\n' : ''}/.dscode-worktrees/\n`);
+  }
+  mkdirSync(directory, { recursive: true });
+  const path = join(directory, randomUUID());
+  signal?.throwIfAborted();
+  try { await git(root, ['worktree', 'add', '--detach', path, 'HEAD'], signal); }
+  catch (error) {
+    try { await git(root, ['worktree', 'remove', '--force', path], undefined, 1500); } catch { /* Git may already have cleaned up. */ }
+    throw error;
+  }
+  return { cwd: path, parentCwd: root };
+}
+
+export async function discardCleanChildWorktree(worktree) {
+  try {
+    if (await git(worktree.cwd, ['status', '--porcelain=v1', '--untracked-files=all'])) return false;
+    await git(worktree.parentCwd, ['worktree', 'remove', worktree.cwd]);
+    return true;
+  } catch { return false; }
+}

package/runtime-sources.json

@@ -0,0 +1,94 @@
+{
+  "runtime": "0.2.0-rc.2",
+  "sources": [
+    {
+      "package": "@deepseek-ai/dsh-tool-bash",
+      "version": "0.2.0-rc.2",
+      "entrySha256": "0c63a09e4b80ec22db256eac4ecab6f7de3a342e16ec590348a40c5f356eff1a"
+    },
+    {
+      "package": "@deepseek-ai/dsh-tool-bash-persistent",
+      "version": "0.2.0-rc.2",
+      "entrySha256": "2cc6627cc2e02ab65960e124f8c249045024fffe2563ab3507f7fbed9872acdc"
+    },
+    {
+      "package": "@deepseek-ai/dsh-terminal-bash",
+      "version": "0.2.0-rc.2",
+      "entrySha256": "24df85fc9a410308c3f145bd773e517e9fd86623eb60c3228703a803513c9c00"
+    },
+    {
+      "package": "@deepseek-ai/dsh-tool-subagent",
+      "version": "0.2.0-rc.2",
+      "entrySha256": "26a1e804aab4c6f9cb53a670c63b817fc8d9409569e6d68eda6fda33b966a840"
+    },
+    {
+      "package": "@deepseek-ai/dsh-subagent",
+      "version": "0.2.0-rc.2",
+      "entrySha256": "75b50b1c9452a6aeb10d1c859e3f45b05e062ea1fad6ed3bcd9577f2bc912541"
+    },
+    {
+      "package": "@deepseek-ai/dsh-subagent-in-process-driver",
+      "version": "0.2.0-rc.2",
+      "entrySha256": "a169b6dac8f9fd0ef6e8db4ec0d2c009580c5c10b6d561e6d214cbe9b89521d1"
+    },
+    {
+      "package": "@deepseek-ai/dsh-subagent-spawn-in-process",
+      "version": "0.2.0-rc.2",
+      "entrySha256": "11c92108dd145957f8251a81fc9bfb8a30e7f6f25d96e34a5cb8581a4be4be06"
+    },
+    {
+      "package": "@deepseek-ai/dsh-subagent-fork-in-process",
+      "version": "0.2.0-rc.2",
+      "entrySha256": "03ba69c10e8da1053f3997bfe6845cc72dfedd1b8f4d795e4b039f8659cfe620"
+    },
+    {
+      "package": "@deepseek-ai/dsh-command-goal",
+      "version": "0.2.0-rc.2",
+      "entrySha256": "ba117f69b62db6ae1d8e546515f1f3309ed4a5ce246223e70315475396f9e5c1"
+    }
+  ],
+  "nativePackages": [
+    {
+      "name": "@deepseek-ai/node-addon-system",
+      "version": "0.1.2",
+      "integrity": "sha512-EFn8K+mXIXiw6s3rxX+cgp2hZTEAQdVIsURhrXnBxycSXvtQ1EQpsSVzoNKtKAQI0I0VqkEcVEjHzS/PeaGsvw==",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/node-addon-system/-/node-addon-system-0.1.2.tgz"
+    },
+    {
+      "name": "@deepseek-ai/node-addon-system-darwin-arm64",
+      "version": "0.1.2",
+      "integrity": "sha512-IR0cx8um19mLCZaJ+H5PLblKr6Eg3PWvVo8eTQBr/SwH2nh5tM9CD9/5fHweNS9Pjt15UdFlGqnvLSd/w+O6Rw==",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/node-addon-system-darwin-arm64/-/node-addon-system-darwin-arm64-0.1.2.tgz"
+    },
+    {
+      "name": "@deepseek-ai/node-addon-system-darwin-x64",
+      "version": "0.1.2",
+      "integrity": "sha512-XDbmquNapk9aT28y4EKn9lbONVr9YNs1NM/GKH1Gi5gUhjOT9wgRaTv72FJdNaVIInbPAYbPoyn7/y+MzQMNNg==",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/node-addon-system-darwin-x64/-/node-addon-system-darwin-x64-0.1.2.tgz"
+    },
+    {
+      "name": "@deepseek-ai/node-addon-system-linux-arm64",
+      "version": "0.1.2",
+      "integrity": "sha512-Z/DQtqgEYzjBzb2ocHGjMzx51W7xDILkJKKj89nyErr8gZMNiLs+JNL1uKzJqc3VLZB+vYCPaHGyQ3oX6EzEmA==",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/node-addon-system-linux-arm64/-/node-addon-system-linux-arm64-0.1.2.tgz"
+    },
+    {
+      "name": "@deepseek-ai/node-addon-system-linux-x64",
+      "version": "0.1.2",
+      "integrity": "sha512-S2aPVHvYCpNCppCFyNlooMYuTB7ucK5lvD9oXQQ42v5Z2s5AoaiCdjz9r2l+ED2rI5oS1x0cUZmKjJH2dxV0pg==",
+      "resolved": "https://registry.npmjs.org/@deepseek-ai/node-addon-system-linux-x64/-/node-addon-system-linux-x64-0.1.2.tgz"
+    }
+  ],
+  "computerUse": {
+    "package": "@anionex/dsh-computer-use",
+    "version": "0.3.3",
+    "license": "MIT",
+    "helperSha256": "55325e0008d755bf2b1d408bcfd5cdb80842ec2a0fa5312da6961eb65d7d6dd3",
+    "architectures": [
+      "arm64",
+      "x86_64"
+    ],
+    "minimumMacOS": "14.0",
+    "toolsEntrySha256": "89693a230ad82d59d10d36cc6957c8f281c7b844573d491343f6482f47a73a69"
+  }
+}

package/vendor/bash/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.