@raingor/pi-web-switch 0.4.2 → 0.4.4

package/server/pi-reader.ts

@@ -1,10 +1,11 @@
-import { readFileSync, readdirSync, existsSync, statSync, unlinkSync, writeFileSync, mkdirSync, renameSync, realpathSync } from "fs";
+import { readFileSync, readdirSync, existsSync, statSync, unlinkSync, writeFileSync, mkdirSync, renameSync, chmodSync } from "fs";
 import { homedir, platform } from "os";
 import { join, resolve, dirname, relative, sep } from "path";
 import { spawnSync } from "child_process";
 import { DatabaseSync } from "node:sqlite";
 
 const PI_DIR = join(homedir(), ".pi", "agent");
+const CODEX_DIR = join(homedir(), ".codex");
 
 // ─── Cindy Pi-Agent Sessions ───────────────────────────
 // When Cindy (the AI assistant) delegates to a pi coding agent, sessions
@@ -45,7 +46,6 @@ export function readSettings() {
 export function writeSettings(settings: any): boolean {
   try {
     const path = piPath("settings.json");
-    const backup = existsSync(path) ? readFileSync(path, "utf-8") : null;
     const raw = JSON.stringify(settings, null, 2);
     writeFileSync(path, raw, "utf-8");
     return true;
@@ -54,6 +54,175 @@ export function writeSettings(settings: any): boolean {
   }
 }
 
+// ─── Official Usage Query ──────────────────────────────
+
+export type OfficialUsageAuthMode = "auto" | "bearer" | "x-api-key" | "api-key";
+
+export interface OfficialUsageConfig {
+  endpoint: string;
+  apiKeys: string[];
+  authMode: OfficialUsageAuthMode;
+}
+
+export interface OfficialUsageSummary {
+  total: number;
+  used: number;
+  remaining: number;
+  remainingPercent: number;
+  unit: string;
+  source: string;
+  checkedAt: string;
+}
+
+const OFFICIAL_USAGE_CONFIG_FILE = "official-usage.json";
+
+function officialUsagePath(): string {
+  return piPath(OFFICIAL_USAGE_CONFIG_FILE);
+}
+
+function normalizeOfficialUsageConfig(value: any): OfficialUsageConfig {
+  const endpoint = typeof value?.endpoint === "string" ? value.endpoint.trim() : "";
+  const apiKeys = Array.isArray(value?.apiKeys)
+    ? value.apiKeys.filter((key: unknown): key is string => typeof key === "string").map((key) => key.trim()).filter(Boolean)
+    : typeof value?.apiKey === "string" && value.apiKey.trim()
+      ? [value.apiKey.trim()]
+      : [];
+  const authMode: OfficialUsageAuthMode = ["auto", "bearer", "x-api-key", "api-key"].includes(value?.authMode)
+    ? value.authMode
+    : "auto";
+  return { endpoint, apiKeys: Array.from(new Set(apiKeys)), authMode };
+}
+
+export function readOfficialUsageConfig(): OfficialUsageConfig {
+  try {
+    if (!existsSync(officialUsagePath())) return { endpoint: "", apiKeys: [], authMode: "auto" };
+    return normalizeOfficialUsageConfig(JSON.parse(readFileSync(officialUsagePath(), "utf-8")));
+  } catch {
+    return { endpoint: "", apiKeys: [], authMode: "auto" };
+  }
+}
+
+export function writeOfficialUsageConfig(config: OfficialUsageConfig): boolean {
+  try {
+    const normalized = normalizeOfficialUsageConfig(config);
+    if (!normalized.endpoint || normalized.apiKeys.length === 0) return false;
+    const url = new URL(normalized.endpoint);
+    if (!/^https?:$/.test(url.protocol)) return false;
+    mkdirSync(PI_DIR, { recursive: true });
+    writeFileSync(officialUsagePath(), JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 0o600 });
+    chmodSync(officialUsagePath(), 0o600);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function officialNumber(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() && Number.isFinite(Number(value.replace(/[, ]/g, "")))) return Number(value.replace(/[, ]/g, ""));
+  return null;
+}
+
+function findOfficialMetric(root: unknown, names: string[]): { value: number; unit?: string } | null {
+  const wanted = new Set(names.map((name) => name.toLowerCase().replace(/[^a-z0-9]/g, "")));
+  const queue: Array<{ value: unknown; path: string[] }> = [{ value: root, path: [] }];
+  while (queue.length) {
+    const current = queue.shift()!;
+    if (!current.value || typeof current.value !== "object") continue;
+    for (const [key, value] of Object.entries(current.value as Record<string, unknown>)) {
+      const normalizedKey = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+      const number = officialNumber(value);
+      if (number !== null && wanted.has(normalizedKey)) {
+        const parent = current.value as Record<string, unknown>;
+        const unit = typeof parent.unit === "string"
+          ? parent.unit
+          : typeof parent.currency === "string"
+            ? parent.currency
+            : normalizedKey.includes("usd") ? "USD" : undefined;
+        return { value: number, unit };
+      }
+      if (value && typeof value === "object") queue.push({ value, path: [...current.path, key] });
+    }
+  }
+  return null;
+}
+
+function parseOfficialUsagePayload(payload: unknown, endpoint: string): OfficialUsageSummary {
+  const total = findOfficialMetric(payload, ["total", "totalquota", "quota", "limit", "usagelimit", "monthlylimit", "included"])?.value ?? null;
+  const used = findOfficialMetric(payload, ["used", "usage", "currentusage", "consumed", "spend", "spent", "utilized"])?.value ?? null;
+  const explicitRemaining = findOfficialMetric(payload, ["remaining", "remainingquota", "balance", "available", "left"])?.value ?? null;
+  const resolvedTotal = total !== null && (used !== null || explicitRemaining !== null)
+    ? total
+    : used !== null && explicitRemaining !== null
+      ? used + explicitRemaining
+      : Number.NaN;
+  const resolvedUsed = used ?? (resolvedTotal - (explicitRemaining ?? 0));
+  const resolvedRemaining = explicitRemaining ?? Math.max(resolvedTotal - resolvedUsed, 0);
+  if (!Number.isFinite(resolvedTotal) || resolvedTotal <= 0 || !Number.isFinite(resolvedUsed) || !Number.isFinite(resolvedRemaining)) {
+    throw new Error("Unable to find total/used/remaining quota fields in the response");
+  }
+  const remainingPercent = Math.min(100, Math.max(0, (resolvedRemaining / resolvedTotal) * 100));
+  return {
+    total: resolvedTotal,
+    used: Math.max(0, resolvedUsed),
+    remaining: Math.max(0, resolvedRemaining),
+    remainingPercent,
+    unit: findOfficialMetric(payload, ["total", "totalquota", "quota", "limit", "usagelimit", "monthlylimit", "included"])?.unit ?? "units",
+    source: endpoint,
+    checkedAt: new Date().toISOString(),
+  };
+}
+
+function officialEndpoint(endpoint: string, apiKey: string): string {
+  return endpoint.replace(/\{apiKey\}/gi, encodeURIComponent(apiKey));
+}
+
+export async function queryOfficialUsage(configInput: OfficialUsageConfig): Promise<OfficialUsageSummary> {
+  const config = normalizeOfficialUsageConfig(configInput);
+  if (!config.endpoint || config.apiKeys.length === 0) throw new Error("Endpoint and at least one API key are required");
+  const errors: string[] = [];
+  const results: OfficialUsageSummary[] = [];
+  for (const apiKey of config.apiKeys) {
+    const modes: OfficialUsageAuthMode[] = config.authMode === "auto" ? ["bearer", "x-api-key", "api-key"] : [config.authMode];
+    let keySucceeded = false;
+    for (const mode of modes) {
+      try {
+        const headers: Record<string, string> = { Accept: "application/json" };
+        if (mode === "bearer") headers.Authorization = `Bearer ${apiKey}`;
+        if (mode === "x-api-key") headers["x-api-key"] = apiKey;
+        if (mode === "api-key") headers["api-key"] = apiKey;
+        const response = await fetch(officialEndpoint(config.endpoint, apiKey), { headers, signal: AbortSignal.timeout(15_000) });
+        const text = await response.text();
+        let payload: unknown;
+        try { payload = JSON.parse(text); } catch { payload = text; }
+        if (!response.ok) {
+          errors.push(`${response.status} ${response.statusText}`);
+          continue;
+        }
+        results.push(parseOfficialUsagePayload(payload, config.endpoint));
+        keySucceeded = true;
+        break;
+      } catch (error) {
+        errors.push(error instanceof Error ? error.message : "request failed");
+      }
+    }
+    if (!keySucceeded) continue;
+  }
+  if (results.length === 0) throw new Error(errors[0] || "Official usage query failed");
+  const total = results.reduce((sum, result) => sum + result.total, 0);
+  const used = results.reduce((sum, result) => sum + result.used, 0);
+  const remaining = results.reduce((sum, result) => sum + result.remaining, 0);
+  return {
+    total,
+    used,
+    remaining,
+    remainingPercent: total > 0 ? Math.min(100, Math.max(0, (remaining / total) * 100)) : 0,
+    unit: results.find((result) => result.unit)?.unit ?? "units",
+    source: config.endpoint,
+    checkedAt: new Date().toISOString(),
+  };
+}
+
 // ─── Auth ───────────────────────────────────────────────
 
 export function readAuth() {
@@ -125,47 +294,6 @@ function getSessionDirs(): string[] {
     .filter((dir) => statSync(dir).isDirectory());
 }
 
-/**
- * Recursively walk a project directory to find all session JSONL files.
- *
- * Supports both the legacy flat layout and the current nested layout:
- *   Legacy:  --project--/session.jsonl  (any .jsonl file at the project root)
- *   Current: --project--/{sessionId}/{hash}/run-0/session.jsonl
- */
-function walkSessionJsonl(dir: string, out: string[]): void {
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return;
-  }
-  for (const name of entries) {
-    const p = join(dir, name);
-    try {
-      const stat = statSync(p);
-      if (stat.isDirectory()) {
-        walkSessionJsonl(p, out);
-      } else if (name.endsWith(".jsonl")) {
-        out.push(p);
-      }
-    } catch {
-      // skip unreadable entries
-    }
-  }
-}
-
-/**
- * Return every session JSONL file across all project directories, handling
- * both the legacy flat layout and the current nested run-0 layout.
- */
-function getAllSessionFiles(): string[] {
-  const files: string[] = [];
-  for (const dir of getSessionDirs()) {
-    walkSessionJsonl(dir, files);
-  }
-  return files;
-}
-
 // Usage stats are bucketed in China time (UTC+8) regardless of the machine's
 // system timezone, so daily totals stay consistent for a Beijing-based user.
 const CN_TZ = "Asia/Shanghai";
@@ -254,13 +382,22 @@ export function readAllUsage(): UsageRecord[] {
     return usageCache.records;
   }
   const allRecords: UsageRecord[] = [];
-  const files = getAllSessionFiles();
+  const dirs = getSessionDirs();
 
-  for (const filePath of files) {
-    const records = parseSessionFile(filePath);
-    allRecords.push(...records);
+  for (const dir of dirs) {
+    try {
+      const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+      for (const file of files) {
+        const filePath = join(dir, file);
+        const records = parseSessionFile(filePath);
+        allRecords.push(...records);
+      }
+    } catch {
+      // skip unreadable directories
+    }
   }
 
+  // Sort by date ascending
   allRecords.sort((a, b) => a.date.localeCompare(b.date));
   usageCache = { records: allRecords, at: Date.now() };
   return allRecords;
@@ -436,23 +573,125 @@ export function readCodexUsage(): UsageRecord[] {
   return allRecords;
 }
 
-// ─── Combined All Sources ──────────────────────────────
+// ─── ChatGPT / Codex Desktop Usage ─────────────────────
 
 /**
- * Combine usage from all sources: local pi, Cindy pi-agent, Claude, Codex.
- * Used for the "All" tab that shows everything in one view.
+ * ChatGPT/Codex Desktop stores local rollout sessions as JSONL under
+ * ~/.codex/sessions and ~/.codex/archived_sessions. Each `token_count` event
+ * contains the usage for the latest model response, so it can be normalized
+ * into the same UsageRecord shape used by Pi sessions.
  */
-export function readAllCombinedUsage(): UsageRecord[] {
-  const all: UsageRecord[] = [
-    ...readAllUsage(),
-    ...readCindyUsage(),
-    ...readClaudeUsage(),
-    ...readCodexUsage(),
-    ...readAtomcodeUsage(),
-    ...readCopilotUsage(),
+function collectJsonlFiles(dir: string, out: string[] = []): string[] {
+  if (!existsSync(dir)) return out;
+  try {
+    for (const name of readdirSync(dir)) {
+      const path = join(dir, name);
+      try {
+        if (statSync(path).isDirectory()) collectJsonlFiles(path, out);
+        else if (name.endsWith(".jsonl")) out.push(path);
+      } catch {
+        // Ignore files that disappear while the desktop app is writing.
+      }
+    }
+  } catch {
+    // Ignore inaccessible directories.
+  }
+  return out;
+}
+
+function numericUsage(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function modelFromCodexPayload(payload: any): string | undefined {
+  const candidates = [
+    payload?.model,
+    payload?.model_id,
+    payload?.modelId,
+    payload?.state?.model,
+    payload?.thread_settings?.model,
+    payload?.thread_settings?.collaboration_mode?.settings?.model,
+    payload?.collaboration_mode?.settings?.model,
+    payload?.item?.model,
+    payload?.item?.content?.model,
+    payload?.base_instructions?.provenance?.model,
   ];
-  all.sort((a, b) => a.date.localeCompare(b.date));
-  return all;
+  return candidates.find((value) => typeof value === "string" && value.trim())?.trim();
+}
+
+function parseCodexSessionFile(filePath: string): UsageRecord[] {
+  const records: UsageRecord[] = [];
+  let currentModel = "chatgpt";
+  try {
+    for (const line of readFileSync(filePath, "utf-8").split("\n")) {
+      if (!line.trim()) continue;
+      let envelope: any;
+      try {
+        envelope = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      const payload = envelope?.payload;
+      if (!payload || typeof payload !== "object") continue;
+      currentModel = modelFromCodexPayload(payload) || currentModel;
+      if (payload.type !== "token_count") continue;
+
+      const usage = payload.info?.last_token_usage;
+      if (!usage || typeof usage !== "object") continue;
+      const timestamp = typeof envelope.timestamp === "string" ? envelope.timestamp : "";
+      if (!timestamp) continue;
+      const { date, hour } = cnDateParts(timestamp);
+      const rawInputTokens = numericUsage(usage.input_tokens);
+      const cachedInputTokens = numericUsage(usage.cached_input_tokens);
+      const cacheWriteTokens = numericUsage(usage.cache_write_input_tokens);
+      // Codex reports cached/cache-write tokens as subsets of input_tokens.
+      // Split them out so the dashboard total remains raw input + output,
+      // rather than counting cached context twice.
+      const inputTokens = Math.max(rawInputTokens - cachedInputTokens - cacheWriteTokens, 0);
+      // reasoning_output_tokens is informational and already included in
+      // output_tokens (total_tokens = input_tokens + output_tokens).
+      const outputTokens = numericUsage(usage.output_tokens);
+
+      // The local format has no per-call price. Keep cost at zero rather than
+      // inventing a price for a ChatGPT subscription/Codex plan.
+      records.push({
+        date,
+        hour,
+        providerId: "chatgpt",
+        modelId: currentModel,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens: cachedInputTokens,
+        cacheWriteTokens,
+        requests: 1,
+        cost: 0,
+      });
+    }
+  } catch {
+    // Ignore unreadable or partially-written rollout files.
+  }
+  return records;
+}
+
+const CODEX_USAGE_TTL_MS = 30_000;
+let codexUsageCache: { records: UsageRecord[]; at: number } | null = null;
+
+export function readChatgptUsage(): UsageRecord[] {
+  if (codexUsageCache && Date.now() - codexUsageCache.at < CODEX_USAGE_TTL_MS) {
+    return codexUsageCache.records;
+  }
+  const files = [
+    ...collectJsonlFiles(join(CODEX_DIR, "sessions")),
+    ...collectJsonlFiles(join(CODEX_DIR, "archived_sessions")),
+  ];
+  const records = files.flatMap(parseCodexSessionFile).sort((a, b) => a.date.localeCompare(b.date));
+  codexUsageCache = { records, at: Date.now() };
+  return records;
+}
+
+export function clearChatgptUsageCache(): void {
+  codexUsageCache = null;
 }
 
 // ─── AtomCode Usage ────────────────────────────────────
@@ -667,9 +906,13 @@ export interface ProviderFilter {
 
 export const PROVIDER_FILTERS: ProviderFilter[] = [
   {
-    id: "copilot",
-    label: "Copilot",
-    patterns: [/^copilot$/i],
+    id: "chatgpt",
+    label: "ChatGPT",
+    // ChatGPT/OpenAI model calls can be recorded under a direct OpenAI
+    // provider or behind a compatible gateway. Match provider and model names
+    // so the dashboard can surface them as one source without changing the
+    // original records used by the default Pi view.
+    patterns: [/^(openai|chatgpt|openai-chatgpt)$/i, /chatgpt/i, /openai/i, /^gpt[-_]/i, /^o[1345](?:[-_]|$)/i],
   },
   {
     id: "atomcode",
@@ -1094,12 +1337,13 @@ export function listSessions(): ProjectGroup[] {
     }
 
     const group = groups.get(projectPath)!;
-    const files: string[] = [];
-    walkSessionJsonl(dir, files);
-    // Sort by path descending (newest session directories first as a rough proxy)
-    files.sort().reverse();
+    const files = readdirSync(dir)
+      .filter((f) => f.endsWith(".jsonl"))
+      .sort()
+      .reverse(); // newest first
 
-    for (const filePath of files) {
+    for (const file of files) {
+      const filePath = join(dir, file);
       const session = parseSessionFileInfo(filePath);
       if (session) {
         group.sessions.push(session);
@@ -1108,10 +1352,11 @@ export function listSessions(): ProjectGroup[] {
 
     group.totalSessions = group.sessions.length;
     if (group.sessions.length > 0) {
-      group.lastActive = group.sessions[0]?.timestamp ?? "";
+      group.lastActive = group.sessions[0]?.timestamp ?? ""; // already sorted newest-first
     }
   }
 
+  // Sort groups by lastActive descending
   return Array.from(groups.values())
     .filter((g) => g.sessions.length > 0)
     .sort((a, b) => b.lastActive.localeCompare(a.lastActive));
@@ -1229,6 +1474,37 @@ function walkJsonl(dir: string, out: string[]): void {
   }
 }
 
+const STALE_SESSION_DAYS = 14;
+
+/**
+ * Move sessions with no activity for more than 14 days into the recoverable
+ * trash. The last message/session timestamp is preferred; file mtime is the
+ * fallback for malformed or very old session files without timestamps.
+ */
+export function autoTrashStaleSessions(maxAgeDays = STALE_SESSION_DAYS): { moved: number; paths: string[] } {
+  const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+  const files: string[] = [];
+  walkJsonl(SESSIONS_DIR, files);
+  const moved: string[] = [];
+
+  for (const filePath of files) {
+    let lastActiveMs = 0;
+    const info = parseSessionFileInfo(filePath);
+    if (info?.lastActive) lastActiveMs = new Date(info.lastActive).getTime();
+    if (!Number.isFinite(lastActiveMs) || lastActiveMs <= 0) {
+      try {
+        lastActiveMs = statSync(filePath).mtimeMs;
+      } catch {
+        continue;
+      }
+    }
+    if (lastActiveMs >= cutoff) continue;
+    if (trashSessionFile(filePath)) moved.push(filePath);
+  }
+
+  return { moved: moved.length, paths: moved };
+}
+
 /** Move a session file into the trash, preserving its path relative to the sessions dir. */
 export function trashSessionFile(filePath: string): boolean {
   try {
@@ -1298,74 +1574,6 @@ export function permanentlyDeleteTrash(trashPath: string): boolean {
   }
 }
 
-// ─── Session Auto-Expiry ──────────────────────────────────
-
-const AUTO_EXPIRE_INTERVAL_MS = 24 * 60 * 60 * 1000; // every 24h
-let autoExpireTimer: ReturnType<typeof setInterval> | null = null;
-
-function getSessionExpiryDays(): number {
-  const settings = readSettings();
-  const val = settings?.sessionExpiryDays;
-  const n = typeof val === "number" ? val : Number(val);
-  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 7;
-}
-
-interface ExpireResult {
-  expired: string[];
-  skipped: string[];
-  errors: string[];
-}
-
-export function autoExpireSessions(): ExpireResult {
-  const result: ExpireResult = { expired: [], skipped: [], errors: [] };
-  const expiryDays = getSessionExpiryDays();
-  const cutoffMs = Date.now() - expiryDays * 24 * 60 * 60 * 1000;
-
-  const dirs = getSessionDirs();
-  for (const dir of dirs) {
-    let files: string[];
-    try {
-      files = readdirSync(dir)
-        .filter((f) => f.endsWith(".jsonl"))
-        .map((f) => join(dir, f));
-    } catch {
-      continue;
-    }
-
-    for (const filePath of files) {
-      try {
-        const info = parseSessionFileInfo(filePath);
-        if (!info) { result.skipped.push(filePath); continue; }
-
-        const lastActiveTs = new Date(info.lastActive || info.timestamp).getTime();
-        if (isNaN(lastActiveTs)) { result.skipped.push(filePath); continue; }
-
-        if (lastActiveTs < cutoffMs) {
-          const ok = trashSessionFile(filePath);
-          if (ok) {
-            result.expired.push(filePath);
-          } else {
-            result.errors.push(`trash failed: ${filePath}`);
-          }
-        }
-      } catch {
-        result.errors.push(`scan failed: ${filePath}`);
-      }
-    }
-  }
-
-  return result;
-}
-
-export function startAutoExpiryTimer(): void {
-  if (autoExpireTimer) return;
-  // Run once at startup (fire-and-forget, swallow errors)
-  try { autoExpireSessions(); } catch { /* ignore */ }
-  autoExpireTimer = setInterval(() => {
-    try { autoExpireSessions(); } catch { /* ignore */ }
-  }, AUTO_EXPIRE_INTERVAL_MS);
-}
-
 // ─── Session Preview ────────────────────────────────
 
 export interface SessionPreviewMessage {
@@ -1647,93 +1855,6 @@ export interface ApplyUpdateResult {
   message?: string;
 }
 
-// ─── npm resolution ──────────────────────────────────────
-// GUI-launched apps (Finder / Launchpad) inherit a minimal PATH
-// (/usr/bin:/bin:/usr/sbin:/sbin) that does NOT contain the user's npm or
-// node, so `spawnSync("npm", ...)` fails with ENOENT in the packaged app.
-// Instead of relying on PATH we locate the real npm-cli.js + node binary
-// from common install locations and run npm via that explicit node.
-
-function realpathOr(p: string): string | null {
-  try {
-    return realpathSync(p);
-  } catch {
-    return null;
-  }
-}
-
-/** Candidate npm binaries across common layouts (PATH + known locations). */
-function npmBinCandidates(): string[] {
-  const home = homedir();
-  const fromPath = (process.env.PATH || "")
-    .split(":")
-    .filter(Boolean)
-    .map((d) => join(d, "npm"));
-  return [
-    ...fromPath,
-    `${home}/.npm-global/bin/npm`,
-    `${home}/.npm-packages/bin/npm`,
-    `${home}/.local/share/pnpm/npm`,
-    "/usr/local/bin/npm",
-    "/opt/homebrew/bin/npm",
-    // pi-node bundles its own node/npm under ~/.local/share/pi-node/node-*/
-    ...(() => {
-      const base = join(home, ".local", "share", "pi-node");
-      try {
-        return readdirSync(base)
-          .filter((n) => n.startsWith("node-"))
-          .map((n) => join(base, n, "bin", "npm"));
-      } catch {
-        return [];
-      }
-    })(),
-  ];
-}
-
-/** Resolve the npm CLI entry (npm-cli.js) — npm bins are symlinks to it. */
-function resolveNpmCliJs(): string | null {
-  for (const bin of npmBinCandidates()) {
-    const real = realpathOr(bin);
-    if (real && existsSync(real) && /npm-cli\.js$/.test(real)) return real;
-  }
-  return null;
-}
-
-/** Candidate node binaries (PATH + common locations + pi-node bundle). */
-function resolveNodeBin(): string | null {
-  const home = homedir();
-  const fromPath = (process.env.PATH || "")
-    .split(":")
-    .filter(Boolean)
-    .map((d) => join(d, "node"));
-  const candidates = [
-    ...fromPath,
-    `${home}/.npm-global/bin/node`,
-    `${home}/.npm-packages/bin/node`,
-    "/usr/local/bin/node",
-    "/opt/homebrew/bin/node",
-    ...(() => {
-      const base = join(home, ".local", "share", "pi-node");
-      try {
-        return readdirSync(base)
-          .filter((n) => n.startsWith("node-"))
-          .map((n) => join(base, n, "bin", "node"));
-      } catch {
-        return [];
-      }
-    })(),
-  ];
-  for (const bin of candidates) {
-    try {
-      const out = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 5000 });
-      if (out.status === 0 && out.stdout) return bin;
-    } catch {
-      // try next candidate
-    }
-  }
-  return null;
-}
-
 /**
  * One-click update: npm install <name>@latest inside ~/.pi/agent/npm.
  * Only packages already installed there are accepted (pi core is excluded —
@@ -1742,8 +1863,6 @@ function resolveNodeBin(): string | null {
 export function applyExtensionUpdates(names: string[]): ApplyUpdateResult[] {
   const dir = join(PI_DIR, "npm");
   const installed = new Set(listInstalledExtensions().map((e) => e.name));
-  const npmCliJs = resolveNpmCliJs();
-  const nodeBin = resolveNodeBin();
 
   return names.map((name) => {
     if (!installed.has(name)) {
@@ -1752,19 +1871,15 @@ export function applyExtensionUpdates(names: string[]): ApplyUpdateResult[] {
     try {
       // --legacy-peer-deps: peer deps (e.g. pi core) are provided by the pi host,
       // not installed here — strict resolution would fail with ERESOLVE.
-      const args = ["install", `${name}@latest`, "--no-audit", "--no-fund", "--legacy-peer-deps"];
-      let out;
-      if (nodeBin && npmCliJs) {
-        // Explicit node + npm-cli.js — works even when PATH lacks npm
-        out = spawnSync(nodeBin, [npmCliJs, ...args], {
+      const out = spawnSync(
+        "npm",
+        ["install", `${name}@latest`, "--no-audit", "--no-fund", "--legacy-peer-deps"],
+        {
           cwd: dir,
           encoding: "utf8",
           timeout: 120000,
-        });
-      } else {
-        // Fall back to PATH resolution (dev / terminal environments)
-        out = spawnSync("npm", args, { cwd: dir, encoding: "utf8", timeout: 120000 });
-      }
+        }
+      );
       if (out.status === 0) return { name, success: true };
       const stderr = (out.stderr || "").trim().split("\n").slice(-3).join(" ");
       return { name, success: false, message: stderr || `npm exited with ${out.status}` };
@@ -1872,7 +1987,8 @@ function heuristicFlags(id: string): { reasoning?: boolean; vision?: boolean; au
   const vision = VISION_RE.test(k);
   const audio = AUDIO_RE.test(k);
   let contextWindow: number | undefined;
-  if (/[-_](1m|1024k|1048576)\b/i.test(k)) contextWindow = 1_048_576;
+  if (/deepseek[-_]v4[-_](flash|chat)(?:[-_:]|$)/i.test(k)) contextWindow = 1_048_576;
+  else if (/[-_](1m|1024k|1048576)\b/i.test(k)) contextWindow = 1_048_576;
   else if (/[-_](256k)\b/i.test(k)) contextWindow = 262_144;
   else if (/[-_](128k)\b/i.test(k)) contextWindow = 131_072;
   else if (/[-_](64k)\b/i.test(k)) contextWindow = 65_536;