@fased/fased 0.1.41 → 0.1.43

package/dist/plugin-sdk/draft-stream-controls-DGYBMJYc.js

@@ -0,0 +1,323 @@
+import { t as createDraftStreamLoop } from "./draft-stream-loop-DZ1OAyye.js";
+
+//#region src/channels/status-reactions.ts
+const DEFAULT_EMOJIS = {
+	queued: "👀",
+	thinking: "🤔",
+	tool: "🔥",
+	coding: "👨‍💻",
+	web: "⚡",
+	done: "👍",
+	error: "😱",
+	stallSoft: "🥱",
+	stallHard: "😨"
+};
+const DEFAULT_TIMING = {
+	debounceMs: 700,
+	stallSoftMs: 1e4,
+	stallHardMs: 3e4,
+	doneHoldMs: 1500,
+	errorHoldMs: 2500
+};
+const CODING_TOOL_TOKENS = [
+	"exec",
+	"process",
+	"read",
+	"write",
+	"edit",
+	"session_status",
+	"bash"
+];
+const WEB_TOOL_TOKENS = [
+	"web_search",
+	"web-search",
+	"web_fetch",
+	"web-fetch",
+	"browser"
+];
+/**
+* Resolve the appropriate emoji for a tool invocation.
+*/
+function resolveToolEmoji(toolName, emojis) {
+	const normalized = toolName?.trim().toLowerCase() ?? "";
+	if (!normalized) return emojis.tool;
+	if (WEB_TOOL_TOKENS.some((token) => normalized.includes(token))) return emojis.web;
+	if (CODING_TOOL_TOKENS.some((token) => normalized.includes(token))) return emojis.coding;
+	return emojis.tool;
+}
+/**
+* Create a status reaction controller.
+*
+* Features:
+* - Promise chain serialization (prevents concurrent API calls)
+* - Debouncing (intermediate states debounce, terminal states are immediate)
+* - Stall timers (soft/hard warnings on inactivity)
+* - Terminal state protection (done/error mark finished, subsequent updates ignored)
+*/
+function createStatusReactionController(params) {
+	const { enabled, adapter, initialEmoji, onError } = params;
+	const emojis = {
+		...DEFAULT_EMOJIS,
+		queued: params.emojis?.queued ?? initialEmoji,
+		...params.emojis
+	};
+	const timing = {
+		...DEFAULT_TIMING,
+		...params.timing
+	};
+	let currentEmoji = "";
+	let pendingEmoji = "";
+	let debounceTimer = null;
+	let stallSoftTimer = null;
+	let stallHardTimer = null;
+	let finished = false;
+	let chainPromise = Promise.resolve();
+	const knownEmojis = new Set([
+		initialEmoji,
+		emojis.queued,
+		emojis.thinking,
+		emojis.tool,
+		emojis.coding,
+		emojis.web,
+		emojis.done,
+		emojis.error,
+		emojis.stallSoft,
+		emojis.stallHard
+	]);
+	/**
+	* Serialize async operations to prevent race conditions.
+	*/
+	function enqueue(fn) {
+		chainPromise = chainPromise.then(fn, fn);
+		return chainPromise;
+	}
+	/**
+	* Clear all timers.
+	*/
+	function clearAllTimers() {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+			debounceTimer = null;
+		}
+		if (stallSoftTimer) {
+			clearTimeout(stallSoftTimer);
+			stallSoftTimer = null;
+		}
+		if (stallHardTimer) {
+			clearTimeout(stallHardTimer);
+			stallHardTimer = null;
+		}
+	}
+	/**
+	* Clear debounce timer only (used during phase transitions).
+	*/
+	function clearDebounceTimer() {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+			debounceTimer = null;
+		}
+	}
+	/**
+	* Reset stall timers (called on each phase change).
+	*/
+	function resetStallTimers() {
+		if (stallSoftTimer) clearTimeout(stallSoftTimer);
+		if (stallHardTimer) clearTimeout(stallHardTimer);
+		stallSoftTimer = setTimeout(() => {
+			scheduleEmoji(emojis.stallSoft, {
+				immediate: true,
+				skipStallReset: true
+			});
+		}, timing.stallSoftMs);
+		stallHardTimer = setTimeout(() => {
+			scheduleEmoji(emojis.stallHard, {
+				immediate: true,
+				skipStallReset: true
+			});
+		}, timing.stallHardMs);
+	}
+	/**
+	* Apply an emoji: set new reaction and optionally remove old one.
+	*/
+	async function applyEmoji(newEmoji) {
+		if (!enabled) return;
+		try {
+			const previousEmoji = currentEmoji;
+			await adapter.setReaction(newEmoji);
+			if (adapter.removeReaction && previousEmoji && previousEmoji !== newEmoji) await adapter.removeReaction(previousEmoji);
+			currentEmoji = newEmoji;
+		} catch (err) {
+			if (onError) onError(err);
+		}
+	}
+	/**
+	* Schedule an emoji change (debounced or immediate).
+	*/
+	function scheduleEmoji(emoji, options = {}) {
+		if (!enabled || finished) return;
+		if (emoji === currentEmoji || emoji === pendingEmoji) {
+			if (!options.skipStallReset) resetStallTimers();
+			return;
+		}
+		pendingEmoji = emoji;
+		clearDebounceTimer();
+		if (options.immediate) enqueue(async () => {
+			await applyEmoji(emoji);
+			pendingEmoji = "";
+		});
+		else debounceTimer = setTimeout(() => {
+			enqueue(async () => {
+				await applyEmoji(emoji);
+				pendingEmoji = "";
+			});
+		}, timing.debounceMs);
+		if (!options.skipStallReset) resetStallTimers();
+	}
+	function setQueued() {
+		scheduleEmoji(emojis.queued, { immediate: true });
+	}
+	function setThinking() {
+		scheduleEmoji(emojis.thinking);
+	}
+	function setTool(toolName) {
+		scheduleEmoji(resolveToolEmoji(toolName, emojis));
+	}
+	function finishWithEmoji(emoji) {
+		if (!enabled) return Promise.resolve();
+		finished = true;
+		clearAllTimers();
+		return enqueue(async () => {
+			await applyEmoji(emoji);
+			pendingEmoji = "";
+		});
+	}
+	function setDone() {
+		return finishWithEmoji(emojis.done);
+	}
+	function setError() {
+		return finishWithEmoji(emojis.error);
+	}
+	async function clear() {
+		if (!enabled) return;
+		clearAllTimers();
+		finished = true;
+		await enqueue(async () => {
+			if (adapter.removeReaction) {
+				const emojisToRemove = Array.from(knownEmojis);
+				for (const emoji of emojisToRemove) try {
+					await adapter.removeReaction(emoji);
+				} catch (err) {
+					if (onError) onError(err);
+				}
+			}
+			currentEmoji = "";
+			pendingEmoji = "";
+		});
+	}
+	async function restoreInitial() {
+		if (!enabled) return;
+		clearAllTimers();
+		await enqueue(async () => {
+			await applyEmoji(initialEmoji);
+			pendingEmoji = "";
+		});
+	}
+	return {
+		setQueued,
+		setThinking,
+		setTool,
+		setDone,
+		setError,
+		clear,
+		restoreInitial
+	};
+}
+
+//#endregion
+//#region src/channels/draft-stream-controls.ts
+function createFinalizableDraftStreamControls(params) {
+	const loop = createDraftStreamLoop({
+		throttleMs: params.throttleMs,
+		isStopped: params.isStopped,
+		sendOrEditStreamMessage: params.sendOrEditStreamMessage
+	});
+	const update = (text) => {
+		if (params.isStopped() || params.isFinal()) return;
+		loop.update(text);
+	};
+	const stop = async () => {
+		params.markFinal();
+		await loop.flush();
+	};
+	const stopForClear = async () => {
+		params.markStopped();
+		loop.stop();
+		await loop.waitForInFlight();
+	};
+	return {
+		loop,
+		update,
+		stop,
+		stopForClear
+	};
+}
+function createFinalizableDraftStreamControlsForState(params) {
+	return createFinalizableDraftStreamControls({
+		throttleMs: params.throttleMs,
+		isStopped: () => params.state.stopped,
+		isFinal: () => params.state.final,
+		markStopped: () => {
+			params.state.stopped = true;
+		},
+		markFinal: () => {
+			params.state.final = true;
+		},
+		sendOrEditStreamMessage: params.sendOrEditStreamMessage
+	});
+}
+async function takeMessageIdAfterStop(params) {
+	await params.stopForClear();
+	const messageId = params.readMessageId();
+	params.clearMessageId();
+	return messageId;
+}
+async function clearFinalizableDraftMessage(params) {
+	const messageId = await takeMessageIdAfterStop({
+		stopForClear: params.stopForClear,
+		readMessageId: params.readMessageId,
+		clearMessageId: params.clearMessageId
+	});
+	if (!params.isValidMessageId(messageId)) return;
+	try {
+		await params.deleteMessage(messageId);
+		params.onDeleteSuccess?.(messageId);
+	} catch (err) {
+		params.warn?.(`${params.warnPrefix}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+function createFinalizableDraftLifecycle(params) {
+	const controls = createFinalizableDraftStreamControlsForState({
+		throttleMs: params.throttleMs,
+		state: params.state,
+		sendOrEditStreamMessage: params.sendOrEditStreamMessage
+	});
+	const clear = async () => {
+		await clearFinalizableDraftMessage({
+			stopForClear: controls.stopForClear,
+			readMessageId: params.readMessageId,
+			clearMessageId: params.clearMessageId,
+			isValidMessageId: params.isValidMessageId,
+			deleteMessage: params.deleteMessage,
+			onDeleteSuccess: params.onDeleteSuccess,
+			warn: params.warn,
+			warnPrefix: params.warnPrefix
+		});
+	};
+	return {
+		...controls,
+		clear
+	};
+}
+
+//#endregion
+export { createStatusReactionController as i, DEFAULT_EMOJIS as n, DEFAULT_TIMING as r, createFinalizableDraftLifecycle as t };

package/dist/plugin-sdk/exec-DQ8j4Fm3.js

@@ -0,0 +1,230 @@
+import { s as shouldLogVerbose, t as danger } from "./globals-B_jjtAje.js";
+import { n as logError, t as logDebug } from "./logger-BbFvCoKk.js";
+import path from "node:path";
+import { promisify } from "node:util";
+import { execFile, spawn } from "node:child_process";
+
+//#region src/process/spawn-utils.ts
+const DEFAULT_RETRY_CODES = ["EBADF"];
+function resolveCommandStdio(params) {
+	return [
+		params.hasInput ? "pipe" : params.preferInherit ? "inherit" : "pipe",
+		"pipe",
+		"pipe"
+	];
+}
+function shouldRetry(err, codes) {
+	const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
+	return code.length > 0 && codes.includes(code);
+}
+async function spawnAndWaitForSpawn(spawnImpl, argv, options) {
+	const child = spawnImpl(argv[0], argv.slice(1), options);
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => {
+			child.removeListener("error", onError);
+			child.removeListener("spawn", onSpawn);
+		};
+		const finishResolve = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(child);
+		};
+		const onError = (err) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(err);
+		};
+		const onSpawn = () => {
+			finishResolve();
+		};
+		child.once("error", onError);
+		child.once("spawn", onSpawn);
+		process.nextTick(() => {
+			if (typeof child.pid === "number") finishResolve();
+		});
+	});
+}
+async function spawnWithFallback(params) {
+	const spawnImpl = params.spawnImpl ?? spawn;
+	const retryCodes = params.retryCodes ?? DEFAULT_RETRY_CODES;
+	const baseOptions = { ...params.options };
+	const fallbacks = params.fallbacks ?? [];
+	const attempts = [{ options: baseOptions }, ...fallbacks.map((fallback) => ({
+		label: fallback.label,
+		options: {
+			...baseOptions,
+			...fallback.options
+		}
+	}))];
+	let lastError;
+	for (let index = 0; index < attempts.length; index += 1) {
+		const attempt = attempts[index];
+		try {
+			return {
+				child: await spawnAndWaitForSpawn(spawnImpl, params.argv, attempt.options),
+				usedFallback: index > 0,
+				fallbackLabel: attempt.label
+			};
+		} catch (err) {
+			lastError = err;
+			const nextFallback = fallbacks[index];
+			if (!nextFallback || !shouldRetry(err, retryCodes)) throw err;
+			params.onFallback?.(err, nextFallback);
+		}
+	}
+	throw lastError;
+}
+
+//#endregion
+//#region src/process/exec.ts
+const execFileAsync = promisify(execFile);
+/**
+* Resolves a command for Windows compatibility.
+* On Windows, non-.exe commands (like npm, pnpm) require their .cmd extension.
+*/
+function resolveCommand(command) {
+	if (process.platform !== "win32") return command;
+	const basename = path.basename(command).toLowerCase();
+	if (path.extname(basename)) return command;
+	if ([
+		"npm",
+		"pnpm",
+		"yarn",
+		"npx"
+	].includes(basename)) return `${command}.cmd`;
+	return command;
+}
+function shouldSpawnWithShell(params) {
+	return false;
+}
+async function runExec(command, args, opts = 1e4) {
+	const options = typeof opts === "number" ? {
+		timeout: opts,
+		encoding: "utf8"
+	} : {
+		timeout: opts.timeoutMs,
+		maxBuffer: opts.maxBuffer,
+		cwd: opts.cwd,
+		encoding: "utf8"
+	};
+	try {
+		const { stdout, stderr } = await execFileAsync(resolveCommand(command), args, options);
+		if (shouldLogVerbose()) {
+			if (stdout.trim()) logDebug(stdout.trim());
+			if (stderr.trim()) logError(stderr.trim());
+		}
+		return {
+			stdout,
+			stderr
+		};
+	} catch (err) {
+		if (shouldLogVerbose()) logError(danger(`Command failed: ${command} ${args.join(" ")}`));
+		throw err;
+	}
+}
+async function runCommandWithTimeout(argv, optionsOrTimeout) {
+	const options = typeof optionsOrTimeout === "number" ? { timeoutMs: optionsOrTimeout } : optionsOrTimeout;
+	const { timeoutMs, cwd, input, env, noOutputTimeoutMs } = options;
+	const { windowsVerbatimArguments } = options;
+	const hasInput = input !== void 0;
+	const shouldSuppressNpmFund = (() => {
+		const cmd = path.basename(argv[0] ?? "");
+		if (cmd === "npm" || cmd === "npm.cmd" || cmd === "npm.exe") return true;
+		if (cmd === "node" || cmd === "node.exe") return (argv[1] ?? "").includes("npm-cli.js");
+		return false;
+	})();
+	const mergedEnv = env ? {
+		...process.env,
+		...env
+	} : { ...process.env };
+	const resolvedEnv = Object.fromEntries(Object.entries(mergedEnv).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)]));
+	if (shouldSuppressNpmFund) {
+		if (resolvedEnv.NPM_CONFIG_FUND == null) resolvedEnv.NPM_CONFIG_FUND = "false";
+		if (resolvedEnv.npm_config_fund == null) resolvedEnv.npm_config_fund = "false";
+	}
+	const stdio = resolveCommandStdio({
+		hasInput,
+		preferInherit: true
+	});
+	const resolvedCommand = resolveCommand(argv[0] ?? "");
+	const child = spawn(resolvedCommand, argv.slice(1), {
+		stdio,
+		cwd,
+		env: resolvedEnv,
+		windowsVerbatimArguments,
+		...shouldSpawnWithShell({
+			resolvedCommand,
+			platform: process.platform
+		}) ? { shell: true } : {}
+	});
+	return await new Promise((resolve, reject) => {
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+		let timedOut = false;
+		let noOutputTimedOut = false;
+		let noOutputTimer = null;
+		const shouldTrackOutputTimeout = typeof noOutputTimeoutMs === "number" && Number.isFinite(noOutputTimeoutMs) && noOutputTimeoutMs > 0;
+		const clearNoOutputTimer = () => {
+			if (!noOutputTimer) return;
+			clearTimeout(noOutputTimer);
+			noOutputTimer = null;
+		};
+		const armNoOutputTimer = () => {
+			if (!shouldTrackOutputTimeout || settled) return;
+			clearNoOutputTimer();
+			noOutputTimer = setTimeout(() => {
+				if (settled) return;
+				noOutputTimedOut = true;
+				if (typeof child.kill === "function") child.kill("SIGKILL");
+			}, Math.floor(noOutputTimeoutMs));
+		};
+		const timer = setTimeout(() => {
+			timedOut = true;
+			if (typeof child.kill === "function") child.kill("SIGKILL");
+		}, timeoutMs);
+		armNoOutputTimer();
+		if (hasInput && child.stdin) {
+			child.stdin.write(input ?? "");
+			child.stdin.end();
+		}
+		child.stdout?.on("data", (d) => {
+			stdout += d.toString();
+			armNoOutputTimer();
+		});
+		child.stderr?.on("data", (d) => {
+			stderr += d.toString();
+			armNoOutputTimer();
+		});
+		child.on("error", (err) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			clearNoOutputTimer();
+			reject(err);
+		});
+		child.on("close", (code, signal) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			clearNoOutputTimer();
+			const termination = noOutputTimedOut ? "no-output-timeout" : timedOut ? "timeout" : signal != null ? "signal" : "exit";
+			resolve({
+				pid: child.pid ?? void 0,
+				stdout,
+				stderr,
+				code,
+				signal,
+				killed: child.killed,
+				termination,
+				noOutputTimedOut
+			});
+		});
+	});
+}
+
+//#endregion
+export { runExec as n, spawnWithFallback as r, runCommandWithTimeout as t };

package/dist/plugin-sdk/fetch-RV7QDF43.js

@@ -0,0 +1,68 @@
+import { t as bindAbortRelay } from "./fetch-timeout-jOIu9Xud.js";
+import { t as normalizeRequestInitHeadersForFetch } from "./fetch-headers-DvXyXtoI.js";
+
+//#region src/infra/fetch.ts
+const wrapFetchWithAbortSignalMarker = Symbol.for("fased.fetch.abort-signal-wrapped");
+function withDuplex(init, input) {
+	const hasInitBody = init?.body != null;
+	const hasRequestBody = !hasInitBody && typeof Request !== "undefined" && input instanceof Request && input.body != null;
+	if (!hasInitBody && !hasRequestBody) return init;
+	if (init && "duplex" in init) return init;
+	return init ? {
+		...init,
+		duplex: "half"
+	} : { duplex: "half" };
+}
+function wrapFetchWithAbortSignal(fetchImpl) {
+	if (fetchImpl[wrapFetchWithAbortSignalMarker]) return fetchImpl;
+	const wrapped = ((input, init) => {
+		const patchedInit = normalizeRequestInitHeadersForFetch(withDuplex(init, input));
+		const signal = patchedInit?.signal;
+		if (!signal) return fetchImpl(input, patchedInit);
+		if (typeof AbortSignal !== "undefined" && signal instanceof AbortSignal) return fetchImpl(input, patchedInit);
+		if (typeof AbortController === "undefined") return fetchImpl(input, patchedInit);
+		if (typeof signal.addEventListener !== "function") return fetchImpl(input, patchedInit);
+		const controller = new AbortController();
+		const onAbort = bindAbortRelay(controller);
+		let listenerAttached = false;
+		if (signal.aborted) controller.abort();
+		else {
+			signal.addEventListener("abort", onAbort, { once: true });
+			listenerAttached = true;
+		}
+		const cleanup = () => {
+			if (!listenerAttached || typeof signal.removeEventListener !== "function") return;
+			listenerAttached = false;
+			try {
+				signal.removeEventListener("abort", onAbort);
+			} catch {}
+		};
+		try {
+			return fetchImpl(input, {
+				...patchedInit,
+				signal: controller.signal
+			}).finally(cleanup);
+		} catch (error) {
+			cleanup();
+			throw error;
+		}
+	});
+	const wrappedFetch = Object.assign(wrapped, fetchImpl);
+	const fetchWithPreconnect = fetchImpl;
+	wrappedFetch.preconnect = typeof fetchWithPreconnect.preconnect === "function" ? fetchWithPreconnect.preconnect.bind(fetchWithPreconnect) : () => {};
+	Object.defineProperty(wrappedFetch, wrapFetchWithAbortSignalMarker, {
+		value: true,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+	return wrappedFetch;
+}
+function resolveFetch(fetchImpl) {
+	const resolved = fetchImpl ?? globalThis.fetch;
+	if (!resolved) return;
+	return wrapFetchWithAbortSignal(resolved);
+}
+
+//#endregion
+export { wrapFetchWithAbortSignal as n, resolveFetch as t };