@duckmind/dm-darwin-x64 0.13.6 → 0.13.8

package/extensions/dm-phone/node_modules/ws/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "ws",
+  "version": "8.20.0",
+  "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
+  "keywords": [
+    "HyBi",
+    "Push",
+    "RFC-6455",
+    "WebSocket",
+    "WebSockets",
+    "real-time"
+  ],
+  "homepage": "https://github.com/websockets/ws",
+  "bugs": "https://github.com/websockets/ws/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/websockets/ws.git"
+  },
+  "author": "Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)",
+  "license": "MIT",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "browser": "./browser.js",
+      "import": "./wrapper.mjs",
+      "require": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "browser": "browser.js",
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "files": [
+    "browser.js",
+    "index.js",
+    "lib/*.js",
+    "wrapper.mjs"
+  ],
+  "scripts": {
+    "test": "nyc --reporter=lcov --reporter=text mocha --throw-deprecation test/*.test.js",
+    "integration": "mocha --throw-deprecation test/*.integration.js",
+    "lint": "eslint . && prettier --check --ignore-path .gitignore \"**/*.{json,md,yaml,yml}\""
+  },
+  "peerDependencies": {
+    "bufferutil": "^4.0.1",
+    "utf-8-validate": ">=5.0.2"
+  },
+  "peerDependenciesMeta": {
+    "bufferutil": {
+      "optional": true
+    },
+    "utf-8-validate": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "benchmark": "^2.1.4",
+    "bufferutil": "^4.0.1",
+    "eslint": "^10.0.1",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.0.0",
+    "globals": "^17.0.0",
+    "mocha": "^8.4.0",
+    "nyc": "^15.0.0",
+    "prettier": "^3.0.0",
+    "utf-8-validate": "^6.0.0"
+  }
+}

package/extensions/dm-phone/node_modules/ws/wrapper.mjs

@@ -0,0 +1,21 @@
+import createWebSocketStream from './lib/stream.js';
+import extension from './lib/extension.js';
+import PerMessageDeflate from './lib/permessage-deflate.js';
+import Receiver from './lib/receiver.js';
+import Sender from './lib/sender.js';
+import subprotocol from './lib/subprotocol.js';
+import WebSocket from './lib/websocket.js';
+import WebSocketServer from './lib/websocket-server.js';
+
+export {
+  createWebSocketStream,
+  extension,
+  PerMessageDeflate,
+  Receiver,
+  Sender,
+  subprotocol,
+  WebSocket,
+  WebSocketServer
+};
+
+export default WebSocket;

package/extensions/dm-phone/package-lock.json

@@ -0,0 +1,66 @@
+{
+  "name": "dm-phone",
+  "version": "0.0.13",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "dm-phone",
+      "version": "0.0.13",
+      "dependencies": {
+        "ws": "^8.18.3"
+      },
+      "devDependencies": {
+        "@types/ws": "^8.18.1"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "25.6.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.6.0.tgz",
+      "integrity": "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.19.0"
+      }
+    },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.19.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.19.2.tgz",
+      "integrity": "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/ws": {
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
+      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

package/extensions/dm-phone/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "dm-phone",
+  "version": "0.0.13",
+  "description": "Phone-first remote UI extension for DM with Tailscale-friendly access",
+  "type": "module",
+  "keywords": [
+    "duckmind",
+    "dm",
+    "extension",
+    "phone",
+    "mobile",
+    "tailscale"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "index.ts",
+    "phone-session-pool.ts",
+    "src",
+    "public",
+    "README.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "dependencies": {
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1"
+  }
+}

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

@@ -0,0 +1,8 @@
+export { PhoneSessionPool } from "./src/session-pool/session-pool";
+export { PhoneSessionWorker } from "./src/session-pool/session-worker";
+export type {
+  PhoneSessionPoolOptions,
+  SessionSnapshot,
+  SessionSummary,
+  SessionWorkerOptions,
+} from "./src/session-pool/types";

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

@@ -0,0 +1,233 @@
+import { insertTextAtCursor } from "./autocomplete.js";
+import { escapeHtml, formatBytes } from "./formatters.js";
+import { el, state } from "./state.js";
+import { autoResizeTextarea, scheduleComposerLayoutSync } from "./ui.js";
+
+function currentPromptText() {
+  return String(el.promptInput?.value || "");
+}
+
+function createAttachmentRecord(file) {
+  const tokenOrder = state.nextAttachmentTokenId || 1;
+  state.nextAttachmentTokenId = tokenOrder + 1;
+
+  return {
+    id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    file,
+    name: file.name,
+    size: file.size,
+    type: file.type,
+    url: URL.createObjectURL(file),
+    token: `⟦img${tokenOrder}⟧`,
+    tokenOrder,
+  };
+}
+
+function orderedAttachments(promptText = currentPromptText()) {
+  return [...state.attachments].sort((left, right) => {
+    const leftIndex = promptText.indexOf(left.token);
+    const rightIndex = promptText.indexOf(right.token);
+    const leftMissing = leftIndex === -1;
+    const rightMissing = rightIndex === -1;
+
+    if (leftMissing !== rightMissing) return leftMissing ? 1 : -1;
+    if (!leftMissing && leftIndex !== rightIndex) return leftIndex - rightIndex;
+    return (left.tokenOrder || 0) - (right.tokenOrder || 0);
+  });
+}
+
+function disposeAttachment(attachment) {
+  if (attachment?.url) {
+    URL.revokeObjectURL(attachment.url);
+  }
+}
+
+function disposeAttachments(attachments = []) {
+  for (const attachment of attachments) {
+    disposeAttachment(attachment);
+  }
+}
+
+function buildTokenInsertion(tokens) {
+  if (!tokens.length) return "";
+
+  const value = currentPromptText();
+  const start = el.promptInput.selectionStart ?? value.length;
+  const end = el.promptInput.selectionEnd ?? start;
+  const beforeChar = start > 0 ? value[start - 1] : "";
+  const afterChar = end < value.length ? value[end] : "";
+  const needsLeadingSpace = beforeChar && !/\s/.test(beforeChar);
+  const needsTrailingSpace = !afterChar || !/\s/.test(afterChar);
+
+  return `${needsLeadingSpace ? " " : ""}${tokens.join(" ")}${needsTrailingSpace ? " " : ""}`;
+}
+
+function stripTokenFromPrompt(token) {
+  const value = currentPromptText();
+  if (!token || !value.includes(token)) return false;
+
+  const selectionStart = el.promptInput.selectionStart ?? value.length;
+  const selectionEnd = el.promptInput.selectionEnd ?? selectionStart;
+  let nextText = "";
+  let nextSelectionStart = selectionStart;
+  let nextSelectionEnd = selectionEnd;
+  let offset = 0;
+
+  while (offset < value.length) {
+    const index = value.indexOf(token, offset);
+    if (index === -1) break;
+
+    nextText += value.slice(offset, index);
+
+    if (index < nextSelectionStart) {
+      nextSelectionStart -= Math.min(token.length, nextSelectionStart - index);
+    }
+    if (index < nextSelectionEnd) {
+      nextSelectionEnd -= Math.min(token.length, nextSelectionEnd - index);
+    }
+
+    offset = index + token.length;
+  }
+
+  nextText += value.slice(offset);
+  if (nextText === value) return false;
+
+  el.promptInput.value = nextText;
+  const clampedStart = Math.max(0, Math.min(nextText.length, nextSelectionStart));
+  const clampedEnd = Math.max(clampedStart, Math.min(nextText.length, nextSelectionEnd));
+  el.promptInput.focus();
+  el.promptInput.setSelectionRange(clampedStart, clampedEnd);
+  autoResizeTextarea();
+  return true;
+}
+
+export function renderAttachmentStrip() {
+  const attachments = orderedAttachments();
+  if (!attachments.length) {
+    el.attachmentStrip.classList.add("hidden");
+    el.attachmentStrip.innerHTML = "";
+    scheduleComposerLayoutSync();
+    return;
+  }
+
+  el.attachmentStrip.innerHTML = attachments.map((attachment) => `
+    <article class="attachment-chip">
+      <img src="${attachment.url}" alt="${escapeHtml(attachment.name)}" />
+      <div class="attachment-chip-header">
+        <div class="attachment-chip-token mono">${escapeHtml(attachment.token)}</div>
+        <button class="attachment-chip-remove" data-remove-attachment="${attachment.id}" aria-label="Remove image ${escapeHtml(attachment.token)}">✕</button>
+      </div>
+      <div class="attachment-chip-name">${escapeHtml(attachment.name)}</div>
+      <div class="attachment-chip-meta">${escapeHtml(formatBytes(attachment.size))}</div>
+    </article>
+  `).join("");
+  el.attachmentStrip.classList.remove("hidden");
+  scheduleComposerLayoutSync();
+}
+
+export function addAttachments(files) {
+  const incoming = Array.from(files || []).filter((file) => file.type.startsWith("image/"));
+  if (!incoming.length) return;
+
+  const added = incoming.map((file) => createAttachmentRecord(file));
+  state.attachments.push(...added);
+
+  const insertion = buildTokenInsertion(added.map((attachment) => attachment.token));
+  if (insertion) {
+    insertTextAtCursor(insertion);
+  }
+
+  syncAttachmentsWithPrompt();
+  renderAttachmentStrip();
+}
+
+export function removeAttachment(id) {
+  const index = state.attachments.findIndex((attachment) => attachment.id === id);
+  if (index === -1) return;
+
+  const [removed] = state.attachments.splice(index, 1);
+  stripTokenFromPrompt(removed.token);
+  disposeAttachment(removed);
+  renderAttachmentStrip();
+}
+
+export function clearAttachments(options = {}) {
+  if (options.removeTokensFromPrompt) {
+    for (const attachment of state.attachments) {
+      stripTokenFromPrompt(attachment.token);
+    }
+  }
+
+  disposeAttachments(state.attachments);
+  state.attachments = [];
+  renderAttachmentStrip();
+}
+
+function fileToBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = String(reader.result || "");
+      const base64 = result.includes(",") ? result.split(",")[1] : result;
+      resolve(base64);
+    };
+    reader.onerror = () => reject(reader.error || new Error(`Failed to read ${file.name}`));
+    reader.readAsDataURL(file);
+  });
+}
+
+export function syncAttachmentsWithPrompt() {
+  if (!state.attachments.length) return [];
+
+  const promptText = currentPromptText();
+  const kept = [];
+  const removed = [];
+
+  for (const attachment of state.attachments) {
+    if (promptText.includes(attachment.token)) {
+      kept.push(attachment);
+    } else {
+      removed.push(attachment);
+    }
+  }
+
+  if (removed.length) {
+    disposeAttachments(removed);
+    state.attachments = kept;
+  }
+
+  renderAttachmentStrip();
+  return removed;
+}
+
+function attachmentOccurrences(promptText = currentPromptText()) {
+  const matches = [];
+
+  for (const attachment of state.attachments) {
+    let offset = 0;
+    while (offset <= promptText.length) {
+      const index = promptText.indexOf(attachment.token, offset);
+      if (index === -1) break;
+      matches.push({ index, attachment });
+      offset = index + attachment.token.length;
+    }
+  }
+
+  matches.sort((left, right) => left.index - right.index || (left.attachment.tokenOrder || 0) - (right.attachment.tokenOrder || 0));
+  return matches.map((match) => match.attachment);
+}
+
+export async function buildPromptPayload(promptText = currentPromptText()) {
+  const rawPrompt = String(promptText || "");
+  const attachments = attachmentOccurrences(rawPrompt);
+
+  const images = await Promise.all(
+    attachments.map(async (attachment) => ({
+      type: "image",
+      data: await fileToBase64(attachment.file),
+      mimeType: attachment.type || "image/png",
+    })),
+  );
+
+  return { message: rawPrompt, images };
+}

package/extensions/dm-phone/public/app/autocomplete-controller.js

@@ -0,0 +1,81 @@
+import {
+  clearAutocompleteSuggestions,
+  detectCdAutocompleteContext,
+  detectMentionAutocompleteContext,
+  detectSlashCommandAutocompleteContext,
+  renderAutocompleteItems,
+} from "./autocomplete.js";
+import { visibleCommandCatalog } from "./command-catalog.js";
+import { el, state } from "./state.js";
+import { sendLocalCommand } from "./transport.js";
+
+function activeAutocompleteContext() {
+  const value = el.promptInput.value || "";
+  const cursor = el.promptInput.selectionStart ?? value.length;
+
+  const mention = detectMentionAutocompleteContext(value, cursor);
+  if (mention) return mention;
+
+  const cd = detectCdAutocompleteContext(value, cursor);
+  if (cd) return cd;
+
+  const slash = detectSlashCommandAutocompleteContext(value, cursor);
+  if (slash) return slash;
+
+  return null;
+}
+
+function requestPathSuggestions(context) {
+  if (state.socket?.readyState !== WebSocket.OPEN) {
+    renderAutocompleteItems([]);
+    return;
+  }
+
+  const requestId = ++state.autocompleteRemoteRequestId;
+  sendLocalCommand({
+    type: "path-suggestions",
+    mode: context.mode,
+    query: context.query,
+    requestId,
+  });
+}
+
+function queuePathSuggestions(context) {
+  if (state.autocompleteRemoteTimer) {
+    clearTimeout(state.autocompleteRemoteTimer);
+  }
+
+  state.autocompleteRemoteTimer = setTimeout(() => {
+    state.autocompleteRemoteTimer = null;
+    requestPathSuggestions(context);
+  }, 90);
+}
+
+export function renderCommandSuggestions() {
+  const context = activeAutocompleteContext();
+  state.autocompleteContext = context;
+
+  if (!context) {
+    clearAutocompleteSuggestions();
+    return;
+  }
+
+  if (context.type === "slash-command") {
+    const matches = visibleCommandCatalog()
+      .filter((command) => command.name.toLowerCase().startsWith(context.query.toLowerCase()))
+      .slice(0, 10)
+      .map((command) => ({
+        kind: command.source === "local" ? (command.insertOnly ? "local-command-insert" : "local-command-run") : "remote-command-insert",
+        label: `/${command.name}`,
+        badge: command.source || "command",
+        description: command.description || "",
+        name: command.name,
+      }));
+
+    renderAutocompleteItems(matches);
+    return;
+  }
+
+  renderAutocompleteItems([]);
+  queuePathSuggestions(context);
+}

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

@@ -0,0 +1,135 @@
+import { AUTOCOMPLETE_DELIMITERS } from "./constants.js";
+import { el, state } from "./state.js";
+import { escapeAttribute, escapeHtml } from "./formatters.js";
+import { autoResizeTextarea, scheduleComposerLayoutSync } from "./ui.js";
+
+export function clearAutocompleteSuggestions() {
+  if (state.autocompleteRemoteTimer) {
+    clearTimeout(state.autocompleteRemoteTimer);
+    state.autocompleteRemoteTimer = null;
+  }
+  state.autocompleteContext = null;
+  state.autocompleteItems = [];
+  el.commandStrip.classList.add("hidden");
+  el.commandStrip.innerHTML = "";
+  scheduleComposerLayoutSync();
+}
+
+export function renderAutocompleteItems(items = []) {
+  state.autocompleteItems = items;
+
+  if (!items.length) {
+    el.commandStrip.classList.add("hidden");
+    el.commandStrip.innerHTML = "";
+    scheduleComposerLayoutSync();
+    return;
+  }
+
+  el.commandStrip.innerHTML = items.map((item, index) => `
+    <button class="command-chip secondary" data-autocomplete-index="${index}" title="${escapeAttribute(item.title || item.description || item.label || "")}">
+      <span>${escapeHtml(item.label || "")}</span>
+      <span class="source">${escapeHtml(item.badge || "")}</span>
+    </button>
+  `).join("");
+  el.commandStrip.classList.remove("hidden");
+  scheduleComposerLayoutSync();
+}
+
+function delimiterBeforeIndex(text, index) {
+  return index <= 0 || AUTOCOMPLETE_DELIMITERS.has(text[index - 1]);
+}
+
+function findTokenBounds(text, start, end) {
+  let tokenStart = start;
+  let tokenEnd = end;
+
+  while (tokenStart > 0 && !AUTOCOMPLETE_DELIMITERS.has(text[tokenStart - 1])) {
+    tokenStart -= 1;
+  }
+  while (tokenEnd < text.length && !AUTOCOMPLETE_DELIMITERS.has(text[tokenEnd])) {
+    tokenEnd += 1;
+  }
+
+  return { start: tokenStart, end: tokenEnd };
+}
+
+export function detectMentionAutocompleteContext(text, cursor) {
+  const scanLimit = Math.min(cursor, text.length);
+  let tokenStart = scanLimit;
+  while (tokenStart > 0 && !AUTOCOMPLETE_DELIMITERS.has(text[tokenStart - 1])) {
+    tokenStart -= 1;
+  }
+
+  if (text[tokenStart] !== "@") return null;
+  if (!delimiterBeforeIndex(text, tokenStart)) return null;
+
+  const bounds = findTokenBounds(text, tokenStart, cursor);
+  return {
+    type: "path",
+    mode: "mention",
+    query: text.slice(tokenStart + 1, cursor),
+    replaceStart: bounds.start,
+    replaceEnd: bounds.end,
+  };
+}
+
+export function detectCdAutocompleteContext(text, cursor) {
+  const leadingWhitespace = text.match(/^\s*/)?.[0] || "";
+  const trimmed = text.slice(leadingWhitespace.length);
+  if (!trimmed.startsWith("/cd")) return null;
+
+  const afterCommand = trimmed.slice(3);
+  if (afterCommand && !/^\s/.test(afterCommand)) return null;
+
+  const commandStart = leadingWhitespace.length;
+  const argsStart = commandStart + 3 + (afterCommand.match(/^\s*/) || [""])[0].length;
+  if (cursor < argsStart) return null;
+
+  return {
+    type: "path",
+    mode: "cd",
+    query: text.slice(argsStart, cursor),
+    replaceStart: argsStart,
+    replaceEnd: text.length,
+  };
+}
+
+export function detectSlashCommandAutocompleteContext(text, cursor) {
+  const leadingWhitespace = text.match(/^\s*/)?.[0] || "";
+  const trimmedBeforeCursor = text.slice(leadingWhitespace.length, cursor);
+  if (!trimmedBeforeCursor.startsWith("/")) return null;
+  if (/\s/.test(trimmedBeforeCursor.slice(1))) return null;
+
+  return {
+    type: "slash-command",
+    query: trimmedBeforeCursor.slice(1),
+  };
+}
+
+export function replacePromptRange(start, end, nextText) {
+  const value = el.promptInput.value;
+  el.promptInput.value = `${value.slice(0, start)}${nextText}${value.slice(end)}`;
+  const nextCursor = start + nextText.length;
+  el.promptInput.focus();
+  el.promptInput.setSelectionRange(nextCursor, nextCursor);
+  autoResizeTextarea();
+}
+
+export function insertTextAtCursor(text) {
+  const start = el.promptInput.selectionStart ?? el.promptInput.value.length;
+  const end = el.promptInput.selectionEnd ?? start;
+  replacePromptRange(start, end, text);
+}
+
+export function insertCdCommand() {
+  const value = el.promptInput.value;
+  if (!value.trim()) {
+    el.promptInput.value = "/cd ";
+    el.promptInput.focus();
+    el.promptInput.setSelectionRange(4, 4);
+    autoResizeTextarea();
+    return;
+  }
+
+  insertTextAtCursor("/cd ");
+}