@duckmind/dm-darwin-arm64 0.13.6 → 0.13.8

package/extensions/dm-phone/public/sw.js

@@ -0,0 +1,78 @@
+const CACHE = "dm-phone-v17";
+const ASSETS = [
+  "/",
+  "/styles.css",
+  "/app.js",
+  "/app/attachments.js",
+  "/app/autocomplete-controller.js",
+  "/app/autocomplete.js",
+  "/app/bindings.js",
+  "/app/command-catalog.js",
+  "/app/commands.js",
+  "/app/constants.js",
+  "/app/formatters.js",
+  "/app/handlers.js",
+  "/app/main.js",
+  "/app/markdown.js",
+  "/app/messages.js",
+  "/app/sheet-actions.js",
+  "/app/sheet-navigation.js",
+  "/app/sheets-view.js",
+  "/app/state.js",
+  "/app/tool-rendering.js",
+  "/app/transport.js",
+  "/app/ui.js",
+  "/manifest.webmanifest",
+  "/icon.svg",
+];
+const APP_SHELL = new Set(ASSETS);
+
+self.addEventListener("install", (event) => {
+  event.waitUntil(caches.open(CACHE).then((cache) => cache.addAll(ASSETS)));
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(
+    caches.keys().then((keys) => Promise.all(keys.filter((key) => key !== CACHE).map((key) => caches.delete(key)))),
+  );
+  self.clients.claim();
+});
+
+async function updateCache(request) {
+  const response = await fetch(request);
+  if (response.ok) {
+    const copy = response.clone();
+    caches.open(CACHE).then((cache) => cache.put(request, copy));
+  }
+  return response;
+}
+
+self.addEventListener("fetch", (event) => {
+  const { request } = event;
+  if (request.method !== "GET") return;
+
+  const url = new URL(request.url);
+  if (url.origin !== self.location.origin) return;
+  if (url.pathname.startsWith("/api/") || url.pathname === "/ws") return;
+
+  const useNetworkFirst = request.mode === "navigate" || APP_SHELL.has(url.pathname);
+
+  if (useNetworkFirst) {
+    event.respondWith(
+      updateCache(request).catch(async () => {
+        const cached = await caches.match(request);
+        if (cached) return cached;
+        return caches.match("/");
+      }),
+    );
+    return;
+  }
+
+  event.respondWith(
+    caches.match(request).then((cached) => {
+      if (cached) return cached;
+      return updateCache(request);
+    }),
+  );
+});

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

@@ -0,0 +1,121 @@
+import { resolve } from "node:path";
+import type { ParsedPhoneArgs, PhoneConfig } from "./types";
+
+export function parsePhoneStartArgs(args: string | undefined, current: PhoneConfig): ParsedPhoneArgs {
+  const next = { ...current };
+  let tokenSpecified = false;
+  let idleSpecified = false;
+
+  if (!args?.trim()) {
+    return { config: next, tokenSpecified, idleSpecified };
+  }
+
+  const tokens = args.trim().split(/\s+/);
+  let index = 0;
+
+  while (index < tokens.length) {
+    const token = tokens[index];
+
+    if (token === "--port" && tokens[index + 1]) {
+      const port = Number(tokens[index + 1]);
+      if (Number.isFinite(port) && port > 0) next.port = port;
+      index += 2;
+      continue;
+    }
+
+    if (token.startsWith("--port=")) {
+      const port = Number(token.slice(7));
+      if (Number.isFinite(port) && port > 0) next.port = port;
+      index += 1;
+      continue;
+    }
+
+    if (token === "--host" && tokens[index + 1]) {
+      next.host = tokens[index + 1];
+      index += 2;
+      continue;
+    }
+
+    if (token.startsWith("--host=")) {
+      next.host = token.slice(7);
+      index += 1;
+      continue;
+    }
+
+    if (token === "--token" && tokens[index + 1] !== undefined) {
+      tokenSpecified = true;
+      next.token = tokens[index + 1] === "-" ? "" : tokens[index + 1];
+      index += 2;
+      continue;
+    }
+
+    if (token.startsWith("--token=")) {
+      tokenSpecified = true;
+      const value = token.slice(8);
+      next.token = value === "-" ? "" : value;
+      index += 1;
+      continue;
+    }
+
+    if (token === "--cwd" && tokens[index + 1]) {
+      next.cwd = resolve(tokens[index + 1]);
+      index += 2;
+      continue;
+    }
+
+    if (token.startsWith("--cwd=")) {
+      next.cwd = resolve(token.slice(6));
+      index += 1;
+      continue;
+    }
+
+    if (token === "--idle-mins" && tokens[index + 1] !== undefined) {
+      idleSpecified = true;
+      const minutes = Number(tokens[index + 1]);
+      if (Number.isFinite(minutes) && minutes >= 0) next.idleTimeoutMs = Math.round(minutes * 60_000);
+      index += 2;
+      continue;
+    }
+
+    if (token.startsWith("--idle-mins=")) {
+      idleSpecified = true;
+      const minutes = Number(token.slice(12));
+      if (Number.isFinite(minutes) && minutes >= 0) next.idleTimeoutMs = Math.round(minutes * 60_000);
+      index += 1;
+      continue;
+    }
+
+    if (token === "--idle-secs" && tokens[index + 1] !== undefined) {
+      idleSpecified = true;
+      const seconds = Number(tokens[index + 1]);
+      if (Number.isFinite(seconds) && seconds >= 0) next.idleTimeoutMs = Math.round(seconds * 1_000);
+      index += 2;
+      continue;
+    }
+
+    if (token.startsWith("--idle-secs=")) {
+      idleSpecified = true;
+      const seconds = Number(token.slice(12));
+      if (Number.isFinite(seconds) && seconds >= 0) next.idleTimeoutMs = Math.round(seconds * 1_000);
+      index += 1;
+      continue;
+    }
+
+    if (/^\d+$/.test(token)) {
+      next.port = Number(token);
+      index += 1;
+      continue;
+    }
+
+    if (!token.startsWith("--") && next.token === current.token) {
+      tokenSpecified = true;
+      next.token = token === "-" ? "" : token;
+      index += 1;
+      continue;
+    }
+
+    index += 1;
+  }
+
+  return { config: next, tokenSpecified, idleSpecified };
+}

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

@@ -0,0 +1,250 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import type { PhonePathSuggestion, PhonePathSuggestionMode } from "./types";
+
+const agentDirFromEnv = process.env.DM_CODING_AGENT_DIR?.trim() || process.env.PI_CODING_AGENT_DIR?.trim();
+const agentDir = agentDirFromEnv
+  ? agentDirFromEnv
+  : join(process.env.HOME || process.env.USERPROFILE || process.cwd(), ".dm", "agent");
+
+const PATH_SUGGESTION_LIMIT = 20;
+const PATH_SUGGESTION_MAX_RESULTS = 100;
+
+function resolveFdBinaryPath(): string | null {
+  const bundledFd = join(agentDir, "bin", "fd");
+  if (existsSync(bundledFd)) return bundledFd;
+
+  for (const candidate of ["fd", "fdfind"]) {
+    const result = spawnSync(candidate, ["--version"], { stdio: "ignore" });
+    if (!result.error && result.status === 0) return candidate;
+  }
+
+  return null;
+}
+
+const fdBinaryPath = resolveFdBinaryPath();
+
+function stripWrappingQuotes(value: string): string {
+  const trimmed = value.trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"'))
+    || (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function expandHomePath(value: string): string {
+  if (value === "~") return homedir();
+  if (value.startsWith("~/")) return join(homedir(), value.slice(2));
+  return value;
+}
+
+export function resolvePhoneCdTargetPath(rawArgs: string | undefined, currentCwd: string, previousCwd?: string | null): string {
+  const input = stripWrappingQuotes(rawArgs ?? "").trim();
+
+  if (!input) return homedir();
+  if (input === "-") {
+    if (!previousCwd) {
+      throw new Error("No previous directory available yet.");
+    }
+    return previousCwd;
+  }
+
+  const expanded = expandHomePath(input);
+  return resolve(currentCwd, expanded);
+}
+
+function createCdPathSuggestions(prefix: string, currentCwd: string, previousCwd?: string | null): PhonePathSuggestion[] {
+  const raw = prefix ?? "";
+  const trimmed = raw.trimStart();
+  const suggestions: PhonePathSuggestion[] = [];
+
+  if ("-".startsWith(trimmed)) {
+    suggestions.push({
+      value: "-",
+      label: "-",
+      description: previousCwd || "Previous directory",
+      isDirectory: true,
+      kind: "previous",
+    });
+  }
+
+  const expanded = expandHomePath(trimmed);
+  const endsWithSeparator = /[\\/]$/.test(expanded);
+  const resolvedInput = expanded ? resolve(currentCwd, expanded) : currentCwd;
+
+  const baseDir = expanded
+    ? endsWithSeparator
+      ? resolvedInput
+      : dirname(resolvedInput)
+    : currentCwd;
+
+  const partial = expanded && !endsWithSeparator ? basename(expanded) : "";
+  const valuePrefix = trimmed
+    ? endsWithSeparator
+      ? trimmed
+      : trimmed.slice(0, Math.max(0, trimmed.length - partial.length))
+    : "";
+
+  try {
+    if (!existsSync(baseDir) || !statSync(baseDir).isDirectory()) {
+      return suggestions.slice(0, PATH_SUGGESTION_LIMIT);
+    }
+
+    const directories = readdirSync(baseDir, { withFileTypes: true })
+      .filter((entry) => {
+        if (entry.isDirectory()) return true;
+        if (!entry.isSymbolicLink()) return false;
+        try {
+          return statSync(join(baseDir, entry.name)).isDirectory();
+        } catch {
+          return false;
+        }
+      })
+      .filter((entry) => !partial || entry.name.startsWith(partial))
+      .sort((left, right) => left.name.localeCompare(right.name));
+
+    for (const entry of directories.slice(0, PATH_SUGGESTION_LIMIT)) {
+      suggestions.push({
+        value: `${valuePrefix}${entry.name}/`,
+        label: `${entry.name}/`,
+        description: join(baseDir, entry.name),
+        isDirectory: true,
+        kind: "path",
+      });
+    }
+  } catch {
+    return suggestions.slice(0, PATH_SUGGESTION_LIMIT);
+  }
+
+  return suggestions.slice(0, PATH_SUGGESTION_LIMIT);
+}
+
+function resolveScopedMentionQuery(rawQuery: string, currentCwd: string): { baseDir: string; query: string; displayBase: string } | null {
+  const slashIndex = rawQuery.lastIndexOf("/");
+  if (slashIndex === -1) return null;
+
+  const displayBase = rawQuery.slice(0, slashIndex + 1);
+  const query = rawQuery.slice(slashIndex + 1);
+  const baseDir = displayBase.startsWith("~/")
+    ? expandHomePath(displayBase)
+    : displayBase.startsWith("/")
+      ? displayBase
+      : join(currentCwd, displayBase);
+
+  try {
+    if (!statSync(baseDir).isDirectory()) return null;
+  } catch {
+    return null;
+  }
+
+  return { baseDir, query, displayBase };
+}
+
+function scopedPathForDisplay(displayBase: string, relativePath: string): string {
+  if (displayBase === "/") return `/${relativePath}`;
+  return `${displayBase}${relativePath}`;
+}
+
+function scorePhonePathEntry(filePath: string, query: string, isDirectory: boolean): number {
+  if (!query) return isDirectory ? 2 : 1;
+
+  const fileName = basename(filePath).toLowerCase();
+  const normalizedQuery = query.toLowerCase();
+  let score = 0;
+
+  if (fileName === normalizedQuery) score = 100;
+  else if (fileName.startsWith(normalizedQuery)) score = 80;
+  else if (fileName.includes(normalizedQuery)) score = 50;
+  else if (filePath.toLowerCase().includes(normalizedQuery)) score = 30;
+
+  if (isDirectory && score > 0) score += 10;
+  return score;
+}
+
+function walkDirectoryWithFd(baseDir: string, query: string, maxResults = PATH_SUGGESTION_MAX_RESULTS) {
+  if (!fdBinaryPath) return [] as Array<{ path: string; isDirectory: boolean }>;
+
+  const args = [
+    "--base-directory",
+    baseDir,
+    "--max-results",
+    String(maxResults),
+    "--type",
+    "f",
+    "--type",
+    "d",
+    "--full-path",
+    "--hidden",
+    "--exclude",
+    ".git",
+    "--exclude",
+    ".git/*",
+    "--exclude",
+    ".git/**",
+  ];
+
+  if (query) args.push(query);
+
+  const result = spawnSync(fdBinaryPath, args, {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  if (result.status !== 0 || !result.stdout) return [];
+
+  return result.stdout
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => ({
+      path: line.endsWith("/") ? line.slice(0, -1) : line,
+      isDirectory: line.endsWith("/"),
+    }))
+    .filter((entry) => entry.path !== ".git" && !entry.path.startsWith(".git/") && !entry.path.includes("/.git/"));
+}
+
+function createMentionPathSuggestions(query: string, currentCwd: string): PhonePathSuggestion[] {
+  const scopedQuery = resolveScopedMentionQuery(query, currentCwd);
+  const fdBaseDir = scopedQuery?.baseDir ?? currentCwd;
+  const fdQuery = scopedQuery?.query ?? query;
+  const entries = walkDirectoryWithFd(fdBaseDir, fdQuery, PATH_SUGGESTION_MAX_RESULTS);
+
+  return entries
+    .map((entry) => ({
+      ...entry,
+      score: scorePhonePathEntry(entry.path, fdQuery, entry.isDirectory),
+    }))
+    .filter((entry) => entry.score > 0)
+    .sort((left, right) => right.score - left.score)
+    .slice(0, PATH_SUGGESTION_LIMIT)
+    .map((entry) => {
+      const displayPath = scopedQuery
+        ? scopedPathForDisplay(scopedQuery.displayBase, entry.path)
+        : entry.path;
+      const completionPath = entry.isDirectory ? `${displayPath}/` : displayPath;
+      return {
+        value: completionPath,
+        label: `${basename(entry.path)}${entry.isDirectory ? "/" : ""}`,
+        description: displayPath,
+        isDirectory: entry.isDirectory,
+        kind: "path" as const,
+      };
+    });
+}
+
+export function listPhonePathSuggestions(
+  mode: PhonePathSuggestionMode,
+  query: string,
+  currentCwd: string,
+  previousCwd?: string | null,
+): PhonePathSuggestion[] {
+  return mode === "cd"
+    ? createCdPathSuggestions(query, currentCwd, previousCwd)
+    : createMentionPathSuggestions(query, currentCwd);
+}

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

@@ -0,0 +1,188 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type {
+  CodexUsageResponse,
+  PhoneQuotaResponse,
+  PhoneQuotaWindow,
+  RateLimitBucket,
+  UsageWindow,
+} from "./types";
+
+const agentDirFromEnv = process.env.DM_CODING_AGENT_DIR?.trim() || process.env.PI_CODING_AGENT_DIR?.trim();
+const agentDir = agentDirFromEnv
+  ? agentDirFromEnv
+  : join(process.env.HOME || process.env.USERPROFILE || process.cwd(), ".dm", "agent");
+const authFile = join(agentDir, "auth.json");
+const codexUsageUrl = "https://chatgpt.com/backend-api/wham/usage";
+const sparkModelId = "gpt-5.3-codex-spark";
+const sparkLimitName = "GPT-5.3-Codex-Spark";
+const missingAuthErrorPrefix = "Missing openai-codex OAuth access/accountId";
+
+function clampPercent(value: number): number {
+  return Math.min(100, Math.max(0, value));
+}
+
+function usedToLeftPercent(value: number | null | undefined): number | null {
+  if (typeof value !== "number" || Number.isNaN(value)) return null;
+  return clampPercent(100 - value);
+}
+
+function asObject(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value as Record<string, unknown>;
+}
+
+function normalizeRateLimitBucket(value: unknown): RateLimitBucket | null {
+  const record = asObject(value);
+  if (!record) return null;
+  if (!("primary_window" in record || "secondary_window" in record || "limit_reached" in record || "allowed" in record)) {
+    return null;
+  }
+  return record as RateLimitBucket;
+}
+
+function extractSparkRateLimitFromEntry(value: unknown): RateLimitBucket | null {
+  const record = asObject(value);
+  if (!record) return null;
+  if (typeof record.limit_name !== "string" || record.limit_name.trim() !== sparkLimitName) return null;
+  return normalizeRateLimitBucket(record.rate_limit);
+}
+
+function findSparkRateLimitBucket(data: CodexUsageResponse): RateLimitBucket | null {
+  const additional = data.additional_rate_limits;
+
+  if (Array.isArray(additional)) {
+    for (const entry of additional) {
+      const bucket = extractSparkRateLimitFromEntry(entry);
+      if (bucket) return bucket;
+    }
+    return null;
+  }
+
+  const additionalMap = asObject(additional);
+  if (!additionalMap) return null;
+
+  for (const value of Object.values(additionalMap)) {
+    const bucket = extractSparkRateLimitFromEntry(value);
+    if (bucket) return bucket;
+  }
+
+  return null;
+}
+
+function selectRateLimitBucket(data: CodexUsageResponse, modelId: string): RateLimitBucket | null {
+  if (modelId === sparkModelId) {
+    return findSparkRateLimitBucket(data);
+  }
+  return normalizeRateLimitBucket(data.rate_limit);
+}
+
+function getResetSeconds(window: UsageWindow | null | undefined): number | null {
+  const resetAfterSeconds = window?.reset_after_seconds;
+  if (typeof resetAfterSeconds === "number" && !Number.isNaN(resetAfterSeconds)) {
+    return resetAfterSeconds;
+  }
+
+  const resetAt = window?.reset_at;
+  if (typeof resetAt !== "number" || Number.isNaN(resetAt)) return null;
+
+  const resetAtSeconds = resetAt > 100_000_000_000 ? resetAt / 1000 : resetAt;
+  return Math.max(0, resetAtSeconds - Date.now() / 1000);
+}
+
+function buildQuotaWindow(label: "5h" | "7d", window: UsageWindow | null | undefined): PhoneQuotaWindow | null {
+  const leftPercent = usedToLeftPercent(window?.used_percent);
+  if (leftPercent === null) return null;
+
+  const roundedLeftPercent = Math.round(leftPercent);
+  const roundedUsedPercent = Math.round(clampPercent(typeof window?.used_percent === "number" ? window.used_percent : 100 - leftPercent));
+
+  return {
+    label,
+    leftPercent: roundedLeftPercent,
+    usedPercent: roundedUsedPercent,
+    resetAfterSeconds: getResetSeconds(window),
+    text: `${roundedLeftPercent}%`,
+  };
+}
+
+function shouldShowQuotaForModel(provider: string | null | undefined, modelId: string | null | undefined): boolean {
+  return provider === "openai-codex" && typeof modelId === "string" && /^gpt-/i.test(modelId);
+}
+
+async function loadCodexAuthCredentials(): Promise<{ accessToken: string; accountId: string }> {
+  const authRaw = await readFile(authFile, "utf8");
+  const auth = JSON.parse(authRaw) as Record<
+    string,
+    | {
+        type?: string;
+        access?: string | null;
+        accountId?: string | null;
+        account_id?: string | null;
+      }
+    | undefined
+  >;
+
+  const codexEntry = auth["openai-codex"];
+  const authEntry = codexEntry?.type === "oauth" ? codexEntry : undefined;
+  const accessToken = authEntry?.access?.trim();
+  const accountId = (authEntry?.accountId ?? authEntry?.account_id)?.trim();
+
+  if (!accessToken || !accountId) {
+    throw new Error(`${missingAuthErrorPrefix} in ${authFile}`);
+  }
+
+  return { accessToken, accountId };
+}
+
+async function requestCodexUsageJson(): Promise<CodexUsageResponse> {
+  const credentials = await loadCodexAuthCredentials();
+  const response = await fetch(codexUsageUrl, {
+    headers: {
+      accept: "*/*",
+      authorization: `Bearer ${credentials.accessToken}`,
+      "chatgpt-account-id": credentials.accountId,
+      "content-type": "application/json",
+      "user-agent": "codex-cli",
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Codex usage request failed (${response.status})`);
+  }
+
+  return (await response.json()) as CodexUsageResponse;
+}
+
+export async function getQuotaForModel(provider: string | null | undefined, modelId: string | null | undefined): Promise<PhoneQuotaResponse> {
+  if (!shouldShowQuotaForModel(provider, modelId)) {
+    return {
+      visible: false,
+      limited: false,
+      primaryWindow: null,
+      secondaryWindow: null,
+    };
+  }
+
+  try {
+    const usage = await requestCodexUsageJson();
+    const selectedBucket = selectRateLimitBucket(usage, modelId || "");
+    const primaryWindow = buildQuotaWindow("5h", selectedBucket?.primary_window);
+    const secondaryWindow = buildQuotaWindow("7d", selectedBucket?.secondary_window);
+
+    return {
+      visible: Boolean(primaryWindow || secondaryWindow),
+      limited: selectedBucket?.limit_reached === true || selectedBucket?.allowed === false,
+      primaryWindow,
+      secondaryWindow,
+    };
+  } catch (error) {
+    return {
+      visible: false,
+      limited: false,
+      primaryWindow: null,
+      secondaryWindow: null,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}