paseo-dsh-direct 0.2.4 → 0.2.6

package/README.md

@@ -15,6 +15,13 @@ In Paseo, open **Settings → Plugins → Install Plugin** and paste either the
 | `0.2.x` | `npm:paseo-dsh-direct` | `https://github.com/Jecvay/paseo-dsh-direct` |
 | `0.1.x` | `npm:paseo-dsh-direct@dsh-0.1` | CLI only: `paseo plugin install https://github.com/Jecvay/paseo-dsh-direct --ref release/0.1` |
 
+To update, run on the daemon machine (the app's plugin menu has no update entry):
+
+```bash
+paseo plugin update paseo-dsh-direct --check   # see if a new version exists
+paseo plugin update paseo-dsh-direct --yes     # update to the latest
+```
+
 More: [compatibility](docs/en/compatibility.md) · [CLI and local install, environment variables](docs/en/installation.md)
 
 ## Why "Direct"

package/README.zh.md

@@ -15,6 +15,13 @@
 | `0.2.x` | `npm:paseo-dsh-direct` | `https://github.com/Jecvay/paseo-dsh-direct` |
 | `0.1.x` | `npm:paseo-dsh-direct@dsh-0.1` | 只能用命令行：`paseo plugin install https://github.com/Jecvay/paseo-dsh-direct --ref release/0.1` |
 
+更新插件在 daemon 所在机器上运行（App 的插件菜单里没有更新入口）：
+
+```bash
+paseo plugin update paseo-dsh-direct --check   # 看有没有新版本
+paseo plugin update paseo-dsh-direct --yes     # 更新到最新
+```
+
 更多：[兼容性说明](docs/compatibility.md) · [命令行安装、本地目录安装、环境变量](docs/plugin-guide.md)
 
 ## 为什么叫 Direct

package/index.server.ts

@@ -1,5 +1,6 @@
 import type { PluginServerContext } from "@getpaseo/plugin/server";
 import { launchDshBridge } from "./server/bridge-client.js";
+import { defaultDshCommand } from "./server/dsh-spawn.js";
 import { DSH_BRIDGE_SOURCE } from "./server/generated-bridge.js";
 import { createDshProvider } from "./server/provider.js";
 
@@ -8,6 +9,7 @@ export default function contribute(server: PluginServerContext) {
   server.registerProvider(
     createDshProvider({
       executable,
+      command: defaultDshCommand(process.env),
       createBridge: (launch) =>
         launchDshBridge({
           ...launch,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-dsh-direct",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "DeepSeek Harness Direct Provider Plugin for Paseo",
   "repository": {
     "type": "git",

package/server/bridge-client.ts

@@ -1,9 +1,10 @@
-import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline";
 import { detectDshVersion } from "./dsh-version.js";
+import { spawnDsh } from "./dsh-spawn.js";
 import type { ProviderLaunch } from "@getpaseo/plugin/server/provider";
 import type {
   BridgeInitializeResult,
@@ -182,10 +183,10 @@ function runProfileInit(
   timeoutMs: number,
 ): Promise<void> {
   return new Promise((resolve, reject) => {
-    const child = spawn(
+    const child = spawnDsh(
       executable,
       [...leadingArgs, "--profile", profile, "--from-default-profile", DEFAULT_PROFILE_TEMPLATE, "--dump-config"],
-      { env, stdio: ["ignore", "ignore", "pipe"], windowsHide: true },
+      { env, stdio: ["ignore", "ignore", "pipe"] },
     );
     let stderr = "";
     child.stderr.setEncoding("utf8");
@@ -293,10 +294,9 @@ function dumpProfileConfig(
   env: Readonly<Record<string, string | undefined>>,
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    const child = spawn(launch.command, [...launch.args, "--profile", profile, "--dump-config"], {
+    const child = spawnDsh(launch.command, [...launch.args, "--profile", profile, "--dump-config"], {
       env,
       stdio: ["ignore", "pipe", "ignore"],
-      windowsHide: true,
     });
     let stdout = "";
     child.stdout.setEncoding("utf8");
@@ -360,10 +360,9 @@ export async function launchDshBridge(options: LaunchBridgeOptions): Promise<Dsh
     { mode: 0o600 },
   );
 
-  const child = spawn(launch.command, [...launch.args, "--profile", profile, "--patch", patchPath], {
+  const child = spawnDsh(launch.command, [...launch.args, "--profile", profile, "--patch", patchPath], {
     env,
     stdio: ["pipe", "pipe", "pipe"],
-    windowsHide: true,
   });
   const client = new JsonlBridgeClient(child, directory, launch);
   try {

package/server/dsh-spawn.ts

@@ -0,0 +1,134 @@
+import { spawn, type SpawnOptions } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+type Env = Readonly<Record<string, string | undefined>>;
+
+/** A command line `child_process.spawn` can start without a shell. */
+export interface DshSpawn {
+  command: string;
+  args: string[];
+  /** The environment to spawn with: the launch environment, plus what the resolved command needs. */
+  env: Env;
+}
+
+/** The host facts the resolution depends on, injected so the Windows branch is testable anywhere. */
+export interface DshSpawnHost {
+  platform: NodeJS.Platform;
+  exists(file: string): boolean;
+}
+
+const defaultHost: DshSpawnHost = { platform: process.platform, exists: existsSync };
+const DESKTOP_EXE = "DeepSeek Harness.exe";
+const WRAPPER_EXTENSIONS = [".cmd", ".ps1"];
+/** Extensions Node finds itself when spawning a bare name; a match means a real executable wins. */
+const EXECUTABLE_EXTENSIONS = [".com", ".exe"];
+
+/**
+ * Spawns dsh without a shell: `spawn` with `command` / `args` / `env` replaced
+ * by `resolveDshSpawn(command, args, options.env)` and `windowsHide` set. Every
+ * dsh process the plugin starts goes through here.
+ */
+export const spawnDsh = ((command: string, args: readonly string[], options: SpawnOptions) => {
+  const target = resolveDshSpawn(command, args, options.env ?? process.env);
+  return spawn(target.command, target.args, { ...options, env: target.env, windowsHide: true });
+}) as typeof spawn;
+
+/**
+ * The spawn for a dsh command chosen by `resolveDshLaunch`, with `args` being
+ * the launch's leading arguments followed by dsh's own. Other platforms, real
+ * executables and unrecognised layouts pass through unchanged; on Windows an
+ * npm or DSH Desktop `dsh.cmd` / `dsh.ps1` wrapper becomes the command it runs,
+ * and a bare `dsh` not on `PATH` falls back to DSH Desktop's default install.
+ * Layouts and reasons: `docs/server-architecture.md` (dsh 的选择).
+ */
+export function resolveDshSpawn(
+  command: string,
+  args: readonly string[],
+  env: Env,
+  host: DshSpawnHost = defaultHost,
+): DshSpawn {
+  const passthrough = { command, args: [...args], env };
+  if (host.platform !== "win32") return passthrough;
+  if (path.win32.basename(command).toLowerCase() === DESKTOP_EXE.toLowerCase()) {
+    return desktopSpawn(path.win32.dirname(command), args, env, host) ?? passthrough;
+  }
+  const found = findCommand(command, env, host);
+  if (found.kind === "executable") return passthrough;
+  if (found.kind === "missing") {
+    return (command.toLowerCase() === "dsh" ? desktopFallback(args, env, host) : undefined) ?? passthrough;
+  }
+  const directory = path.win32.dirname(found.path);
+  return (
+    npmSpawn(directory, args, env, host) ??
+    // <install>\resources\runtime\cli\bin\dsh.cmd
+    desktopSpawn(path.win32.resolve(directory, "..", "..", "..", ".."), args, env, host) ??
+    passthrough
+  );
+}
+
+/**
+ * The command the provider registers with Paseo. Paseo resolves it on `PATH`
+ * before the plugin sees it, so on Windows, when `PATH` has no `dsh` but DSH
+ * Desktop is installed in its default location, the desktop executable is
+ * registered instead; `resolveDshSpawn` then runs it as dsh. Otherwise `dsh`.
+ */
+export function defaultDshCommand(env: Env, host: DshSpawnHost = defaultHost): string {
+  if (host.platform !== "win32" || findCommand("dsh", env, host).kind !== "missing") return "dsh";
+  return desktopFallback([], env, host)?.command ?? "dsh";
+}
+
+/** npm's layout: `node <wrapper dir>\node_modules\@deepseek-ai\dsh\lib\bin.js`, preferring a `node.exe` beside the wrapper. */
+function npmSpawn(directory: string, args: readonly string[], env: Env, host: DshSpawnHost): DshSpawn | undefined {
+  const binJs = path.win32.join(directory, "node_modules", "@deepseek-ai", "dsh", "lib", "bin.js");
+  if (!host.exists(binJs)) return undefined;
+  const bundledNode = path.win32.join(directory, "node.exe");
+  return { command: host.exists(bundledNode) ? bundledNode : "node", args: [binJs, ...args], env };
+}
+
+/** DSH Desktop's default per-user install, `%LOCALAPPDATA%\Programs\DeepSeek Harness`, when present. */
+function desktopFallback(args: readonly string[], env: Env, host: DshSpawnHost): DshSpawn | undefined {
+  const local = windowsEnv(env, "LOCALAPPDATA");
+  return local ? desktopSpawn(path.win32.join(local, "Programs", "DeepSeek Harness"), args, env, host) : undefined;
+}
+
+/** DSH Desktop's own CLI, as its `dsh.cmd` runs it, when `install` holds a desktop install. */
+function desktopSpawn(install: string, args: readonly string[], env: Env, host: DshSpawnHost): DshSpawn | undefined {
+  const exe = path.win32.join(install, DESKTOP_EXE);
+  const asar = path.win32.join(install, "resources", "app.asar");
+  if (!host.exists(exe) || !host.exists(asar)) return undefined;
+  const cli = path.win32.join(asar, "dsh", "node_modules", "@deepseek-ai", "dsh-desktop-host", "lib", "cli.js");
+  return { command: exe, args: ["--expose-internals", cli, ...args], env: { ...env, ELECTRON_RUN_AS_NODE: "1" } };
+}
+
+type Found = { kind: "executable" } | { kind: "wrapper"; path: string } | { kind: "missing" };
+
+/** What `command` names: a wrapper script, a real executable Node finds first, or nothing. */
+function findCommand(command: string, env: Env, host: DshSpawnHost): Found {
+  const extension = path.win32.extname(command).toLowerCase();
+  if (extension !== "" && !WRAPPER_EXTENSIONS.includes(extension)) return { kind: "executable" };
+  const candidates = (base: string) => (extension ? [base] : WRAPPER_EXTENSIONS.map((suffix) => base + suffix));
+  const wrapperAt = (base: string): Found => {
+    const wrapper = candidates(base).find((candidate) => host.exists(candidate));
+    return wrapper === undefined ? { kind: "missing" } : { kind: "wrapper", path: wrapper };
+  };
+  if (/[\\/]/.test(command)) return wrapperAt(command);
+  for (const directory of (windowsEnv(env, "PATH") ?? "").split(";")) {
+    if (!directory.trim()) continue;
+    const base = path.win32.join(directory.trim().replace(/^"|"$/g, ""), command);
+    if (extension === "" && EXECUTABLE_EXTENSIONS.some((suffix) => host.exists(base + suffix))) {
+      return { kind: "executable" };
+    }
+    const found = wrapperAt(base);
+    if (found.kind === "wrapper") return found;
+  }
+  return { kind: "missing" };
+}
+
+/** Windows environment names are case-insensitive (`Path` as well as `PATH`). */
+function windowsEnv(env: Env, key: string): string | undefined {
+  for (const [name, value] of Object.entries(env)) {
+    if (name.toUpperCase() === key && value) return value;
+  }
+  return undefined;
+}

package/server/dsh-version.ts

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawnDsh } from "./dsh-spawn.js";
 
 const DEFAULT_TIMEOUT_MS = 3_000;
 
@@ -41,10 +41,9 @@ function runVersionProbe(executable: string, options: DetectDshVersionOptions):
 
     let child;
     try {
-      child = spawn(executable, [...(options.args ?? []), "--version"], {
+      child = spawnDsh(executable, [...(options.args ?? []), "--version"], {
         env: options.env ?? process.env,
         stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true,
       });
     } catch {
       // Synchronous spawn failure (e.g. the executable does not exist).

package/server/provider.ts

@@ -63,6 +63,8 @@ interface DshProviderOptions {
   createBridge(launch?: SessionLaunch): Promise<DshBridge>;
   /** The `PASEO_DSH_EXECUTABLE` value; it outranks the `launch` Paseo resolves. `status()` and `createBridge` use the same precedence. */
   executable?: string;
+  /** The command registered with Paseo; defaults to `dsh` (see `defaultDshCommand`). */
+  command?: string;
   /** Detects the local dsh version for the startup compatibility check; defaults to spawning `<exe> --version`. */
   detectDshVersion?: DetectVersion;
 }
@@ -103,7 +105,7 @@ export function createDshProvider(options: DshProviderOptions): ProviderRegistra
     icon: "dsh.svg",
     getCatalogCacheKey: async (options) =>
       options.scope === "workspace" ? `dsh-pi:${options.cwd}` : "dsh-pi:global",
-    command: ["dsh"],
+    command: [options.command ?? "dsh"],
     async status(request) {
       return dshStatus(
         resolveDshLaunch(options.executable, request?.launch),

package/server/timeline.ts

@@ -263,20 +263,8 @@ export class TimelineProjector {
         projected.push(timeline(this.paseoSessionId, item, timestamp));
       }
     });
-    const usage = objectValue(data.usage) ?? objectValue(message.usage);
-    if (usage) {
-      projected.push({
-        type: "session.usage",
-        sessionId: this.paseoSessionId,
-        usage: {
-          inputTokens: numberValue(usage.inputTokens) ?? numberValue(usage.input_tokens),
-          cachedInputTokens:
-            numberValue(usage.cachedInputTokens) ?? numberValue(usage.cached_input_tokens),
-          outputTokens: numberValue(usage.outputTokens) ?? numberValue(usage.output_tokens),
-          totalCostUsd: numberValue(usage.totalCostUsd) ?? numberValue(usage.total_cost_usd),
-        },
-      });
-    }
+    // No session.usage here: Paseo replaces `lastUsage` whole, and a per-message
+    // reading would overwrite the bridge's complete one with fewer fields.
     return projected;
   }