@deepseek-ai/dsh-native-command 0.1.1-rc.2 → 0.1.2-alpha.2

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/util/native-command/README.md
-README.md: 8a552ac36fac150ae18b2a8adaab1dd489ecb476
-README.zh.md: 7b5ea7fa1985d394b88fd5bcdbce9d9831eef8ee
+README.md: 282cefcc00d296b3c09741e64c88647343e1bef2
+README.zh.md: aecb60d2e8f68a6e9468e3f2d4b0e2d99bebefc6

package/README.md

@@ -1,27 +1,115 @@
-# dsh-native-command
+---
+description: "Host-native command and path-opening utilities with shell-free execution, cancellation, desktop detection, and WSL path handoff."
+kind: "package-library"
+---
+
+# @deepseek-ai/dsh-native-command
 
 English | [中文](README.zh.md)
 
-A **zero-dependency no-shell `execFile` runner** shared by host-native OS integrations: one `runNativeCommand(command, args, signal)` call spawns the executable directly (never a shell string), captures utf8 stdout/stderr, propagates the caller's abort into child termination, and hides the transient console window on Windows. Failures reject with the exit `code` and both captured streams attached, so callers classify (missing tool, cancelled, real failure) without re-running anything.
+## Summary
+
+`dsh-native-command` runs host executables without a shell and opens Host filesystem paths through the desktop. The command runner captures utf8 output, propagates cancellation, and hides transient Windows consoles. The path opener supports default-application and text-editor intents, browser-renderable documents, WSL translation, and desktop availability checks. It is a library, not a plugin: no `ctx`, no state, no events.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
 
-Its two consumers are the host-side native integrations: the [`directory-picker-native`](../../host/directory-picker-native/README.md) backend's OS chooser commands and the gateway's open-with-default-application hand-off ([`dsh-host-apiproxy`](../../host/apiproxy/README.md) `host.openPath`). The `NativeCommandRunner` type is their injectable command boundary.
+-----
 
-It is a **library, not a service or plugin**: no `ctx`, registers nothing, holds no state, emits no events.
+<a id="use-this-package"></a>
+## Use this package
 
-## Surface
+Use this runner when a host-side integration must execute one native command and needs its output, its failure, or both — and must never involve a shell.
+
+### Running a command
 
 ```ts
-import { runNativeCommand, type NativeCommandRunner } from '@deepseek-ai/dsh-native-command'
+import { runNativeCommand } from '@deepseek-ai/dsh-native-command'
+
+declare const script: string
+declare const signal: AbortSignal
+const { stdout, stderr } = await runNativeCommand('osascript', ['-e', script], signal)
 ```
 
+On exit 0 the call resolves with captured stdout and stderr. On any failure it rejects with the exit `code` and both captured streams attached, so a caller can tell a missing tool (`ENOENT`), a cancellation (`ABORT_ERR`), and a real command failure apart without re-running the command.
+
+### Injecting the command boundary
+
+The `NativeCommandRunner` type is the injectable command boundary for host integrations: pass the function (or a wrapper) where the integration needs a testable seam, so tests can substitute a fake runner.
+
+### Opening a Host path
+
+`openNativePath(path, signal)` hands a path to the default application and prefers the named default browser for HTML and SVG where the platform can identify one. `openNativeTextFile(path, signal)` selects text-editor intent; on macOS it uses `open -t`. WSL paths are translated with `wslpath -w` before the Windows desktop receives them. `canOpenNativePath()` reports whether the current Host plausibly has a desktop target.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+The command runner is a thin wrapper over Node's `execFile`. The path opener selects one shell-free command from platform and environment facts, while callers retain authority over which path may be opened.
+
+### Source map
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Public command-runner and path-opener exports |
+| [`src/runner.ts`](src/runner.ts) | Shell-free `execFile` adapter |
+| [`src/path-opener.ts`](src/path-opener.ts) | Desktop detection, open intents, browser preference, and WSL translation |
+| [`src/invariant.ts`](src/invariant.ts) | Invariant companion (no runtime invariant; each run is one stateless child-process round trip) |
+
+### What execFile gives the runner
+
+`execFile` spawns the executable directly with an argv array — no shell string, no shell interpretation of the arguments. The `signal` option terminates the child when the caller's abort fires; `windowsHide` suppresses the transient console window on Windows. On a non-zero exit or spawn error, the callback attaches `code`, `stdout`, and `stderr` to the rejected error and keeps the original error as `cause`.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+Read these pages when you need the consumers or the general subprocess capability this utility deliberately is not.
+
+- [Native directory picker](../../host/directory-picker-native/README.md) — the OS chooser commands this runner executes.
+- [Session Controller](../../api/session-controller/README.md) — resolves Session-relative workspace paths before opening them.
+- [Settings Controller](../../api/settings-controller/README.md) — selects settings documents and agent-preset directories.
+- [Subprocess capability](../../subprocess/subprocess/README.md) — the general subprocess seam, of which this package is not a part.
+
+-----
+
+<a id="model-experience"></a>
 ## Model Experience
 
-None, as this is host-side subprocess plumbing; nothing here reaches a model request.
+None, as the host-side utilities register nothing model-facing.
 
 #### KV Cache effect
 
-None; this package neither assembles nor sends a provider request.
+Nothing here enters a request prefix; this package neither assembles nor sends a provider request.
 
 ## Known Limitations and Deferred Work
 
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits define when this runner is not the right tool. They are current package constraints, not a task backlog.
+
 - **No output bounding** — both streams buffer unbounded in memory; every current caller invokes small native tools whose output is a path or an error line. Adopt `dsh-output-retention` bounding before pointing this at commands with meaningful output volume.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -1,27 +1,115 @@
-# dsh-native-command
+---
+description: "宿主原生命令与路径打开工具，提供无 shell 执行、取消、桌面探测与 WSL 路径交接。"
+kind: "package-library"
+---
+
+# @deepseek-ai/dsh-native-command
 
 [English](README.md) | 中文
 
-宿主原生 OS 集成共享的**零依赖免 shell `execFile` 运行器**：一次 `runNativeCommand(command, args, signal)` 调用直接 spawn 可执行文件（绝不拼 shell 字符串），以 utf8 捕获 stdout/stderr，把调用方的 abort 传播为子进程终止，并在 Windows 上隐藏瞬时控制台窗口。失败时，调用会以错误拒绝；该错误附带退出 `code` 与两路已捕获输出，调用方无需重跑即可分类（工具缺失、已取消、真实失败）。
+## 概述
+
+`dsh-native-command` 无需 shell 即可运行 Host 可执行文件，并通过桌面打开 Host 文件系统路径。命令运行器捕获 utf8 输出、传播取消，并隐藏 Windows 瞬时控制台。路径打开器支持默认应用与文本编辑器意图、浏览器可渲染文档、WSL 转换与桌面可用性检查。它是库而非插件：没有 `ctx`、无状态、不发事件。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
 
-它的两个消费方都是宿主侧原生集成：[`directory-picker-native`](../../host/directory-picker-native/README.zh.md) 后端的 OS 选择器命令，以及网关将路径交由默认应用打开的操作（[`dsh-host-apiproxy`](../../host/apiproxy/README.zh.md) 的 `host.openPath`）。`NativeCommandRunner` 类型是这些调用方的可注入命令边界。
+-----
 
-它是**库，不是服务或插件**：没有 `ctx`、不注册任何东西、不持有状态、不发事件。
+<a id="use-this-package"></a>
+## 使用本包
 
-## 接口面
+当宿主侧集成需要执行一条原生命令、并需要它的输出或失败信息（或两者兼要）、且绝不能涉及 shell 时，使用本运行器。
+
+### 运行一条命令
 
 ```ts
-import { runNativeCommand, type NativeCommandRunner } from '@deepseek-ai/dsh-native-command'
+import { runNativeCommand } from '@deepseek-ai/dsh-native-command'
+
+declare const script: string
+declare const signal: AbortSignal
+const { stdout, stderr } = await runNativeCommand('osascript', ['-e', script], signal)
 ```
 
+退出码为 0 时，调用解析为捕获到的 stdout 与 stderr。任何失败都会以错误拒绝，错误附带退出 `code` 与两路已捕获输出，因此调用方无需重跑命令即可区分工具缺失（`ENOENT`）、取消（`ABORT_ERR`）与真实的命令失败。
+
+### 注入命令边界
+
+`NativeCommandRunner` 类型是宿主集成的可注入命令边界：在集成需要一个可测试接缝的位置传入该函数（或其包装层），测试即可替换为假运行器。
+
+### 打开 Host 路径
+
+`openNativePath(path, signal)` 将路径交给默认应用；平台能够确定默认浏览器时，HTML 与 SVG 会优先交给该浏览器。`openNativeTextFile(path, signal)` 选择文本编辑器意图；macOS 使用 `open -t`。WSL 路径先通过 `wslpath -w` 转换，再交给 Windows 桌面。`canOpenNativePath()` 报告当前 Host 是否可能具备桌面目标。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+命令运行器是 Node `execFile` 的薄包装。路径打开器根据平台与环境事实选择一条无 shell 命令，而调用方继续负责决定允许打开哪个路径。
+
+### 源码地图
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | 命令运行器与路径打开器的公共导出 |
+| [`src/runner.ts`](src/runner.ts) | 无 shell 的 `execFile` 适配器 |
+| [`src/path-opener.ts`](src/path-opener.ts) | 桌面探测、打开意图、浏览器偏好与 WSL 转换 |
+| [`src/invariant.ts`](src/invariant.ts) | 不变式伴生插件（无运行时不变式；每次运行都是一次无状态的子进程往返） |
+
+### execFile 给了运行器什么
+
+`execFile` 以 argv 数组直接 spawn 可执行文件——没有 shell 字符串，参数不经 shell 解释。`signal` 选项在调用方中止触发时终止子进程；`windowsHide` 在 Windows 上抑制瞬时控制台窗口。遇到非零退出或 spawn 错误时，回调把 `code`、`stdout`、`stderr` 挂到被拒绝的错误上，并保留原始错误作为 `cause`。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+当你需要消费方或本工具刻意不属于的通用子进程能力时，阅读以下页面。
+
+- [原生目录选择器](../../host/directory-picker-native/README.zh.md)——本运行器执行的 OS 选择器命令。
+- [Session Controller](../../api/session-controller/README.zh.md)——打开前解析 Session 相对 workspace 路径。
+- [Settings Controller](../../api/settings-controller/README.zh.md)——选择 settings 文档与 agent-preset 目录。
+- [子进程能力](../../subprocess/subprocess/README.zh.md)——通用子进程 seam，本包并非其组成部分。
+
+-----
+
+<a id="model-experience"></a>
 ## 模型体验
 
-无；这是宿主侧子进程管道，这里没有任何东西进入模型请求。
+无：宿主侧工具不注册任何面向模型的内容。
 
 #### KV Cache 影响
 
-无；该包既不组装也不发送提供方请求。
+此处没有任何内容进入请求前缀；本包既不组装也不发送提供方请求。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
 
-## 已知限制与暂缓事项
+这些限制说明本运行器何时不是合适的工具。它们是当前包约束，不是任务积压。
 
 - **不做输出限量**——两路流在内存中无界缓冲；当前每个调用方只运行输出为一个路径或一行错误的小型原生工具。把它指向输出量可观的命令之前，先接入 `dsh-output-retention` 限量。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -1,11 +1,10 @@
 import { execFile } from "node:child_process";
-//#region lib/types/index.js
+import { release } from "node:os";
+import { extname } from "node:path";
+//#region lib/types/runner.js
 /**
-* Shared no-shell `execFile` runner for host-native OS integrations (the
-* native directory chooser, the open-with-default-application hand-off):
-* utf8 stdio capture, abort propagation, Windows console hide. A library,
-* not a plugin — no ctx, no state, no events.
-* @module @deepseek-ai/dsh-native-command
+* Shared no-shell `execFile` runner for host-native OS integrations.
+* @module @deepseek-ai/dsh-native-command/runner
 */
 /**
 * Run a host command with utf8 stdio, abort propagation, and Windows hide.
@@ -35,4 +34,157 @@ const runNativeCommand = (command, args, signal) => new Promise((resolve, reject
 	});
 });
 //#endregion
-export { runNativeCommand };
+//#region lib/types/path-opener.js
+/**
+* Cross-platform native path and text-document openers for Host UI
+* integrations.
+*
+* The default intent prefers the default browser for documents it renders when
+* the platform can name one, then falls back to the default application. WSL
+* translates every path for the Windows desktop instead of assuming a Linux
+* GUI. The text-editor intent never consults the browser.
+* @module @deepseek-ai/dsh-native-command/path-opener
+*/
+/** Documents a browser renders, as opposed to ones an editor merely edits. */
+const BROWSER_DOCUMENTS = new Set([
+	".html",
+	".htm",
+	".xhtml",
+	".svg"
+]);
+/**
+* The macOS bundle registered for `https` — the default browser, as
+* LaunchServices records it. The nested version dict is stripped first
+* because it carries its own `LSHandlerRoleAll`.
+*/
+function macBundleForHttps(plist) {
+	const stripped = plist.replace(/LSHandlerPreferredVersions\s*=\s*\{[^}]*\};/g, "");
+	const block = /\{[^{}]*LSHandlerURLScheme\s*=\s*"?https"?;[^{}]*\}/.exec(stripped)?.[0];
+	if (block === void 0) return void 0;
+	return /LSHandlerRoleAll\s*=\s*"?([\w.-]+)"?;/.exec(block)?.[1];
+}
+/**
+* Open one browser-renderable document with the default browser.
+* @returns true when a browser took it; false when this platform cannot name
+* one, or naming it failed — the caller then uses the default application.
+*/
+async function openInBrowser(path, signal, platform, run, env) {
+	if (platform === "darwin") {
+		let bundle;
+		try {
+			const { stdout } = await run("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure"], signal);
+			bundle = macBundleForHttps(stdout);
+		} catch {
+			return false;
+		}
+		if (bundle === void 0) return false;
+		await run("open", [
+			"-b",
+			bundle,
+			path
+		], signal);
+		return true;
+	}
+	if (platform === "linux") {
+		const browser = env.BROWSER;
+		if (browser === void 0 || browser === "") return false;
+		await run(browser, [path], signal);
+		return true;
+	}
+	return false;
+}
+/** PowerShell single-quoted literal (doubles embedded quotes). */
+function powershellLiteral(path) {
+	return `'${path.replace(/'/g, "''")}'`;
+}
+/** Whether one environment marker is set to a non-empty value. */
+function present(value) {
+	return value !== void 0 && value !== "";
+}
+/** Distinguish WSL from desktop Linux using its process and kernel markers. */
+function isWsl(internals) {
+	const env = internals.env ?? process.env;
+	if (present(env.WSL_DISTRO_NAME) || present(env.WSL_INTEROP)) return true;
+	return (internals.osRelease ?? release()).toLowerCase().includes("microsoft");
+}
+/** Open one Windows-resolvable path through its registered desktop application. */
+async function openWindowsPath(path, signal, run) {
+	await run("powershell.exe", [
+		"-NoProfile",
+		"-Command",
+		`Invoke-Item -LiteralPath ${powershellLiteral(path)}`
+	], signal);
+}
+/** Translate a WSL path before handing it to the Windows desktop. */
+async function openWslPath(path, signal, run) {
+	const translated = await run("wslpath", ["-w", path], signal);
+	signal.throwIfAborted();
+	const windowsPath = translated.stdout.replace(/[\r\n]+$/, "");
+	if (windowsPath === "") throw new Error("wslpath returned no Windows path");
+	await openWindowsPath(windowsPath, signal, run);
+}
+/** Dispatch one shell-free platform command for the requested open intent. */
+async function openNativePathWithIntent(path, signal, intent, internals = {}) {
+	const platform = internals.platform ?? process.platform;
+	const run = internals.run ?? runNativeCommand;
+	const env = internals.env ?? process.env;
+	const wsl = platform === "linux" && isWsl(internals);
+	if (!wsl && intent === "default" && BROWSER_DOCUMENTS.has(extname(path).toLowerCase()) && await openInBrowser(path, signal, platform, run, env)) return;
+	if (platform === "darwin") {
+		await run("open", intent === "text-editor" ? ["-t", path] : [path], signal);
+		return;
+	}
+	if (platform === "win32") {
+		await openWindowsPath(path, signal, run);
+		return;
+	}
+	if (platform === "linux") {
+		if (wsl) {
+			await openWslPath(path, signal, run);
+			return;
+		}
+		await run("xdg-open", [path], signal);
+		return;
+	}
+	throw new Error(`native path opener is unsupported on ${platform}`);
+}
+/**
+* Whether {@link openNativePath} plausibly reaches a desktop on this host.
+*
+* macOS and Windows always carry a desktop opener; Linux does when it is WSL
+* (the Windows desktop takes the path) or a display server is announced.
+* A headless or containerised Linux host answers false, which is what lets a
+* surface show a path as text instead of offering a button that would spawn
+* `xdg-open` into nothing.
+* @param internals - platform and environment seam for deterministic tests.
+* @returns true when handing a path to the native opener can work at all.
+*/
+function canOpenNativePath(internals = {}) {
+	const platform = internals.platform ?? process.platform;
+	if (platform === "darwin" || platform === "win32") return true;
+	if (platform !== "linux") return false;
+	const env = internals.env ?? process.env;
+	return isWsl(internals) || present(env.DISPLAY) || present(env.WAYLAND_DISPLAY);
+}
+/**
+* Open a filesystem path with the operating system's default application, or
+* with the default browser when the path names a document a browser renders.
+* @param path - absolute or host-resolvable path (caller owns resolution).
+* @param signal - caller/connection lifetime; abort terminates the native command.
+* @param internals - Platform, environment, and runner hooks for deterministic tests.
+*/
+function openNativePath(path, signal, internals = {}) {
+	return openNativePathWithIntent(path, signal, "default", internals);
+}
+/**
+* Open a text document for editing; macOS bypasses the file-type association
+* so a YAML association with a browser cannot consume the gesture.
+* @param path - absolute or host-resolvable text-document path.
+* @param signal - caller/connection lifetime; abort terminates the native command.
+* @param internals - Platform and runner hooks for deterministic tests.
+*/
+function openNativeTextFile(path, signal, internals = {}) {
+	return openNativePathWithIntent(path, signal, "text-editor", internals);
+}
+//#endregion
+export { canOpenNativePath, openNativePath, openNativeTextFile, runNativeCommand };

package/lib/types/index.d.ts

@@ -1,21 +1,9 @@
 /**
- * Shared no-shell `execFile` runner for host-native OS integrations (the
- * native directory chooser, the open-with-default-application hand-off):
- * utf8 stdio capture, abort propagation, Windows console hide. A library,
- * not a plugin — no ctx, no state, no events.
+ * Host-native command execution and path-opening utilities.
  * @module @deepseek-ai/dsh-native-command
  */
-/** Testable command boundary; native implementations never invoke a shell. */
-export type NativeCommandRunner = (command: string, args: readonly string[], signal: AbortSignal) => Promise<{
-    stdout: string;
-    stderr: string;
-}>;
-/**
- * Run a host command with utf8 stdio, abort propagation, and Windows hide.
- * @param command - executable path or PATH name.
- * @param args - argv (never a shell string).
- * @param signal - caller/connection lifetime; abort terminates the child.
- * @returns captured stdout/stderr on exit 0.
- */
-export declare const runNativeCommand: NativeCommandRunner;
+export { runNativeCommand } from './runner.ts';
+export type { NativeCommandRunner } from './runner.ts';
+export { canOpenNativePath, openNativePath, openNativeTextFile, } from './path-opener.ts';
+export type { PathOpenerInternals, PathOpenerRunner, } from './path-opener.ts';
 //# sourceMappingURL=index.d.ts.map

package/lib/types/path-opener.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Cross-platform native path and text-document openers for Host UI
+ * integrations.
+ *
+ * The default intent prefers the default browser for documents it renders when
+ * the platform can name one, then falls back to the default application. WSL
+ * translates every path for the Windows desktop instead of assuming a Linux
+ * GUI. The text-editor intent never consults the browser.
+ * @module @deepseek-ai/dsh-native-command/path-opener
+ */
+import { type NativeCommandRunner } from './runner.ts';
+/** Testable command boundary; native implementations never invoke a shell. */
+export type PathOpenerRunner = NativeCommandRunner;
+/** Injectable platform facts for deterministic adapter tests. */
+export interface PathOpenerInternals {
+    platform?: NodeJS.Platform;
+    /** Kernel release override used to distinguish WSL from desktop Linux. */
+    osRelease?: string;
+    /** Environment used for WSL markers and the desktop Linux browser convention. */
+    env?: NodeJS.ProcessEnv;
+    run?: PathOpenerRunner;
+}
+/**
+ * Whether {@link openNativePath} plausibly reaches a desktop on this host.
+ *
+ * macOS and Windows always carry a desktop opener; Linux does when it is WSL
+ * (the Windows desktop takes the path) or a display server is announced.
+ * A headless or containerised Linux host answers false, which is what lets a
+ * surface show a path as text instead of offering a button that would spawn
+ * `xdg-open` into nothing.
+ * @param internals - platform and environment seam for deterministic tests.
+ * @returns true when handing a path to the native opener can work at all.
+ */
+export declare function canOpenNativePath(internals?: PathOpenerInternals): boolean;
+/**
+ * Open a filesystem path with the operating system's default application, or
+ * with the default browser when the path names a document a browser renders.
+ * @param path - absolute or host-resolvable path (caller owns resolution).
+ * @param signal - caller/connection lifetime; abort terminates the native command.
+ * @param internals - Platform, environment, and runner hooks for deterministic tests.
+ */
+export declare function openNativePath(path: string, signal: AbortSignal, internals?: PathOpenerInternals): Promise<void>;
+/**
+ * Open a text document for editing; macOS bypasses the file-type association
+ * so a YAML association with a browser cannot consume the gesture.
+ * @param path - absolute or host-resolvable text-document path.
+ * @param signal - caller/connection lifetime; abort terminates the native command.
+ * @param internals - Platform and runner hooks for deterministic tests.
+ */
+export declare function openNativeTextFile(path: string, signal: AbortSignal, internals?: PathOpenerInternals): Promise<void>;
+//# sourceMappingURL=path-opener.d.ts.map

package/lib/types/runner.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared no-shell `execFile` runner for host-native OS integrations.
+ * @module @deepseek-ai/dsh-native-command/runner
+ */
+/** Testable command boundary; native implementations never invoke a shell. */
+export type NativeCommandRunner = (command: string, args: readonly string[], signal: AbortSignal) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Run a host command with utf8 stdio, abort propagation, and Windows hide.
+ * @param command - executable path or PATH name.
+ * @param args - argv (never a shell string).
+ * @param signal - caller/connection lifetime; abort terminates the child.
+ * @returns captured stdout/stderr on exit 0.
+ */
+export declare const runNativeCommand: NativeCommandRunner;
+//# sourceMappingURL=runner.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-native-command",
-  "description": "Zero-dependency no-shell execFile runner for host-native OS integrations: utf8 stdio capture, abort propagation, Windows hide",
-  "version": "0.1.1-rc.2",
+  "description": "Host-native command and path-opening utilities with shell-free execution, cancellation, desktop detection, and WSL handoff",
+  "version": "0.1.2-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -32,11 +32,11 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2"
   }
 }