@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/event-stream-BDPi64mK.mjs

@@ -0,0 +1,151 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { C as classifyMessage, s as ProviderResponseError } from "./error-B3bevhrs.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/event-stream.ts
+var EventStream = class {
+	queue = [];
+	waiting = [];
+	done = false;
+	/** True once finalResultPromise has been resolved or rejected. */
+	resultSettled = false;
+	#failed = false;
+	#error = void 0;
+	/**
+	* Consumer-side local operations currently in flight for this stream — a
+	* provider transport waiting on a server-requested local tool bridge
+	* (e.g. the Cursor exec channel) before it can send the result upstream.
+	* While non-zero, event silence is attributable to our own pending work,
+	* not a provider stall; idle watchdogs consult {@link hasPendingLocalWork}.
+	*/
+	#pendingLocalWork = 0;
+	finalResultPromise;
+	resolveFinalResult;
+	rejectFinalResult;
+	isComplete;
+	extractResult;
+	constructor(isComplete, extractResult) {
+		const { promise, resolve, reject } = Promise.withResolvers();
+		promise.catch(() => {});
+		this.finalResultPromise = promise;
+		this.resolveFinalResult = resolve;
+		this.rejectFinalResult = reject;
+		this.isComplete = isComplete;
+		this.extractResult = extractResult;
+	}
+	push(event) {
+		if (this.done) return;
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resultSettled = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		const waiter = this.waiting.shift();
+		if (waiter) waiter.resolve({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	deliver(event) {
+		const waiter = this.waiting.shift();
+		if (waiter) waiter.resolve({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) {
+			this.resultSettled = true;
+			this.resolveFinalResult(result);
+		} else if (!this.resultSettled) {
+			this.resultSettled = true;
+			this.rejectFinalResult(new ProviderResponseError("Stream ended without a final result", { kind: "envelope" }));
+		}
+		while (this.waiting.length > 0) this.waiting.shift().resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	endWaiting() {
+		while (this.waiting.length > 0) this.waiting.shift().resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	fail(err) {
+		if (this.done) return;
+		this.done = true;
+		this.#failed = true;
+		this.#error = err;
+		this.resultSettled = true;
+		this.rejectFinalResult(err);
+		while (this.waiting.length > 0) this.waiting.shift().reject(err);
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) if (this.queue.length > 0) yield this.queue.shift();
+		else if (this.#failed) throw this.#error;
+		else if (this.done) return;
+		else {
+			const result = await new Promise((resolve, reject) => this.waiting.push({
+				resolve,
+				reject
+			}));
+			if (result.done) return;
+			yield result.value;
+		}
+	}
+	result() {
+		return this.finalResultPromise;
+	}
+	/** True while local work tracked via {@link trackLocalWork} is pending. */
+	get hasPendingLocalWork() {
+		return this.#pendingLocalWork > 0;
+	}
+	/**
+	* Track a local-work promise so idle watchdogs on this stream do not treat
+	* the event silence while it is pending as a provider stall.
+	*/
+	async trackLocalWork(work) {
+		this.#pendingLocalWork++;
+		try {
+			return await work;
+		} finally {
+			this.#pendingLocalWork--;
+		}
+	}
+};
+var AssistantMessageEventStream = class extends EventStream {
+	constructor() {
+		super((event) => event.type === "done" || event.type === "error", (event) => {
+			if (event.type === "done") return event.message;
+			else if (event.type === "error") return event.error;
+			throw new ProviderResponseError("Unexpected event type for final result", { kind: "envelope" });
+		});
+	}
+	push(event) {
+		if (this.done) return;
+		if (event.type === "error" && event.error.stopReason === "error") classifyMessage(event.error);
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resultSettled = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		this.deliver(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) {
+			if (result.stopReason === "error") classifyMessage(result);
+			this.resultSettled = true;
+			this.resolveFinalResult(result);
+		} else if (!this.resultSettled) {
+			this.resultSettled = true;
+			this.rejectFinalResult(new ProviderResponseError("Stream ended without a final result", { kind: "envelope" }));
+		}
+		this.endWaiting();
+	}
+};
+//#endregion
+export { AssistantMessageEventStream as t };

package/lib/event-stream-BbFZJy-z.mjs

@@ -0,0 +1,151 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { C as classifyMessage, s as ProviderResponseError } from "./error-Dd8DIqs-.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/event-stream.ts
+var EventStream = class {
+	queue = [];
+	waiting = [];
+	done = false;
+	/** True once finalResultPromise has been resolved or rejected. */
+	resultSettled = false;
+	#failed = false;
+	#error = void 0;
+	/**
+	* Consumer-side local operations currently in flight for this stream — a
+	* provider transport waiting on a server-requested local tool bridge
+	* (e.g. the Cursor exec channel) before it can send the result upstream.
+	* While non-zero, event silence is attributable to our own pending work,
+	* not a provider stall; idle watchdogs consult {@link hasPendingLocalWork}.
+	*/
+	#pendingLocalWork = 0;
+	finalResultPromise;
+	resolveFinalResult;
+	rejectFinalResult;
+	isComplete;
+	extractResult;
+	constructor(isComplete, extractResult) {
+		const { promise, resolve, reject } = Promise.withResolvers();
+		promise.catch(() => {});
+		this.finalResultPromise = promise;
+		this.resolveFinalResult = resolve;
+		this.rejectFinalResult = reject;
+		this.isComplete = isComplete;
+		this.extractResult = extractResult;
+	}
+	push(event) {
+		if (this.done) return;
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resultSettled = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		const waiter = this.waiting.shift();
+		if (waiter) waiter.resolve({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	deliver(event) {
+		const waiter = this.waiting.shift();
+		if (waiter) waiter.resolve({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) {
+			this.resultSettled = true;
+			this.resolveFinalResult(result);
+		} else if (!this.resultSettled) {
+			this.resultSettled = true;
+			this.rejectFinalResult(new ProviderResponseError("Stream ended without a final result", { kind: "envelope" }));
+		}
+		while (this.waiting.length > 0) this.waiting.shift().resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	endWaiting() {
+		while (this.waiting.length > 0) this.waiting.shift().resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	fail(err) {
+		if (this.done) return;
+		this.done = true;
+		this.#failed = true;
+		this.#error = err;
+		this.resultSettled = true;
+		this.rejectFinalResult(err);
+		while (this.waiting.length > 0) this.waiting.shift().reject(err);
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) if (this.queue.length > 0) yield this.queue.shift();
+		else if (this.#failed) throw this.#error;
+		else if (this.done) return;
+		else {
+			const result = await new Promise((resolve, reject) => this.waiting.push({
+				resolve,
+				reject
+			}));
+			if (result.done) return;
+			yield result.value;
+		}
+	}
+	result() {
+		return this.finalResultPromise;
+	}
+	/** True while local work tracked via {@link trackLocalWork} is pending. */
+	get hasPendingLocalWork() {
+		return this.#pendingLocalWork > 0;
+	}
+	/**
+	* Track a local-work promise so idle watchdogs on this stream do not treat
+	* the event silence while it is pending as a provider stall.
+	*/
+	async trackLocalWork(work) {
+		this.#pendingLocalWork++;
+		try {
+			return await work;
+		} finally {
+			this.#pendingLocalWork--;
+		}
+	}
+};
+var AssistantMessageEventStream = class extends EventStream {
+	constructor() {
+		super((event) => event.type === "done" || event.type === "error", (event) => {
+			if (event.type === "done") return event.message;
+			else if (event.type === "error") return event.error;
+			throw new ProviderResponseError("Unexpected event type for final result", { kind: "envelope" });
+		});
+	}
+	push(event) {
+		if (this.done) return;
+		if (event.type === "error" && event.error.stopReason === "error") classifyMessage(event.error);
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resultSettled = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		this.deliver(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) {
+			if (result.stopReason === "error") classifyMessage(result);
+			this.resultSettled = true;
+			this.resolveFinalResult(result);
+		} else if (!this.resultSettled) {
+			this.resultSettled = true;
+			this.rejectFinalResult(new ProviderResponseError("Stream ended without a final result", { kind: "envelope" }));
+		}
+		this.endWaiting();
+	}
+};
+//#endregion
+export { AssistantMessageEventStream as t };

package/lib/event-stream-loUa0s1T.mjs

@@ -0,0 +1,151 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { C as classifyMessage, s as ProviderResponseError } from "./error-yCSG0mGC.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/event-stream.ts
+var EventStream = class {
+	queue = [];
+	waiting = [];
+	done = false;
+	/** True once finalResultPromise has been resolved or rejected. */
+	resultSettled = false;
+	#failed = false;
+	#error = void 0;
+	/**
+	* Consumer-side local operations currently in flight for this stream — a
+	* provider transport waiting on a server-requested local tool bridge
+	* (e.g. the Cursor exec channel) before it can send the result upstream.
+	* While non-zero, event silence is attributable to our own pending work,
+	* not a provider stall; idle watchdogs consult {@link hasPendingLocalWork}.
+	*/
+	#pendingLocalWork = 0;
+	finalResultPromise;
+	resolveFinalResult;
+	rejectFinalResult;
+	isComplete;
+	extractResult;
+	constructor(isComplete, extractResult) {
+		const { promise, resolve, reject } = Promise.withResolvers();
+		promise.catch(() => {});
+		this.finalResultPromise = promise;
+		this.resolveFinalResult = resolve;
+		this.rejectFinalResult = reject;
+		this.isComplete = isComplete;
+		this.extractResult = extractResult;
+	}
+	push(event) {
+		if (this.done) return;
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resultSettled = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		const waiter = this.waiting.shift();
+		if (waiter) waiter.resolve({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	deliver(event) {
+		const waiter = this.waiting.shift();
+		if (waiter) waiter.resolve({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) {
+			this.resultSettled = true;
+			this.resolveFinalResult(result);
+		} else if (!this.resultSettled) {
+			this.resultSettled = true;
+			this.rejectFinalResult(new ProviderResponseError("Stream ended without a final result", { kind: "envelope" }));
+		}
+		while (this.waiting.length > 0) this.waiting.shift().resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	endWaiting() {
+		while (this.waiting.length > 0) this.waiting.shift().resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	fail(err) {
+		if (this.done) return;
+		this.done = true;
+		this.#failed = true;
+		this.#error = err;
+		this.resultSettled = true;
+		this.rejectFinalResult(err);
+		while (this.waiting.length > 0) this.waiting.shift().reject(err);
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) if (this.queue.length > 0) yield this.queue.shift();
+		else if (this.#failed) throw this.#error;
+		else if (this.done) return;
+		else {
+			const result = await new Promise((resolve, reject) => this.waiting.push({
+				resolve,
+				reject
+			}));
+			if (result.done) return;
+			yield result.value;
+		}
+	}
+	result() {
+		return this.finalResultPromise;
+	}
+	/** True while local work tracked via {@link trackLocalWork} is pending. */
+	get hasPendingLocalWork() {
+		return this.#pendingLocalWork > 0;
+	}
+	/**
+	* Track a local-work promise so idle watchdogs on this stream do not treat
+	* the event silence while it is pending as a provider stall.
+	*/
+	async trackLocalWork(work) {
+		this.#pendingLocalWork++;
+		try {
+			return await work;
+		} finally {
+			this.#pendingLocalWork--;
+		}
+	}
+};
+var AssistantMessageEventStream = class extends EventStream {
+	constructor() {
+		super((event) => event.type === "done" || event.type === "error", (event) => {
+			if (event.type === "done") return event.message;
+			else if (event.type === "error") return event.error;
+			throw new ProviderResponseError("Unexpected event type for final result", { kind: "envelope" });
+		});
+	}
+	push(event) {
+		if (this.done) return;
+		if (event.type === "error" && event.error.stopReason === "error") classifyMessage(event.error);
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resultSettled = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		this.deliver(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) {
+			if (result.stopReason === "error") classifyMessage(result);
+			this.resultSettled = true;
+			this.resolveFinalResult(result);
+		} else if (!this.resultSettled) {
+			this.resultSettled = true;
+			this.rejectFinalResult(new ProviderResponseError("Stream ended without a final result", { kind: "envelope" }));
+		}
+		this.endWaiting();
+	}
+};
+//#endregion
+export { AssistantMessageEventStream as t };

package/lib/fs-promises-shim-Bx0fpxuk.mjs

@@ -0,0 +1,57 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import * as fsp from "fs/promises";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+//#region src/tools/shared/fs-promises-shim.ts
+/**
+* DSH node:fs/promises shim.
+*
+* OMP tool code imports `node:fs/promises` and calls `fs.exists(path)`, a
+* Bun-only extension that Node's `fs/promises` does not provide. This module
+* re-exports the whole Node `fs/promises` API and adds the missing `exists`.
+*
+* NOTE: the import MUST be `from 'fs/promises'` (no `node:` prefix) so the
+* tsdown alias for `node:fs/promises` does not recursively substitute its own
+* target back onto itself.
+*/
+var fs_promises_shim_exports = /* @__PURE__ */ __exportAll({ exists: () => exists });
+import * as import_fs_promises from "fs/promises";
+__reExport(fs_promises_shim_exports, import_fs_promises);
+/** Bun's `node:fs/promises` extension: `exists(path)` → `Promise<boolean>`.
+* Bun swallows every stat error, not just ENOENT — ENAMETOOLONG on a 60k-char
+* path also yields false (probe audit-probes/S15/s15-exists4.ts). */
+async function exists(path) {
+	try {
+		await fsp.stat(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { fs_promises_shim_exports as n, __exportAll as r, exists as t };