@duckmind/dm-darwin-arm64 0.13.6 → 0.13.8

package/extensions/dm-phone/public/app/formatters.js

@@ -0,0 +1,131 @@
+export function escapeHtml(text = "") {
+  return String(text)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#039;");
+}
+
+export function escapeAttribute(text = "") {
+  return escapeHtml(text).replaceAll("`", "&#096;");
+}
+
+export function formatCwdDisplay(path = "") {
+  const value = String(path || "").trim();
+  if (!value) return "";
+
+  const homeMatch = value.match(/^\/(?:home|Users)\/[^/]+(\/.*)?$/);
+  if (homeMatch) {
+    const suffix = homeMatch[1] || "";
+    const parts = suffix.split("/").filter(Boolean);
+    if (!parts.length) return "~";
+    if (parts.length === 1) return `~/${parts[0]}`;
+    return `~/…/${parts[parts.length - 1]}`;
+  }
+
+  if (value === "/") return value;
+
+  const parts = value.split("/").filter(Boolean);
+  if (parts.length <= 2) return value;
+  return `/…/${parts[parts.length - 1]}`;
+}
+
+export function formatTimestamp(timestamp) {
+  if (!timestamp) return "";
+  const date = new Date(timestamp);
+  return date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+}
+
+export function formatDateTime(value) {
+  if (!value) return "";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "";
+  return date.toLocaleString([], { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
+}
+
+export function formatBytes(bytes) {
+  if (!Number.isFinite(bytes)) return "";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+export function formatTokenCount(count) {
+  if (!Number.isFinite(count) || count <= 0) return "";
+  if (count < 1000) return String(Math.round(count));
+  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1000000) return `${Math.round(count / 1000)}k`;
+  if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
+  return `${Math.round(count / 1000000)}M`;
+}
+
+export function normalizeNewlines(text = "") {
+  return String(text ?? "").replace(/\r\n?/g, "\n");
+}
+
+export function stripTerminalControlSequences(text = "") {
+  return String(text ?? "")
+    .replace(/\u001B\][^\u0007\u001B]*(?:\u0007|\u001B\\)/g, "")
+    .replace(/\u009D[^\u009C]*\u009C/g, "")
+    .replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/\u009B[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/\u001B[@-_]/g, "")
+    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, "");
+}
+
+export function countTextLines(text = "") {
+  const normalized = normalizeNewlines(text);
+  if (!normalized.length) return 0;
+  return normalized.split("\n").length;
+}
+
+export function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+
+export function contentToText(content) {
+  if (typeof content === "string") return stripTerminalControlSequences(content);
+  if (!Array.isArray(content)) return "";
+  return stripTerminalControlSequences(content
+    .map((part) => {
+      if (part.type === "text") return part.text || "";
+      if (part.type === "image") return "[image]";
+      if (part.type === "thinking") return "";
+      if (part.type === "toolCall") return "";
+      return "";
+    })
+    .join(" ")
+    .trim());
+}
+
+export function countImages(content) {
+  if (!Array.isArray(content)) return 0;
+  return content.filter((part) => part.type === "image").length;
+}
+
+export function assistantParts(content) {
+  const parts = { text: "", thinking: "", toolCalls: [] };
+  if (!Array.isArray(content)) return parts;
+
+  for (const block of content) {
+    if (block.type === "text") parts.text += stripTerminalControlSequences(block.text || "");
+    if (block.type === "thinking") parts.thinking += stripTerminalControlSequences(block.thinking || "");
+    if (block.type === "toolCall") {
+      parts.toolCalls.push({ id: block.id || "", name: block.name || "tool", arguments: block.arguments || {} });
+    }
+  }
+
+  return parts;
+}
+
+export function toDetailString(details) {
+  if (details == null) return "";
+  if (typeof details === "string") return details;
+  try {
+    return JSON.stringify(details, null, 2);
+  } catch {
+    return String(details);
+  }
+}

package/extensions/dm-phone/public/app/handlers.js

@@ -0,0 +1,442 @@
+import { contentToText } from "./formatters.js";
+import {
+  clearSnapshotView,
+  clearTransientState,
+  handleAssistantEvent,
+  renderMessages,
+  renderWidgets,
+  transformMessage,
+  upsertLiveTool,
+} from "./messages.js";
+import { closeSheet } from "./sheet-navigation.js";
+import { renderSheet } from "./sheets-view.js";
+import { state } from "./state.js";
+import { refreshAll, refreshQuota, sendRpc } from "./transport.js";
+import {
+  autoResizeTextarea,
+  clearUiModal,
+  openTokenModal,
+  openUiModalForRequest,
+  renderHeader,
+  resetToken,
+  showBanner,
+  showToast,
+} from "./ui.js";
+import { renderCommandSuggestions } from "./autocomplete-controller.js";
+import { renderAutocompleteItems } from "./autocomplete.js";
+
+export function handleAuthFailure() {
+  resetToken({ clearInput: true });
+  state.socket = null;
+  renderHeader();
+  openTokenModal();
+  showBanner("Access token required. Enter the current /phone-start token.", "error");
+}
+
+function sendUiResponse(payload) {
+  sendRpc({ type: "extension_ui_response", ...payload });
+  clearUiModal();
+}
+
+function handleExtensionUiRequest(request) {
+  if (request.method === "notify") {
+    showToast(request.message || "Notification");
+    return;
+  }
+
+  if (request.method === "setStatus") {
+    state.footerStatus = request.statusText || "";
+    renderWidgets();
+    return;
+  }
+
+  if (request.method === "setWidget") {
+    if (request.widgetLines?.length) state.widgets.set(request.widgetKey || "widget", request.widgetLines);
+    else state.widgets.delete(request.widgetKey || "widget");
+    renderWidgets();
+    return;
+  }
+
+  if (request.method === "setTitle") {
+    document.title = request.title || "DM Phone";
+    return;
+  }
+
+  if (request.method === "set_editor_text") {
+    const promptInput = document.querySelector("#prompt-input");
+    if (promptInput) promptInput.value = request.text || "";
+    autoResizeTextarea();
+    renderCommandSuggestions();
+    return;
+  }
+
+  if (!["select", "confirm", "input", "editor"].includes(request.method)) {
+    showToast(`Unsupported UI request: ${request.method || "unknown"}`);
+    return;
+  }
+
+  openUiModalForRequest(request, sendUiResponse);
+}
+
+function handleRpcPayload(payload) {
+  if (!payload) return;
+
+  if (payload.type === "response") {
+    if (!payload.success) {
+      if (payload.command === "path_suggestions") {
+        renderAutocompleteItems([]);
+        return;
+      }
+      showToast(payload.error || `Command failed: ${payload.command}`, "error");
+      return;
+    }
+
+    if (payload.command === "get_state") {
+      state.snapshotState = payload.data || state.snapshotState;
+      renderHeader();
+      void refreshQuota();
+      return;
+    }
+
+    if (payload.command === "get_messages") {
+      state.messages = (payload.data?.messages || []).flatMap(transformMessage);
+      clearTransientState();
+      renderMessages();
+      return;
+    }
+
+    if (payload.command === "get_commands") {
+      state.commands = payload.data?.commands || [];
+      renderCommandSuggestions();
+      renderSheet();
+      return;
+    }
+
+    if (payload.command === "path_suggestions") {
+      const context = state.autocompleteContext;
+      if (!context || context.type !== "path") return;
+      if (Number(payload.data?.requestId) !== state.autocompleteRemoteRequestId) return;
+      if (payload.data?.mode !== context.mode) return;
+      if ((payload.data?.query || "") !== context.query) return;
+
+      const suggestions = Array.isArray(payload.data?.suggestions) ? payload.data.suggestions : [];
+      renderAutocompleteItems(suggestions.map((suggestion) => ({
+        kind: "path",
+        label: context.mode === "mention" ? `@${suggestion.value}` : suggestion.value,
+        badge: suggestion.kind === "previous" ? "recent" : suggestion.isDirectory ? "dir" : "file",
+        description: suggestion.description || suggestion.value,
+        value: suggestion.value,
+        isDirectory: Boolean(suggestion.isDirectory),
+        title: suggestion.description || suggestion.value,
+      })));
+      return;
+    }
+
+    if (payload.command === "cd") {
+      showToast(`Changed directory to ${payload.data?.cwd || "the selected path"}.`);
+      refreshAll();
+      return;
+    }
+
+    if (payload.command === "get_available_models") {
+      state.models = payload.data?.models || [];
+      renderSheet();
+      return;
+    }
+
+    if (payload.command === "get_session_stats") {
+      state.stats = payload.data || null;
+      renderSheet();
+      return;
+    }
+
+    if (payload.command === "phone_list_sessions") {
+      state.sessions = payload.data?.sessions || [];
+      renderSheet();
+      return;
+    }
+
+    if (payload.command === "phone_get_tree") {
+      state.tree = payload.data || null;
+      renderSheet();
+      return;
+    }
+
+    if (payload.command === "new_parent_session") {
+      clearTransientState();
+      refreshAll();
+      showToast("Started a new parent session.");
+      return;
+    }
+
+    if (payload.command === "new_session") {
+      clearTransientState();
+      refreshAll();
+      showToast("Started a new DM session.");
+      return;
+    }
+
+    if (payload.command === "compact") {
+      showToast("Compaction triggered.");
+      refreshAll();
+      return;
+    }
+
+    if (payload.command === "slash_command") {
+      if (payload.data?.source === "extension") {
+        refreshAll({ forceQuota: true });
+      }
+      return;
+    }
+
+    if (payload.command === "reload") {
+      clearTransientState();
+      showToast("Reloaded extensions, skills, prompts, and themes.");
+      refreshAll({ forceQuota: true });
+      return;
+    }
+
+    if (payload.command === "set_model") {
+      showToast("Model updated.");
+      refreshAll();
+      return;
+    }
+
+    if (payload.command === "set_thinking_level") {
+      showToast("Thinking level updated.");
+      refreshAll();
+      return;
+    }
+
+    if (payload.command === "switch_session") {
+      showToast("Session switched.");
+      refreshAll();
+      closeSheet();
+      return;
+    }
+
+    if (payload.command === "fork") {
+      showToast("Fork created.");
+      refreshAll();
+      closeSheet();
+      return;
+    }
+
+    if (payload.command === "phone_open_branch_path") {
+      showToast("Opened selected branch path as a new session.");
+      refreshAll();
+      closeSheet();
+      return;
+    }
+
+    return;
+  }
+
+  if (payload.type === "agent_start") {
+    state.status = { ...(state.status || {}), isStreaming: true };
+    renderHeader();
+    return;
+  }
+
+  if (payload.type === "agent_end") {
+    state.status = { ...(state.status || {}), isStreaming: false };
+    renderHeader();
+    refreshAll({ forceQuota: true });
+    return;
+  }
+
+  if (payload.type === "message_update") {
+    handleAssistantEvent(payload.assistantMessageEvent);
+    return;
+  }
+
+  if (payload.type === "message_end" && payload.message?.role === "assistant") {
+    const transformed = transformMessage(payload.message, Date.now())[0];
+    if (transformed) {
+      state.liveAssistant = { ...transformed, live: false };
+      renderMessages();
+    }
+    return;
+  }
+
+  if (payload.type === "tool_execution_start") {
+    upsertLiveTool(payload.toolCallId, {
+      id: `tool-live-${payload.toolCallId}`,
+      kind: "tool",
+      toolCallId: payload.toolCallId,
+      toolName: payload.toolName || "tool",
+      args: payload.args || {},
+      command: payload.args?.command || "",
+      live: true,
+      title: payload.toolName || "tool",
+      text: JSON.stringify(payload.args || {}, null, 2),
+      meta: "Running…",
+      status: "running",
+      rawContent: null,
+    });
+    return;
+  }
+
+  if (payload.type === "tool_execution_update") {
+    upsertLiveTool(payload.toolCallId, {
+      ...(state.liveTools.get(payload.toolCallId) || {}),
+      id: `tool-live-${payload.toolCallId}`,
+      kind: "tool",
+      toolCallId: payload.toolCallId,
+      toolName: payload.toolName || "tool",
+      args: payload.args || state.liveTools.get(payload.toolCallId)?.args || {},
+      command: payload.args?.command || state.liveTools.get(payload.toolCallId)?.command || "",
+      live: true,
+      title: payload.toolName || "tool",
+      text: contentToText(payload.partialResult?.content) || JSON.stringify(payload.args || {}, null, 2),
+      meta: "Running…",
+      status: "running",
+      details: payload.partialResult?.details,
+      rawContent: payload.partialResult?.content || state.liveTools.get(payload.toolCallId)?.rawContent || null,
+    });
+    return;
+  }
+
+  if (payload.type === "tool_execution_end") {
+    upsertLiveTool(payload.toolCallId, {
+      ...(state.liveTools.get(payload.toolCallId) || {}),
+      id: `tool-live-${payload.toolCallId}`,
+      kind: "tool",
+      toolCallId: payload.toolCallId,
+      toolName: payload.toolName || "tool",
+      args: payload.args || state.liveTools.get(payload.toolCallId)?.args || {},
+      command: payload.args?.command || state.liveTools.get(payload.toolCallId)?.command || "",
+      live: false,
+      title: payload.toolName || "tool",
+      text: contentToText(payload.result?.content),
+      meta: payload.isError ? "Failed" : "Done",
+      status: payload.isError ? "error" : "done",
+      details: payload.result?.details,
+      rawContent: payload.result?.content || state.liveTools.get(payload.toolCallId)?.rawContent || null,
+    });
+    return;
+  }
+
+  if (payload.type === "extension_ui_request") {
+    handleExtensionUiRequest(payload);
+    return;
+  }
+
+  if (payload.type === "auto_retry_start") {
+    showBanner(`Retrying after error: ${payload.errorMessage || "temporary failure"}`);
+    return;
+  }
+
+  if (payload.type === "auto_retry_end") {
+    showBanner(payload.success ? "" : `Retry failed: ${payload.finalError || "Unknown error"}`, payload.success ? "info" : "error");
+  }
+}
+
+export async function handleEnvelope(event) {
+  if (event.channel === "sessions" && event.event === "catalog") {
+    const nextActiveSessionId = event.data?.activeSessionId || state.activeSessionId;
+    const activeSessionChanged = nextActiveSessionId !== state.activeSessionId;
+
+    state.activeSessions = event.data?.sessions || [];
+    state.activeSessionId = nextActiveSessionId;
+
+    if (activeSessionChanged && state.snapshotWorkerId && state.snapshotWorkerId !== state.activeSessionId) {
+      clearSnapshotView();
+      renderMessages();
+    }
+
+    renderHeader();
+    renderSheet();
+    return;
+  }
+
+  if (event.channel === "snapshot") {
+    if (event.sessionWorkerId && state.activeSessionId && event.sessionWorkerId !== state.activeSessionId) {
+      return;
+    }
+
+    state.snapshotState = event.state || null;
+    state.snapshotWorkerId = event.sessionWorkerId || state.activeSessionId || null;
+    state.status = { ...(state.status || {}), isStreaming: Boolean(event.state?.isStreaming) };
+    state.messages = (event.messages || []).flatMap(transformMessage);
+    state.commands = event.commands || state.commands;
+    clearTransientState();
+
+    if (event.liveAssistantMessage?.role === "assistant") {
+      const assistant = transformMessage(event.liveAssistantMessage, Date.now())[0];
+      if (assistant) {
+        state.liveAssistant = { ...assistant, id: "assistant-live", live: true };
+      }
+    }
+
+    for (const tool of event.liveTools || []) {
+      const text =
+        contentToText(tool.result?.content)
+        || contentToText(tool.partialResult?.content)
+        || JSON.stringify(tool.args || {}, null, 2);
+
+      state.liveTools.set(tool.toolCallId, {
+        id: `tool-live-${tool.toolCallId}`,
+        kind: "tool",
+        toolCallId: tool.toolCallId,
+        toolName: tool.toolName || "tool",
+        args: tool.args || {},
+        command: tool.args?.command || "",
+        live: !tool.result,
+        title: tool.toolName || "tool",
+        text,
+        meta: tool.result ? (tool.isError ? "Failed" : "Done") : "Running…",
+        details: tool.result?.details || tool.partialResult?.details,
+        status: tool.isError ? "error" : (tool.result ? "done" : "running"),
+        rawContent: tool.result?.content || tool.partialResult?.content || null,
+      });
+    }
+
+    renderHeader();
+    renderMessages();
+    renderSheet();
+    renderCommandSuggestions();
+    void refreshQuota();
+    return;
+  }
+
+  if (event.channel === "server") {
+    if (event.event === "status") {
+      state.status = event.data;
+      renderHeader();
+      return;
+    }
+    if (event.event === "stderr") {
+      showBanner(event.data?.text?.trim() || "", "error");
+      return;
+    }
+    if (event.event === "reloading") {
+      showBanner(event.data?.message || "");
+      return;
+    }
+    if (event.event === "session-spawned") {
+      showToast(event.data?.message || "Opened new parallel session.");
+      return;
+    }
+    if (event.event === "single-client-replaced") {
+      showBanner(event.data?.message || "This phone session was replaced by another client.", "error");
+      return;
+    }
+    if (event.event === "idle-timeout") {
+      showBanner(event.data?.message || "DM Phone stopped because it was idle.", "error");
+      return;
+    }
+    if (["startup-error", "snapshot-error", "client-error"].includes(event.event)) {
+      showToast(event.data?.message || "Server error", "error");
+      return;
+    }
+    if (event.event === "agent-exit") {
+      showBanner(event.data?.message || "DM rpc exited.", "error");
+      return;
+    }
+  }
+
+  if (event.channel === "rpc") {
+    handleRpcPayload(event.payload);
+  }
+}

package/extensions/dm-phone/public/app/main.js

@@ -0,0 +1,6 @@
+import { initializeBindings } from "./bindings.js";
+import { handleAuthFailure, handleEnvelope } from "./handlers.js";
+import { boot } from "./transport.js";
+
+initializeBindings({ handleEnvelope, handleAuthFailure });
+boot({ handleEnvelope, handleAuthFailure });

package/extensions/dm-phone/public/app/markdown.js

@@ -0,0 +1,105 @@
+import { escapeHtml } from "./formatters.js";
+
+function findInlineCodeMarker(text, startIndex = 0) {
+  for (let index = Math.max(0, startIndex); index < text.length; index += 1) {
+    if (text[index] !== "`") continue;
+    if (text[index - 1] === "`" || text[index + 1] === "`") continue;
+    return index;
+  }
+  return -1;
+}
+
+function renderStrongText(text = "") {
+  let html = "";
+  let cursor = 0;
+
+  while (cursor < text.length) {
+    const open = text.indexOf("**", cursor);
+    if (open === -1) {
+      html += escapeHtml(text.slice(cursor));
+      break;
+    }
+
+    const close = text.indexOf("**", open + 2);
+    if (close === -1) {
+      html += escapeHtml(text.slice(cursor));
+      break;
+    }
+
+    html += escapeHtml(text.slice(cursor, open));
+    html += `<strong>${escapeHtml(text.slice(open + 2, close))}</strong>`;
+    cursor = close + 2;
+  }
+
+  return html;
+}
+
+function renderInlineMarkdown(text = "") {
+  let html = "";
+  let cursor = 0;
+
+  while (cursor < text.length) {
+    const open = findInlineCodeMarker(text, cursor);
+    if (open === -1) {
+      html += renderStrongText(text.slice(cursor));
+      break;
+    }
+
+    const close = findInlineCodeMarker(text, open + 1);
+    if (close === -1) {
+      html += renderStrongText(text.slice(cursor));
+      break;
+    }
+
+    html += renderStrongText(text.slice(cursor, open));
+    html += `<code>${escapeHtml(text.slice(open + 1, close))}</code>`;
+    cursor = close + 1;
+  }
+
+  return html;
+}
+
+function renderTextBlocks(text = "") {
+  const blocks = text
+    .split(/\n{2,}/)
+    .map((block) => (block.trim() ? `<p>${renderInlineMarkdown(block)}</p>` : ""))
+    .filter(Boolean);
+
+  if (blocks.length) return blocks.join("");
+  return text.trim() ? `<p>${renderInlineMarkdown(text)}</p>` : "";
+}
+
+function renderCodeBlock(code = "") {
+  return `
+    <pre class="message-code-block"><code>${escapeHtml(code)}</code></pre>
+  `;
+}
+
+export function renderMarkdownLite(text = "") {
+  const normalized = String(text || "").replace(/\r\n?/g, "\n");
+  const fencePattern = /```([^`\n]*)\n([\s\S]*?)```/g;
+  const parts = [];
+  let cursor = 0;
+  let match;
+
+  while ((match = fencePattern.exec(normalized))) {
+    if (match.index > cursor) {
+      parts.push({ type: "text", value: normalized.slice(cursor, match.index) });
+    }
+
+    parts.push({ type: "code", value: match[2].replace(/\n$/, "") });
+    cursor = match.index + match[0].length;
+  }
+
+  if (cursor < normalized.length) {
+    parts.push({ type: "text", value: normalized.slice(cursor) });
+  }
+
+  const html = parts.map((part) => (
+    part.type === "code"
+      ? renderCodeBlock(part.value)
+      : renderTextBlocks(part.value)
+  )).join("");
+
+  return html || '<p><span class="label">(no text)</span></p>';
+}