@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.33

package/vendor/computer-use/native/macos/Sources/Monitor/main.swift

@@ -0,0 +1,153 @@
+import AppKit
+import CoreGraphics
+import Darwin
+import Foundation
+
+private func argument(_ name: String, default fallback: Int) -> Int {
+    let values = ProcessInfo.processInfo.arguments
+    guard let index = values.firstIndex(of: name), values.indices.contains(index + 1),
+          let value = Int(values[index + 1]), value > 0 else { return fallback }
+    return value
+}
+
+private func stringArgument(_ name: String) -> String? {
+    let values = ProcessInfo.processInfo.arguments
+    guard let index = values.firstIndex(of: name), values.indices.contains(index + 1) else { return nil }
+    return values[index + 1]
+}
+
+private func optionalIntegerArgument(_ name: String) -> Int32? {
+    guard let value = stringArgument(name), let parsed = Int32(value), parsed > 0 else { return nil }
+    return parsed
+}
+
+private func cursorLocation() -> CGPoint {
+    CGEvent(source: nil)?.location ?? .zero
+}
+
+private func frontmostPid() -> pid_t? {
+    NSWorkspace.shared.frontmostApplication?.processIdentifier
+}
+
+private func matchingWindows(ownerPid: pid_t?, title: String?) -> [[String: Any]] {
+    guard let windows = CGWindowListCopyWindowInfo(
+        [.optionOnScreenOnly, .excludeDesktopElements],
+        kCGNullWindowID
+    ) as? [[String: Any]] else { return [] }
+    return windows.filter { window in
+        if let ownerPid,
+           (window[kCGWindowOwnerPID as String] as? NSNumber)?.int32Value != ownerPid { return false }
+        if let title,
+           (window[kCGWindowName as String] as? String) != title { return false }
+        return true
+    }
+}
+
+private let durationMs = argument("--duration-ms", default: 1200)
+private let intervalMicros = useconds_t(argument("--interval-micros", default: 1000))
+private let windowOwnerPid = stringArgument("--window-owner-pid").flatMap { Int32($0) }
+private let windowTitle = stringArgument("--window-title")
+private let monitoredSourcePid = optionalIntegerArgument("--source-pid")
+private let baselineCursor = cursorLocation()
+private let baselineFrontmostPid = frontmostPid()
+private var maximumCursorDistance = 0.0
+private var observedFrontmostPids = Set<Int32>()
+private var maximumMatchingWindowCount = 0
+private var matchingWindowFrames: [[String: Any]] = []
+private var matchingWindowNumbers: [Int] = []
+private var seenWindowFrames = Set<String>()
+private var monitoredSourcePointerEvents = 0
+private var pointerEventSourceCounts: [String: Int] = [:]
+private var samples = 0
+
+private let pointerMask = [
+    CGEventType.mouseMoved,
+    .leftMouseDown,
+    .leftMouseUp,
+    .leftMouseDragged,
+    .rightMouseDown,
+    .rightMouseUp,
+    .rightMouseDragged,
+    .otherMouseDown,
+    .otherMouseUp,
+    .otherMouseDragged,
+    .scrollWheel,
+].reduce(CGEventMask(0)) { mask, type in
+    mask | (CGEventMask(1) << type.rawValue)
+}
+private let eventTap = CGEvent.tapCreate(
+    tap: .cgSessionEventTap,
+    place: .headInsertEventTap,
+    options: .listenOnly,
+    eventsOfInterest: pointerMask,
+    callback: { _, _, event, _ in
+        let sourcePid = event.getIntegerValueField(.eventSourceUnixProcessID)
+        pointerEventSourceCounts[String(sourcePid), default: 0] += 1
+        if let monitoredSourcePid, sourcePid == Int64(monitoredSourcePid) {
+            monitoredSourcePointerEvents += 1
+        }
+        return Unmanaged.passUnretained(event)
+    },
+    userInfo: nil
+)
+private let eventTapSource = eventTap.map {
+    CFMachPortCreateRunLoopSource(kCFAllocatorDefault, $0, 0)
+}
+
+if let eventTap, let eventTapSource {
+    CFRunLoopAddSource(CFRunLoopGetCurrent(), eventTapSource, .defaultMode)
+    CGEvent.tapEnable(tap: eventTap, enable: true)
+}
+
+if let baselineFrontmostPid { observedFrontmostPids.insert(baselineFrontmostPid) }
+FileHandle.standardOutput.write(Data("READY\n".utf8))
+
+let deadline = DispatchTime.now().uptimeNanoseconds + UInt64(durationMs) * 1_000_000
+while DispatchTime.now().uptimeNanoseconds < deadline {
+    let location = cursorLocation()
+    let distance = hypot(location.x - baselineCursor.x, location.y - baselineCursor.y)
+    maximumCursorDistance = max(maximumCursorDistance, distance)
+    if let pid = frontmostPid() { observedFrontmostPids.insert(pid) }
+    let windows = matchingWindows(ownerPid: windowOwnerPid, title: windowTitle)
+    maximumMatchingWindowCount = max(maximumMatchingWindowCount, windows.count)
+    if let first = windows.first,
+       let bounds = first[kCGWindowBounds as String] as? [String: Any] {
+        let frameKey = ["X", "Y", "Width", "Height"]
+            .map { String(describing: bounds[$0] ?? "") }
+            .joined(separator: ",")
+        if seenWindowFrames.insert(frameKey).inserted {
+            matchingWindowFrames.append(bounds)
+        }
+        if let number = (first[kCGWindowNumber as String] as? NSNumber)?.intValue,
+           !matchingWindowNumbers.contains(number) {
+            matchingWindowNumbers.append(number)
+        }
+    }
+    samples += 1
+    if eventTapSource != nil {
+        CFRunLoopRunInMode(.defaultMode, Double(intervalMicros) / 1_000_000, true)
+    } else {
+        usleep(intervalMicros)
+    }
+}
+
+let finalCursor = cursorLocation()
+let finalFrontmostPid = frontmostPid()
+let result: [String: Any] = [
+    "baselineCursor": ["x": baselineCursor.x, "y": baselineCursor.y],
+    "finalCursor": ["x": finalCursor.x, "y": finalCursor.y],
+    "maximumCursorDistance": maximumCursorDistance,
+    "baselineFrontmostPid": baselineFrontmostPid.map(Int.init) as Any,
+    "observedFrontmostPids": observedFrontmostPids.sorted().map(Int.init),
+    "finalFrontmostPid": finalFrontmostPid.map(Int.init) as Any,
+    "samples": samples,
+    "maximumMatchingWindowCount": maximumMatchingWindowCount,
+    "matchingWindowFrames": matchingWindowFrames,
+    "matchingWindowNumbers": matchingWindowNumbers,
+    "eventTapAvailable": eventTap != nil,
+    "monitoredSourcePointerEvents": monitoredSourcePointerEvents,
+    "pointerEventSourceCounts": pointerEventSourceCounts,
+]
+let data = try JSONSerialization.data(withJSONObject: result, options: [.sortedKeys])
+FileHandle.standardOutput.write(data)
+FileHandle.standardOutput.write(Data("\n".utf8))

package/vendor/computer-use/native/macos/manifest.json

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "helperVersion": "0.3.3",
+  "sourceSha256": "b5de65a33e53689c5b490d8f6641a6577ba61a6f6f45798210b0df65bd0ced07",
+  "binary": {
+    "path": "bin/dsh-computer-use-helper",
+    "sha256": "55325e0008d755bf2b1d408bcfd5cdb80842ec2a0fa5312da6961eb65d7d6dd3",
+    "architectures": [
+      "arm64",
+      "x86_64"
+    ],
+    "minimumMacOS": "14.0"
+  }
+}

package/vendor/persistent/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.

package/vendor/persistent/index.js

@@ -0,0 +1,411 @@
+// dscode-shell-capture-v1
+// dscode-stdin-stall-v2
+const STDIN_STALL_MS = 5000;
+const STDIN_STALL_NOTE = "\n[Interrupted after 5s with no output: the command held the terminal without producing anything, and this tool cannot supply terminal input. Give it stdin (a heredoc, `< file` or `< /dev/null`) or use a non-interactive form.]";
+// dscode-shell-reset-v1
+import { randomUUID } from "node:crypto";
+import z from "@deepseek-ai/schemastery";
+import { truncateWithoutSplittingSurrogatePair } from "@deepseek-ai/dsh-output-retention";
+import { deadline, timeoutOf } from "@deepseek-ai/dsh-timeout";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region lib/types/index.js
+/**
+* Model-facing persistent `bash` tool over the owner-scoped PTY seam.
+* @module @deepseek-ai/dsh-tool-bash-persistent
+*/
+var __addDisposableResource = function(env, value, async) {
+	if (value !== null && value !== void 0) {
+		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+		var dispose, inner;
+		if (async) {
+			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+			dispose = value[Symbol.asyncDispose];
+		}
+		if (dispose === void 0) {
+			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+			dispose = value[Symbol.dispose];
+			if (async) inner = dispose;
+		}
+		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+		if (inner) dispose = function() {
+			try {
+				inner.call(this);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		};
+		env.stack.push({
+			value,
+			dispose,
+			async
+		});
+	} else if (async) env.stack.push({ async: true });
+	return value;
+};
+var __disposeResources = (function(SuppressedError) {
+	return function(env) {
+		function fail(e) {
+			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+			env.hasError = true;
+		}
+		var r, s = 0;
+		function next() {
+			while (r = env.stack.pop()) try {
+				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+				if (r.dispose) {
+					var result = r.dispose.call(r.value);
+					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+						fail(e);
+						return next();
+					});
+				} else s |= 1;
+			} catch (e) {
+				fail(e);
+			}
+			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+			if (env.hasError) throw env.error;
+		}
+		return next();
+	};
+})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+	var e = new Error(message);
+	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+const TRUNCATED_MESSAGE = "<response clipped><NOTE>To save on context only part of this file has been shown to you. You should retry this tool after you have searched inside the file with `grep -n` in order to find the line numbers of what you are looking for.</NOTE>";
+const LOST_PREFIX_MESSAGE = "<response clipped><NOTE>The beginning of this command output was dropped by the terminal scrollback limit. The following text is the earliest retained output.</NOTE>\n";
+const SHELL_RESET_MESSAGE = "The persistent bash shell was reset; the next bash call starts from the workspace with a fresh current directory and environment.";
+const TIMEOUT_STATUS_MARKER = "[Command timed out or OOM]";
+const TIMEOUT_CODE = "PERSISTENT_BASH_TIMEOUT";
+const SCROLLBACK_PAGE_LINES = 1e3;
+const POLL_INTERVAL_MS = 25;
+const DEFAULT_DESCRIPTION = "Run commands in a persistent bash shell. State, including the current directory and exported environment variables, persists across calls for this agent.";
+function maybeTruncate(content, maxOutputChars, incomplete = false) {
+	if (content.length <= maxOutputChars && !incomplete) return content;
+	return content.length <= maxOutputChars ? content + TRUNCATED_MESSAGE : truncateWithoutSplittingSurrogatePair(content, maxOutputChars) + TRUNCATED_MESSAGE;
+}
+function markers() {
+	const nonce = randomUUID();
+	return {
+		start: `__DSH_PERSISTENT_BASH_START_${nonce}__`,
+		end: `__DSH_PERSISTENT_BASH_END_${nonce}:`
+	};
+}
+function quoteForBash(value) {
+	return `$'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("\r", "\\r").replaceAll("\n", "\\n")}'`;
+}
+function wrapCommand(command, marker) {
+	return `printf '%s\\n' ${quoteForBash(marker.start)}; eval -- ${quoteForBash(command)}; __dsh_persistent_bash_status=$?; printf '%s%s\\n' ${quoteForBash(marker.end)} "$__dsh_persistent_bash_status"`;
+}
+function trimTrailingNewline(text) {
+	return text.replace(/(?:\r?\n)+$/, "");
+}
+function commandOutput(snapshot, marker) {
+	const text = snapshot.text;
+	const end = text.lastIndexOf(marker.end);
+	const status = /^(\d+)\r?\n/.exec(text.slice(end + marker.end.length))?.[1];
+	if (status === void 0) return void 0;
+	const startMarker = text.lastIndexOf(marker.start, end);
+	const start = startMarker < 0 ? 0 : startMarker + marker.start.length;
+	return {
+		text: trimTrailingNewline(text.slice(start, end).replace(/^\r?\n/, "")),
+		incomplete: startMarker < 0,
+		exitCode: Number(status)
+	};
+}
+function partialOutput(snapshot, marker, fallback, fallbackTruncated = false) {
+	const startMarker = snapshot.text.lastIndexOf(marker.start);
+	if (startMarker >= 0) return {
+		text: trimTrailingNewline(snapshot.text.slice(startMarker + marker.start.length).replace(/^\r?\n/, "")),
+		incomplete: false
+	};
+	const fallbackStart = fallback.lastIndexOf(marker.start);
+	const afterStart = fallbackStart < 0 ? fallback : fallback.slice(fallbackStart + marker.start.length).replace(/^\r?\n/, "");
+	const fallbackEnd = afterStart.lastIndexOf(marker.end);
+	return {
+		text: trimTrailingNewline(fallbackEnd < 0 ? afterStart : afterStart.slice(0, fallbackEnd)),
+		incomplete: fallbackTruncated || fallbackStart < 0
+	};
+}
+async function pause() {
+	await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+}
+function nextScrollbackOffset(page, offset) {
+	if (page.text.length === 0 || page.lineEnd <= offset) return void 0;
+	return page.lineEnd;
+}
+function retainedScrollback(ctx, owner, id, latest = ctx.terminals.read(owner, id, {
+	offset: 0,
+	count: SCROLLBACK_PAGE_LINES
+})) {
+	const pages = latest.text.length === 0 ? [] : [latest.text];
+	let offset = latest.lineEnd;
+	let truncated = latest.truncated;
+	while (true) {
+		if (offset >= latest.totalLines) break;
+		const page = ctx.terminals.read(owner, id, {
+			offset,
+			count: SCROLLBACK_PAGE_LINES
+		});
+		truncated ||= page.truncated;
+		if (page.text.length > 0) pages.unshift(page.text);
+		const next = nextScrollbackOffset(page, offset);
+		if (next === void 0 || next >= page.totalLines) break;
+		offset = next;
+	}
+	return {
+		text: pages.join("\n"),
+		truncated
+	};
+}
+function renderCaptured(output, maxOutputChars) {
+	const rendered = maybeTruncate(output.text, maxOutputChars, output.incomplete);
+	return appendStatusMarker(output.incomplete && output.text.length > 0 ? LOST_PREFIX_MESSAGE + rendered : rendered, output.exitCode !== void 0 ? `[Command finished with exit code ${output.exitCode}]` : void 0);
+}
+function appendStatusMarker(content, marker) {
+	if (marker === void 0) return content;
+	return content.length === 0 ? marker : `${content}\n${marker}`;
+}
+function renderShellExitStatus(content, exitCode, signal) {
+	return appendStatusMarker(content, signal !== null ? `[shell killed by signal: ${signal}]` : exitCode !== null ? `[shell exited: code ${exitCode}]` : "[shell exited]");
+}
+/**
+* Render the exited-session result, reset the owner's shell, and reset the
+* message that tells the model the next call starts fresh.
+* @param shells - the owner-scoped registry to reset.
+* @param status - the exited session status (exit code and signal).
+* @returns the complete model-facing result.
+*/
+async function respondToSessionExit(ctx, shells, owner, id, status, marker, fallback, fallbackTruncated, config) {
+	const window = ctx.terminals.read(owner, id, { capture: true });
+	const snapshot = window.text.length > 0 ? window : retainedScrollback(ctx, owner, id);
+	await shells.reset(owner, "persistent bash shell exited");
+	return [renderShellExitStatus(renderCaptured(partialOutput(snapshot, marker, fallback, fallbackTruncated), config.maxOutputChars), status.exitCode, status.signal), SHELL_RESET_MESSAGE].filter((part) => part.length > 0).join("\n");
+}
+function persistentShells(ctx, config) {
+	const pending = /* @__PURE__ */ new WeakMap();
+	const live = /* @__PURE__ */ new Map();
+	const creating = /* @__PURE__ */ new Set();
+	const ownerCleanupInstalled = /* @__PURE__ */ new WeakSet();
+	const lifecycle = new AbortController();
+	const close = async (owner, id, reason) => {
+		if (!ctx.terminals.list(owner).some((snapshot) => snapshot.sessionId === id)) return;
+		await ctx.terminals.kill(owner, id, reason);
+	};
+	ctx.effect(() => async () => {
+		lifecycle.abort(/* @__PURE__ */ new Error("tool-bash-persistent disposed during shell creation"));
+		await Promise.allSettled([...creating]);
+		const closing = [...live].map(async ([owner, id]) => {
+			await close(owner, id, "tool-bash-persistent disposed");
+		});
+		await Promise.all(closing);
+		live.clear();
+	}, "tool-bash-persistent shell cleanup");
+	const reset = async (owner, reason) => {
+		pending.delete(owner);
+		const id = live.get(owner);
+		live.delete(owner);
+		if (id !== void 0) await close(owner, id, reason);
+	};
+	const get = (owner, signal) => {
+		const liveId = live.get(owner);
+      if (liveId !== undefined && !ctx.terminals.list(owner).some(s => s.sessionId === liveId && s.status.kind !== "exited")) { pending.delete(owner); live.delete(owner); }
+      const existing = pending.get(owner);
+		if (existing !== void 0) return existing;
+		const combinedSignal = AbortSignal.any([signal, lifecycle.signal]);
+		const tracked = (async () => {
+			try {
+				const cwd = owner.session.header.cwd;
+				const spawned = await ctx.terminals.spawn(owner, {
+					type: config.backendType,
+					...cwd === void 0 ? {} : { cwd }
+				}, combinedSignal);
+				live.set(owner, spawned.sessionId);
+				if (!ownerCleanupInstalled.has(owner)) {
+					ownerCleanupInstalled.add(owner);
+					owner.ctx.effect(() => () => {
+						pending.delete(owner);
+						live.delete(owner);
+					}, "tool-bash-persistent owner cache cleanup");
+				}
+				const result = await ctx.terminals.startSend(owner, spawned.sessionId, {
+					text: "stty -echo",
+					submit: true,
+					signal: combinedSignal
+				}).done;
+				if (result.sessionStatus.kind === "exited" || result.waitReason === "timeout") throw new Error("persistent bash shell did not accept initialization");
+				return spawned.sessionId;
+			} catch (error) {
+				await reset(owner, "persistent bash initialization failed");
+				throw error;
+			}
+		})().finally(() => {
+			creating.delete(tracked);
+		});
+		creating.add(tracked);
+		pending.set(owner, tracked);
+		return tracked;
+	};
+	return {
+		get,
+		reset
+	};
+}
+async function executeCommand(ctx, shells, owner, command, config, upstream) {
+	const env_1 = {
+		stack: [],
+		error: void 0,
+		hasError: false
+	};
+	try {
+		const commandDeadline = __addDisposableResource(env_1, deadline(upstream, config.timeoutMs, TIMEOUT_CODE), false);
+		let id;
+		try {
+			id = await shells.get(owner, commandDeadline.signal);
+		} catch (error) {
+			if (upstream.aborted && error === upstream.reason) return "";
+			throw error;
+		}
+		const marker = markers();
+		const wrapped = wrapCommand(command, marker);
+		const startedAt = Date.now();
+		let stdinWaited = false;
+		let stdinStalled = false;
+		let first = true;
+		let fallback = "";
+		let fallbackTruncated = false;
+		while (true) {
+			const status = ctx.terminals.list(owner).find((session) => session.sessionId === id)?.status;
+			if (status?.kind === "exited") return await respondToSessionExit(ctx, shells, owner, id, status, marker, fallback, fallbackTruncated, config);
+			let operation;
+			let result;
+			try {
+				operation = ctx.terminals.startSend(owner, id, {
+					text: first ? wrapped : "",
+					capture: first,
+					submit: first,
+					signal: commandDeadline.signal
+				});
+				first = false;
+				result = await operation.done;
+			} catch (error) {
+				await shells.reset(owner, "persistent bash send failed");
+				throw error;
+			}
+			const incremental = operation.readOutput();
+			fallback = incremental.delta.length > 0 ? fallback + incremental.delta : result.viewport;
+			fallbackTruncated ||= incremental.truncated || result.truncated;
+			const captured = ctx.terminals.read(owner, id, { capture: true });
+			fallbackTruncated ||= captured.truncated;
+			const timedOut = timeoutOf(commandDeadline.signal, TIMEOUT_CODE);
+			if (timedOut !== void 0) {
+				const partial = renderCaptured(partialOutput(captured, marker, fallback, fallbackTruncated), config.maxOutputChars);
+				await shells.reset(owner, "persistent bash command timed out");
+				return [
+					`Your command timed out after ${Math.round(timedOut.timeoutMs / 1e3)} seconds or experienced an OOM error. Below is partial output:`,
+					appendStatusMarker(partial, TIMEOUT_STATUS_MARKER),
+					SHELL_RESET_MESSAGE
+				].join("\n");
+			}
+			if (commandDeadline.signal.aborted) {
+				await shells.reset(owner, "persistent bash command aborted");
+				return "";
+			}
+			if (captured.text.includes(marker.end)) {
+				const complete = commandOutput(captured, marker);
+				if (complete !== void 0) return renderCaptured(complete, config.maxOutputChars) + (stdinStalled ? STDIN_STALL_NOTE : "");
+			}
+			if (result.sessionStatus.kind === "exited") return await respondToSessionExit(ctx, shells, owner, id, result.sessionStatus, marker, fallback, fallbackTruncated, config);
+			const partial = renderCaptured(partialOutput(captured, marker, fallback, fallbackTruncated), config.maxOutputChars);
+			if (result.waitReason === "stdin_read") stdinWaited = true;
+			if (result.waitReason === "stdin_read" && partial.length > 0) return partial;
+			if (stdinWaited && partial.length === 0 && !stdinStalled && Date.now() - startedAt >= STDIN_STALL_MS) {
+				stdinStalled = true;
+				try {
+					await ctx.terminals.signal(owner, id, "SIGINT");
+				} catch (_unsignallableForeground) {
+					stdinStalled = false;
+					return partial;
+				}
+			}
+			await pause();
+		}
+	} catch (e_1) {
+		env_1.error = e_1;
+		env_1.hasError = true;
+	} finally {
+		__disposeResources(env_1);
+	}
+}
+/**
+* Register the model-facing persistent `bash` tool.
+* @param ctx - plugin context carrying tools and the owner-scoped PTY service.
+* @param config - selected PTY backend and command deadline.
+*/
+function registerPersistentBash(ctx, config) {
+	const shells = persistentShells(ctx, config);
+	const queues = /* @__PURE__ */ new WeakMap();
+	const serialized = async (owner, operation) => {
+		const run = (queues.get(owner) ?? Promise.resolve()).then(operation, operation);
+		const tail = run.then(() => void 0, () => void 0);
+		queues.set(owner, tail);
+		try {
+			return await run;
+		} finally {
+			if (queues.get(owner) === tail) queues.delete(owner);
+		}
+	};
+	ctx.tools.register(defineTool({
+		name: "bash",
+		description: config.description,
+		parameters: { command: {
+			type: "string",
+			required: true,
+			description: "The bash command to run. Relative path is preferred in the command."
+		} },
+		output: {
+			schema: { type: "string" },
+			render: (_args, value) => [{
+				type: "text",
+				text: value
+			}]
+		},
+		async execute(args, exec) {
+			if (args.command.trim().length === 0) throw new Error("command must be a non-empty string");
+			const owner = exec.agent;
+			if (owner === void 0) throw new Error("bash requires an owning agent session");
+			return serialized(owner, async () => {
+				if (exec.signal.aborted) return "";
+				return executeCommand(ctx, shells, owner, args.command, config, exec.signal);
+			});
+		},
+		presentCall: (args) => ({
+			card: "terminal",
+			title: args.command
+		})
+	}));
+}
+const name = "tool-bash-persistent";
+const inject = ["tools", "terminals"];
+/** Runtime configuration schema for the persistent Bash tool. */
+const Config = z.object({
+	backendType: z.string().default("shell"),
+	timeoutMs: z.number().default(3e5),
+	maxOutputChars: z.number().default(16e3),
+	description: z.string().default(DEFAULT_DESCRIPTION)
+});
+/** Register one owner-scoped persistent `bash` tool. */
+function apply(ctx, config) {
+	const resolved = {
+		backendType: config.backendType ?? "shell",
+		timeoutMs: config.timeoutMs ?? 3e5,
+		maxOutputChars: config.maxOutputChars ?? 16e3,
+		description: config.description ?? DEFAULT_DESCRIPTION
+	};
+	if (resolved.backendType.trim().length === 0) throw new Error("tool-bash-persistent: backendType must be non-empty");
+	if (!Number.isSafeInteger(resolved.timeoutMs) || resolved.timeoutMs <= 0) throw new Error("tool-bash-persistent: timeoutMs must be a positive safe integer");
+	if (!Number.isSafeInteger(resolved.maxOutputChars) || resolved.maxOutputChars <= 0) throw new Error("tool-bash-persistent: maxOutputChars must be a positive safe integer");
+	if (resolved.description.trim().length === 0) throw new Error("tool-bash-persistent: description must be non-empty");
+	registerPersistentBash(ctx, resolved);
+}
+//#endregion
+export { Config, apply, inject, name };

package/vendor/persistent/types/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Model-facing persistent `bash` tool over the owner-scoped PTY seam.
+ * @module @deepseek-ai/dsh-tool-bash-persistent
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export declare const name = "tool-bash-persistent";
+export declare const inject: string[];
+/** Configuration for the persistent Bash tool. */
+export interface Config {
+    /** PTY backend used for each owner-isolated persistent shell (default `shell`). */
+    backendType?: string;
+    /** Wall-clock limit for one command (default 300000). */
+    timeoutMs?: number;
+    /** Maximum returned command-output characters before clipping (default 16000). */
+    maxOutputChars?: number;
+    /** Model-facing tool description; deployments may describe their environment. */
+    description?: string;
+}
+/** Runtime configuration schema for the persistent Bash tool. */
+export declare const Config: z<Config>;
+/** Register one owner-scoped persistent `bash` tool. */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/vendor/subagent/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.