@deepseek-ai/dsh-ssh 0.2.1-alpha.3 → 0.2.1-alpha.4

package/lib/helper.js

@@ -1,5 +1,5 @@
-import { a as SshRpcPeer, t as RemoteOperationError } from "./protocol-CDhW_IHU.js";
-import { S as textStreamIdSchema, _ as remotePath, a as environmentSchema, b as targetSchema, d as outputSnapshotFrameLimit, g as processIdSchema, l as intentSchema, m as policySchema, r as editSchema, v as spawnSchema } from "./schemas-BD3YbDxe.js";
+import { RemoteOperationError, SshRpcPeer } from "./protocol.js";
+import { editSchema, environmentSchema, intentSchema, outputSnapshotFrameLimit, policySchema, processIdSchema, remotePath, spawnSchema, targetSchema, textStreamIdSchema } from "./schemas.js";
 import { t as SSH_STREAM_TLS_OPTIONS } from "./stream-security-DJlQsPG-.js";
 import { chmod, mkdir, mkdtemp, rm } from "node:fs/promises";
 import { join } from "node:path";
@@ -813,34 +813,38 @@ async function runSshHelper(transport) {
 //#region lib/types/helper-entry.js
 /** Private OpenSSH process entry; the helper module owns request and cleanup behavior. */
 /* v8 ignore file -- launched through plain Node in SSH acceptance; helper behavior is exercised through its explicit streams. */
-const controller = new AbortController();
-const stop = () => {
-	controller.abort(/* @__PURE__ */ new Error("SSH helper process terminated"));
-};
-for (const signal of [
-	"SIGTERM",
-	"SIGHUP",
-	"SIGINT"
-]) process.once(signal, stop);
-try {
-	if (process.argv.length !== 2) throw new Error("SSH helper accepts no command arguments");
-	const packaged = isSea();
-	await runSshHelper({
-		input: process.stdin,
-		output: process.stdout,
-		entryPath: packaged ? process.execPath : fileURLToPath(import.meta.url),
-		kind: packaged ? "executable" : "node-script",
-		signal: controller.signal
-	});
-} catch (error) {
-	process.stderr.write(`dsh-ssh-sandbox: ${error instanceof Error ? error.message : String(error)}\n`);
-	process.exitCode = 127;
-} finally {
+/** Serve one helper request; every failure is reported on stderr with exit code 127. */
+async function main() {
+	const controller = new AbortController();
+	const stop = () => {
+		controller.abort(/* @__PURE__ */ new Error("SSH helper process terminated"));
+	};
 	for (const signal of [
 		"SIGTERM",
 		"SIGHUP",
 		"SIGINT"
-	]) process.off(signal, stop);
+	]) process.once(signal, stop);
+	try {
+		if (process.argv.length !== 2) throw new Error("SSH helper accepts no command arguments");
+		const packaged = isSea();
+		await runSshHelper({
+			input: process.stdin,
+			output: process.stdout,
+			entryPath: packaged ? process.execPath : fileURLToPath(import.meta.url),
+			kind: packaged ? "executable" : "node-script",
+			signal: controller.signal
+		});
+	} catch (error) {
+		process.stderr.write(`dsh-ssh-sandbox: ${error instanceof Error ? error.message : String(error)}\n`);
+		process.exitCode = 127;
+	} finally {
+		for (const signal of [
+			"SIGTERM",
+			"SIGHUP",
+			"SIGINT"
+		]) process.off(signal, stop);
+	}
 }
+main();
 //#endregion
 export {};

package/lib/index.js

@@ -1,5 +1,5 @@
-import { a as SshRpcPeer } from "./protocol-CDhW_IHU.js";
-import { s as helloSchema } from "./schemas-BD3YbDxe.js";
+import { SshRpcPeer } from "./protocol.js";
+import { helloSchema } from "./schemas.js";
 import { n as authenticateStream } from "./stream-security-DJlQsPG-.js";
 import { execFile, spawn } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";

package/lib/protocol.js

@@ -1,2 +1,276 @@
-import { a as SshRpcPeer, i as SSH_PROTOCOL_VERSION, n as SSH_MAX_PROCESS_HANDLES, r as SSH_MAX_TEXT_STREAMS, t as RemoteOperationError } from "./protocol-CDhW_IHU.js";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+//#region lib/types/protocol.js
+/** Bounded, versioned requests between an SSH client and its private remote helper. */
+/** Wire version shared by the installed helper and client package. */
+const SSH_PROTOCOL_VERSION = 2;
+/** Maximum prepared or running process handles owned by one helper. */
+const SSH_MAX_PROCESS_HANDLES = 128;
+/** Maximum open text iterators owned by one helper. */
+const SSH_MAX_TEXT_STREAMS = 128;
+const managementLimits = {
+	heartbeat: 1,
+	close: 1,
+	"process.terminate": 128,
+	"fs.streamClose": 128
+};
+function requestClass(method) {
+	switch (method) {
+		case "heartbeat":
+		case "close":
+		case "process.terminate":
+		case "fs.streamClose": return method;
+		default: return "ordinary";
+	}
+}
+const errorSchema = z.object({
+	name: z.string(),
+	message: z.string(),
+	code: z.string().optional()
+}).strict();
+const requestIdSchema = z.string().transform((value) => value);
+const frameSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("request"),
+		id: requestIdSchema,
+		method: z.string(),
+		params: z.unknown()
+	}).strict(),
+	z.object({
+		type: z.literal("result"),
+		id: requestIdSchema,
+		value: z.unknown()
+	}).strict(),
+	z.object({
+		type: z.literal("error"),
+		id: requestIdSchema,
+		error: errorSchema
+	}).strict(),
+	z.object({
+		type: z.literal("cancel"),
+		id: requestIdSchema
+	}).strict()
+]);
+function operationError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+/** A remote error retains its typed filesystem or sandbox code. */
+var RemoteOperationError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "RemoteOperationError";
+	}
+};
+/** The peer owns pending calls and rejects ambiguous operations on connection loss; it never replays requests. */
+var SshRpcPeer = class extends EventEmitter {
+	input;
+	output;
+	maxFrameBytes;
+	maxPending;
+	handler;
+	pending = /* @__PURE__ */ new Map();
+	active = /* @__PURE__ */ new Map();
+	writeTail = Promise.resolve();
+	queuedBytes = 0;
+	failure;
+	constructor(input, output, maxFrameBytes, maxPending, handler) {
+		super();
+		this.input = input;
+		this.output = output;
+		this.maxFrameBytes = maxFrameBytes;
+		this.maxPending = maxPending;
+		this.handler = handler;
+		input.on("error", (error) => {
+			this.close(error);
+		});
+		output.on("error", (error) => {
+			this.close(error);
+		});
+		output.on("close", () => {
+			this.close();
+		});
+		this.readFrames().catch((error) => {
+			this.close(operationError(error));
+		});
+	}
+	/**
+	* Send one request and validate its response before exposing it to the caller.
+	* @param method - the private helper operation.
+	* @param params - JSON request fields.
+	* @param schema - validation for the remote response.
+	* @param signal - cancellation without rollback of remote effects.
+	* @returns the validated response or a transport/remote-operation rejection.
+	*/
+	async request(method, params, schema, signal) {
+		signal?.throwIfAborted();
+		if (this.failure !== void 0) throw this.failure;
+		const kind = requestClass(method);
+		if (this.atCapacity(kind, this.pending.values())) throw new Error("SSH helper pending request limit reached");
+		const id = randomUUID();
+		const result = Promise.withResolvers();
+		result.promise.catch(() => {});
+		this.pending.set(id, {
+			...result,
+			requestClass: kind
+		});
+		const abort = () => {
+			result.reject(/* @__PURE__ */ new Error("SSH operation cancelled; a completed remote mutation is not rolled back"));
+			this.send({
+				type: "cancel",
+				id
+			}).catch(() => {});
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		try {
+			this.send({
+				type: "request",
+				id,
+				method,
+				params
+			}).catch((error) => {
+				this.pending.delete(id);
+				result.reject(operationError(error));
+			});
+			return schema.parse(await result.promise);
+		} finally {
+			signal?.removeEventListener("abort", abort);
+		}
+	}
+	/**
+	* Fail pending operations and abort remote handlers without claiming rollback.
+	* @param error - the transport failure reported to all pending operations.
+	*/
+	close(error = /* @__PURE__ */ new Error("SSH connection lost; remote operation outcome and cleanup are unknown")) {
+		if (this.failure !== void 0) return;
+		this.failure = error;
+		for (const pending of this.pending.values()) pending.reject(error);
+		this.pending.clear();
+		for (const { controller } of this.active.values()) controller.abort(error);
+		this.active.clear();
+		this.input.destroy();
+		this.output.destroy();
+		this.emit("closed", error);
+	}
+	async send(frame) {
+		if (this.failure !== void 0) return Promise.reject(this.failure);
+		const body = Buffer.from(JSON.stringify(frame));
+		if (body.length > this.maxFrameBytes || this.queuedBytes + body.length + 4 > this.maxFrameBytes * 2) return Promise.reject(/* @__PURE__ */ new Error("SSH helper frame or write queue limit exceeded"));
+		const header = Buffer.alloc(4);
+		header.writeUInt32BE(body.length);
+		const bytes = Buffer.concat([header, body]);
+		this.queuedBytes += bytes.length;
+		const write = this.writeTail.then(async () => {
+			if (this.failure !== void 0) throw this.failure;
+			if (!this.output.write(bytes)) await new Promise((resolve, reject) => {
+				const cleanup = () => {
+					this.output.off("drain", drained);
+					this.off("closed", closed);
+				};
+				const drained = () => {
+					cleanup();
+					resolve();
+				};
+				const closed = (error) => {
+					cleanup();
+					reject(error);
+				};
+				this.output.once("drain", drained);
+				this.once("closed", closed);
+				if (this.failure !== void 0) closed(this.failure);
+			});
+		});
+		this.writeTail = write.catch((error) => {
+			this.close(operationError(error));
+		});
+		return write.finally(() => {
+			this.queuedBytes -= bytes.length;
+		});
+	}
+	async readFrames() {
+		const header = Buffer.alloc(4);
+		let headerBytes = 0;
+		let payload;
+		let payloadBytes = 0;
+		for await (const raw of this.input) {
+			const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+			let offset = 0;
+			while (offset < chunk.length) {
+				if (payload === void 0) {
+					const count = Math.min(4 - headerBytes, chunk.length - offset);
+					chunk.copy(header, headerBytes, offset, offset + count);
+					headerBytes += count;
+					offset += count;
+					if (headerBytes < 4) continue;
+					const size = header.readUInt32BE(0);
+					if (size === 0 || size > this.maxFrameBytes) throw new Error("SSH helper sent an invalid frame length");
+					payload = Buffer.alloc(size);
+					payloadBytes = 0;
+				}
+				const count = Math.min(payload.length - payloadBytes, chunk.length - offset);
+				chunk.copy(payload, payloadBytes, offset, offset + count);
+				payloadBytes += count;
+				offset += count;
+				if (payloadBytes === payload.length) {
+					const frame = frameSchema.parse(JSON.parse(payload.toString("utf8")));
+					payload = void 0;
+					headerBytes = 0;
+					this.receive(frame);
+				}
+			}
+		}
+		throw new Error(headerBytes > 0 || payload !== void 0 ? "SSH helper disconnected during a frame; outcome is unknown" : "SSH helper disconnected; outcome is unknown");
+	}
+	receive(frame) {
+		if (frame.type === "result" || frame.type === "error") {
+			const pending = this.pending.get(frame.id);
+			if (pending === void 0) return;
+			this.pending.delete(frame.id);
+			if (frame.type === "result") pending.resolve(frame.value);
+			else pending.reject(new RemoteOperationError(frame.error.message, frame.error.code));
+			return;
+		}
+		if (frame.type === "cancel") {
+			this.active.get(frame.id)?.controller.abort(/* @__PURE__ */ new Error("SSH caller cancelled the operation"));
+			return;
+		}
+		const kind = requestClass(frame.method);
+		if (this.handler === void 0 || this.active.has(frame.id) || this.atCapacity(kind, this.active.values())) throw new Error("SSH helper received an unexpected or excessive request");
+		const controller = new AbortController();
+		this.active.set(frame.id, {
+			controller,
+			requestClass: kind
+		});
+		this.handler(frame.method, frame.params, controller.signal).then((value) => this.send({
+			type: "result",
+			id: frame.id,
+			value: value ?? null
+		}), (error) => {
+			const detail = operationError(error);
+			const code = "code" in detail && typeof detail.code === "string" ? detail.code : void 0;
+			return this.send({
+				type: "error",
+				id: frame.id,
+				error: {
+					name: detail.name,
+					message: detail.message,
+					...code === void 0 ? {} : { code }
+				}
+			});
+		}).catch((error) => {
+			this.close(operationError(error));
+		}).finally(() => {
+			this.active.delete(frame.id);
+		});
+	}
+	atCapacity(kind, requests) {
+		const limit = kind === "ordinary" ? this.maxPending : managementLimits[kind];
+		let count = 0;
+		for (const request of requests) if (request.requestClass === kind) count++;
+		return count >= limit;
+	}
+};
+//#endregion
 export { RemoteOperationError, SSH_MAX_PROCESS_HANDLES, SSH_MAX_TEXT_STREAMS, SSH_PROTOCOL_VERSION, SshRpcPeer };

package/lib/schemas.js

@@ -1,2 +1,189 @@
-import { C as writeResultSchema, S as textStreamIdSchema, _ as remotePath, a as environmentSchema, b as targetSchema, c as infoSchema, d as outputSnapshotFrameLimit, f as outputSnapshotSchema, g as processIdSchema, h as preparedSchema, i as entriesSchema, l as intentSchema, m as policySchema, n as editResultSchema, o as foregroundSchema, p as pathInfoSchema, r as editSchema, s as helloSchema, t as doneSchema, u as outcomeSchema, v as spawnSchema, x as terminalActivitySchema, y as streamEndpointSchema } from "./schemas-BD3YbDxe.js";
+import "./protocol.js";
+import { z } from "zod";
+//#region lib/types/schemas.js
+/** Strict JSON validation for SSH helper requests and remote observations. */
+/** Admit a process identity from the private helper protocol. */
+const processIdSchema = z.uuid().transform((value) => value);
+/** Admit a text iterator identity from the private helper protocol. */
+const textStreamIdSchema = z.uuid().transform((value) => value);
+/** A remote POSIX absolute path; spelling is preserved until remote canonicalization. */
+const remotePath = z.string().min(1).refine((value) => value.startsWith("/") && !value.includes("\0"), "expected an absolute POSIX path");
+/** Filesystem identity returned by the remote filesystem provider. */
+const targetSchema = z.object({
+	targetKey: remotePath,
+	displayPath: z.string()
+}).strict();
+/** Remote metadata observation. */
+const infoSchema = z.object({
+	version: z.string(),
+	type: z.enum([
+		"file",
+		"directory",
+		"other"
+	]),
+	size: z.number().nonnegative().optional()
+}).strict();
+/** Metadata that preserves a final symlink. */
+const pathInfoSchema = infoSchema.extend({ type: z.enum([
+	"file",
+	"directory",
+	"symlink",
+	"other"
+]) });
+/** A resolved file-effect policy; the remote helper owns path canonicalization. */
+const policySchema = z.object({
+	mode: z.enum([
+		"read-only",
+		"workspace-write",
+		"danger-full-access"
+	]),
+	workspaceRoot: remotePath,
+	sessionId: z.string().optional()
+}).strict();
+/** Complete directory entries. */
+const entriesSchema = z.array(z.object({
+	name: z.string(),
+	type: z.enum([
+		"file",
+		"directory",
+		"other"
+	]),
+	target: targetSchema,
+	version: z.string().optional(),
+	size: z.number().nonnegative().optional()
+}).strict());
+/** Guarded write intent. */
+const intentSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("createIfAbsent") }).strict(), z.object({
+	kind: z.literal("replaceIfVersion"),
+	version: z.string()
+}).strict()]);
+/** Literal text edit. */
+const editSchema = z.object({
+	oldString: z.string(),
+	newString: z.string(),
+	replaceAll: z.boolean()
+}).strict();
+/** Atomic write observation. */
+const writeResultSchema = z.object({
+	operation: z.enum(["create", "update"]),
+	version: z.string(),
+	before: z.string().nullable(),
+	after: z.string()
+}).strict();
+/** Atomic edit observation. */
+const editResultSchema = z.object({
+	version: z.string(),
+	before: z.string(),
+	after: z.string()
+}).strict();
+/** Explicit child environment; null encodes an environment tombstone. */
+const environmentSchema = z.record(z.string(), z.string().nullable());
+const collection = z.object({
+	maxBytes: z.number().int().positive(),
+	spill: z.object({ maxBytes: z.number().int().positive() }).strict().optional()
+}).strict();
+/** Ordinary or terminal process requested by a trusted SSH client. */
+const spawnSchema = z.object({
+	argv: z.array(z.string().refine((value) => !value.includes("\0"))).min(1),
+	cwd: remotePath,
+	env: environmentSchema.optional(),
+	graceMs: z.number().int().positive().max(2147483647),
+	stdio: z.object({
+		stdin: z.union([
+			z.literal("ignore"),
+			z.literal("pipe"),
+			z.object({ data: z.string() }).strict()
+		]),
+		stdout: z.union([
+			z.literal("pipe"),
+			z.literal("inherit"),
+			collection
+		]),
+		stderr: z.union([
+			z.literal("pipe"),
+			z.literal("inherit"),
+			collection
+		]),
+		control: z.literal("pipe").optional()
+	}).strict().optional(),
+	terminal: z.object({
+		terminalType: z.string().min(1),
+		rows: z.number().int().positive(),
+		cols: z.number().int().positive(),
+		shellActivity: z.boolean().optional()
+	}).strict().optional()
+}).strict().refine((value) => value.stdio === void 0 !== (value.terminal === void 0), "select ordinary or terminal execution");
+/** Connection handshake binds sockets and workspace to one helper process. */
+const helloSchema = z.object({
+	protocol: z.literal(2),
+	hash: z.string().regex(/^[0-9a-f]{64}$/),
+	kind: z.enum(["node-script", "executable"]),
+	platform: z.enum(["linux", "darwin"]),
+	nodeVersion: z.string(),
+	executable: remotePath,
+	root: remotePath,
+	workspace: remotePath,
+	bootstrapHash: z.string().regex(/^[0-9a-f]{64}$/).optional()
+}).strict();
+/** A prepared process publishes its sockets before target code may execute. */
+const streamEndpointSchema = z.object({
+	path: remotePath,
+	capability: z.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
+/** Prepared process and its independently authenticated stream endpoints. */
+const preparedSchema = z.object({
+	id: processIdSchema,
+	streams: z.partialRecord(z.enum([
+		"stdin",
+		"stdout",
+		"stderr",
+		"control",
+		"terminal"
+	]), streamEndpointSchema)
+}).strict();
+/** Direct process exit facts. */
+const outcomeSchema = z.object({
+	exitCode: z.number().int().nullable(),
+	signal: z.string().nullable()
+}).strict();
+/** A bounded raw tail positioned in whole-stream byte coordinates. */
+const outputSnapshotSchema = z.object({
+	tail: z.base64(),
+	totalBytes: z.number().int().nonnegative()
+}).strict();
+/**
+* Bound one encoded tail and its RPC envelope by the declared collection budget.
+* @param maxBytes - the collector's retained raw-byte limit.
+* @returns the private snapshot frame limit, capped by the helper protocol ceiling.
+*/
+function outputSnapshotFrameLimit(maxBytes) {
+	return Math.min(64 * 1024 * 1024, maxBytes * 2 + 1024);
+}
+/** Direct exit, retained output snapshots, and optional complete spill locations. */
+const doneSchema = z.object({
+	outcome: outcomeSchema,
+	spills: z.object({
+		stdout: remotePath.optional(),
+		stderr: remotePath.optional()
+	}).strict(),
+	collected: z.object({
+		stdout: outputSnapshotSchema.optional(),
+		stderr: outputSnapshotSchema.optional()
+	}).strict()
+}).strict();
+/** Remote terminal foreground observation. */
+const foregroundSchema = z.object({
+	processGroupId: z.number().int().positive(),
+	inputWaiting: z.boolean()
+}).strict().nullable();
+/** Conservative shell lifecycle and process observation returned by the execution provider. */
+const terminalActivitySchema = z.object({
+	state: z.enum([
+		"idle",
+		"busy",
+		"unknown"
+	]),
+	revision: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
+}).strict();
+//#endregion
 export { doneSchema, editResultSchema, editSchema, entriesSchema, environmentSchema, foregroundSchema, helloSchema, infoSchema, intentSchema, outcomeSchema, outputSnapshotFrameLimit, outputSnapshotSchema, pathInfoSchema, policySchema, preparedSchema, processIdSchema, remotePath, spawnSchema, streamEndpointSchema, targetSchema, terminalActivitySchema, textStreamIdSchema, writeResultSchema };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-ssh",
   "description": "Shared OpenSSH connection and versioned POSIX remote helper",
-  "version": "0.2.1-alpha.3",
+  "version": "0.2.1-alpha.4",
   "publishConfig": {
     "access": "public"
   },
@@ -46,17 +46,17 @@
   "license": "MIT",
   "peerDependencies": {
     "@deepseek-ai/cordis": "~4.0.5-alpha.2",
-    "@deepseek-ai/dsh-fs": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-fs-local": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-fs-sandbox": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-subprocess": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-subprocess-local": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-sandbox": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-sandbox-local": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-sandbox-policy": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-session-projection": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-brand": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-util-values": "0.2.1-alpha.3"
+    "@deepseek-ai/dsh-fs": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-fs-local": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-fs-sandbox": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-subprocess": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-subprocess-local": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox-local": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-session-projection": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-brand": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-util-values": "0.2.1-alpha.4"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "~3.18.5-alpha.2",
@@ -64,22 +64,22 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "~4.0.5-alpha.2",
-    "@deepseek-ai/dsh-fs": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-fs-local": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-fs-sandbox": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-subprocess": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-subprocess-local": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-sandbox": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-sandbox-local": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-sandbox-policy": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-session-projection": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-ptc-runtime-node": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-fs-ssh": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-subprocess-ssh": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-sandbox-ssh": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-lsp": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-lsp-stdio": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-brand": "0.2.1-alpha.3",
-    "@deepseek-ai/dsh-util-values": "0.2.1-alpha.3"
+    "@deepseek-ai/dsh-fs": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-fs-local": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-fs-sandbox": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-subprocess": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-subprocess-local": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox-local": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-session-projection": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-ptc-runtime-node": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-fs-ssh": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-subprocess-ssh": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox-ssh": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-lsp": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-lsp-stdio": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-brand": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-util-values": "0.2.1-alpha.4"
   }
 }

package/lib/protocol-CDhW_IHU.js

@@ -1,276 +0,0 @@
-import { z } from "zod";
-import { randomUUID } from "node:crypto";
-import { EventEmitter } from "node:events";
-//#region lib/types/protocol.js
-/** Bounded, versioned requests between an SSH client and its private remote helper. */
-/** Wire version shared by the installed helper and client package. */
-const SSH_PROTOCOL_VERSION = 2;
-/** Maximum prepared or running process handles owned by one helper. */
-const SSH_MAX_PROCESS_HANDLES = 128;
-/** Maximum open text iterators owned by one helper. */
-const SSH_MAX_TEXT_STREAMS = 128;
-const managementLimits = {
-	heartbeat: 1,
-	close: 1,
-	"process.terminate": 128,
-	"fs.streamClose": 128
-};
-function requestClass(method) {
-	switch (method) {
-		case "heartbeat":
-		case "close":
-		case "process.terminate":
-		case "fs.streamClose": return method;
-		default: return "ordinary";
-	}
-}
-const errorSchema = z.object({
-	name: z.string(),
-	message: z.string(),
-	code: z.string().optional()
-}).strict();
-const requestIdSchema = z.string().transform((value) => value);
-const frameSchema = z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal("request"),
-		id: requestIdSchema,
-		method: z.string(),
-		params: z.unknown()
-	}).strict(),
-	z.object({
-		type: z.literal("result"),
-		id: requestIdSchema,
-		value: z.unknown()
-	}).strict(),
-	z.object({
-		type: z.literal("error"),
-		id: requestIdSchema,
-		error: errorSchema
-	}).strict(),
-	z.object({
-		type: z.literal("cancel"),
-		id: requestIdSchema
-	}).strict()
-]);
-function operationError(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-/** A remote error retains its typed filesystem or sandbox code. */
-var RemoteOperationError = class extends Error {
-	code;
-	constructor(message, code) {
-		super(message);
-		this.code = code;
-		this.name = "RemoteOperationError";
-	}
-};
-/** The peer owns pending calls and rejects ambiguous operations on connection loss; it never replays requests. */
-var SshRpcPeer = class extends EventEmitter {
-	input;
-	output;
-	maxFrameBytes;
-	maxPending;
-	handler;
-	pending = /* @__PURE__ */ new Map();
-	active = /* @__PURE__ */ new Map();
-	writeTail = Promise.resolve();
-	queuedBytes = 0;
-	failure;
-	constructor(input, output, maxFrameBytes, maxPending, handler) {
-		super();
-		this.input = input;
-		this.output = output;
-		this.maxFrameBytes = maxFrameBytes;
-		this.maxPending = maxPending;
-		this.handler = handler;
-		input.on("error", (error) => {
-			this.close(error);
-		});
-		output.on("error", (error) => {
-			this.close(error);
-		});
-		output.on("close", () => {
-			this.close();
-		});
-		this.readFrames().catch((error) => {
-			this.close(operationError(error));
-		});
-	}
-	/**
-	* Send one request and validate its response before exposing it to the caller.
-	* @param method - the private helper operation.
-	* @param params - JSON request fields.
-	* @param schema - validation for the remote response.
-	* @param signal - cancellation without rollback of remote effects.
-	* @returns the validated response or a transport/remote-operation rejection.
-	*/
-	async request(method, params, schema, signal) {
-		signal?.throwIfAborted();
-		if (this.failure !== void 0) throw this.failure;
-		const kind = requestClass(method);
-		if (this.atCapacity(kind, this.pending.values())) throw new Error("SSH helper pending request limit reached");
-		const id = randomUUID();
-		const result = Promise.withResolvers();
-		result.promise.catch(() => {});
-		this.pending.set(id, {
-			...result,
-			requestClass: kind
-		});
-		const abort = () => {
-			result.reject(/* @__PURE__ */ new Error("SSH operation cancelled; a completed remote mutation is not rolled back"));
-			this.send({
-				type: "cancel",
-				id
-			}).catch(() => {});
-		};
-		signal?.addEventListener("abort", abort, { once: true });
-		try {
-			this.send({
-				type: "request",
-				id,
-				method,
-				params
-			}).catch((error) => {
-				this.pending.delete(id);
-				result.reject(operationError(error));
-			});
-			return schema.parse(await result.promise);
-		} finally {
-			signal?.removeEventListener("abort", abort);
-		}
-	}
-	/**
-	* Fail pending operations and abort remote handlers without claiming rollback.
-	* @param error - the transport failure reported to all pending operations.
-	*/
-	close(error = /* @__PURE__ */ new Error("SSH connection lost; remote operation outcome and cleanup are unknown")) {
-		if (this.failure !== void 0) return;
-		this.failure = error;
-		for (const pending of this.pending.values()) pending.reject(error);
-		this.pending.clear();
-		for (const { controller } of this.active.values()) controller.abort(error);
-		this.active.clear();
-		this.input.destroy();
-		this.output.destroy();
-		this.emit("closed", error);
-	}
-	async send(frame) {
-		if (this.failure !== void 0) return Promise.reject(this.failure);
-		const body = Buffer.from(JSON.stringify(frame));
-		if (body.length > this.maxFrameBytes || this.queuedBytes + body.length + 4 > this.maxFrameBytes * 2) return Promise.reject(/* @__PURE__ */ new Error("SSH helper frame or write queue limit exceeded"));
-		const header = Buffer.alloc(4);
-		header.writeUInt32BE(body.length);
-		const bytes = Buffer.concat([header, body]);
-		this.queuedBytes += bytes.length;
-		const write = this.writeTail.then(async () => {
-			if (this.failure !== void 0) throw this.failure;
-			if (!this.output.write(bytes)) await new Promise((resolve, reject) => {
-				const cleanup = () => {
-					this.output.off("drain", drained);
-					this.off("closed", closed);
-				};
-				const drained = () => {
-					cleanup();
-					resolve();
-				};
-				const closed = (error) => {
-					cleanup();
-					reject(error);
-				};
-				this.output.once("drain", drained);
-				this.once("closed", closed);
-				if (this.failure !== void 0) closed(this.failure);
-			});
-		});
-		this.writeTail = write.catch((error) => {
-			this.close(operationError(error));
-		});
-		return write.finally(() => {
-			this.queuedBytes -= bytes.length;
-		});
-	}
-	async readFrames() {
-		const header = Buffer.alloc(4);
-		let headerBytes = 0;
-		let payload;
-		let payloadBytes = 0;
-		for await (const raw of this.input) {
-			const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
-			let offset = 0;
-			while (offset < chunk.length) {
-				if (payload === void 0) {
-					const count = Math.min(4 - headerBytes, chunk.length - offset);
-					chunk.copy(header, headerBytes, offset, offset + count);
-					headerBytes += count;
-					offset += count;
-					if (headerBytes < 4) continue;
-					const size = header.readUInt32BE(0);
-					if (size === 0 || size > this.maxFrameBytes) throw new Error("SSH helper sent an invalid frame length");
-					payload = Buffer.alloc(size);
-					payloadBytes = 0;
-				}
-				const count = Math.min(payload.length - payloadBytes, chunk.length - offset);
-				chunk.copy(payload, payloadBytes, offset, offset + count);
-				payloadBytes += count;
-				offset += count;
-				if (payloadBytes === payload.length) {
-					const frame = frameSchema.parse(JSON.parse(payload.toString("utf8")));
-					payload = void 0;
-					headerBytes = 0;
-					this.receive(frame);
-				}
-			}
-		}
-		throw new Error(headerBytes > 0 || payload !== void 0 ? "SSH helper disconnected during a frame; outcome is unknown" : "SSH helper disconnected; outcome is unknown");
-	}
-	receive(frame) {
-		if (frame.type === "result" || frame.type === "error") {
-			const pending = this.pending.get(frame.id);
-			if (pending === void 0) return;
-			this.pending.delete(frame.id);
-			if (frame.type === "result") pending.resolve(frame.value);
-			else pending.reject(new RemoteOperationError(frame.error.message, frame.error.code));
-			return;
-		}
-		if (frame.type === "cancel") {
-			this.active.get(frame.id)?.controller.abort(/* @__PURE__ */ new Error("SSH caller cancelled the operation"));
-			return;
-		}
-		const kind = requestClass(frame.method);
-		if (this.handler === void 0 || this.active.has(frame.id) || this.atCapacity(kind, this.active.values())) throw new Error("SSH helper received an unexpected or excessive request");
-		const controller = new AbortController();
-		this.active.set(frame.id, {
-			controller,
-			requestClass: kind
-		});
-		this.handler(frame.method, frame.params, controller.signal).then((value) => this.send({
-			type: "result",
-			id: frame.id,
-			value: value ?? null
-		}), (error) => {
-			const detail = operationError(error);
-			const code = "code" in detail && typeof detail.code === "string" ? detail.code : void 0;
-			return this.send({
-				type: "error",
-				id: frame.id,
-				error: {
-					name: detail.name,
-					message: detail.message,
-					...code === void 0 ? {} : { code }
-				}
-			});
-		}).catch((error) => {
-			this.close(operationError(error));
-		}).finally(() => {
-			this.active.delete(frame.id);
-		});
-	}
-	atCapacity(kind, requests) {
-		const limit = kind === "ordinary" ? this.maxPending : managementLimits[kind];
-		let count = 0;
-		for (const request of requests) if (request.requestClass === kind) count++;
-		return count >= limit;
-	}
-};
-//#endregion
-export { SshRpcPeer as a, SSH_PROTOCOL_VERSION as i, SSH_MAX_PROCESS_HANDLES as n, SSH_MAX_TEXT_STREAMS as r, RemoteOperationError as t };

package/lib/schemas-BD3YbDxe.js

@@ -1,189 +0,0 @@
-import "./protocol-CDhW_IHU.js";
-import { z } from "zod";
-//#region lib/types/schemas.js
-/** Strict JSON validation for SSH helper requests and remote observations. */
-/** Admit a process identity from the private helper protocol. */
-const processIdSchema = z.uuid().transform((value) => value);
-/** Admit a text iterator identity from the private helper protocol. */
-const textStreamIdSchema = z.uuid().transform((value) => value);
-/** A remote POSIX absolute path; spelling is preserved until remote canonicalization. */
-const remotePath = z.string().min(1).refine((value) => value.startsWith("/") && !value.includes("\0"), "expected an absolute POSIX path");
-/** Filesystem identity returned by the remote filesystem provider. */
-const targetSchema = z.object({
-	targetKey: remotePath,
-	displayPath: z.string()
-}).strict();
-/** Remote metadata observation. */
-const infoSchema = z.object({
-	version: z.string(),
-	type: z.enum([
-		"file",
-		"directory",
-		"other"
-	]),
-	size: z.number().nonnegative().optional()
-}).strict();
-/** Metadata that preserves a final symlink. */
-const pathInfoSchema = infoSchema.extend({ type: z.enum([
-	"file",
-	"directory",
-	"symlink",
-	"other"
-]) });
-/** A resolved file-effect policy; the remote helper owns path canonicalization. */
-const policySchema = z.object({
-	mode: z.enum([
-		"read-only",
-		"workspace-write",
-		"danger-full-access"
-	]),
-	workspaceRoot: remotePath,
-	sessionId: z.string().optional()
-}).strict();
-/** Complete directory entries. */
-const entriesSchema = z.array(z.object({
-	name: z.string(),
-	type: z.enum([
-		"file",
-		"directory",
-		"other"
-	]),
-	target: targetSchema,
-	version: z.string().optional(),
-	size: z.number().nonnegative().optional()
-}).strict());
-/** Guarded write intent. */
-const intentSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("createIfAbsent") }).strict(), z.object({
-	kind: z.literal("replaceIfVersion"),
-	version: z.string()
-}).strict()]);
-/** Literal text edit. */
-const editSchema = z.object({
-	oldString: z.string(),
-	newString: z.string(),
-	replaceAll: z.boolean()
-}).strict();
-/** Atomic write observation. */
-const writeResultSchema = z.object({
-	operation: z.enum(["create", "update"]),
-	version: z.string(),
-	before: z.string().nullable(),
-	after: z.string()
-}).strict();
-/** Atomic edit observation. */
-const editResultSchema = z.object({
-	version: z.string(),
-	before: z.string(),
-	after: z.string()
-}).strict();
-/** Explicit child environment; null encodes an environment tombstone. */
-const environmentSchema = z.record(z.string(), z.string().nullable());
-const collection = z.object({
-	maxBytes: z.number().int().positive(),
-	spill: z.object({ maxBytes: z.number().int().positive() }).strict().optional()
-}).strict();
-/** Ordinary or terminal process requested by a trusted SSH client. */
-const spawnSchema = z.object({
-	argv: z.array(z.string().refine((value) => !value.includes("\0"))).min(1),
-	cwd: remotePath,
-	env: environmentSchema.optional(),
-	graceMs: z.number().int().positive().max(2147483647),
-	stdio: z.object({
-		stdin: z.union([
-			z.literal("ignore"),
-			z.literal("pipe"),
-			z.object({ data: z.string() }).strict()
-		]),
-		stdout: z.union([
-			z.literal("pipe"),
-			z.literal("inherit"),
-			collection
-		]),
-		stderr: z.union([
-			z.literal("pipe"),
-			z.literal("inherit"),
-			collection
-		]),
-		control: z.literal("pipe").optional()
-	}).strict().optional(),
-	terminal: z.object({
-		terminalType: z.string().min(1),
-		rows: z.number().int().positive(),
-		cols: z.number().int().positive(),
-		shellActivity: z.boolean().optional()
-	}).strict().optional()
-}).strict().refine((value) => value.stdio === void 0 !== (value.terminal === void 0), "select ordinary or terminal execution");
-/** Connection handshake binds sockets and workspace to one helper process. */
-const helloSchema = z.object({
-	protocol: z.literal(2),
-	hash: z.string().regex(/^[0-9a-f]{64}$/),
-	kind: z.enum(["node-script", "executable"]),
-	platform: z.enum(["linux", "darwin"]),
-	nodeVersion: z.string(),
-	executable: remotePath,
-	root: remotePath,
-	workspace: remotePath,
-	bootstrapHash: z.string().regex(/^[0-9a-f]{64}$/).optional()
-}).strict();
-/** A prepared process publishes its sockets before target code may execute. */
-const streamEndpointSchema = z.object({
-	path: remotePath,
-	capability: z.string().regex(/^[0-9a-f]{64}$/)
-}).strict();
-/** Prepared process and its independently authenticated stream endpoints. */
-const preparedSchema = z.object({
-	id: processIdSchema,
-	streams: z.partialRecord(z.enum([
-		"stdin",
-		"stdout",
-		"stderr",
-		"control",
-		"terminal"
-	]), streamEndpointSchema)
-}).strict();
-/** Direct process exit facts. */
-const outcomeSchema = z.object({
-	exitCode: z.number().int().nullable(),
-	signal: z.string().nullable()
-}).strict();
-/** A bounded raw tail positioned in whole-stream byte coordinates. */
-const outputSnapshotSchema = z.object({
-	tail: z.base64(),
-	totalBytes: z.number().int().nonnegative()
-}).strict();
-/**
-* Bound one encoded tail and its RPC envelope by the declared collection budget.
-* @param maxBytes - the collector's retained raw-byte limit.
-* @returns the private snapshot frame limit, capped by the helper protocol ceiling.
-*/
-function outputSnapshotFrameLimit(maxBytes) {
-	return Math.min(64 * 1024 * 1024, maxBytes * 2 + 1024);
-}
-/** Direct exit, retained output snapshots, and optional complete spill locations. */
-const doneSchema = z.object({
-	outcome: outcomeSchema,
-	spills: z.object({
-		stdout: remotePath.optional(),
-		stderr: remotePath.optional()
-	}).strict(),
-	collected: z.object({
-		stdout: outputSnapshotSchema.optional(),
-		stderr: outputSnapshotSchema.optional()
-	}).strict()
-}).strict();
-/** Remote terminal foreground observation. */
-const foregroundSchema = z.object({
-	processGroupId: z.number().int().positive(),
-	inputWaiting: z.boolean()
-}).strict().nullable();
-/** Conservative shell lifecycle and process observation returned by the execution provider. */
-const terminalActivitySchema = z.object({
-	state: z.enum([
-		"idle",
-		"busy",
-		"unknown"
-	]),
-	revision: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
-}).strict();
-//#endregion
-export { writeResultSchema as C, textStreamIdSchema as S, remotePath as _, environmentSchema as a, targetSchema as b, infoSchema as c, outputSnapshotFrameLimit as d, outputSnapshotSchema as f, processIdSchema as g, preparedSchema as h, entriesSchema as i, intentSchema as l, policySchema as m, editResultSchema as n, foregroundSchema as o, pathInfoSchema as p, editSchema as r, helloSchema as s, doneSchema as t, outcomeSchema as u, spawnSchema as v, terminalActivitySchema as x, streamEndpointSchema as y };