@duckmind/dm-darwin-x64 0.33.0 → 0.33.2

package/extensions/dm-phone/src/session-pool/types.ts

@@ -1,111 +0,0 @@
-import type { WebSocket } from "ws";
-
-export type SessionKind = "parent" | "parallel";
-
-export type SessionSummary = {
-  id: string;
-  kind: SessionKind;
-  sessionId: string | null;
-  sessionFile: string | null;
-  sessionName: string | null;
-  label: string;
-  secondaryLabel: string;
-  firstUserPreview: string | null;
-  lastUserPreview: string | null;
-  model: {
-    id: string;
-    name: string;
-    provider: string;
-    actualProvider?: string;
-    actualModelId?: string;
-  } | null;
-  isRunning: boolean;
-  isStreaming: boolean;
-  isCompacting: boolean;
-  messageCount: number;
-  pendingMessageCount: number;
-  hasPendingUiRequest: boolean;
-  lastError: string;
-  lastActivityAt: number;
-  childPid: number | null;
-  cwd?: string | null;
-  mirrorsCli?: boolean;
-};
-
-export type PendingRequest = {
-  resolve: (value: any) => void;
-  reject: (error: Error) => void;
-  timer: NodeJS.Timeout;
-};
-
-export type PendingClientResponse = {
-  ws: WebSocket;
-  responseCommand?: string;
-  responseData?: Record<string, unknown>;
-  onSuccess?: (payload: any) => void;
-  onError?: (payload: any) => void;
-};
-
-export type SessionSnapshot = {
-  state: any;
-  messages: any[];
-  commands: any[];
-  liveAssistantMessage: any;
-  liveTools: any[];
-};
-
-export type ClientState = {
-  activeSessionId: string | null;
-};
-
-export type SessionWorkerOptions<TWorker> = {
-  cwd: string;
-  send: (ws: WebSocket, payload: unknown) => void;
-  onActivity: () => void;
-  onStateChange: () => void;
-  onEnvelope: (worker: TWorker, envelope: any) => void;
-  shouldAutoRestart: (worker: TWorker) => boolean;
-};
-
-export type SessionStatus = {
-  childRunning: boolean;
-  cwd: string;
-  previousCwd: string | null;
-  isStreaming: boolean;
-  isCompacting: boolean;
-  lastError: string;
-  childPid: number | null;
-  sessionWorkerId: string;
-  sessionKind: SessionKind;
-};
-
-export interface SessionController {
-  id: string;
-  kind: SessionKind;
-  cwd: string;
-  previousCwd: string | null;
-  currentSessionFile: string | null;
-  lastError: string;
-  lastActivityAt: number;
-  pendingUiRequest: any;
-  ensureStarted(startOptions?: { sessionFile?: string | null }): Promise<void>;
-  request(command: Record<string, unknown>, timeoutMs?: number): Promise<any>;
-  refreshCachedSnapshot(timeoutMs?: number): Promise<SessionSnapshot>;
-  getSnapshot(): Promise<SessionSnapshot>;
-  sendClientCommand(command: Record<string, unknown>, meta?: PendingClientResponse): Promise<string | undefined>;
-  reload(): Promise<void>;
-  dispose(): Promise<void>;
-  getStatus(): SessionStatus;
-  getSummary(): SessionSummary;
-  getCachedSnapshot(): SessionSnapshot;
-  setTrackedCwd?(cwd: string, previousCwd?: string | null): void;
-}
-
-export type PhoneSessionPoolOptions = {
-  cwd: string;
-  send: (ws: WebSocket, payload: unknown) => void;
-  onActivity: () => void;
-  buildStatusMeta: () => Record<string, unknown>;
-  createDefaultSession: () => SessionController;
-  createParallelSession: (sessionFile?: string | null) => SessionController;
-};

package/extensions/dm-phone/src/session-pool/utils.ts

@@ -1,23 +0,0 @@
-export function contentToPreviewText(content: unknown): string {
-  if (typeof content === "string") {
-    return content.replace(/\s+/g, " ").trim();
-  }
-
-  if (!Array.isArray(content)) {
-    return "";
-  }
-
-  return content
-    .map((part: any) => {
-      if (part?.type === "text") return part.text || "";
-      if (part?.type === "image") return "[image]";
-      return "";
-    })
-    .join(" ")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-export function shortId(value: unknown): string {
-  return String(value || "").trim().slice(0, 8);
-}

package/extensions/dm-phone/test/duckmind-models.test.js

@@ -1,147 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-	getPhoneVisibleModels,
-	normalizePhoneSessionModel,
-	resolvePhoneVisibleModel,
-} from "../src/extension/duckmind-models.js";
-
-const BASE_MODELS = [
-	{ provider: "openrouter", id: "@preset/free", name: "OpenRouter Free" },
-	{ provider: "openrouter", id: "@preset/auto", name: "OpenRouter Auto" },
-	{ provider: "openrouter", id: "@preset/lite", name: "OpenRouter Lite" },
-	{ provider: "openrouter", id: "@preset/smart", name: "OpenRouter Smart" },
-	{ provider: "openrouter", id: "@preset/deep", name: "OpenRouter Deep" },
-	{ provider: "openrouter", id: "@preset/image2", name: "OpenRouter Image2" },
-	{ provider: "openrouter", id: "openai/gpt-4o-mini", name: "GPT-4o Mini" },
-	{ provider: "anthropic", id: "claude-sonnet-4-5", name: "Claude Sonnet 4.5" },
-	{ provider: "openai-codex", id: "gpt-5.5", name: "GPT-5.5" },
-];
-
-function withTempAgentDir({ withUltradexAccounts = false } = {}, fn) {
-	const tempDir = mkdtempSync(join(tmpdir(), "dm-phone-models-"));
-	const previousAgentDir = process.env.DM_CODING_AGENT_DIR;
-
-	try {
-		process.env.DM_CODING_AGENT_DIR = tempDir;
-		if (withUltradexAccounts) {
-			writeFileSync(join(tempDir, "codex-accounts.json"), JSON.stringify({ accounts: [{ id: "acct-1" }] }), "utf-8");
-		}
-		return fn(tempDir);
-	} finally {
-		if (previousAgentDir === undefined) {
-			delete process.env.DM_CODING_AGENT_DIR;
-		} else {
-			process.env.DM_CODING_AGENT_DIR = previousAgentDir;
-		}
-		rmSync(tempDir, { recursive: true, force: true });
-	}
-}
-
-test("phone model picker keeps DuckMind aliases and appends connected provider models", () => {
-	withTempAgentDir({}, () => {
-		const visible = getPhoneVisibleModels(BASE_MODELS);
-		const refs = visible.map((model) => `${model.provider}/${model.id}`);
-		assert.deepEqual(refs.slice(0, 6), [
-			"duckmind/free",
-			"duckmind/auto",
-			"duckmind/lite",
-			"duckmind/smart",
-			"duckmind/deep",
-			"duckmind/image2",
-		]);
-		assert.deepEqual(visible.slice(0, 6).map((model) => model.name), [
-			"Free",
-			"Auto",
-			"Lite",
-			"Smart",
-			"Deep",
-			"Image2",
-		]);
-		assert.ok(refs.includes("duckmind/openai/gpt-4o-mini"));
-		assert.ok(!refs.includes("openrouter/openai/gpt-4o-mini"));
-		assert.equal(visible.find((model) => model.id === "openai/gpt-4o-mini")?.actualProvider, "openrouter");
-		assert.ok(refs.includes("anthropic/claude-sonnet-4-5"));
-		assert.ok(refs.includes("openai-codex/gpt-5.5"));
-		assert.ok(!refs.includes("duckmind/ultra"));
-	});
-});
-
-test("phone model picker adds ultra only when ultradex accounts are present", () => {
-	withTempAgentDir({ withUltradexAccounts: true }, () => {
-		const visible = getPhoneVisibleModels(BASE_MODELS);
-		assert.deepEqual(visible.map((model) => `${model.provider}/${model.id}`).slice(0, 7), [
-			"duckmind/free",
-			"duckmind/auto",
-			"duckmind/lite",
-			"duckmind/smart",
-			"duckmind/deep",
-			"duckmind/image2",
-			"duckmind/ultra",
-		]);
-	});
-});
-
-test("duckmind aliases resolve back to their actual runtime model", () => {
-	withTempAgentDir({}, () => {
-		const resolved = resolvePhoneVisibleModel(BASE_MODELS, "duckmind", "smart");
-		assert.ok(resolved);
-		assert.equal(resolved.option.provider, "duckmind");
-		assert.equal(resolved.option.id, "smart");
-		assert.equal(resolved.option.name, "Smart");
-		assert.equal(resolved.model.provider, "openrouter");
-		assert.equal(resolved.model.id, "@preset/smart");
-	});
-});
-
-test("providerless actual model ids still map back to the duckmind alias for compat", () => {
-	withTempAgentDir({}, () => {
-		const resolved = resolvePhoneVisibleModel(BASE_MODELS, "", "@preset/lite");
-		assert.ok(resolved);
-		assert.equal(resolved.option.id, "lite");
-		assert.equal(resolved.option.actualModelId, "@preset/lite");
-	});
-});
-
-test("session model snapshots normalize raw OpenRouter models to DuckMind labels", () => {
-	withTempAgentDir({}, () => {
-		assert.deepEqual(
-			normalizePhoneSessionModel({
-				provider: "openrouter",
-				id: "@preset/deep",
-				name: "OpenRouter Deep",
-				contextWindow: 1234,
-			}),
-			{
-				provider: "duckmind",
-				id: "deep",
-				name: "Deep",
-				actualProvider: "openrouter",
-				actualModelId: "@preset/deep",
-				contextWindow: 1234,
-			},
-		);
-	});
-});
-
-test("session model snapshots normalize raw Codex ultra models to DuckMind Ultra", () => {
-	withTempAgentDir({ withUltradexAccounts: true }, () => {
-		assert.deepEqual(
-			normalizePhoneSessionModel({
-				provider: "openai-codex",
-				id: "gpt-5.5",
-				name: "GPT-5.5",
-			}),
-			{
-				provider: "duckmind",
-				id: "ultra",
-				name: "Ultra",
-				actualProvider: "openai-codex",
-				actualModelId: "gpt-5.5",
-			},
-		);
-	});
-});

package/extensions/dm-thinking-timer/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 xryul
-
-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/extensions/dm-thinking-timer/README.md

@@ -1,7 +0,0 @@
-# dm-thinking-timer
-
-Bundled DM extension that shows a live timer next to collapsed Thinking blocks.
-
-## Bundled with dm
-
-No separate install step is required. Install `dm` and restart the TUI if the timer patch is not already active.

package/extensions/dm-thinking-timer/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "dm-thinking-timer",
-  "version": "0.1.4",
-  "description": "DM extension that shows a live timer next to collapsed Thinking blocks",
-  "type": "module",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/xRyul/pi-thinking-timer.git"
-  },
-  "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*"
-  },
-  "pi": {
-    "extensions": [
-      "./thinking-timer.ts"
-    ]
-  }
-}

package/extensions/dm-thinking-timer/thinking-timer.ts

@@ -1,250 +0,0 @@
-/**
- * Thinking Timer Extension
- *
- * Goal: show a live ticking timer *inline* on the collapsed "Thinking..." line,
- * so you see:
- *
- *   Thinking... 6.5s
- *
- * instead of having a second "Working..."/"Thinking ..." indicator line.
- *
- * Implementation notes:
- * - We track thinking_start/thinking_end stream events to measure durations.
- * - We monkey-patch AssistantMessageComponent.updateContent() to replace the
- *   hardcoded "Thinking..." label with "Thinking... <time>".
- * - This relies on internal rendering behavior (but uses exported components),
- *   so it may break if dm changes how it renders collapsed thinking blocks.
- */
-
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { AssistantMessageComponent } from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
-
-type Store = {
-	/** Active thinking blocks: key -> start time (ms since epoch) */
-	starts: Map<string, number>;
-	/** Finalized thinking blocks: key -> duration ms */
-	durations: Map<string, number>;
-	/** Rendered label components for collapsed thinking blocks */
-	labels: Map<string, Text>;
-	/** Latest theme reference (ctx.ui.theme) */
-	theme?: ExtensionContext["ui"]["theme"];
-};
-
-const STORE_KEY = Symbol.for("dm.extensions.thinkingTimer.store");
-const PATCH_KEY = Symbol.for("dm.extensions.thinkingTimer.patch");
-
-function getStore(): Store | undefined {
-	return (globalThis as any)[STORE_KEY] as Store | undefined;
-}
-
-function formatElapsed(ms: number): string {
-	const totalSeconds = ms / 1000;
-	if (totalSeconds < 60) return `${totalSeconds.toFixed(1)}s`;
-	const minutes = Math.floor(totalSeconds / 60);
-	const seconds = totalSeconds - minutes * 60;
-	return `${minutes}:${seconds.toFixed(1).padStart(4, "0")}`;
-}
-
-function makeThinkingLabel(theme: Store["theme"] | undefined, ms: number | null): string {
-	if (!theme) {
-		return ms === null ? "Thinking..." : `Thinking... ${formatElapsed(ms)}`;
-	}
-	if (ms === null) {
-		return theme.italic(theme.fg("thinkingText", "Thinking..."));
-	}
-	const base = theme.fg("thinkingText", "Thinking...");
-	const time = theme.fg("dim", ` ${formatElapsed(ms)}`);
-	return theme.italic(base + time);
-}
-
-function keyFor(timestamp: number, contentIndex: number): string {
-	return `${timestamp}:${contentIndex}`;
-}
-
-function ensureAssistantMessagePatchInstalled(): void {
-	const proto: any = AssistantMessageComponent.prototype as any;
-	if (proto[PATCH_KEY]) return;
-	proto[PATCH_KEY] = true;
-
-	const originalUpdateContent = proto.updateContent;
-
-	proto.updateContent = function patchedUpdateContent(this: any, message: any) {
-		originalUpdateContent.call(this, message);
-
-		try {
-			const store = getStore();
-			if (!store) return;
-			if (!message || !message.content || !Array.isArray(message.content)) return;
-			if (!this.hideThinkingBlock) return;
-			if (!this.contentContainer || !Array.isArray(this.contentContainer.children)) return;
-
-			// Find thinking content indices that would produce a collapsed label.
-			const thinkingIndices: number[] = [];
-			for (let i = 0; i < message.content.length; i++) {
-				const c = message.content[i];
-				if (c?.type === "thinking" && typeof c.thinking === "string" && c.thinking.trim()) {
-					thinkingIndices.push(i);
-				}
-			}
-			if (thinkingIndices.length === 0) return;
-
-			// Find the Text components that currently contain the hardcoded "Thinking..." label.
-			const labelComponents: Text[] = [];
-			for (const child of this.contentContainer.children as any[]) {
-				// Be defensive: avoid relying on instanceof across module boundaries.
-				if (!child || typeof child !== "object") continue;
-				if (typeof child.setText !== "function") continue;
-				if (typeof child.text !== "string") continue;
-				if (!child.text.includes("Thinking...")) continue;
-				labelComponents.push(child as Text);
-			}
-			if (labelComponents.length === 0) return;
-
-			const count = Math.min(thinkingIndices.length, labelComponents.length);
-			for (let j = 0; j < count; j++) {
-				const contentIndex = thinkingIndices[j]!;
-				const label = labelComponents[j]!;
-				const k = keyFor(message.timestamp, contentIndex);
-				store.labels.set(k, label);
-
-				// Apply either live or finalized duration if we have it.
-				let ms: number | null = null;
-				const start = store.starts.get(k);
-				const dur = store.durations.get(k);
-				if (dur !== undefined) {
-					ms = dur;
-				} else if (start !== undefined) {
-					ms = Date.now() - start;
-				}
-
-				// Only override label when we have timing info (or when live),
-				// otherwise leave the original rendering alone.
-				if (ms !== null) {
-					label.setText(makeThinkingLabel(store.theme, ms));
-				}
-			}
-		} catch {
-			// Never break rendering
-		}
-	};
-}
-
-export default function (pi: ExtensionAPI) {
-	// Shared store used by the patch (global so /reload replaces it cleanly)
-	const store: Store = {
-		starts: new Map(),
-		durations: new Map(),
-		labels: new Map(),
-		theme: undefined,
-	};
-	(globalThis as any)[STORE_KEY] = store;
-	ensureAssistantMessagePatchInstalled();
-
-	let ticker: ReturnType<typeof setInterval> | null = null;
-
-	function stopTicker() {
-		if (ticker) {
-			clearInterval(ticker);
-			ticker = null;
-		}
-	}
-
-	function tick() {
-		const s = getStore();
-		if (!s) return;
-		if (s.starts.size === 0) {
-			stopTicker();
-			return;
-		}
-		for (const [k, start] of s.starts.entries()) {
-			const label = s.labels.get(k);
-			if (!label) continue;
-			label.setText(makeThinkingLabel(s.theme, Date.now() - start));
-		}
-	}
-
-	function startTicker() {
-		if (ticker) return;
-		ticker = setInterval(tick, 100);
-	}
-
-	function finalizeThinkingBlock(k: string, endTimeMs = Date.now()) {
-		const s = getStore();
-		if (!s) return;
-		const start = s.starts.get(k);
-		if (start === undefined) return;
-		const dur = Math.max(0, endTimeMs - start);
-		s.starts.delete(k);
-		s.durations.set(k, dur);
-
-		const label = s.labels.get(k);
-		if (label) {
-			label.setText(makeThinkingLabel(s.theme, dur));
-		}
-	}
-
-	function resetAll(ctx: ExtensionContext) {
-		stopTicker();
-		store.starts.clear();
-		store.durations.clear();
-		store.labels.clear();
-		store.theme = ctx.ui.theme;
-		// Ensure we don't leave a custom working message around from earlier versions.
-		ctx.ui.setWorkingMessage();
-	}
-
-	pi.on("session_start", async (_event, ctx) => {
-		resetAll(ctx);
-	});
-
-	pi.on("message_update", async (event, ctx) => {
-		store.theme = ctx.ui.theme;
-
-		const se = event.assistantMessageEvent as any;
-		if (!se || typeof se.type !== "string") return;
-
-		if (se.type === "thinking_start" || se.type === "thinking_delta") {
-			const msg = se.partial;
-			const k = keyFor(msg.timestamp, se.contentIndex);
-			if (!store.starts.has(k)) {
-				store.starts.set(k, Date.now());
-			}
-			startTicker();
-			// Try immediate paint if label already exists
-			tick();
-			return;
-		}
-
-		if (se.type === "thinking_end") {
-			const msg = se.partial;
-			const k = keyFor(msg.timestamp, se.contentIndex);
-			finalizeThinkingBlock(k);
-			if (store.starts.size === 0) stopTicker();
-			return;
-		}
-	});
-
-	// Safety: if a message ends while a thinking_start was seen but thinking_end was not,
-	// finalize any active thinking blocks for that message.
-	pi.on("message_end", async (event, ctx) => {
-		store.theme = ctx.ui.theme;
-		const msg: any = event.message;
-		if (!msg || msg.role !== "assistant" || !Array.isArray(msg.content)) return;
-
-		for (let i = 0; i < msg.content.length; i++) {
-			const c = msg.content[i];
-			if (c?.type !== "thinking") continue;
-			const k = keyFor(msg.timestamp, i);
-			if (store.starts.has(k)) {
-				finalizeThinkingBlock(k, Date.now());
-			}
-		}
-		if (store.starts.size === 0) stopTicker();
-	});
-
-
-	pi.on("session_shutdown", async (_event, ctx) => {
-		resetAll(ctx);
-	});
-}