@duckmind/dm-darwin-x64 0.43.2 → 0.43.8

package/extensions/dm-subagents/src/shared/jsonl-writer.ts

@@ -1,81 +0,0 @@
-import * as fs from "node:fs";
-
-export interface DrainableSource {
-	pause(): void;
-	resume(): void;
-}
-
-export interface JsonlWriteStream {
-	write(chunk: string): boolean;
-	once(event: "drain", listener: () => void): JsonlWriteStream;
-	end(callback?: () => void): void;
-}
-
-const DEFAULT_MAX_JSONL_BYTES = 50 * 1024 * 1024;
-
-interface JsonlWriterDeps {
-	createWriteStream?: (filePath: string) => JsonlWriteStream;
-	maxBytes?: number;
-}
-
-interface JsonlWriter {
-	writeLine(line: string): void;
-	close(): Promise<void>;
-}
-
-export function createJsonlWriter(
-	filePath: string | undefined,
-	source: DrainableSource,
-	deps: JsonlWriterDeps = {},
-): JsonlWriter {
-	if (!filePath) {
-		return {
-			writeLine() {},
-			async close() {},
-		};
-	}
-
-	const createWriteStream = deps.createWriteStream ?? ((targetPath: string) => fs.createWriteStream(targetPath, { flags: "a" }));
-	let stream: JsonlWriteStream | undefined;
-	try {
-		stream = createWriteStream(filePath);
-	} catch {
-		return {
-			writeLine() {},
-			async close() {},
-		};
-	}
-
-	let backpressured = false;
-	let closed = false;
-	let bytesWritten = 0;
-	const maxBytes = deps.maxBytes ?? DEFAULT_MAX_JSONL_BYTES;
-
-	return {
-		writeLine(line: string) {
-			if (!stream || closed || !line.trim()) return;
-			const chunk = `${line}\n`;
-			const chunkBytes = Buffer.byteLength(chunk, "utf-8");
-			if (bytesWritten + chunkBytes > maxBytes) return;
-			try {
-				const ok = stream.write(chunk);
-				bytesWritten += chunkBytes;
-				if (!ok && !backpressured) {
-					backpressured = true;
-					source.pause();
-					stream.once("drain", () => {
-						backpressured = false;
-						if (!closed) source.resume();
-					});
-				}
-			} catch {}
-		},
-		async close() {
-			if (!stream || closed) return;
-			closed = true;
-			const current = stream;
-			stream = undefined;
-			await new Promise<void>((resolve) => current.end(() => resolve()));
-		},
-	};
-}

package/extensions/dm-subagents/src/shared/model-info.ts

@@ -1,78 +0,0 @@
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
-export type ThinkingLevel = typeof THINKING_LEVELS[number];
-export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
-
-export interface ModelInfo {
-	provider: string;
-	id: string;
-	fullId: string;
-	reasoning?: boolean;
-	thinkingLevelMap?: ThinkingLevelMap;
-}
-
-interface RegistryModelLike {
-	provider: string;
-	id: string;
-	reasoning?: boolean;
-	thinkingLevelMap?: ThinkingLevelMap;
-}
-
-export function toModelInfo(model: RegistryModelLike): ModelInfo {
-	return {
-		provider: model.provider,
-		id: model.id,
-		fullId: `${model.provider}/${model.id}`,
-		reasoning: model.reasoning,
-		thinkingLevelMap: model.thinkingLevelMap,
-	};
-}
-
-/** Resolve the effective thinking level from a model string (which may contain a known suffix like `:high`)
- * and an explicit thinking config value. Returns `undefined` when no thinking is applicable
- * (e.g. no model was specified, or the model has no suffix and no config was provided). */
-export function resolveEffectiveThinking(model: string | undefined, configThinking: string | undefined): string | undefined {
-	if (!model) return undefined;
-	const { thinkingSuffix } = splitKnownThinkingSuffix(model);
-	if (thinkingSuffix) return thinkingSuffix.slice(1);
-	return THINKING_LEVELS.find((level) => level === configThinking);
-}
-
-export function splitKnownThinkingSuffix(model: string): { baseModel: string; thinkingSuffix: string } {
-	const colonIdx = model.lastIndexOf(":");
-	if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
-	const suffix = THINKING_LEVELS.find((level) => level === model.substring(colonIdx + 1));
-	if (!suffix) return { baseModel: model, thinkingSuffix: "" };
-	return {
-		baseModel: model.substring(0, colonIdx),
-		thinkingSuffix: `:${suffix}`,
-	};
-}
-
-export function findModelInfo(model: string | undefined, availableModels: ModelInfo[] | undefined, preferredProvider?: string): ModelInfo | undefined {
-	if (!model || !availableModels || availableModels.length === 0) return undefined;
-	const { baseModel } = splitKnownThinkingSuffix(model);
-	const exact = availableModels.find((entry) => entry.fullId === baseModel);
-	if (exact) return exact;
-
-	const matches = availableModels.filter((entry) => entry.id === baseModel);
-	if (preferredProvider) {
-		const preferred = matches.find((entry) => entry.provider === preferredProvider);
-		if (preferred) return preferred;
-	}
-	return matches.length === 1 ? matches[0] : undefined;
-}
-
-export function getSupportedThinkingLevels(model: ModelInfo | undefined): ThinkingLevel[] {
-	if (!model) return [...THINKING_LEVELS];
-	if (model.reasoning === false) return ["off"];
-
-	if (!model.thinkingLevelMap) return [...THINKING_LEVELS];
-
-	const levels = THINKING_LEVELS.filter((level) => {
-		const mapped = model.thinkingLevelMap?.[level];
-		if (mapped === null) return false;
-		if (level === "xhigh") return mapped !== undefined;
-		return true;
-	});
-	return levels;
-}

package/extensions/dm-subagents/src/shared/post-exit-stdio-guard.ts

@@ -1,85 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-
-interface PostExitStdioGuardOptions {
-	idleMs: number;
-	hardMs: number;
-}
-
-interface ChildWithPipedStdio {
-	stdout: ChildProcess["stdout"];
-	stderr: ChildProcess["stderr"];
-	on: ChildProcess["on"];
-}
-
-interface ChildWithKill {
-	kill(signal?: NodeJS.Signals | number): boolean;
-}
-
-export function trySignalChild(child: ChildWithKill, signal: NodeJS.Signals): boolean {
-	try {
-		return child.kill(signal);
-	} catch {
-		return false;
-	}
-}
-
-export function attachPostExitStdioGuard(
-	child: ChildWithPipedStdio,
-	options: PostExitStdioGuardOptions,
-): () => void {
-	const { idleMs, hardMs } = options;
-	let exited = false;
-	let stdoutEnded = false;
-	let stderrEnded = false;
-	let idleTimer: NodeJS.Timeout | undefined;
-	let hardTimer: NodeJS.Timeout | undefined;
-
-	const destroyUnendedStdio = () => {
-		if (!stdoutEnded) {
-			try { child.stdout?.destroy(); } catch {}
-		}
-		if (!stderrEnded) {
-			try { child.stderr?.destroy(); } catch {}
-		}
-	};
-
-	const clearTimers = () => {
-		if (idleTimer) {
-			clearTimeout(idleTimer);
-			idleTimer = undefined;
-		}
-		if (hardTimer) {
-			clearTimeout(hardTimer);
-			hardTimer = undefined;
-		}
-	};
-
-	const armIdleTimer = () => {
-		if (!exited) return;
-		if (idleTimer) clearTimeout(idleTimer);
-		idleTimer = setTimeout(destroyUnendedStdio, idleMs);
-		idleTimer.unref?.();
-	};
-
-	child.stdout?.on("data", armIdleTimer);
-	child.stderr?.on("data", armIdleTimer);
-	child.stdout?.on("end", () => {
-		stdoutEnded = true;
-		if (stdoutEnded && stderrEnded) clearTimers();
-	});
-	child.stderr?.on("end", () => {
-		stderrEnded = true;
-		if (stdoutEnded && stderrEnded) clearTimers();
-	});
-	child.on("exit", () => {
-		exited = true;
-		armIdleTimer();
-		if (hardTimer) return;
-		hardTimer = setTimeout(destroyUnendedStdio, hardMs);
-		hardTimer.unref?.();
-	});
-	child.on("close", clearTimers);
-	child.on("error", clearTimers);
-
-	return clearTimers;
-}

package/extensions/dm-subagents/src/shared/session-identity.ts

@@ -1,10 +0,0 @@
-interface SessionIdentityManager {
-	getSessionFile(): string | null | undefined;
-	getSessionId(): string | null | undefined;
-}
-
-export function resolveCurrentSessionId(sessionManager: SessionIdentityManager): string {
-	const sessionId = sessionManager.getSessionFile() ?? sessionManager.getSessionId();
-	if (!sessionId) throw new Error("Current session identity is unavailable.");
-	return sessionId;
-}

package/extensions/dm-subagents/src/shared/session-tokens.ts

@@ -1,44 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { TokenUsage } from "./types.ts";
-
-function findLatestSessionFile(sessionDir: string): string | null {
-	try {
-		const files = fs.readdirSync(sessionDir)
-			.filter((f) => f.endsWith(".jsonl"))
-			.map((f) => path.join(sessionDir, f));
-		if (files.length === 0) return null;
-		files.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-		return files[0] ?? null;
-	} catch {
-		// Session token lookup is optional metadata.
-		return null;
-	}
-}
-
-export function parseSessionTokens(sessionDir: string): TokenUsage | null {
-	const sessionFile = findLatestSessionFile(sessionDir);
-	if (!sessionFile) return null;
-	try {
-		const content = fs.readFileSync(sessionFile, "utf-8");
-		let input = 0;
-		let output = 0;
-		for (const line of content.split("\n")) {
-			if (!line.trim()) continue;
-			try {
-				const entry = JSON.parse(line);
-				const usage = entry.usage ?? entry.message?.usage;
-				if (usage) {
-					input += usage.inputTokens ?? usage.input ?? 0;
-					output += usage.outputTokens ?? usage.output ?? 0;
-				}
-			} catch {
-				// Ignore malformed lines while scanning usage entries.
-			}
-		}
-		return { input, output, total: input + output };
-	} catch {
-		// Usage extraction should not fail the run.
-		return null;
-	}
-}