@raingor/pi-web-switch 0.4.1 → 0.4.2

package/dist-electron/main/main.cjs

@@ -0,0 +1,2453 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const path = require("path");
+const fs = require("fs");
+const url = require("url");
+const os = require("os");
+const child_process = require("child_process");
+const node_sqlite = require("node:sqlite");
+const http = require("http");
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+const PI_DIR = path.join(os.homedir(), ".pi", "agent");
+function getCindySessionsDir() {
+  const home = os.homedir();
+  if (os.platform() === "darwin") {
+    return path.join(home, "Library", "Application Support", "Cindy", "pi-agent-home", "sessions");
+  }
+  return path.join(home, ".config", "cindy", "pi-agent-home", "sessions");
+}
+function piPath(filename) {
+  return path.join(PI_DIR, filename);
+}
+function readJson(filename) {
+  const path2 = piPath(filename);
+  try {
+    if (!fs.existsSync(path2)) return null;
+    const raw = fs.readFileSync(path2, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function readSettings() {
+  return readJson("settings.json");
+}
+function writeSettings(settings) {
+  try {
+    const path2 = piPath("settings.json");
+    const backup = fs.existsSync(path2) ? fs.readFileSync(path2, "utf-8") : null;
+    const raw = JSON.stringify(settings, null, 2);
+    fs.writeFileSync(path2, raw, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readAuth() {
+  return readJson("auth.json");
+}
+function writeAuth(auth) {
+  try {
+    const path2 = piPath("auth.json");
+    fs.writeFileSync(path2, JSON.stringify(auth, null, 2), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readModels() {
+  return readJson("models.json");
+}
+function writeModels(models) {
+  try {
+    const path2 = piPath("models.json");
+    fs.writeFileSync(path2, JSON.stringify(models, null, 2), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getSessionDirs() {
+  const sessionsPath = path.join(PI_DIR, "sessions");
+  if (!fs.existsSync(sessionsPath)) return [];
+  return fs.readdirSync(sessionsPath).filter((name) => name.startsWith("--")).map((name) => path.join(sessionsPath, name)).filter((dir) => fs.statSync(dir).isDirectory());
+}
+function walkSessionJsonl(dir, out) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const p = path.join(dir, name);
+    try {
+      const stat = fs.statSync(p);
+      if (stat.isDirectory()) {
+        walkSessionJsonl(p, out);
+      } else if (name === "session.jsonl" || name.endsWith(".jsonl")) {
+        out.push(p);
+      }
+    } catch {
+    }
+  }
+}
+function getAllSessionFiles() {
+  const files = [];
+  for (const dir of getSessionDirs()) {
+    walkSessionJsonl(dir, files);
+  }
+  return files;
+}
+const CN_TZ = "Asia/Shanghai";
+function cnDateParts(ts) {
+  const d = new Date(ts);
+  if (isNaN(d.getTime())) return { date: "unknown", hour: 0 };
+  const date = new Intl.DateTimeFormat("en-CA", {
+    timeZone: CN_TZ,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(d);
+  const hour = Number(
+    new Intl.DateTimeFormat("en-US", {
+      timeZone: CN_TZ,
+      hour: "2-digit",
+      hour12: false
+    }).format(d)
+  );
+  return { date, hour: hour === 24 ? 0 : hour };
+}
+function parseSessionFile(filePath) {
+  const records = [];
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    let currentProvider = "unknown";
+    let currentModel = "unknown";
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        const type = obj.type;
+        if (type === "model_change") {
+          currentProvider = obj.provider || currentProvider;
+          currentModel = obj.modelId || currentModel;
+          continue;
+        }
+        if (type === "message" && obj.message?.role === "assistant") {
+          const usage = obj.message.usage;
+          if (!usage || !usage.input) continue;
+          const timestamp = obj.timestamp || obj.message.timestamp;
+          const { date, hour } = cnDateParts(timestamp);
+          records.push({
+            date,
+            hour,
+            providerId: obj.message.provider || currentProvider,
+            modelId: obj.message.model || currentModel,
+            inputTokens: usage.input ?? 0,
+            outputTokens: usage.output ?? 0,
+            cacheReadTokens: usage.cacheRead ?? 0,
+            cacheWriteTokens: usage.cacheWrite ?? 0,
+            requests: 1,
+            cost: usage.cost?.total ?? 0
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return records;
+}
+const USAGE_CACHE_TTL_MS = 3e4;
+let usageCache = null;
+function clearUsageCache() {
+  usageCache = null;
+}
+function readAllUsage() {
+  if (usageCache && Date.now() - usageCache.at < USAGE_CACHE_TTL_MS) {
+    return usageCache.records;
+  }
+  const allRecords = [];
+  const files = getAllSessionFiles();
+  for (const filePath of files) {
+    const records = parseSessionFile(filePath);
+    allRecords.push(...records);
+  }
+  allRecords.sort((a, b) => a.date.localeCompare(b.date));
+  usageCache = { records: allRecords, at: Date.now() };
+  return allRecords;
+}
+function readCindyUsage() {
+  const allRecords = [];
+  const cindyDir = getCindySessionsDir();
+  if (!fs.existsSync(cindyDir)) return allRecords;
+  try {
+    const files = fs.readdirSync(cindyDir).filter((f) => f.endsWith(".jsonl"));
+    for (const file of files) {
+      const filePath = path.join(cindyDir, file);
+      if (!fs.statSync(filePath).isFile()) continue;
+      const records = parseSessionFile(filePath);
+      allRecords.push(...records);
+    }
+  } catch {
+  }
+  allRecords.sort((a, b) => a.date.localeCompare(b.date));
+  return allRecords;
+}
+function getCindyDbPaths() {
+  const home = os.homedir();
+  let cindyAppDir;
+  if (os.platform() === "darwin") {
+    cindyAppDir = path.join(home, "Library", "Application Support", "Cindy");
+  } else if (os.platform() === "win32") {
+    cindyAppDir = path.join(process.env.APPDATA ?? path.join(home, "AppData", "Roaming"), "Cindy");
+  } else {
+    cindyAppDir = path.join(home, ".config", "Cindy");
+  }
+  if (!fs.existsSync(cindyAppDir)) return [];
+  try {
+    return fs.readdirSync(cindyAppDir).filter((f) => f.startsWith("cindy-cms") && f.endsWith(".db")).map((f) => path.join(cindyAppDir, f));
+  } catch {
+    return [];
+  }
+}
+function readClaudeUsage() {
+  const allRecords = [];
+  const dbPaths = getCindyDbPaths();
+  if (dbPaths.length === 0) return allRecords;
+  for (const dbPath of dbPaths) {
+    try {
+      const query = "SELECT day, model, cost_usd, input_tokens, output_tokens, cache_read_tokens, cache_create_tokens FROM daily_model_usage WHERE agent_kind = 'claude-code' ORDER BY day";
+      const result = child_process.spawnSync("sqlite3", [dbPath, "-json", query], {
+        encoding: "utf8",
+        timeout: 1e4
+      });
+      if (result.status !== 0) continue;
+      const output = result.stdout?.trim();
+      if (!output) continue;
+      const rows = JSON.parse(output);
+      for (const row of rows) {
+        allRecords.push({
+          date: row.day,
+          providerId: "claude",
+          modelId: row.model,
+          inputTokens: row.input_tokens ?? 0,
+          outputTokens: row.output_tokens ?? 0,
+          cacheReadTokens: row.cache_read_tokens ?? 0,
+          cacheWriteTokens: row.cache_create_tokens ?? 0,
+          requests: 1,
+          cost: row.cost_usd ?? 0
+        });
+      }
+    } catch {
+    }
+  }
+  allRecords.sort((a, b) => a.date.localeCompare(b.date));
+  return allRecords;
+}
+function readCodexUsage() {
+  const allRecords = [];
+  const dbPaths = getCindyDbPaths();
+  if (dbPaths.length === 0) return allRecords;
+  for (const dbPath of dbPaths) {
+    try {
+      const query = "SELECT day, model, cost_usd, input_tokens, output_tokens, cache_read_tokens, cache_create_tokens FROM daily_model_usage WHERE agent_kind = 'codex' ORDER BY day";
+      const result = child_process.spawnSync("sqlite3", [dbPath, "-json", query], {
+        encoding: "utf8",
+        timeout: 1e4
+      });
+      if (result.status !== 0) continue;
+      const output = result.stdout?.trim();
+      if (!output) continue;
+      const rows = JSON.parse(output);
+      for (const row of rows) {
+        allRecords.push({
+          date: row.day,
+          providerId: "codex",
+          modelId: row.model,
+          inputTokens: row.input_tokens ?? 0,
+          outputTokens: row.output_tokens ?? 0,
+          cacheReadTokens: row.cache_read_tokens ?? 0,
+          cacheWriteTokens: row.cache_create_tokens ?? 0,
+          requests: 1,
+          cost: row.cost_usd ?? 0
+        });
+      }
+    } catch {
+    }
+  }
+  allRecords.sort((a, b) => a.date.localeCompare(b.date));
+  return allRecords;
+}
+function readAllCombinedUsage() {
+  const all = [
+    ...readAllUsage(),
+    ...readCindyUsage(),
+    ...readClaudeUsage(),
+    ...readCodexUsage(),
+    ...readAtomcodeUsage(),
+    ...readCopilotUsage()
+  ];
+  all.sort((a, b) => a.date.localeCompare(b.date));
+  return all;
+}
+const ATOMCODE_DIR = path.join(os.homedir(), ".atomcode");
+function readAtomcodeUsage() {
+  const allRecords = [];
+  const sessionsDir = path.join(ATOMCODE_DIR, "sessions");
+  if (!fs.existsSync(sessionsDir)) return allRecords;
+  let sessionDirs = [];
+  try {
+    sessionDirs = fs.readdirSync(sessionsDir).map((name) => path.join(sessionsDir, name)).filter((dir) => fs.statSync(dir).isDirectory());
+  } catch {
+    return allRecords;
+  }
+  for (const dir of sessionDirs) {
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+    for (const file of files) {
+      const filePath = path.join(dir, file);
+      try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const model = sniffAtomcodeModel(path.join(dir, file.replace(/\.jsonl$/, ".snapshot")));
+        for (const line of raw.split("\n").filter((l) => l.trim())) {
+          try {
+            const obj = JSON.parse(line);
+            const usage = obj.usage;
+            if (!usage || typeof usage.prompt !== "number") continue;
+            const { date, hour } = cnDateParts(obj.iso ?? obj.ts ?? "");
+            allRecords.push({
+              date,
+              hour,
+              providerId: "atomcode",
+              modelId: model,
+              inputTokens: usage.prompt ?? 0,
+              outputTokens: usage.completion ?? 0,
+              cacheReadTokens: usage.cached ?? 0,
+              cacheWriteTokens: 0,
+              requests: 1,
+              cost: 0
+            });
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  allRecords.sort((a, b) => a.date.localeCompare(b.date));
+  return allRecords;
+}
+function sniffAtomcodeModel(snapshotPath) {
+  try {
+    if (!fs.existsSync(snapshotPath)) return "atomcode";
+    const txt = fs.readFileSync(snapshotPath, "utf-8");
+    const m = txt.match(/running the ([\w.-]+) model/i);
+    return m?.[1] ?? "atomcode";
+  } catch {
+    return "atomcode";
+  }
+}
+const COPILOT_CONFIG_PATH = path.join(PI_DIR, "copilot.json");
+function readCopilotConfig() {
+  try {
+    if (!fs.existsSync(COPILOT_CONFIG_PATH)) return {};
+    const raw = fs.readFileSync(COPILOT_CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      username: typeof parsed.username === "string" ? parsed.username : void 0,
+      token: typeof parsed.token === "string" ? parsed.token : void 0
+    };
+  } catch {
+    return {};
+  }
+}
+function writeCopilotConfig(cfg) {
+  try {
+    const clean = {
+      username: cfg.username?.trim() || void 0,
+      token: cfg.token?.trim() || void 0
+    };
+    fs.writeFileSync(COPILOT_CONFIG_PATH, JSON.stringify(clean, null, 2), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+const COPILOT_STORE_PATH = path.join(os.homedir(), ".copilot", "session-store.db");
+function copilotNum(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function readCopilotStore() {
+  const records = [];
+  let db = null;
+  try {
+    db = new node_sqlite.DatabaseSync(COPILOT_STORE_PATH, { readOnly: true });
+    const rows = db.prepare(
+      `SELECT model, input_tokens, output_tokens, cache_read_tokens,
+                cache_write_tokens, created_at
+         FROM assistant_usage_events`
+    ).all();
+    for (const row of rows) {
+      const ts = row.created_at;
+      if (typeof ts !== "string" || !ts) continue;
+      const { date, hour } = cnDateParts(ts);
+      records.push({
+        date,
+        hour,
+        providerId: "copilot",
+        modelId: typeof row.model === "string" && row.model ? row.model : "copilot",
+        inputTokens: copilotNum(row.input_tokens),
+        outputTokens: copilotNum(row.output_tokens),
+        cacheReadTokens: copilotNum(row.cache_read_tokens),
+        cacheWriteTokens: copilotNum(row.cache_write_tokens),
+        requests: 1,
+        cost: 0
+      });
+    }
+  } catch {
+  } finally {
+    try {
+      db?.close();
+    } catch {
+    }
+  }
+  records.sort((a, b) => a.date.localeCompare(b.date));
+  return records;
+}
+const COPILOT_USAGE_TTL_MS = 3e4;
+let copilotUsageCache = null;
+function readCopilotUsage() {
+  if (copilotUsageCache && Date.now() - copilotUsageCache.at < COPILOT_USAGE_TTL_MS) {
+    return copilotUsageCache.records;
+  }
+  const records = readCopilotStore();
+  copilotUsageCache = { records, at: Date.now() };
+  return records;
+}
+function clearCopilotCaches() {
+  copilotUsageCache = null;
+}
+const PROVIDER_FILTERS = [
+  {
+    id: "copilot",
+    label: "Copilot",
+    patterns: [/^copilot$/i]
+  },
+  {
+    id: "atomcode",
+    label: "AtomCode",
+    patterns: [/^atomcode$/i]
+  },
+  {
+    id: "opencode",
+    label: "OpenCode",
+    patterns: [/^opencode$/, /^opencode-go$/i]
+  },
+  {
+    id: "gemini",
+    label: "Gemini",
+    patterns: [/^google$/, /gemini/i]
+  },
+  {
+    id: "grok",
+    label: "Grok",
+    patterns: [/^xai$/, /grok/i]
+  }
+];
+function filterByProvider(records, providerId) {
+  const filter = PROVIDER_FILTERS.find((f) => f.id === providerId);
+  if (!filter) return records;
+  return records.filter(
+    (r) => filter.patterns.some((p) => p.test(r.providerId) || p.test(r.modelId))
+  );
+}
+function getDailyAggregates(records) {
+  const daily = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const d = daily.get(r.date) ?? {
+      totalTokens: 0,
+      totalCost: 0,
+      totalRequests: 0,
+      inputTokens: 0,
+      outputTokens: 0
+    };
+    d.totalTokens += r.inputTokens + r.outputTokens + r.cacheReadTokens + r.cacheWriteTokens;
+    d.totalCost += r.cost;
+    d.totalRequests += r.requests;
+    d.inputTokens += r.inputTokens;
+    d.outputTokens += r.outputTokens;
+    daily.set(r.date, d);
+  }
+  return Array.from(daily.entries()).map(([date, agg]) => ({ date, ...agg })).sort((a, b) => a.date.localeCompare(b.date));
+}
+function getProviderSummaries(records) {
+  const sums = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const s = sums.get(r.providerId) ?? {
+      totalTokens: 0,
+      totalCost: 0,
+      totalRequests: 0
+    };
+    s.totalTokens += r.inputTokens + r.outputTokens + r.cacheReadTokens + r.cacheWriteTokens;
+    s.totalCost += r.cost;
+    s.totalRequests += r.requests;
+    sums.set(r.providerId, s);
+  }
+  return Array.from(sums.entries()).map(([providerId, s]) => ({
+    providerId,
+    ...s
+  }));
+}
+function getModelSummaries(records) {
+  const sums = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const key = `${r.providerId}/${r.modelId}`;
+    const s = sums.get(key) ?? {
+      providerId: r.providerId,
+      totalTokens: 0,
+      totalCost: 0,
+      totalRequests: 0,
+      count: 0
+    };
+    s.totalTokens += r.inputTokens + r.outputTokens + r.cacheReadTokens + r.cacheWriteTokens;
+    s.totalCost += r.cost;
+    s.totalRequests += r.requests;
+    s.count++;
+    sums.set(key, s);
+  }
+  return Array.from(sums.entries()).map(([key, s]) => {
+    const [providerId, modelId] = key.split("/");
+    return {
+      modelId,
+      providerId: s.providerId,
+      totalTokens: s.totalTokens,
+      totalCost: s.totalCost,
+      totalRequests: s.totalRequests,
+      avgTokensPerRequest: s.totalRequests > 0 ? Math.round(s.totalTokens / s.totalRequests) : 0
+    };
+  });
+}
+function getTotals(records) {
+  let totalTokens = 0;
+  let totalCost = 0;
+  let totalRequests = 0;
+  for (const r of records) {
+    totalTokens += r.inputTokens + r.outputTokens + r.cacheReadTokens + r.cacheWriteTokens;
+    totalCost += r.cost;
+    totalRequests += r.requests;
+  }
+  return { totalTokens, totalCost, totalRequests };
+}
+function getUsageByRange(records, fromDate, toDate) {
+  const filtered = records.filter((r) => r.date >= fromDate && r.date <= toDate);
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCacheRead = 0;
+  let totalCacheWrite = 0;
+  let totalCost = 0;
+  let totalRequests = 0;
+  for (const r of filtered) {
+    totalInput += r.inputTokens;
+    totalOutput += r.outputTokens;
+    totalCacheRead += r.cacheReadTokens;
+    totalCacheWrite += r.cacheWriteTokens;
+    totalCost += r.cost;
+    totalRequests += r.requests;
+  }
+  const totalTokens = totalInput + totalOutput + totalCacheRead + totalCacheWrite;
+  const cacheHitRate = totalTokens > 0 ? (totalCacheRead + totalCacheWrite) / totalTokens * 100 : 0;
+  const daily = /* @__PURE__ */ new Map();
+  for (const r of filtered) {
+    const d = daily.get(r.date) ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, requests: 0 };
+    d.input += r.inputTokens;
+    d.output += r.outputTokens;
+    d.cacheRead += r.cacheReadTokens;
+    d.cacheWrite += r.cacheWriteTokens;
+    d.cost += r.cost;
+    d.requests += r.requests;
+    daily.set(r.date, d);
+  }
+  const hourly = /* @__PURE__ */ new Map();
+  for (const r of filtered) {
+    if (r.hour !== void 0) {
+      const hKey = `${r.date} ${String(r.hour).padStart(2, "0")}:00`;
+      const h = hourly.get(hKey) ?? {
+        hour: hKey,
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: 0,
+        requests: 0
+      };
+      h.input += r.inputTokens;
+      h.output += r.outputTokens;
+      h.cacheRead += r.cacheReadTokens;
+      h.cacheWrite += r.cacheWriteTokens;
+      h.cost += r.cost;
+      h.requests += r.requests;
+      hourly.set(hKey, h);
+    }
+  }
+  const requestLog = /* @__PURE__ */ new Map();
+  for (const r of filtered) {
+    const key = `${r.date}|${r.providerId}|${r.modelId}`;
+    const existing = requestLog.get(key) ?? {
+      timestamp: r.date,
+      providerId: r.providerId,
+      modelId: r.modelId,
+      input: 0,
+      output: 0,
+      cost: 0,
+      requests: 0
+    };
+    existing.input += r.inputTokens;
+    existing.output += r.outputTokens;
+    existing.cost += r.cost;
+    existing.requests += r.requests;
+    requestLog.set(key, existing);
+  }
+  const providerStats = /* @__PURE__ */ new Map();
+  const modelStats = /* @__PURE__ */ new Map();
+  for (const r of filtered) {
+    const ps = providerStats.get(r.providerId) ?? {
+      providerId: r.providerId,
+      totalTokens: 0,
+      totalInput: 0,
+      totalOutput: 0,
+      totalCost: 0,
+      totalRequests: 0,
+      modelCount: /* @__PURE__ */ new Set()
+    };
+    ps.totalTokens += r.inputTokens + r.outputTokens + r.cacheReadTokens + r.cacheWriteTokens;
+    ps.totalInput += r.inputTokens;
+    ps.totalOutput += r.outputTokens;
+    ps.totalCost += r.cost;
+    ps.totalRequests += r.requests;
+    ps.modelCount.add(r.modelId);
+    providerStats.set(r.providerId, ps);
+    const mk = `${r.providerId}/${r.modelId}`;
+    const ms = modelStats.get(mk) ?? {
+      modelId: r.modelId,
+      providerId: r.providerId,
+      totalTokens: 0,
+      totalInput: 0,
+      totalOutput: 0,
+      totalCost: 0,
+      totalRequests: 0
+    };
+    ms.totalTokens += r.inputTokens + r.outputTokens + r.cacheReadTokens + r.cacheWriteTokens;
+    ms.totalInput += r.inputTokens;
+    ms.totalOutput += r.outputTokens;
+    ms.totalCost += r.cost;
+    ms.totalRequests += r.requests;
+    modelStats.set(mk, ms);
+  }
+  return {
+    totalTokens,
+    totalInput,
+    totalOutput,
+    totalCacheRead,
+    totalCacheWrite,
+    totalCost,
+    totalRequests,
+    cacheHitRate: Math.round(cacheHitRate * 10) / 10,
+    dailyBreakdown: Array.from(daily.entries()).map(([date, d]) => ({ date, ...d })).sort((a, b) => a.date.localeCompare(b.date)),
+    hourlyBreakdown: Array.from(hourly.entries()).map(([, h]) => ({ hour: h.hour, input: h.input, output: h.output, cacheRead: h.cacheRead, cacheWrite: h.cacheWrite, cost: h.cost, requests: h.requests })).sort((a, b) => a.hour.localeCompare(b.hour)),
+    requestLog: Array.from(requestLog.values()).sort((a, b) => b.timestamp.localeCompare(a.timestamp)),
+    providerStats: Array.from(providerStats.values()).map((ps) => ({ ...ps, modelCount: ps.modelCount.size })).sort((a, b) => b.totalCost - a.totalCost),
+    modelStats: Array.from(modelStats.values()).sort((a, b) => b.totalCost - a.totalCost)
+  };
+}
+const HERMES_DIR = path.join(PI_DIR, "pi-hermes-memory");
+function readMemoryFiles() {
+  const files = [
+    { name: "Project Memories", filename: "MEMORY.md" },
+    { name: "User Profile", filename: "USER.md" },
+    { name: "Failure Records", filename: "failures.md" }
+  ];
+  return files.map(({ name, filename }) => {
+    const filePath = path.join(HERMES_DIR, filename);
+    let content = "";
+    let updatedAt = "";
+    try {
+      if (fs.existsSync(filePath)) {
+        content = fs.readFileSync(filePath, "utf-8");
+        const stat = fs.statSync(filePath);
+        updatedAt = stat.mtime.toISOString();
+      }
+    } catch {
+      content = "// Error reading file";
+    }
+    return { name, filename, content, updatedAt };
+  });
+}
+function decodeProjectName(dirName) {
+  let decoded = dirName.replace(/^--|--$/g, "").replace(/--/g, "/");
+  const home = os.homedir();
+  let displayName = decoded;
+  if (displayName.startsWith(home)) {
+    displayName = "~" + displayName.slice(home.length);
+  }
+  const segments = displayName.split("/").filter(Boolean);
+  const projectName = segments.length > 0 ? segments[segments.length - 1] ?? dirName : dirName;
+  return { projectPath: decoded, projectName };
+}
+function listSessions() {
+  const dirs = getSessionDirs();
+  const groups = /* @__PURE__ */ new Map();
+  for (const dir of dirs) {
+    const dirName = dir.split("/").pop() || dir;
+    const { projectPath, projectName } = decodeProjectName(dirName);
+    if (!groups.has(projectPath)) {
+      groups.set(projectPath, {
+        projectPath,
+        projectName,
+        sessions: [],
+        totalSessions: 0,
+        lastActive: ""
+      });
+    }
+    const group = groups.get(projectPath);
+    const files = [];
+    walkSessionJsonl(dir, files);
+    files.sort().reverse();
+    for (const filePath of files) {
+      const session = parseSessionFileInfo(filePath);
+      if (session) {
+        group.sessions.push(session);
+      }
+    }
+    group.totalSessions = group.sessions.length;
+    if (group.sessions.length > 0) {
+      group.lastActive = group.sessions[0]?.timestamp ?? "";
+    }
+  }
+  return Array.from(groups.values()).filter((g) => g.sessions.length > 0).sort((a, b) => b.lastActive.localeCompare(a.lastActive));
+}
+function parseSessionFileInfo(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    let id = "";
+    let timestamp = "";
+    let name;
+    let provider = "unknown";
+    let model = "unknown";
+    let messageCount = 0;
+    let firstTs = 0;
+    let lastTs = 0;
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        const type = obj.type;
+        if (type === "session") {
+          id = obj.id || "";
+          timestamp = obj.timestamp || "";
+          const ts = new Date(timestamp).getTime();
+          firstTs = ts;
+          lastTs = ts;
+        } else if (type === "session_info") {
+          name = obj.name || name;
+        } else if (type === "model_change") {
+          provider = obj.provider || provider;
+          model = obj.modelId || model;
+        } else if (type === "message") {
+          messageCount++;
+          const ts = new Date(obj.timestamp).getTime();
+          if (ts > lastTs) lastTs = ts;
+          if (firstTs === 0) firstTs = ts;
+        }
+      } catch {
+      }
+    }
+    const duration = lastTs > firstTs ? lastTs - firstTs : void 0;
+    const fileName = filePath.split("/").pop() || filePath;
+    return {
+      id,
+      fileName,
+      filePath,
+      timestamp,
+      lastActive: lastTs > 0 ? new Date(lastTs).toISOString() : timestamp,
+      name,
+      provider,
+      model,
+      messageCount,
+      duration
+    };
+  } catch {
+    return null;
+  }
+}
+const SESSIONS_DIR = path.join(PI_DIR, "sessions");
+const TRASH_DIR = path.join(PI_DIR, ".trash");
+function walkJsonl(dir, out) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const p = path.join(dir, name);
+    try {
+      if (fs.statSync(p).isDirectory()) walkJsonl(p, out);
+      else if (name.endsWith(".jsonl")) out.push(p);
+    } catch {
+    }
+  }
+}
+function trashSessionFile(filePath) {
+  try {
+    const resolved = path.resolve(filePath);
+    if (!resolved.startsWith(SESSIONS_DIR + path.sep)) return false;
+    if (!resolved.endsWith(".jsonl") || !fs.existsSync(resolved)) return false;
+    const rel = path.relative(SESSIONS_DIR, resolved);
+    const trashPath = path.join(TRASH_DIR, rel);
+    fs.mkdirSync(path.dirname(trashPath), { recursive: true });
+    fs.renameSync(resolved, trashPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listTrash() {
+  const files = [];
+  walkJsonl(TRASH_DIR, files);
+  const entries = [];
+  for (const trashPath of files) {
+    const info = parseSessionFileInfo(trashPath);
+    let trashedAt = "";
+    try {
+      trashedAt = fs.statSync(trashPath).ctime.toISOString();
+    } catch {
+    }
+    const rel = path.relative(TRASH_DIR, trashPath);
+    entries.push({
+      trashPath,
+      originalPath: path.join(SESSIONS_DIR, rel),
+      fileName: trashPath.split("/").pop() || trashPath,
+      trashedAt,
+      sessionId: info?.id || "",
+      sessionName: info?.name || "",
+      lastActive: info?.lastActive || "",
+      messageCount: info?.messageCount || 0
+    });
+  }
+  return entries.sort((a, b) => b.trashedAt.localeCompare(a.trashedAt));
+}
+function restoreFromTrash(trashPath) {
+  try {
+    const resolved = path.resolve(trashPath);
+    if (!resolved.startsWith(TRASH_DIR + path.sep) || !fs.existsSync(resolved)) return false;
+    const rel = path.relative(TRASH_DIR, resolved);
+    const original = path.join(SESSIONS_DIR, rel);
+    fs.mkdirSync(path.dirname(original), { recursive: true });
+    fs.renameSync(resolved, original);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function permanentlyDeleteTrash(trashPath) {
+  try {
+    const resolved = path.resolve(trashPath);
+    if (!resolved.startsWith(TRASH_DIR + path.sep) || !fs.existsSync(resolved)) return false;
+    fs.unlinkSync(resolved);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const AUTO_EXPIRE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+let autoExpireTimer = null;
+function getSessionExpiryDays() {
+  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;
+}
+function autoExpireSessions() {
+  const result = { expired: [], skipped: [], errors: [] };
+  const expiryDays = getSessionExpiryDays();
+  const cutoffMs = Date.now() - expiryDays * 24 * 60 * 60 * 1e3;
+  const dirs = getSessionDirs();
+  for (const dir of dirs) {
+    let files;
+    try {
+      files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path.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;
+}
+function startAutoExpiryTimer() {
+  if (autoExpireTimer) return;
+  try {
+    autoExpireSessions();
+  } catch {
+  }
+  autoExpireTimer = setInterval(() => {
+    try {
+      autoExpireSessions();
+    } catch {
+    }
+  }, AUTO_EXPIRE_INTERVAL_MS);
+}
+function readSessionPreview(filePath, limit = 20) {
+  try {
+    const resolved = path.resolve(filePath);
+    const inSessions = resolved.startsWith(SESSIONS_DIR + path.sep);
+    const inTrash = resolved.startsWith(TRASH_DIR + path.sep);
+    if (!inSessions && !inTrash || !resolved.endsWith(".jsonl") || !fs.existsSync(resolved)) return null;
+    const lines = fs.readFileSync(resolved, "utf-8").split("\n").filter((l) => l.trim());
+    const messages = [];
+    let total = 0;
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type !== "message") continue;
+        const msg = obj.message || {};
+        const role = msg.role || "";
+        if (role !== "user" && role !== "assistant") continue;
+        total++;
+        if (messages.length >= limit) continue;
+        let text = "";
+        if (typeof msg.content === "string") {
+          text = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          text = msg.content.filter((c) => c?.type === "text" && c.text).map((c) => c.text).join("\n");
+          if (!text) {
+            const tools = msg.content.filter((c) => c?.type === "toolCall").length;
+            if (tools > 0) text = `[${tools} tool call${tools > 1 ? "s" : ""}]`;
+          }
+        }
+        text = text.trim();
+        if (text.length > 400) text = text.slice(0, 400) + "…";
+        messages.push({ role, text, timestamp: obj.timestamp || "" });
+      } catch {
+      }
+    }
+    return { messages, total };
+  } catch {
+    return null;
+  }
+}
+const MEMORY_FILENAMES = ["MEMORY.md", "USER.md", "failures.md"];
+function sectionText(section) {
+  return section.replace(/<!--\s*created\s*=[^>]*-->\s*$/, "").trim();
+}
+function deleteMemoryEntry(filename, entryText) {
+  try {
+    if (!MEMORY_FILENAMES.includes(filename)) return false;
+    const filePath = path.join(HERMES_DIR, filename);
+    if (!fs.existsSync(filePath)) return false;
+    const content = fs.readFileSync(filePath, "utf-8");
+    const sections = content.split("§");
+    const target = entryText.trim();
+    const idx = sections.findIndex((s) => s.trim().length > 0 && sectionText(s) === target);
+    if (idx === -1) return false;
+    sections.splice(idx, 1);
+    fs.writeFileSync(filePath, sections.join("§"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+const PI_CORE_PACKAGE = "@earendil-works/pi-coding-agent";
+const REGISTRY_TIMEOUT_MS = 8e3;
+function getPiVersion() {
+  const home = os.homedir();
+  const candidates = [
+    process.env.PI_BINARY,
+    "pi",
+    `${home}/.npm-global/bin/pi`,
+    `${home}/.npm-packages/bin/pi`,
+    `${home}/.config/yarn/global/node_modules/.bin/pi`,
+    `${home}/.local/share/pnpm/pi`
+  ].filter(Boolean);
+  for (const bin of candidates) {
+    try {
+      const out = child_process.spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 15e3 });
+      if (out.status === 0) {
+        const v = out.stdout.trim();
+        if (v) return v;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isNewerVersion(installed, latest) {
+  const parse = (v) => (v.replace(/^v/, "").split("-")[0] ?? "").split(".").map((s) => parseInt(s, 10) || 0);
+  const a = parse(installed);
+  const b = parse(latest);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const ai = a[i] ?? 0;
+    const bi = b[i] ?? 0;
+    if (bi > ai) return true;
+    if (bi < ai) return false;
+  }
+  return false;
+}
+let undiciPromise = null;
+function getUndici() {
+  if (!undiciPromise) {
+    undiciPromise = import("undici").catch(() => null);
+  }
+  return undiciPromise;
+}
+let proxyCache = null;
+function detectProxyUrl() {
+  if (proxyCache && Date.now() - proxyCache.at < 6e4) return proxyCache.url;
+  let found = process.env.https_proxy || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.HTTP_PROXY || null;
+  if (found && !found.startsWith("http")) found = null;
+  if (!found && process.platform === "darwin") {
+    try {
+      const out = child_process.spawnSync("scutil", ["--proxy"], { encoding: "utf8", timeout: 3e3 }).stdout || "";
+      const get = (k) => out.match(new RegExp(`${k} : (\\S+)`))?.[1];
+      if (get("HTTPSEnable") === "1" && get("HTTPSProxy")) {
+        found = `http://${get("HTTPSProxy")}:${get("HTTPSPort") ?? "80"}`;
+      } else if (get("HTTPEnable") === "1" && get("HTTPProxy")) {
+        found = `http://${get("HTTPProxy")}:${get("HTTPPort") ?? "80"}`;
+      }
+    } catch {
+    }
+  }
+  proxyCache = { url: found, at: Date.now() };
+  return found;
+}
+const proxyAgents = /* @__PURE__ */ new Map();
+async function fetchExternal(url2, init) {
+  const target = url2 instanceof URL ? url2.toString() : url2;
+  const proxy = detectProxyUrl();
+  const undici = proxy ? await getUndici() : null;
+  if (proxy && undici) {
+    try {
+      let agent = proxyAgents.get(proxy);
+      if (!agent) {
+        agent = new undici.ProxyAgent(proxy);
+        proxyAgents.set(proxy, agent);
+      }
+      return await undici.fetch(target, { ...init, dispatcher: agent });
+    } catch {
+    }
+  }
+  return await fetch(target, init);
+}
+async function fetchLatestVersion(pkgName) {
+  try {
+    const res = await fetchExternal(`https://registry.npmjs.org/${encodeURIComponent(pkgName)}/latest`, {
+      signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS),
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+function listInstalledExtensions() {
+  const dir = path.join(PI_DIR, "npm");
+  const manifest = readJsonFile(path.join(dir, "package.json"));
+  if (!manifest?.dependencies) return [];
+  return Object.keys(manifest.dependencies).map((name) => {
+    const pkg = readJsonFile(path.join(dir, "node_modules", name, "package.json"));
+    return { name, installed: pkg?.version ?? "unknown" };
+  });
+}
+async function checkUpdates() {
+  const piVersion = getPiVersion();
+  const extensions = listInstalledExtensions();
+  const toItem = async (name, installed) => {
+    const latest = await fetchLatestVersion(name);
+    return {
+      name,
+      installed,
+      latest,
+      hasUpdate: latest !== null && installed !== "unknown" && isNewerVersion(installed, latest)
+    };
+  };
+  const [piItem, ...extItems] = await Promise.all([
+    piVersion ? toItem(PI_CORE_PACKAGE, piVersion) : Promise.resolve(null),
+    ...extensions.map((e) => toItem(e.name, e.installed))
+  ]);
+  return { pi: piItem, extensions: extItems, checkedAt: Date.now() };
+}
+function realpathOr(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return null;
+  }
+}
+function npmBinCandidates() {
+  const home = os.homedir();
+  const fromPath = (process.env.PATH || "").split(":").filter(Boolean).map((d) => path.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 = path.join(home, ".local", "share", "pi-node");
+      try {
+        return fs.readdirSync(base).filter((n) => n.startsWith("node-")).map((n) => path.join(base, n, "bin", "npm"));
+      } catch {
+        return [];
+      }
+    })()
+  ];
+}
+function resolveNpmCliJs() {
+  for (const bin of npmBinCandidates()) {
+    const real = realpathOr(bin);
+    if (real && fs.existsSync(real) && /npm-cli\.js$/.test(real)) return real;
+  }
+  return null;
+}
+function resolveNodeBin() {
+  const home = os.homedir();
+  const fromPath = (process.env.PATH || "").split(":").filter(Boolean).map((d) => path.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 = path.join(home, ".local", "share", "pi-node");
+      try {
+        return fs.readdirSync(base).filter((n) => n.startsWith("node-")).map((n) => path.join(base, n, "bin", "node"));
+      } catch {
+        return [];
+      }
+    })()
+  ];
+  for (const bin of candidates) {
+    try {
+      const out = child_process.spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 5e3 });
+      if (out.status === 0 && out.stdout) return bin;
+    } catch {
+    }
+  }
+  return null;
+}
+function applyExtensionUpdates(names) {
+  const dir = path.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)) {
+      return { name, success: false, message: "not an installed extension" };
+    }
+    try {
+      const args = ["install", `${name}@latest`, "--no-audit", "--no-fund", "--legacy-peer-deps"];
+      let out;
+      if (nodeBin && npmCliJs) {
+        out = child_process.spawnSync(nodeBin, [npmCliJs, ...args], {
+          cwd: dir,
+          encoding: "utf8",
+          timeout: 12e4
+        });
+      } else {
+        out = child_process.spawnSync("npm", args, { cwd: dir, encoding: "utf8", timeout: 12e4 });
+      }
+      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}` };
+    } catch (e) {
+      return { name, success: false, message: String(e) };
+    }
+  });
+}
+async function testProviderConnection(baseUrl, apiKey) {
+  let url2;
+  try {
+    url2 = new URL(baseUrl.replace(/\/+$/, "") + "/models");
+  } catch {
+    return { success: false, message: "invalid URL" };
+  }
+  if (url2.protocol !== "http:" && url2.protocol !== "https:") {
+    return { success: false, message: "invalid URL" };
+  }
+  let key = apiKey ?? "";
+  if (key.startsWith("$")) key = process.env[key.slice(1)] ?? "";
+  const headers = {};
+  if (key) headers["Authorization"] = `Bearer ${key}`;
+  const started = Date.now();
+  try {
+    const res = await fetchExternal(url2, {
+      headers,
+      signal: AbortSignal.timeout(1e4)
+    });
+    const latencyMs = Date.now() - started;
+    if (res.ok) return { success: true, status: res.status, latencyMs };
+    return { success: false, status: res.status, latencyMs, message: `HTTP ${res.status}` };
+  } catch (e) {
+    const latencyMs = Date.now() - started;
+    const msg = e?.name === "TimeoutError" ? "timeout" : e?.cause?.code || e?.message || String(e);
+    return { success: false, latencyMs, message: msg };
+  }
+}
+function toNum(v) {
+  if (typeof v === "number") return v;
+  if (typeof v !== "string") return void 0;
+  const m = v.match(/^([0-9]+)([KkMm]?)$/);
+  if (!m) return void 0;
+  const n = parseInt(m[1] ?? "0", 10);
+  const u = (m[2] ?? "").toUpperCase();
+  return u === "K" ? n * 1e3 : u === "M" ? n * 1e6 : n;
+}
+const REASONING_RE = /(^|[/_\-])(r1|o1|o3|o4|z1|reasoner|reasoning|qwq|deepseek-r|think)([/_\-:]|$)/i;
+const VISION_RE = /(vision|[-_]vl\b|multimodal|gpt-4o|gpt-5|claude-(sonnet|opus)|gemini|llama-.*vision|qwen.*vl|glm-.*v\b)/i;
+const AUDIO_RE = /(audio|whisper|tts|speech)/i;
+function heuristicFlags(id) {
+  const k = id.toLowerCase();
+  const reasoning = REASONING_RE.test(k);
+  const vision = VISION_RE.test(k);
+  const audio = AUDIO_RE.test(k);
+  let contextWindow;
+  if (/[-_](1m|1024k|1048576)\b/i.test(k)) contextWindow = 1048576;
+  else if (/[-_](256k)\b/i.test(k)) contextWindow = 262144;
+  else if (/[-_](128k)\b/i.test(k)) contextWindow = 131072;
+  else if (/[-_](64k)\b/i.test(k)) contextWindow = 65536;
+  else if (/[-_](32k)\b/i.test(k)) contextWindow = 32768;
+  else if (/[-_](16k)\b/i.test(k)) contextWindow = 16384;
+  else if (/[-_](8k)\b/i.test(k)) contextWindow = 8192;
+  return { reasoning, vision, audio, contextWindow };
+}
+function isOpenRouter(baseUrl, host) {
+  return host === "openrouter.ai" || host.endsWith(".openrouter.ai") || baseUrl.includes("openrouter.ai");
+}
+async function fetchJson(url2, headers, timeoutMs = 15e3) {
+  const res = await fetchExternal(url2, { headers, signal: AbortSignal.timeout(timeoutMs) });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const text = await res.text();
+  const trimmed = text.trimStart();
+  const ctype = res.headers.get("content-type") ?? "";
+  if (trimmed.startsWith("<") || ctype.includes("text/html")) {
+    throw new Error(`endpoint returned HTML, not JSON (check base URL): ${url2.toString()}`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`invalid JSON from ${url2.toString()}`);
+  }
+}
+function makeHeaders(key, providerId, host) {
+  const headers = {};
+  if (!key) return headers;
+  if (providerId === "anthropic" || host && host.endsWith("api.anthropic.com")) {
+    headers["x-api-key"] = key;
+    headers["anthropic-version"] = "2023-06-01";
+  } else if (providerId === "google" || host && host.endsWith("generativelanguage.googleapis.com")) ;
+  else {
+    headers["Authorization"] = `Bearer ${key}`;
+  }
+  return headers;
+}
+async function fetchProviderModels(baseUrl, apiKey, providerId) {
+  let key = apiKey ?? "";
+  if (key.startsWith("$")) key = process.env[key.slice(1)] ?? "";
+  let base;
+  try {
+    base = new URL(baseUrl.replace(/\/+$/, ""));
+  } catch {
+    return { models: [], error: "invalid URL" };
+  }
+  if (base.protocol !== "http:" && base.protocol !== "https:") {
+    return { models: [], error: "invalid URL" };
+  }
+  const host = base.hostname;
+  try {
+    const isOllama = host === "localhost" && base.port === "11434";
+    if (isOllama) {
+      const tagsUrl = new URL("/api/tags", base);
+      const data2 = await fetchJson(tagsUrl, {});
+      const models2 = [];
+      const models_ = data2?.models ?? [];
+      for (const m of models_) {
+        const id = typeof m === "string" ? m : m.name ?? m.model ?? "";
+        if (!id) continue;
+        const flags = heuristicFlags(id);
+        let cw = flags.contextWindow;
+        let mt;
+        try {
+          const showUrl = new URL("/api/show", base);
+          const show = await fetch(showUrl.toString(), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: id }),
+            signal: AbortSignal.timeout(5e3)
+          }).then((r) => r.json());
+          cw = toNum(show?.model_info?.[`${show?.modelfile?.split("\n").find((l) => l.startsWith("FROM")) ?? ""}`]) ?? cw;
+          if (show?.context_length) cw = toNum(show.context_length) ?? cw;
+        } catch {
+        }
+        models2.push({
+          id,
+          contextWindow: cw,
+          maxTokens: mt,
+          reasoning: flags.reasoning,
+          vision: flags.vision,
+          audio: flags.audio,
+          source: "ollama"
+        });
+      }
+      return { models: models2 };
+    }
+    const modelsUrl = new URL(base.toString().replace(/\/+$/, "") + "/models");
+    if (providerId === "google" || host.endsWith("generativelanguage.googleapis.com")) {
+      if (key) modelsUrl.searchParams.set("key", key);
+    }
+    const headers = makeHeaders(key, providerId, host);
+    const data = await fetchJson(modelsUrl, headers, isOpenRouter(baseUrl, host) ? 2e4 : 15e3);
+    const seen = /* @__PURE__ */ new Set();
+    const models = [];
+    const pushModel = (m) => {
+      const v = (m.id ?? "").trim();
+      if (!v || seen.has(v)) return;
+      seen.add(v);
+      const flags = heuristicFlags(v);
+      m.reasoning = m.reasoning ?? flags.reasoning;
+      m.vision = m.vision ?? flags.vision;
+      m.audio = m.audio ?? flags.audio;
+      m.contextWindow = m.contextWindow ?? flags.contextWindow;
+      models.push(m);
+    };
+    const visionOf = (item) => {
+      if (!item || typeof item !== "object") return void 0;
+      if (typeof item.capabilities?.vision === "boolean") return item.capabilities.vision;
+      if (item.supports_vision === true || item.vision === true) return true;
+      const mods = item.architecture?.input_modalities ?? item.input_modalities ?? item.modalities;
+      if (Array.isArray(mods)) return mods.includes("image");
+      const modality = item.architecture?.modality;
+      if (typeof modality === "string") {
+        return (modality.split("->")[0] ?? "").includes("image");
+      }
+      return void 0;
+    };
+    const audioOf = (item) => {
+      const mods = item.architecture?.input_modalities ?? item.input_modalities ?? item.modalities;
+      if (Array.isArray(mods)) return mods.includes("audio");
+      return void 0;
+    };
+    const reasoningOf = (item) => {
+      if (item?.reasoning === true || item?.supports_reasoning === true) return true;
+      return void 0;
+    };
+    const parseCost = (pricing) => {
+      if (!pricing) return void 0;
+      const toDollar = (v) => typeof v === "string" ? parseFloat(v) * 1e6 : typeof v === "number" ? v * 1e6 : void 0;
+      const input = toDollar(pricing.prompt ?? pricing.input);
+      const output = toDollar(pricing.completion ?? pricing.output);
+      const cacheRead = toDollar(pricing.cache_read ?? pricing.cacheRead);
+      const cacheWrite = toDollar(pricing.cache_write ?? pricing.cacheWrite);
+      if (input === void 0 && output === void 0) return void 0;
+      return { input: input ?? 0, output: output ?? 0, cacheRead, cacheWrite };
+    };
+    const parseItem = (item) => {
+      const rawId = typeof item === "string" ? item : item?.id ?? item?.model ?? item?.name ?? "";
+      const id = typeof rawId === "string" ? rawId.replace(/^models\//, "") : "";
+      if (!id) return;
+      const name = typeof item?.name === "string" ? item.name : void 0;
+      const cw = toNum(item?.context_length) ?? toNum(item?.max_context) ?? toNum(item?.context_window) ?? toNum(item?.inputTokenLimit) ?? toNum(item?.max_tokens) ?? void 0;
+      const mt = toNum(item?.max_output_tokens) ?? toNum(item?.top_provider?.max_completion_tokens) ?? toNum(item?.max_completion_tokens) ?? toNum(item?.outputTokenLimit) ?? toNum(item?.max_tokens) ?? void 0;
+      const isOR = isOpenRouter(baseUrl, host);
+      pushModel({
+        id,
+        name: name !== id ? name : void 0,
+        contextWindow: cw,
+        maxTokens: mt,
+        reasoning: reasoningOf(item),
+        vision: visionOf(item),
+        audio: audioOf(item),
+        cost: isOR ? parseCost(item.pricing) : void 0,
+        source: isOR ? "openrouter" : "openai"
+      });
+    };
+    if (Array.isArray(data)) {
+      data.forEach(parseItem);
+    } else if (data && typeof data === "object") {
+      const dataArr = data.data ?? data.models ?? data.models_list ?? null;
+      if (Array.isArray(dataArr)) dataArr.forEach(parseItem);
+    }
+    return { models };
+  } catch (e) {
+    const msg = e?.name === "TimeoutError" ? "timeout" : e?.cause?.code || e?.message || String(e);
+    return { models: [], error: msg };
+  }
+}
+async function testModel(baseUrl, modelId, apiKey, apiType = "openai-completions") {
+  let url2;
+  try {
+    url2 = new URL(baseUrl.replace(/\/+$/, "") + "/chat/completions");
+  } catch {
+    return { success: false, message: "invalid URL" };
+  }
+  if (url2.protocol !== "http:" && url2.protocol !== "https:") {
+    return { success: false, message: "invalid URL" };
+  }
+  let key = apiKey ?? "";
+  if (key.startsWith("$")) key = process.env[key.slice(1)] ?? "";
+  const headers = { "Content-Type": "application/json" };
+  if (key) headers["Authorization"] = `Bearer ${key}`;
+  const body = {
+    model: modelId,
+    messages: [{ role: "user", content: "Reply with a single word: ok" }],
+    max_tokens: 4,
+    temperature: 0
+  };
+  const started = Date.now();
+  try {
+    const res = await fetchExternal(url2, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15e3)
+    });
+    const latencyMs = Date.now() - started;
+    if (res.ok) {
+      const data = await res.json();
+      const choice = data?.choices?.[0];
+      const hasContent = choice && (choice.message?.content || choice.delta?.content);
+      if (hasContent) {
+        return { success: true, latencyMs };
+      }
+      const hasUsage = !!data?.usage;
+      if (hasUsage) {
+        return { success: true, latencyMs, message: "response received (no content)" };
+      }
+      return { success: false, latencyMs, message: "invalid response: " + JSON.stringify(data).slice(0, 150) };
+    }
+    try {
+      const d = await res.json();
+      return { success: false, status: res.status, latencyMs, message: d?.error?.message || `HTTP ${res.status}` };
+    } catch {
+      return { success: false, status: res.status, latencyMs, message: `HTTP ${res.status}` };
+    }
+  } catch (e) {
+    const latencyMs = Date.now() - started;
+    const msg = e?.name === "TimeoutError" ? "timeout" : e?.message || String(e);
+    return { success: false, latencyMs, message: msg };
+  }
+}
+const AGENTS_DIR = path.join(PI_DIR, "agents");
+const CHAINS_DIR = path.join(PI_DIR, "chains");
+const RUN_HISTORY_PATH = path.join(PI_DIR, "run-history.jsonl");
+function parseFrontmatter(raw) {
+  const frontmatter = {};
+  const first = raw.indexOf("---");
+  if (first !== 0) return { frontmatter, body: raw };
+  const second = raw.indexOf("---", 3);
+  if (second === -1) return { frontmatter, body: raw };
+  const yamlLines = raw.slice(3, second).trim().split("\n");
+  const body = raw.slice(second + 3).trim();
+  for (const line of yamlLines) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+    if (value.startsWith("[") && value.endsWith("]")) {
+      value = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+    } else if (value === "true" || value === "false") {
+      value = value === "true";
+    } else if (/^\d+$/.test(value)) {
+      value = parseInt(value, 10);
+    } else if (/^\d+\.\d+$/.test(value)) {
+      value = parseFloat(value);
+    } else {
+      value = value.replace(/^["']|["']$/g, "");
+    }
+    frontmatter[key] = value;
+  }
+  return { frontmatter, body };
+}
+function listAgents() {
+  try {
+    if (!fs.existsSync(AGENTS_DIR)) return [];
+    const files = fs.readdirSync(AGENTS_DIR).filter((f) => f.endsWith(".md"));
+    return files.map((fileName) => {
+      const filePath = path.join(AGENTS_DIR, fileName);
+      try {
+        let splitMaybe = function(val) {
+          if (Array.isArray(val)) return val.map(String);
+          if (typeof val === "string" && val.trim()) return val.split(/\s*,\s*/).filter(Boolean);
+          return void 0;
+        };
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const { frontmatter, body } = parseFrontmatter(raw);
+        return {
+          name: frontmatter.name || fileName.replace(/\.md$/, ""),
+          fileName,
+          filePath,
+          package: frontmatter.package || "custom",
+          description: frontmatter.description || "",
+          model: frontmatter.model,
+          tools: splitMaybe(frontmatter.tools),
+          thinking: frontmatter.thinking,
+          systemPromptMode: frontmatter.systemPromptMode,
+          inheritProjectContext: frontmatter.inheritProjectContext,
+          inheritSkills: frontmatter.inheritSkills,
+          input: splitMaybe(frontmatter.input),
+          body: body.slice(0, 500)
+        };
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function listChains() {
+  try {
+    if (!fs.existsSync(CHAINS_DIR)) return [];
+    const files = fs.readdirSync(CHAINS_DIR).filter((f) => f.endsWith(".chain.md"));
+    return files.map((fileName) => {
+      const filePath = path.join(CHAINS_DIR, fileName);
+      try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const { frontmatter, body } = parseFrontmatter(raw);
+        const steps = [];
+        const stepRegex = /##\s+(\([^)]+\)\s*\|[^\n]+|[^\n]+)/g;
+        let match;
+        while ((match = stepRegex.exec(body)) !== null) {
+          const header = match[1].trim();
+          const parallelMatch = header.match(/^\(([^)]+)\)/);
+          if (parallelMatch) {
+            const agents = parallelMatch[1].split("|").map((s) => s.trim());
+            agents.forEach((agent) => steps.push({ agent }));
+          } else {
+            steps.push({ agent: header });
+          }
+        }
+        return {
+          name: frontmatter.name || fileName.replace(/\.chain\.md$/, ""),
+          fileName,
+          filePath,
+          description: frontmatter.description || "",
+          steps,
+          body: raw.slice(0, 300)
+        };
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function readRunHistory(limit = 100) {
+  try {
+    if (!fs.existsSync(RUN_HISTORY_PATH)) return [];
+    const raw = fs.readFileSync(RUN_HISTORY_PATH, "utf-8");
+    const lines = raw.split("\n").filter(Boolean);
+    return lines.slice(-limit).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((r) => r !== null).reverse();
+  } catch {
+    return [];
+  }
+}
+function readSubagents() {
+  return {
+    agents: listAgents(),
+    chains: listChains(),
+    runHistory: readRunHistory()
+  };
+}
+function findPiAiProvidersDir() {
+  const home = os.homedir();
+  const roots = [];
+  const which = child_process.spawnSync("which", ["pi"], { encoding: "utf8", timeout: 5e3 });
+  const bin = which.status === 0 ? which.stdout.trim() : "";
+  if (bin) {
+    const real = child_process.spawnSync("readlink", ["-f", bin], { encoding: "utf8", timeout: 5e3 });
+    const cli = real.status === 0 ? real.stdout.trim() : "";
+    if (cli) roots.push(path.resolve(path.dirname(cli), ".."));
+  }
+  const piNode = path.join(home, ".local", "share", "pi-node");
+  try {
+    for (const v of fs.readdirSync(piNode)) {
+      roots.push(path.join(piNode, v, "lib", "node_modules", PI_CORE_PACKAGE));
+    }
+  } catch {
+  }
+  for (const root of roots) {
+    const dir = path.join(root, "node_modules", "@earendil-works", "pi-ai", "dist", "providers");
+    if (fs.existsSync(path.join(dir, "data"))) return dir;
+  }
+  return null;
+}
+let catalogCache = null;
+function readBuiltinCatalog() {
+  if (catalogCache && Date.now() - catalogCache.at < 3e5) return catalogCache.providers;
+  const dir = findPiAiProvidersDir();
+  if (!dir) return null;
+  const providers = [];
+  let files;
+  try {
+    files = fs.readdirSync(path.join(dir, "data")).filter(
+      (f) => f.endsWith(".json") && !f.startsWith(".")
+    );
+  } catch {
+    return null;
+  }
+  for (const file of files) {
+    const id = file.replace(/\.json$/, "");
+    const data = readJsonFile(path.join(dir, "data", file));
+    if (!data) continue;
+    const models = [];
+    let baseUrl;
+    let api;
+    for (const apiKey of Object.keys(data)) {
+      for (const m of Object.values(data[apiKey] ?? {})) {
+        if (!m?.id) continue;
+        baseUrl = baseUrl ?? m.baseUrl;
+        api = api ?? m.api;
+        models.push({
+          id: m.id,
+          name: m.name,
+          reasoning: !!m.reasoning,
+          input: Array.isArray(m.input) ? m.input : ["text"],
+          contextWindow: m.contextWindow,
+          maxTokens: m.maxTokens,
+          cost: m.cost
+        });
+      }
+    }
+    if (models.length === 0) continue;
+    let name = "";
+    try {
+      const src = fs.readFileSync(path.join(dir, `${id}.js`), "utf-8");
+      const esc = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      name = src.match(new RegExp(`id:\\s*"${esc}",\\s*name:\\s*"([^"]+)"`))?.[1] ?? src.match(/createProvider\(\{[^}]*?name:\s*"([^"]+)"/)?.[1] ?? "";
+    } catch {
+    }
+    if (!name) {
+      name = id.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" ");
+    }
+    providers.push({
+      id,
+      name,
+      type: "builtin",
+      api,
+      baseUrl,
+      hasAuth: false,
+      authMethod: "env",
+      models: models.sort((a, b) => a.id.localeCompare(b.id))
+    });
+  }
+  if (providers.length === 0) return null;
+  providers.sort((a, b) => a.id.localeCompare(b.id));
+  catalogCache = { providers, at: Date.now() };
+  return providers;
+}
+const BUILTIN_PROVIDERS = [
+  {
+    id: "anthropic",
+    name: "Anthropic",
+    type: "builtin",
+    api: "anthropic-messages",
+    baseUrl: "https://api.anthropic.com/v1",
+    hasAuth: true,
+    authMethod: "env",
+    models: [
+      { id: "claude-sonnet-4", name: "Claude 4 Sonnet", reasoning: true, input: ["text", "image"], contextWindow: 2e5, maxTokens: 16384, cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }, enabled: true },
+      { id: "claude-sonnet-4-5", name: "Claude 4.5 Sonnet", reasoning: true, input: ["text", "image"], contextWindow: 2e5, maxTokens: 16384, cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }, enabled: false },
+      { id: "claude-opus-4", name: "Claude 4 Opus", reasoning: true, input: ["text", "image"], contextWindow: 2e5, maxTokens: 32e3, cost: { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 }, enabled: false },
+      { id: "claude-haiku-3-5", name: "Claude 3.5 Haiku", reasoning: false, input: ["text", "image"], contextWindow: 2e5, maxTokens: 8192, cost: { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 }, enabled: true }
+    ]
+  },
+  {
+    id: "openai",
+    name: "OpenAI",
+    type: "builtin",
+    api: "openai-completions",
+    baseUrl: "https://api.openai.com/v1",
+    hasAuth: true,
+    authMethod: "env",
+    models: [
+      { id: "gpt-4o", name: "GPT-4o", reasoning: false, input: ["text", "image"], contextWindow: 128e3, maxTokens: 16384, cost: { input: 2.5, output: 10, cacheRead: 1.25, cacheWrite: 3.75 }, enabled: true },
+      { id: "gpt-4o-mini", name: "GPT-4o Mini", reasoning: false, input: ["text", "image"], contextWindow: 128e3, maxTokens: 16384, cost: { input: 0.15, output: 0.6, cacheRead: 0.075, cacheWrite: 0.225 }, enabled: true },
+      { id: "gpt-5.1", name: "GPT-5.1", reasoning: true, input: ["text", "image"], contextWindow: 256e3, maxTokens: 65536, cost: { input: 10, output: 40, cacheRead: 5, cacheWrite: 10 }, enabled: false },
+      { id: "o3-mini", name: "o3-mini", reasoning: true, input: ["text"], contextWindow: 2e5, maxTokens: 1e5, cost: { input: 1.1, output: 4.4, cacheRead: 0.55, cacheWrite: 1.65 }, enabled: false }
+    ]
+  },
+  {
+    id: "deepseek",
+    name: "DeepSeek",
+    type: "builtin",
+    api: "openai-completions",
+    baseUrl: "https://api.deepseek.com/v1",
+    hasAuth: true,
+    authMethod: "env",
+    models: [
+      { id: "deepseek-chat", name: "DeepSeek V3", reasoning: false, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 0.27, output: 1.1, cacheRead: 0.07, cacheWrite: 0.27 }, enabled: true },
+      { id: "deepseek-reasoner", name: "DeepSeek R1", reasoning: true, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 0.55, output: 2.19, cacheRead: 0.14, cacheWrite: 0.55 }, enabled: true }
+    ]
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    type: "builtin",
+    api: "openai-completions",
+    hasAuth: true,
+    authMethod: "file",
+    models: [
+      { id: "deepseek-v4-flash-free", name: "DeepSeek V4 Flash (Free)", reasoning: false, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, enabled: true },
+      { id: "deepseek-v4-flash", name: "DeepSeek V4 Flash", reasoning: false, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 0.3, output: 0.6, cacheRead: 0.15, cacheWrite: 0.3 }, enabled: true }
+    ]
+  },
+  {
+    id: "opencode-go",
+    name: "OpenCode Go",
+    type: "builtin",
+    api: "openai-completions",
+    hasAuth: true,
+    authMethod: "file",
+    models: [
+      { id: "deepseek-v4-flash", name: "DeepSeek V4 Flash", reasoning: false, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 0.3, output: 0.6, cacheRead: 0.15, cacheWrite: 0.3 }, enabled: true },
+      { id: "deepseek-v4-pro", name: "DeepSeek V4 Pro", reasoning: true, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 2, output: 8, cacheRead: 1, cacheWrite: 2 }, enabled: true },
+      { id: "glm-5.1", name: "GLM 5.1", reasoning: false, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 0.5, output: 2, cacheRead: 0.25, cacheWrite: 0.5 }, enabled: true },
+      { id: "qwen3.7-max", name: "Qwen 3.7 Max", reasoning: true, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 1.5, output: 6, cacheRead: 0.75, cacheWrite: 1.5 }, enabled: true },
+      { id: "mimo-v2.5", name: "MiMo V2.5", reasoning: true, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 1.2, output: 4.8, cacheRead: 0.6, cacheWrite: 1.2 }, enabled: true }
+    ]
+  },
+  {
+    id: "google",
+    name: "Google Gemini",
+    type: "builtin",
+    api: "google-generative-ai",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    hasAuth: true,
+    authMethod: "env",
+    models: [
+      { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash", reasoning: false, input: ["text", "image"], contextWindow: 1048576, maxTokens: 65536, cost: { input: 0.15, output: 0.6, cacheRead: 0.075, cacheWrite: 0.15 }, enabled: true },
+      { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro", reasoning: true, input: ["text", "image"], contextWindow: 1048576, maxTokens: 65536, cost: { input: 1.25, output: 10, cacheRead: 0.625, cacheWrite: 1.25 }, enabled: false }
+    ]
+  },
+  {
+    id: "openrouter",
+    name: "OpenRouter",
+    type: "builtin",
+    api: "openai-completions",
+    baseUrl: "https://openrouter.ai/api/v1",
+    hasAuth: false,
+    authMethod: "none",
+    models: [
+      { id: "openrouter/anthropic/claude-sonnet-4", name: "Claude 4 Sonnet (OpenRouter)", reasoning: true, input: ["text", "image"], contextWindow: 2e5, maxTokens: 16384, cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }, enabled: false },
+      { id: "openrouter/deepseek/deepseek-r1", name: "DeepSeek R1 (OpenRouter)", reasoning: true, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 0.55, output: 2.19, cacheRead: 0.14, cacheWrite: 0.55 }, enabled: false }
+    ]
+  },
+  {
+    id: "mistral",
+    name: "Mistral",
+    type: "builtin",
+    api: "mistral-conversations",
+    baseUrl: "https://api.mistral.ai/v1",
+    hasAuth: false,
+    authMethod: "none",
+    models: [
+      { id: "mistral-large", name: "Mistral Large", reasoning: false, input: ["text"], contextWindow: 128e3, maxTokens: 8192, cost: { input: 2, output: 6, cacheRead: 1, cacheWrite: 2 }, enabled: false }
+    ]
+  },
+  {
+    id: "github-copilot",
+    name: "GitHub Copilot",
+    type: "builtin",
+    api: "openai-completions",
+    baseUrl: "https://api.githubcopilot.com",
+    hasAuth: false,
+    authMethod: "none",
+    models: [
+      { id: "copilot-gpt-4o", name: "Copilot GPT-4o", reasoning: false, input: ["text"], contextWindow: 128e3, maxTokens: 4096, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, enabled: false }
+    ]
+  },
+  {
+    id: "groq",
+    name: "Groq",
+    type: "builtin",
+    api: "openai-completions",
+    baseUrl: "https://api.groq.com/openai/v1",
+    hasAuth: false,
+    authMethod: "none",
+    models: [
+      { id: "llama-3.3-70b", name: "Llama 3.3 70B", reasoning: false, input: ["text"], contextWindow: 128e3, maxTokens: 4096, cost: { input: 0.59, output: 0.79, cacheRead: 0, cacheWrite: 0 }, enabled: false }
+    ]
+  }
+];
+function getBuiltinProviders() {
+  return BUILTIN_PROVIDERS;
+}
+const __dirname$2 = path.dirname(url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("main.cjs", document.baseURI).href));
+const DIST_DIR = path.join(__dirname$2, "../../dist");
+const MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".webmanifest": "application/manifest+json",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function sendJson(res, status, data) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(data));
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}
+function localDateStr(dt) {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(dt);
+}
+function resolveDateRange(range, fromParam, toParam) {
+  const now = /* @__PURE__ */ new Date();
+  let fromDate;
+  let toDate = localDateStr(now);
+  if (range === "today") fromDate = toDate;
+  else if (range === "7d") {
+    const d = new Date(now);
+    d.setDate(d.getDate() - 6);
+    fromDate = localDateStr(d);
+  } else if (range === "30d") {
+    const d = new Date(now);
+    d.setDate(d.getDate() - 29);
+    fromDate = localDateStr(d);
+  } else if (range === "custom" && fromParam) {
+    fromDate = fromParam;
+    if (toParam) toDate = toParam;
+  } else fromDate = toDate;
+  return { fromDate, toDate };
+}
+async function handleApi(method, pathOnly, parsedUrl, req, res) {
+  if (method === "DELETE" && (pathOnly === "/api/pi/session" || pathOnly === "/api/pi/trash")) {
+    const filePath = parsedUrl.searchParams.get("path");
+    if (!filePath) return sendJson(res, 400, { success: false, error: "Missing path" });
+    const decoded = decodeURIComponent(filePath);
+    const ok = pathOnly === "/api/pi/session" ? trashSessionFile(decoded) : permanentlyDeleteTrash(decoded);
+    return sendJson(res, 200, { success: ok });
+  }
+  if (method === "GET" && pathOnly.endsWith("usage-range")) {
+    if (parsedUrl.searchParams.get("refresh") === "1") {
+      clearUsageCache();
+    }
+    const range = parsedUrl.searchParams.get("range") || "today";
+    const fromParam = parsedUrl.searchParams.get("from") || "";
+    const toParam = parsedUrl.searchParams.get("to") || "";
+    const { fromDate, toDate } = resolveDateRange(range, fromParam, toParam);
+    let records = null;
+    if (pathOnly === "/api/pi/usage-range") {
+      records = readAllUsage();
+    } else if (pathOnly === "/api/pi/cindy-usage-range") {
+      records = readCindyUsage();
+    } else if (pathOnly === "/api/pi/claude-usage-range") {
+      records = readClaudeUsage();
+    } else if (pathOnly === "/api/pi/codex-usage-range") {
+      records = readCodexUsage();
+    } else if (pathOnly === "/api/pi/all-usage-range") {
+      records = readAllCombinedUsage();
+    } else {
+      const providerMatch = pathOnly.match(/^\/api\/pi\/(atomcode|copilot|opencode|gemini|grok)-usage-range$/);
+      if (providerMatch) {
+        records = filterByProvider(readAllCombinedUsage(), providerMatch[1]);
+      }
+    }
+    if (!records) return sendJson(res, 404, { error: "Not found" });
+    const usage = getUsageByRange(records, fromDate, toDate);
+    return sendJson(res, 200, usage);
+  }
+  const key = `${method} ${pathOnly}`;
+  const body = await readBody(req).catch(() => "");
+  try {
+    switch (key) {
+      case "GET /api/pi/settings":
+        return sendJson(res, 200, readSettings() ?? {});
+      case "POST /api/pi/settings":
+        return sendJson(res, 200, { success: writeSettings(JSON.parse(body)) });
+      case "GET /api/pi/auth":
+        return sendJson(res, 200, readAuth() ?? {});
+      case "POST /api/pi/auth":
+        return sendJson(res, 200, { success: writeAuth(JSON.parse(body)) });
+      case "GET /api/pi/models":
+        return sendJson(res, 200, readModels() ?? { providers: {} });
+      case "POST /api/pi/models":
+        return sendJson(res, 200, { success: writeModels(JSON.parse(body)) });
+      case "GET /api/pi/builtin-providers": {
+        const catalog = readBuiltinCatalog();
+        return sendJson(res, 200, catalog ?? getBuiltinProviders());
+      }
+      case "GET /api/pi/usage": {
+        const records = readAllUsage();
+        return sendJson(res, 200, {
+          records,
+          dailyAggregates: getDailyAggregates(records),
+          providerSummaries: getProviderSummaries(records),
+          modelSummaries: getModelSummaries(records),
+          totals: getTotals(records)
+        });
+      }
+      case "GET /api/pi/sessions":
+        return sendJson(res, 200, listSessions());
+      case "GET /api/pi/memory":
+        return sendJson(res, 200, readMemoryFiles());
+      case "GET /api/pi/subagents":
+        return sendJson(res, 200, readSubagents());
+      case "POST /api/pi/memory/delete-entry": {
+        const { filename, text } = JSON.parse(body);
+        return sendJson(res, 200, { success: deleteMemoryEntry(filename, text) });
+      }
+      case "GET /api/pi/trash":
+        return sendJson(res, 200, listTrash());
+      case "GET /api/pi/copilot-config":
+        return sendJson(res, 200, readCopilotConfig() ?? {});
+      case "POST /api/pi/copilot-config": {
+        const cfg = JSON.parse(body);
+        const ok = writeCopilotConfig(cfg);
+        clearCopilotCaches();
+        return sendJson(res, 200, { success: ok });
+      }
+      case "POST /api/pi/session/trash": {
+        const { path: p } = JSON.parse(body);
+        return sendJson(res, 200, { success: trashSessionFile(p) });
+      }
+      case "POST /api/pi/session/restore": {
+        const { trashPath } = JSON.parse(body);
+        return sendJson(res, 200, { success: restoreFromTrash(trashPath) });
+      }
+      case "POST /api/pi/session/auto-expire": {
+        try {
+          const result = autoExpireSessions();
+          return sendJson(res, 200, { success: true, ...result });
+        } catch {
+          return sendJson(res, 500, { success: false, error: "Auto-expire failed" });
+        }
+      }
+      case "GET /api/pi/session-preview": {
+        const p = parsedUrl.searchParams.get("path") || "";
+        const preview = readSessionPreview(decodeURIComponent(p));
+        if (!preview) return sendJson(res, 404, { error: "Session not found" });
+        return sendJson(res, 200, preview);
+      }
+      case "GET /api/pi/check-updates": {
+        try {
+          const result = await checkUpdates();
+          return sendJson(res, 200, result);
+        } catch {
+          return sendJson(res, 500, { error: "Update check failed" });
+        }
+      }
+      case "POST /api/pi/apply-updates": {
+        const { names } = JSON.parse(body);
+        return sendJson(res, 200, { results: applyExtensionUpdates(Array.isArray(names) ? names : []) });
+      }
+      case "POST /api/pi/provider-models": {
+        const { baseUrl, apiKey, providerId } = JSON.parse(body);
+        if (!baseUrl) throw new Error("missing baseUrl");
+        const result = await fetchProviderModels(baseUrl, apiKey, providerId);
+        return sendJson(res, 200, result);
+      }
+      case "POST /api/pi/model-test": {
+        const { baseUrl, modelId, apiKey, apiType } = JSON.parse(body);
+        if (!baseUrl || !modelId) throw new Error("missing baseUrl or modelId");
+        const result = await testModel(baseUrl, modelId, apiKey, apiType ?? "openai-completions");
+        return sendJson(res, 200, result);
+      }
+      case "POST /api/pi/provider-test": {
+        const { baseUrl, apiKey } = JSON.parse(body);
+        if (!baseUrl) throw new Error("missing baseUrl");
+        const result = await testProviderConnection(baseUrl, apiKey);
+        return sendJson(res, 200, result);
+      }
+      default:
+        return sendJson(res, 404, { error: "Not found" });
+    }
+  } catch {
+    return sendJson(res, 400, { success: false, error: "Invalid request body" });
+  }
+}
+function serveStatic(pathOnly, res) {
+  let filePath = path.join(DIST_DIR, pathOnly === "/" ? "index.html" : pathOnly);
+  if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+    filePath = path.join(DIST_DIR, "index.html");
+  }
+  const ext = path.extname(filePath).toLowerCase();
+  res.setHeader("Content-Type", MIME[ext] ?? "application/octet-stream");
+  fs.createReadStream(filePath).pipe(res);
+}
+function startApiServer() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const method = req.method ?? "GET";
+      const url2 = req.url ?? "/";
+      const parsedUrl = new URL(url2, "http://localhost");
+      const pathOnly = parsedUrl.pathname;
+      if (pathOnly.startsWith("/api/pi/")) {
+        handleApi(method, pathOnly, parsedUrl, req, res).catch(() => {
+          sendJson(res, 500, { error: "Internal error" });
+        });
+      } else {
+        serveStatic(pathOnly, res);
+      }
+    });
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      resolve({ server, port, url: `http://127.0.0.1:${port}` });
+    });
+  });
+}
+const { app, BrowserWindow, Menu, Tray, ipcMain, nativeImage, shell } = process.mainModule?.require("electron") || require("electron");
+const __dirname$1 = path.dirname(url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("main.cjs", document.baseURI).href));
+let mainWindow = null;
+let popupWindow = null;
+let tray = null;
+let popupHideTimer = null;
+let apiServerUrl = null;
+function pickPath(...candidates) {
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+function resolvePreload() {
+  return path.join(__dirname$1, "../preload/preload.cjs");
+}
+function resolveIndexHtml() {
+  return path.join(__dirname$1, "../../dist/index.html");
+}
+function resolvePopupHtml() {
+  return path.join(__dirname$1, "../../dist/electron/popup.html");
+}
+function resolveAppIcon() {
+  return pickPath(
+    path.join(__dirname$1, "../../public/icon-512.png"),
+    path.join(__dirname$1, "../../dist/icon-512.png")
+  );
+}
+function createTrayIcon() {
+  const iconPath = pickPath(
+    path.join(__dirname$1, "../../build/trayIconTemplate.png"),
+    path.join(__dirname$1, "../../dist/trayIconTemplate.png"),
+    resolveAppIcon() ?? ""
+  );
+  const image = iconPath ? nativeImage.createFromPath(iconPath) : nativeImage.createEmpty();
+  image.setTemplateImage(true);
+  return image;
+}
+function windowStatePath() {
+  return path.join(app.getPath("userData"), "window-state.json");
+}
+function loadWindowState() {
+  const fallback = { width: 1280, height: 800 };
+  try {
+    const raw = fs.readFileSync(windowStatePath(), "utf-8");
+    const state = JSON.parse(raw);
+    const width = typeof state.width === "number" && state.width >= 800 ? Math.round(state.width) : fallback.width;
+    const height = typeof state.height === "number" && state.height >= 600 ? Math.round(state.height) : fallback.height;
+    return { width, height };
+  } catch {
+    return fallback;
+  }
+}
+function saveWindowState(state) {
+  try {
+    const file = windowStatePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(state, null, 2), "utf-8");
+  } catch {
+  }
+}
+function createMainWindow() {
+  const state = loadWindowState();
+  const win = new BrowserWindow({
+    width: state.width,
+    height: state.height,
+    minWidth: 800,
+    minHeight: 600,
+    title: "pi-web-switch",
+    icon: resolveAppIcon() ?? void 0,
+    // macOS immersive title bar: hides the window chrome/title bar while
+    // keeping the traffic-light buttons inset into the content. Non-macOS
+    // platforms ignore this option and keep the native frame.
+    titleBarStyle: "hiddenInset",
+    webPreferences: {
+      preload: resolvePreload(),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  mainWindow = win;
+  let resizeTimer = null;
+  win.on("resize", () => {
+    if (resizeTimer) clearTimeout(resizeTimer);
+    resizeTimer = setTimeout(() => {
+      const [width, height] = win.getSize();
+      saveWindowState({ width, height });
+    }, 400);
+  });
+  if (process.env.VITE_DEV_SERVER_URL) {
+    win.loadURL(process.env.VITE_DEV_SERVER_URL);
+  } else if (apiServerUrl) {
+    win.loadURL(apiServerUrl);
+  } else {
+    win.loadFile(resolveIndexHtml());
+  }
+  win.on("closed", () => {
+    mainWindow = null;
+  });
+  return win;
+}
+function createPopupWindow() {
+  const trayBounds = tray?.getBounds();
+  const x = trayBounds ? Math.round(trayBounds.x + trayBounds.width / 2 - 175) : void 0;
+  const y = trayBounds ? trayBounds.y + trayBounds.height + 4 : void 0;
+  const win = new BrowserWindow({
+    width: 350,
+    height: 420,
+    x,
+    y,
+    show: false,
+    frame: false,
+    resizable: false,
+    maximizable: false,
+    fullscreenable: false,
+    skipTaskbar: true,
+    movable: false,
+    transparent: false,
+    hasShadow: true,
+    backgroundColor: "#ffffff",
+    webPreferences: {
+      preload: resolvePreload(),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  const popupDevUrl = process.env.VITE_DEV_SERVER_URL ? `${process.env.VITE_DEV_SERVER_URL}/electron/popup.html` : null;
+  const popupFile = resolvePopupHtml();
+  if (popupDevUrl) {
+    win.loadURL(popupDevUrl);
+  } else if (fs.existsSync(popupFile)) {
+    win.loadFile(popupFile);
+  } else {
+    win.loadURL("data:text/html;charset=utf-8," + encodeURIComponent(
+      '<html><body style="font-family:-apple-system;padding:16px;">Popup HTML not found.</body></html>'
+    ));
+  }
+  win.on("blur", () => {
+    if (popupHideTimer) clearTimeout(popupHideTimer);
+    popupHideTimer = setTimeout(() => {
+      if (popupWindow && popupWindow.isVisible()) {
+        popupWindow.hide();
+      }
+    }, 150);
+  });
+  win.on("closed", () => {
+    popupWindow = null;
+  });
+  popupWindow = win;
+  return win;
+}
+function createTray() {
+  const t = new Tray(createTrayIcon());
+  tray = t;
+  t.setToolTip("pi-web-switch — 点击查看使用量");
+  t.on("click", () => {
+    togglePopup();
+  });
+  t.on("right-click", () => {
+    showTrayMenu();
+  });
+  t.on("mouse-down", (_e, bounds) => {
+  });
+}
+function showTrayMenu() {
+  if (!tray) return;
+  const menu = Menu.buildFromTemplate([
+    { label: "打开 Dashboard", click: showMainWindow },
+    { label: "刷新使用量", click: () => popupWindow?.webContents.reload() },
+    { type: "separator" },
+    { label: "退出", accelerator: "Command+Q", click: () => app.quit() }
+  ]);
+  tray.popUpContextMenu(menu);
+}
+function togglePopup() {
+  if (!popupWindow) {
+    popupWindow = createPopupWindow();
+  }
+  const popup = popupWindow;
+  if (!popup) return;
+  if (popup.isVisible()) {
+    popup.hide();
+  } else {
+    const t = tray;
+    const trayBounds = t ? t.getBounds() : null;
+    if (trayBounds) {
+      const x = Math.round(trayBounds.x + trayBounds.width / 2 - 175);
+      const y = trayBounds.y + trayBounds.height + 4;
+      popup.setPosition(x, y);
+    }
+    popup.show();
+    popup.focus();
+  }
+}
+function showMainWindow() {
+  if (!mainWindow) {
+    mainWindow = createMainWindow();
+  }
+  const win = mainWindow;
+  if (!win) return;
+  if (win.isMinimized()) win.restore();
+  win.show();
+  win.focus();
+}
+function createMenu() {
+  const template = [
+    {
+      label: "Application",
+      submenu: [
+        { label: "About Application", selector: "orderFrontStandardAboutPanel:" },
+        { type: "separator" },
+        { label: "Quit", accelerator: "Command+Q", click: () => app.quit() }
+      ]
+    },
+    {
+      label: "Edit",
+      submenu: [
+        { label: "Undo", accelerator: "CmdOrCtrl+Z", selector: "undo:" },
+        { label: "Redo", accelerator: "Shift+CmdOrCtrl+Z", selector: "redo:" },
+        { type: "separator" },
+        { label: "Cut", accelerator: "CmdOrCtrl+X", selector: "cut:" },
+        { label: "Copy", accelerator: "CmdOrCtrl+C", selector: "copy:" },
+        { label: "Paste", accelerator: "CmdOrCtrl+V", selector: "paste:" },
+        { label: "Select All", accelerator: "CmdOrCtrl+A", selector: "selectAll:" }
+      ]
+    }
+  ];
+  Menu.setApplicationMenu(Menu.buildFromTemplate(template));
+}
+const SUMMARY_CACHE_TTL_MS = 25e3;
+let summaryCache = null;
+function cnTodayStr() {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(/* @__PURE__ */ new Date());
+}
+function computeUsageSummary() {
+  const records = readAllCombinedUsage();
+  const today = cnTodayStr();
+  const now = /* @__PURE__ */ new Date();
+  const sevenDaysAgo = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(new Date(now.getTime() - 6 * 24 * 60 * 60 * 1e3));
+  const todayRecords = records.filter((r) => r.date === today);
+  const sevenDayRecords = records.filter((r) => r.date >= sevenDaysAgo);
+  const sum = (recs) => {
+    let tokens = 0, input = 0, output = 0, cacheRead = 0, cacheWrite = 0;
+    let cost = 0, requests = 0;
+    for (const r of recs) {
+      input += r.inputTokens;
+      output += r.outputTokens;
+      cacheRead += r.cacheReadTokens;
+      cacheWrite += r.cacheWriteTokens;
+      cost += r.cost;
+      requests += r.requests;
+    }
+    tokens = input + output + cacheRead + cacheWrite;
+    return { tokens, input, output, cacheRead, cacheWrite, cost, requests };
+  };
+  const todaySummary = sum(todayRecords);
+  const sevenDaySummary = sum(sevenDayRecords);
+  const dailyMap = /* @__PURE__ */ new Map();
+  for (const r of sevenDayRecords) {
+    const d = dailyMap.get(r.date) ?? { tokens: 0, cost: 0, requests: 0 };
+    d.tokens += r.inputTokens + r.outputTokens + r.cacheReadTokens + r.cacheWriteTokens;
+    d.cost += r.cost;
+    d.requests += r.requests;
+    dailyMap.set(r.date, d);
+  }
+  const daily = Array.from(dailyMap.entries()).map(([date, v]) => ({ date, ...v })).sort((a, b) => a.date.localeCompare(b.date));
+  const providerMap = /* @__PURE__ */ new Map();
+  for (const r of sevenDayRecords) {
+    const p = providerMap.get(r.providerId) ?? { providerId: r.providerId, cost: 0, tokens: 0, requests: 0 };
+    p.cost += r.cost;
+    p.tokens += r.inputTokens + r.outputTokens + r.cacheReadTokens + r.cacheWriteTokens;
+    p.requests += r.requests;
+    providerMap.set(r.providerId, p);
+  }
+  const providers = Array.from(providerMap.values()).sort((a, b) => b.cost - a.cost).slice(0, 5);
+  return {
+    today: todaySummary,
+    sevenDays: sevenDaySummary,
+    daily,
+    providers,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function setupIPC() {
+  ipcMain.handle("pi:settings:get", () => readSettings());
+  ipcMain.handle("pi:settings:set", (_e, data) => writeSettings(data));
+  ipcMain.handle("pi:auth:get", () => readAuth());
+  ipcMain.handle("pi:auth:set", (_e, data) => writeAuth(data));
+  ipcMain.handle("pi:models:get", () => readModels());
+  ipcMain.handle("pi:models:set", (_e, data) => writeModels(data));
+  ipcMain.handle("pi:usage:summary", (_e, opts) => {
+    try {
+      if (!opts?.force && summaryCache && Date.now() - summaryCache.at < SUMMARY_CACHE_TTL_MS) {
+        return summaryCache.data;
+      }
+      const data = computeUsageSummary();
+      summaryCache = { data, at: Date.now() };
+      return data;
+    } catch (err) {
+      return { error: String(err) };
+    }
+  });
+  ipcMain.handle("pi:open:dashboard", () => {
+    showMainWindow();
+  });
+  ipcMain.handle("pi:open:external", (_e, url2) => {
+    if (typeof url2 === "string" && /^https?:\/\//.test(url2)) {
+      shell.openExternal(url2);
+    }
+  });
+}
+function warmUsageCache() {
+  setTimeout(() => {
+    try {
+      if (!summaryCache) {
+        summaryCache = { data: computeUsageSummary(), at: Date.now() };
+        console.log("[pi-web-switch] usage summary warmed");
+      }
+    } catch (err) {
+      console.error("[pi-web-switch] warm usage failed:", err);
+    }
+  }, 1500);
+}
+function setDockIcon() {
+  if (process.platform !== "darwin" || !app.dock) return;
+  const iconPath = resolveAppIcon();
+  if (iconPath && fs.existsSync(iconPath)) {
+    try {
+      app.dock.setIcon(nativeImage.createFromPath(iconPath));
+    } catch {
+    }
+  }
+}
+app.whenReady().then(async () => {
+  try {
+    setDockIcon();
+    createMenu();
+    setupIPC();
+    if (!process.env.VITE_DEV_SERVER_URL) {
+      const handle = await startApiServer();
+      apiServerUrl = handle.url;
+      console.log(`[pi-web-switch] api server: ${handle.url}`);
+    }
+    createTray();
+    createPopupWindow();
+    showMainWindow();
+    warmUsageCache();
+    try {
+      startAutoExpiryTimer();
+    } catch {
+    }
+    console.log("[pi-web-switch] tray + popup ready");
+  } catch (err) {
+    console.error("[pi-web-switch] startup failed:", err);
+  }
+  app.on("activate", () => {
+    showMainWindow();
+  });
+}).catch((err) => {
+  console.error("[pi-web-switch] whenReady rejected:", err);
+});
+app.on("window-all-closed", () => {
+});
+if (process.platform === "darwin") ;