@duckmind/dm-darwin-arm64 0.13.6 → 0.13.7

package/extensions/dm-phone/src/extension/phone-sessions.ts

@@ -0,0 +1,139 @@
+import type { SessionEntry } from "@mariozechner/pi-coding-agent";
+import { SessionManager } from "@mariozechner/pi-coding-agent";
+
+export function summarizeSessionEntry(entry: SessionEntry): {
+  kind: string;
+  preview: string;
+  role?: string;
+} {
+  if (entry.type === "message") {
+    const message: any = entry.message;
+    if (message.role === "user") {
+      const preview = typeof message.content === "string"
+        ? message.content
+        : Array.isArray(message.content)
+          ? message.content
+              .map((part: any) => (part.type === "text" ? part.text || "" : part.type === "image" ? "[image]" : ""))
+              .join(" ")
+          : "";
+      return { kind: "message", role: "user", preview: preview || "(user message)" };
+    }
+
+    if (message.role === "assistant") {
+      const preview = Array.isArray(message.content)
+        ? message.content
+            .map((part: any) => (part.type === "text" ? part.text || "" : part.type === "toolCall" ? `[tool:${part.name || "tool"}]` : ""))
+            .join(" ")
+        : "";
+      return { kind: "message", role: "assistant", preview: preview || "(assistant message)" };
+    }
+
+    if (message.role === "toolResult") {
+      const preview = Array.isArray(message.content)
+        ? message.content.map((part: any) => (part.type === "text" ? part.text || "" : "")).join(" ")
+        : "";
+      return { kind: "tool", role: message.toolName || "tool", preview: preview || `(${message.toolName || "tool"} result)` };
+    }
+
+    if (message.role === "custom") {
+      return {
+        kind: "custom",
+        role: message.customType || "custom",
+        preview: typeof message.content === "string" ? message.content : "(custom message)",
+      };
+    }
+
+    if (message.role === "branchSummary") {
+      return { kind: "summary", role: "branchSummary", preview: message.summary || "(branch summary)" };
+    }
+
+    if (message.role === "compactionSummary") {
+      return { kind: "summary", role: "compactionSummary", preview: message.summary || "(compaction summary)" };
+    }
+
+    return { kind: "message", role: message.role, preview: `(${message.role || "message"})` };
+  }
+
+  if (entry.type === "compaction") {
+    return { kind: "compaction", preview: entry.summary || "(compaction)" };
+  }
+  if (entry.type === "branch_summary") {
+    return { kind: "branch_summary", preview: entry.summary || "(branch summary)" };
+  }
+  if (entry.type === "session_info") {
+    return { kind: "session_info", preview: entry.name || "(session info)" };
+  }
+  if (entry.type === "label") {
+    return { kind: "label", preview: entry.label || "(label cleared)" };
+  }
+  if (entry.type === "model_change") {
+    return { kind: "model_change", preview: `${entry.provider}/${entry.modelId}` };
+  }
+  if (entry.type === "thinking_level_change") {
+    return { kind: "thinking_level_change", preview: entry.thinkingLevel || "(thinking change)" };
+  }
+  if (entry.type === "custom") {
+    return { kind: "custom", preview: entry.customType || "(custom entry)" };
+  }
+
+  return { kind: entry.type, preview: `(${entry.type})` };
+}
+
+function flattenTreeNode(node: any, depth = 0, out: any[] = []): any[] {
+  const summary = summarizeSessionEntry(node.entry as SessionEntry);
+  out.push({
+    id: node.entry.id,
+    parentId: node.entry.parentId,
+    type: node.entry.type,
+    depth,
+    timestamp: node.entry.timestamp,
+    label: node.label,
+    childCount: Array.isArray(node.children) ? node.children.length : 0,
+    summary,
+  });
+
+  for (const childNode of node.children || []) {
+    flattenTreeNode(childNode, depth + 1, out);
+  }
+
+  return out;
+}
+
+export async function listSessionsForCwd(cwd: string) {
+  const sessions = await SessionManager.list(cwd);
+  return sessions.map((session) => ({
+    path: session.path,
+    id: session.id,
+    cwd: session.cwd,
+    name: session.name,
+    parentSessionPath: session.parentSessionPath,
+    created: session.created,
+    modified: session.modified,
+    messageCount: session.messageCount,
+    firstMessage: session.firstMessage,
+  }));
+}
+
+export function getTreeStateFromSessionFile(sessionFile: string) {
+  const sessionManager = SessionManager.open(sessionFile);
+  const branch = sessionManager.getBranch();
+  const currentPathIds = new Set(branch.map((entry) => entry.id));
+  const roots = sessionManager.getTree();
+  const nodes = roots.flatMap((root) => flattenTreeNode(root));
+
+  return {
+    sessionFile,
+    currentLeafId: sessionManager.getLeafId(),
+    currentPathIds: [...currentPathIds],
+    nodes,
+  };
+}
+
+export function createBranchSessionFromEntry(sessionFile: string, entryId: string) {
+  const sessionManager = SessionManager.open(sessionFile);
+  const nextPath = sessionManager.createBranchedSession(entryId);
+  if (!nextPath) {
+    throw new Error("Failed to create branch session.");
+  }
+  return nextPath;
+}

package/extensions/dm-phone/src/extension/phone-static.ts

@@ -0,0 +1,30 @@
+import { fileURLToPath } from "node:url";
+import { dirname, join, normalize, resolve } from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export const publicDir = resolve(__dirname, "../../public");
+
+export const mimeTypes: Record<string, string> = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webmanifest": "application/manifest+json; charset=utf-8",
+};
+
+export function sanitizePublicPath(pathname: string): string | null {
+  const normalized = normalize(pathname).replace(/^\/+/, "");
+  const filePath = resolve(publicDir, normalized === "" ? "index.html" : normalized);
+  if (!filePath.startsWith(publicDir)) return null;
+  return filePath;
+}
+
+export function publicFilePath(relativePath: string): string {
+  return join(publicDir, relativePath);
+}

package/extensions/dm-phone/src/extension/phone-tailscale.ts

@@ -0,0 +1,148 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+function isPhoneServeProxyTarget(proxy: string, port: number) {
+  try {
+    const url = new URL(proxy);
+    return url.protocol === "http:" && url.port === String(port) && ["127.0.0.1", "localhost", "::1", "[::1]"].includes(url.hostname);
+  } catch {
+    return false;
+  }
+}
+
+async function getTailscaleUrl(pi: ExtensionAPI) {
+  try {
+    const status = await pi.exec("tailscale", ["status", "--json"], { timeout: 5000 });
+    if (status.code !== 0) return "";
+
+    const payload = JSON.parse(status.stdout || "{}");
+    const dnsName = typeof payload?.Self?.DNSName === "string" ? payload.Self.DNSName.replace(/\.$/, "") : "";
+    return dnsName ? `https://${dnsName}/` : "";
+  } catch {
+    return "";
+  }
+}
+
+export async function getTailscaleServeInfo(pi: ExtensionAPI, port: number) {
+  const url = await getTailscaleUrl(pi);
+  try {
+    const status = await pi.exec("tailscale", ["serve", "status", "--json"], { timeout: 5000 });
+    if (status.code !== 0) {
+      return {
+        active: false,
+        url,
+        hadAnyWebConfig: false,
+        error: (status.stderr || status.stdout || `tailscale serve status exited ${status.code}`).trim(),
+      };
+    }
+
+    let payload: any;
+    try {
+      payload = JSON.parse(status.stdout || "{}");
+    } catch {
+      return {
+        active: false,
+        url,
+        hadAnyWebConfig: false,
+        error: "Failed to parse tailscale serve status output.",
+      };
+    }
+
+    const services = Object.values(payload?.Web || {}) as any[];
+    let active = false;
+    for (const service of services) {
+      const handlers = service?.Handlers || {};
+      for (const handler of Object.values(handlers) as any[]) {
+        if (typeof handler?.Proxy === "string" && isPhoneServeProxyTarget(handler.Proxy, port)) {
+          active = true;
+          break;
+        }
+      }
+      if (active) break;
+    }
+
+    return {
+      active,
+      url,
+      hadAnyWebConfig: services.length > 0,
+      error: "",
+    };
+  } catch (error) {
+    return {
+      active: false,
+      url,
+      hadAnyWebConfig: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export async function enableTailscaleServe(pi: ExtensionAPI, port: number) {
+  const before = await getTailscaleServeInfo(pi, port);
+  if (before.active) {
+    return {
+      enabled: true,
+      changed: false,
+      replacedExisting: false,
+      url: before.url,
+      error: "",
+    };
+  }
+
+  try {
+    const target = `http://127.0.0.1:${port}`;
+    const result = await pi.exec("tailscale", ["serve", "--bg", "--yes", "--https=443", target], { timeout: 5000 });
+    if (result.code !== 0) {
+      return {
+        enabled: false,
+        changed: false,
+        replacedExisting: before.hadAnyWebConfig,
+        url: before.url,
+        error: (result.stderr || result.stdout || `tailscale serve exited ${result.code}`).trim(),
+      };
+    }
+
+    const after = await getTailscaleServeInfo(pi, port);
+    return {
+      enabled: after.active || !after.error,
+      changed: true,
+      replacedExisting: before.hadAnyWebConfig,
+      url: after.url || before.url,
+      error: after.active ? "" : after.error,
+    };
+  } catch (error) {
+    return {
+      enabled: false,
+      changed: false,
+      replacedExisting: before.hadAnyWebConfig,
+      url: before.url,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export async function disableMatchingTailscaleServe(pi: ExtensionAPI, port: number) {
+  const info = await getTailscaleServeInfo(pi, port);
+  if (!info.active) {
+    return {
+      disabled: false,
+      error: info.error,
+    };
+  }
+
+  try {
+    const off = await pi.exec("tailscale", ["serve", "--yes", "--https=443", "off"], { timeout: 5000 });
+    if (off.code === 0) {
+      return { disabled: true, error: "" };
+    }
+
+    return {
+      disabled: false,
+      error: (off.stderr || off.stdout || `tailscale serve --https=443 off exited ${off.code}`).trim(),
+    };
+  } catch (error) {
+    return {
+      disabled: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/extensions/dm-phone/src/extension/phone-theme.ts

@@ -0,0 +1,85 @@
+type ThemeLike = {
+  name?: string;
+  getFgAnsi: (...args: any[]) => string | undefined;
+};
+
+function rgbToHex(r: number, g: number, b: number) {
+  return `#${[r, g, b].map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+
+function xterm256ToHex(index: number) {
+  const ansi16 = [
+    "#000000",
+    "#800000",
+    "#008000",
+    "#808000",
+    "#000080",
+    "#800080",
+    "#008080",
+    "#c0c0c0",
+    "#808080",
+    "#ff0000",
+    "#00ff00",
+    "#ffff00",
+    "#0000ff",
+    "#ff00ff",
+    "#00ffff",
+    "#ffffff",
+  ];
+
+  if (index >= 0 && index < ansi16.length) {
+    return ansi16[index];
+  }
+
+  if (index >= 16 && index <= 231) {
+    const cube = [0, 95, 135, 175, 215, 255];
+    const value = index - 16;
+    const r = cube[Math.floor(value / 36)] ?? 0;
+    const g = cube[Math.floor((value % 36) / 6)] ?? 0;
+    const b = cube[value % 6] ?? 0;
+    return rgbToHex(r, g, b);
+  }
+
+  if (index >= 232 && index <= 255) {
+    const gray = 8 + (index - 232) * 10;
+    return rgbToHex(gray, gray, gray);
+  }
+
+  return "";
+}
+
+function ansiColorToCss(value: string | undefined) {
+  if (!value) return "";
+
+  const trueColorMatch = /\x1b\[38;2;(\d+);(\d+);(\d+)m/.exec(value);
+  if (trueColorMatch) {
+    return rgbToHex(Number(trueColorMatch[1]), Number(trueColorMatch[2]), Number(trueColorMatch[3]));
+  }
+
+  const color256Match = /\x1b\[38;5;(\d+)m/.exec(value);
+  if (color256Match) {
+    return xterm256ToHex(Number(color256Match[1]));
+  }
+
+  return "";
+}
+
+export function buildThemePayload(theme?: ThemeLike | null) {
+  if (!theme) return null;
+
+  const colors = {
+    accent: ansiColorToCss(theme.getFgAnsi("accent")),
+    mdCode: ansiColorToCss(theme.getFgAnsi("mdCode")),
+    mdCodeBlock: ansiColorToCss(theme.getFgAnsi("mdCodeBlock")),
+    mdCodeBlockBorder: ansiColorToCss(theme.getFgAnsi("mdCodeBlockBorder")),
+  };
+
+  if (!Object.values(colors).some(Boolean)) {
+    return null;
+  }
+
+  return {
+    name: theme.name || "",
+    colors,
+  };
+}

package/extensions/dm-phone/src/extension/register-phone-child-extension.ts

@@ -0,0 +1,112 @@
+import type { ImageContent, TextContent } from "@mariozechner/pi-ai";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+const INLINE_MESSAGE_TYPE = "phone-inline-user-message";
+const INLINE_IMAGE_TOKEN_PATTERN = /⟦img\d+⟧|\{img\d*\}/g;
+
+function isInlineImageTokenPrompt(text: string): boolean {
+  INLINE_IMAGE_TOKEN_PATTERN.lastIndex = 0;
+  return INLINE_IMAGE_TOKEN_PATTERN.test(text);
+}
+
+function buildInlineContent(text: string, images: ImageContent[]) {
+  INLINE_IMAGE_TOKEN_PATTERN.lastIndex = 0;
+  const matches = [...text.matchAll(INLINE_IMAGE_TOKEN_PATTERN)];
+  if (matches.length === 0 || images.length === 0) {
+    return { content: text ? [{ type: "text", text } satisfies TextContent] : [], matchedCount: 0 };
+  }
+
+  const content: (TextContent | ImageContent)[] = [];
+  let lastIndex = 0;
+  let imageIndex = 0;
+
+  for (const match of matches) {
+    const token = match[0] || "";
+    const index = match.index ?? -1;
+    if (index < 0) continue;
+    if (imageIndex >= images.length) break;
+
+    const before = text.slice(lastIndex, index);
+    if (before) {
+      content.push({ type: "text", text: before });
+    }
+
+    const image = images[imageIndex];
+    if (image?.type === "image" && image.data && image.mimeType) {
+      content.push({
+        type: "image",
+        data: image.data,
+        mimeType: image.mimeType,
+      });
+      imageIndex += 1;
+    } else {
+      content.push({ type: "text", text: token });
+    }
+
+    lastIndex = index + token.length;
+  }
+
+  const after = text.slice(lastIndex);
+  if (after) {
+    content.push({ type: "text", text: after });
+  }
+
+  while (imageIndex < images.length) {
+    const image = images[imageIndex];
+    if (image?.type === "image" && image.data && image.mimeType) {
+      content.push({
+        type: "image",
+        data: image.data,
+        mimeType: image.mimeType,
+      });
+    }
+    imageIndex += 1;
+  }
+
+  return { content, matchedCount: Math.min(matches.length, images.length) };
+}
+
+function flattenText(content: (TextContent | ImageContent)[]): string {
+  return content
+    .filter((part): part is TextContent => part.type === "text")
+    .map((part) => part.text)
+    .join("");
+}
+
+export default function registerPhoneChildExtension(pi: ExtensionAPI) {
+  pi.on("input", async (event, ctx) => {
+    if (event.source !== "rpc" || !Array.isArray(event.images) || event.images.length === 0) {
+      return { action: "continue" };
+    }
+
+    if (!isInlineImageTokenPrompt(event.text || "")) {
+      return { action: "continue" };
+    }
+
+    const { content, matchedCount } = buildInlineContent(event.text || "", event.images as ImageContent[]);
+    if (matchedCount === 0) {
+      return { action: "continue" };
+    }
+
+    const trimmed = (event.text || "").trimStart();
+    const looksLikeSlashCommand = trimmed.startsWith("/");
+    if (!ctx.isIdle() || looksLikeSlashCommand) {
+      return {
+        action: "transform",
+        text: flattenText(content),
+        images: content.filter((part): part is ImageContent => part.type === "image"),
+      };
+    }
+
+    pi.sendMessage(
+      {
+        customType: INLINE_MESSAGE_TYPE,
+        content,
+        display: true,
+      },
+      { triggerTurn: true },
+    );
+
+    return { action: "handled" };
+  });
+}

package/extensions/dm-phone/src/extension/register-phone-extension.ts

@@ -0,0 +1,106 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { PhoneServerRuntime } from "./phone-server-runtime";
+
+export default function registerPhoneExtension(pi: ExtensionAPI) {
+  if (process.env.DM_PHONE_CHILD === "1" || process.env.PI_PHONE_CHILD === "1") {
+    return;
+  }
+
+  const runtime = new PhoneServerRuntime(pi);
+
+  pi.registerCommand("phone-start", {
+    description: "Start the phone web UI. Usage: /phone-start [port] [token] [--cwd path] [--host 127.0.0.1] [--idle-mins 20]",
+    handler: async (args, ctx) => {
+      await runtime.handlePhoneStart(args, ctx);
+    },
+  });
+
+  pi.registerCommand("phone-stop", {
+    description: "Stop the phone web UI server and remove the matching Tailscale Serve route",
+    handler: async (_args, ctx) => {
+      await runtime.handlePhoneStop(ctx);
+    },
+  });
+
+  pi.registerCommand("phone-status", {
+    description: "Show phone server and Tailscale Serve status",
+    handler: async (_args, ctx) => {
+      await runtime.handlePhoneStatus(ctx);
+    },
+  });
+
+  pi.registerCommand("phone-token", {
+    description: "Show the current phone UI token",
+    handler: async (_args, ctx) => {
+      runtime.handlePhoneToken(ctx);
+    },
+  });
+
+  pi.on("input", async (event, ctx) => {
+    return runtime.handleInput(event, ctx);
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    await runtime.handleSessionStart(ctx);
+  });
+
+  pi.on("session_switch", async (_event, ctx) => {
+    await runtime.handleSessionSwitch(ctx);
+  });
+
+  pi.on("session_fork", async (_event, ctx) => {
+    await runtime.handleSessionSwitch(ctx);
+  });
+
+  pi.on("session_tree", async (_event, ctx) => {
+    await runtime.handleSessionSwitch(ctx);
+  });
+
+  pi.on("session_before_compact", async (_event, ctx) => {
+    runtime.handleParentCompactionStart(ctx);
+  });
+
+  pi.on("session_compact", async (_event, ctx) => {
+    runtime.handleParentCompactionEnd(ctx);
+  });
+
+  pi.on("model_select", async (_event, ctx) => {
+    await runtime.handleSessionSwitch(ctx);
+  });
+
+  pi.on("agent_start", async (_event, ctx) => {
+    runtime.handleParentAgentStart(ctx);
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    runtime.handleParentAgentEnd(ctx);
+  });
+
+  pi.on("message_start", async (event, ctx) => {
+    runtime.handleParentMessageStart(event, ctx);
+  });
+
+  pi.on("message_update", async (event, ctx) => {
+    runtime.handleParentMessageUpdate(event, ctx);
+  });
+
+  pi.on("message_end", async (event, ctx) => {
+    runtime.handleParentMessageEnd(event, ctx);
+  });
+
+  pi.on("tool_execution_start", async (event, ctx) => {
+    runtime.handleParentToolExecutionStart(event, ctx);
+  });
+
+  pi.on("tool_execution_update", async (event, ctx) => {
+    runtime.handleParentToolExecutionUpdate(event, ctx);
+  });
+
+  pi.on("tool_execution_end", async (event, ctx) => {
+    runtime.handleParentToolExecutionEnd(event, ctx);
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    await runtime.handleSessionShutdown(ctx);
+  });
+}

package/extensions/dm-phone/src/extension/types.ts

@@ -0,0 +1,73 @@
+import type { WebSocket } from "ws";
+
+export type PhoneConfig = {
+  host: string;
+  port: number;
+  token: string;
+  cwd: string;
+  idleTimeoutMs: number;
+};
+
+export type ParsedPhoneArgs = {
+  config: PhoneConfig;
+  tokenSpecified: boolean;
+  idleSpecified: boolean;
+};
+
+export type PersistedPhoneRuntime = {
+  pid: number;
+  host: string;
+  port: number;
+  controlToken: string;
+  startedAt: string;
+};
+
+export type PendingClientResponse = {
+  ws: WebSocket;
+  responseCommand?: string;
+  responseData?: Record<string, unknown>;
+};
+
+export type UsageWindow = {
+  used_percent?: number | null;
+  reset_after_seconds?: number | null;
+  reset_at?: number | null;
+};
+
+export type RateLimitBucket = {
+  allowed?: boolean;
+  limit_reached?: boolean;
+  primary_window?: UsageWindow | null;
+  secondary_window?: UsageWindow | null;
+};
+
+export type CodexUsageResponse = {
+  rate_limit?: RateLimitBucket | null;
+  additional_rate_limits?: Record<string, unknown> | unknown[] | null;
+};
+
+export type PhoneQuotaWindow = {
+  label: "5h" | "7d";
+  leftPercent: number;
+  usedPercent: number;
+  resetAfterSeconds: number | null;
+  text: string;
+};
+
+export type PhoneQuotaResponse = {
+  visible: boolean;
+  limited: boolean;
+  primaryWindow: PhoneQuotaWindow | null;
+  secondaryWindow: PhoneQuotaWindow | null;
+  error?: string;
+};
+
+export type PhonePathSuggestionMode = "mention" | "cd";
+
+export type PhonePathSuggestion = {
+  value: string;
+  label: string;
+  description?: string;
+  isDirectory: boolean;
+  kind: "path" | "previous";
+};