@bitkyc08/opencodex 2.7.35 → 2.7.36

package/src/update/index.ts

@@ -3,6 +3,7 @@ import { readFileSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { getConfigDir, loadConfig, readPid, readRuntimePort } from "../config";
+import { handoffWindowsTrayForUpdate, planWindowsTrayUpdate } from "./tray-update-plan.mjs";
 
 /**
  * A `codex-history-backup-*.json` surviving a stop means the native-history restore was
@@ -170,6 +171,26 @@ export async function runUpdate(): Promise<void> {
     const { isServiceInstalled } = await import("../service");
     serviceWasInstalled = isServiceInstalled();
   } catch { /* best-effort */ }
+  let trayWasInstalled = false;
+  let trayWasRunning = false;
+  if (process.platform === "win32") {
+    try {
+      const { getWindowsTrayStatus, startWindowsTray, stopWindowsTray } = await import("../tray/windows");
+      const tray = getWindowsTrayStatus();
+      const trayPlan = handoffWindowsTrayForUpdate(tray, {
+        stop: () => {
+          const stopped = stopWindowsTray();
+          return { exitStatus: 0, running: stopped.running };
+        },
+        start: () => startWindowsTray(),
+      });
+      trayWasInstalled = trayPlan.refreshAfterReplacement;
+      trayWasRunning = trayPlan.restoreOnFailure;
+    } catch (error) {
+      console.error(`⚠️  Could not stop the Windows tray; aborting before package replacement: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  }
 
   // Capture listen target before stop clears runtime state (same contract as GUI update worker).
   // Prefer a live runtime record; a stale crashed leftover must not override config.port.
@@ -200,6 +221,12 @@ export async function runUpdate(): Promise<void> {
     });
     if (stopStdio === "pipe") logSpawnOutput("", stop);
     if (stop.status !== 0 || readPid() || readRuntimePort()) {
+      if (trayWasRunning) {
+        try {
+          const { startWindowsTray } = await import("../tray/windows");
+          startWindowsTray();
+        } catch { /* preserve the proxy stop failure */ }
+      }
       console.error("⚠️  Could not stop the running proxy; aborting the update. Run 'ocx stop' and retry.");
       process.exit(1);
     }
@@ -238,6 +265,16 @@ export async function runUpdate(): Promise<void> {
     } catch (e) {
       console.warn(`⚠️  Shim repair skipped: ${e instanceof Error ? e.message : e}`);
     }
+    if (trayWasInstalled) {
+      const trayArgs = [process.argv[1], ...planWindowsTrayUpdate({ installed: trayWasInstalled, running: trayWasRunning }).installArgs];
+      const tray = spawnSync(process.execPath, trayArgs, { stdio: "inherit", windowsHide: true });
+      if (tray.status === 0) {
+        console.log("🔧 Refreshed Windows tray startup paths.");
+      } else {
+        console.warn("⚠️  Windows tray refresh failed. Run 'ocx tray install'.");
+        if (trayWasRunning) spawnSync(process.execPath, [process.argv[1], "tray", "start"], { stdio: "ignore", windowsHide: true });
+      }
+    }
     // The stop above unloaded any managed service; reinstall it with the NEW files
     // (spawn the fresh cli.ts so updated code writes the baked paths) so a
     // launchd/schtasks/systemd user isn't left with the background proxy down.
@@ -286,6 +323,12 @@ export async function runUpdate(): Promise<void> {
       console.log("Restart the proxy:  ocx start");
     }
   } else {
+    if (trayWasRunning) {
+      try {
+        const { startWindowsTray } = await import("../tray/windows");
+        startWindowsTray();
+      } catch { /* keep the primary update failure */ }
+    }
     console.error(`\n⚠️  Update failed (${bin} exit ${r.status ?? "?"}). Try manually:  ${bin} ${cmdArgs.join(" ")}`);
     process.exit(1);
   }

package/src/update/job.ts

@@ -20,6 +20,7 @@ import {
   updateCommandStr,
 } from "./index";
 import { isNewer } from "./notify";
+import { handoffWindowsTrayForUpdate, planWindowsTrayUpdate } from "./tray-update-plan.mjs";
 
 const RELEASE_NOTES_URL = "https://github.com/lidge-jun/opencodex/releases/latest";
 const UPDATE_JOB_FILENAME = "update-job.json";
@@ -474,6 +475,8 @@ export async function runGuiUpdateWorker(jobId: string, channel: Channel, restar
     port: runtimeTrusted ? rt.port : configPort,
     hostname: (runtimeTrusted ? rt.hostname : undefined) ?? preUpdateConfig.hostname ?? "127.0.0.1",
   };
+  let trayWasInstalled = false;
+  let trayWasRunning = false;
   if (!job) {
     job = {
       id: jobId,
@@ -517,6 +520,28 @@ export async function runGuiUpdateWorker(jobId: string, channel: Channel, restar
       command: cmd.display,
     }, integrityLine);
 
+    if (process.platform === "win32") {
+      try {
+        const { getWindowsTrayStatus, startWindowsTray, stopWindowsTray } = await import("../tray/windows");
+        const tray = getWindowsTrayStatus();
+        const trayPlan = handoffWindowsTrayForUpdate(tray, {
+          stop: () => {
+            const stopped = stopWindowsTray();
+            return { exitStatus: 0, running: stopped.running };
+          },
+          start: () => startWindowsTray(),
+        });
+        trayWasInstalled = trayPlan.refreshAfterReplacement;
+        trayWasRunning = trayPlan.restoreOnFailure;
+      } catch (error) {
+        updateJob(job, {
+          status: "failed",
+          error: `Could not stop the Windows tray; aborting before package replacement: ${error instanceof Error ? error.message : String(error)}`,
+        });
+        return;
+      }
+    }
+
     /* [Decision Log]
     - 목적: GUI 요청 처리 프로세스가 자신이 실행 중인 패키지를 직접 덮어쓰지 않도록 업데이트를 별도 worker에서 수행한다.
     - 대안 분석: (1) 서버에서 runUpdate 직접 호출: process.exit/stdio/실행 파일 교체 위험. (2) GUI에서 CLI 명령 안내만 제공: 자동 업데이트 UX 부족. (3) 숨은 worker가 Node launcher/Bun 전역 명령을 실행: 상태 추적과 안전한 재시작이 가능.
@@ -524,6 +549,12 @@ export async function runGuiUpdateWorker(jobId: string, channel: Channel, restar
     */
     const result = runLoggedCommand(job, cmd.bin, cmd.args, UPDATE_TIMEOUT_MS);
     if (result.status !== 0) {
+      if (trayWasRunning) {
+        try {
+          const { startWindowsTray } = await import("../tray/windows");
+          startWindowsTray();
+        } catch { /* retain the primary update failure */ }
+      }
       updateJob(job, {
         status: "failed",
         exitCode: result.status,
@@ -533,6 +564,15 @@ export async function runGuiUpdateWorker(jobId: string, channel: Channel, restar
       return;
     }
 
+    if (trayWasInstalled) {
+      const trayArgs = [process.argv[1], ...planWindowsTrayUpdate({ installed: trayWasInstalled, running: trayWasRunning }).installArgs];
+      const tray = runLoggedCommand(job, process.execPath, trayArgs, 20_000);
+      if (tray.status !== 0) {
+        updateJob(job, {}, "Windows tray refresh failed; run 'ocx tray install'.");
+        if (trayWasRunning) runLoggedCommand(job, process.execPath, [process.argv[1], "tray", "start"], 15_000);
+      }
+    }
+
     if (restart) {
       job = updateJob(job, { status: "restarting" }, "Update installed. Restarting proxy...");
       await restartAfterUpdate(job, captured);
@@ -543,6 +583,12 @@ export async function runGuiUpdateWorker(jobId: string, channel: Channel, restar
 
     updateJob(job, { status: "succeeded", restarted: false }, "Update installed. Restart the proxy to use the new version.");
   } catch (err) {
+    if (trayWasRunning) {
+      try {
+        const { startWindowsTray } = await import("../tray/windows");
+        startWindowsTray();
+      } catch { /* retain the primary worker failure */ }
+    }
     updateJob(job, {
       status: "failed",
       error: err instanceof Error ? err.message : String(err),

package/src/update/tray-update-plan.d.mts

@@ -0,0 +1,18 @@
+export interface WindowsTrayUpdatePlan {
+  installed: boolean;
+  running: boolean;
+  stopBeforeReplacement: boolean;
+  restoreOnFailure: boolean;
+  refreshAfterReplacement: boolean;
+  installArgs: string[];
+}
+
+export declare function planWindowsTrayUpdate(status: { installed?: boolean; running?: boolean }): WindowsTrayUpdatePlan;
+export declare function windowsTrayStopConfirmed(exitStatus: number | null, stillRunning: boolean): boolean;
+export declare function handoffWindowsTrayForUpdate(
+  status: { installed?: boolean; running?: boolean },
+  io: {
+    stop: () => { exitStatus: number | null; running: boolean };
+    start: () => unknown;
+  },
+): WindowsTrayUpdatePlan;

package/src/update/tray-update-plan.mjs

@@ -0,0 +1,38 @@
+/**
+ * Shared, side-effect-free contract for preserving the Windows tray across all
+ * updater entry points (npm launcher, CLI updater, and GUI worker).
+ */
+export function planWindowsTrayUpdate(status) {
+  const installed = status?.installed === true;
+  const running = status?.running === true;
+  return {
+    installed,
+    running,
+    stopBeforeReplacement: running,
+    restoreOnFailure: running,
+    refreshAfterReplacement: installed,
+    installArgs: ["tray", "install", ...(!running ? ["--no-start"] : [])],
+  };
+}
+
+export function windowsTrayStopConfirmed(exitStatus, stillRunning) {
+  return exitStatus === 0 && !stillRunning;
+}
+
+/** Stop before replacement and restore best-effort when the handoff cannot be confirmed. */
+export function handoffWindowsTrayForUpdate(status, io) {
+  const plan = planWindowsTrayUpdate(status);
+  if (!plan.stopBeforeReplacement) return plan;
+  try {
+    const stopped = io.stop();
+    if (!windowsTrayStopConfirmed(stopped.exitStatus, stopped.running)) {
+      throw new Error("the tray still reports running after shutdown");
+    }
+    return plan;
+  } catch (error) {
+    if (plan.restoreOnFailure) {
+      try { io.start(); } catch { /* preserve the handoff failure */ }
+    }
+    throw error;
+  }
+}

package/src/usage/expected-prices.ts

@@ -38,6 +38,10 @@ const KIMI_K27_CODE_HIGHSPEED: Cost4 = { input: 1.9, output: 8, cacheRead: 0.38,
 const KIMI_K26: Cost4 = { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0.95 };
 const KIMI_K25: Cost4 = { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0.6 };
 const QWEN38_ROUTEWAY_TEMPORARY: Cost4 = { input: 1.5, output: 5, cacheRead: 0.15, cacheWrite: 0 };
+// Anthropic official list prices (USD / 1M tokens). Cache write uses the published 5-minute rate.
+const CLAUDE_SONNET_46: Cost4 = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
+const CLAUDE_OPUS_46: Cost4 = { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 };
+const ANTHROPIC_PRICING = "https://platform.claude.com/docs/en/about-claude/pricing (official; 5m cache-write tier)";
 
 const GEMINI_PRICING = "https://ai.google.dev/gemini-api/docs/pricing (2026-07-22); cacheWrite=0: storage is billed per-hour, not per-token";
 const MINIMAX_PRICING = "https://platform.minimax.io/docs/guides/pricing-paygo";
@@ -63,6 +67,7 @@ export const EXPECTED_PRICE_OVERLAYS: readonly ExpectedPriceOverlay[] = [
   { provider: "google-antigravity", modelId: "gemini-3.1-pro", cost4: GEMINI_31_PRO, source: `collapsed base ID ${GEMINI_PRICING}`, verifiedAt: "2026-07-22", status: "verified" },
   { provider: "google-antigravity", modelId: "gemini-3.1-pro-low", cost4: GEMINI_31_PRO, source: `derived: gemini-3.1-pro (<=200k tier) ${GEMINI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
   { provider: "google-antigravity", modelId: "gemini-3.1-pro-high", cost4: GEMINI_31_PRO, source: `derived: gemini-3.1-pro (<=200k tier) ${GEMINI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "gemini-pro-agent", cost4: GEMINI_31_PRO, source: `wire id for gemini-3.1-pro high ${GEMINI_PRICING}`, verifiedAt: "2026-07-23", status: "verified-derived" },
   { provider: "google-antigravity", modelId: "gemini-3.6-flash-low", cost4: GEMINI_36_FLASH, source: `derived: gemini-3.6-flash ${GEMINI_PRICING}`, verifiedAt: "2026-07-22", status: "verified-derived" },
   { provider: "google-antigravity", modelId: "gemini-3.6-flash-medium", cost4: GEMINI_36_FLASH, source: `derived: gemini-3.6-flash ${GEMINI_PRICING}`, verifiedAt: "2026-07-22", status: "verified-derived" },
   { provider: "google-antigravity", modelId: "gemini-3.6-flash-high", cost4: GEMINI_36_FLASH, source: `derived: gemini-3.6-flash ${GEMINI_PRICING}`, verifiedAt: "2026-07-22", status: "verified-derived" },
@@ -76,8 +81,10 @@ export const EXPECTED_PRICE_OVERLAYS: readonly ExpectedPriceOverlay[] = [
   { provider: "google-antigravity", modelId: "gemini-3.1-pro-preview", cost4: GEMINI_31_PRO, source: GEMINI_PRICING, verifiedAt: "2026-07-20", status: "verified" },
   // Antigravity-bundled third-party models — derived from the underlying vendor's
   // official API price (Antigravity itself bills via subscription quota).
-  { provider: "google-antigravity", modelId: "claude-sonnet-4-6", cost4: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }, source: "derived: anthropic official https://platform.claude.com/docs/en/about-claude/pricing (5m cache-write; 1h is $6)", verifiedAt: "2026-07-20", status: "verified-derived" },
-  { provider: "google-antigravity", modelId: "claude-opus-4-6-thinking", cost4: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }, source: "derived: anthropic official https://platform.claude.com/docs/en/about-claude/pricing (5m cache-write; 1h is $10)", verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "claude-sonnet-4-6", cost4: CLAUDE_SONNET_46, source: `anthropic official Claude Sonnet 4.6 ${ANTHROPIC_PRICING}`, verifiedAt: "2026-07-23", status: "verified" },
+  { provider: "google-antigravity", modelId: "claude-opus-4-6-thinking", cost4: CLAUDE_OPUS_46, source: `anthropic official Claude Opus 4.6 ${ANTHROPIC_PRICING}`, verifiedAt: "2026-07-23", status: "verified" },
+  // Alias without the Antigravity "-thinking" suffix (if logs/UI ever surface it).
+  { provider: "google-antigravity", modelId: "claude-opus-4-6", cost4: CLAUDE_OPUS_46, source: `anthropic official Claude Opus 4.6 ${ANTHROPIC_PRICING}`, verifiedAt: "2026-07-23", status: "verified" },
   { provider: "google-antigravity", modelId: "gpt-oss-120b-medium", cost4: { input: 0.03, output: 0.15, cacheRead: 0, cacheWrite: 0 }, source: "derived: gpt-oss-120b open-weights — OpenRouter advertised lowest https://openrouter.ai/openai/gpt-oss-120b/providers", verifiedAt: "2026-07-20", status: "verified-derived" },
   // Kimi / Moonshot — official price tables are now published (2026-07-20 re-check;
   // previously empty). kimi = Kimi Code OAuth surface, moonshot = CN key surface,

package/src/usage/summary.ts

@@ -1,4 +1,5 @@
 import { baseProviderLabel } from "../providers/label";
+import { canonicalAntigravityUsageModel } from "../providers/antigravity-models";
 import { usageDisplayTotalTokens } from "./totals";
 import type { PersistedUsageEntry, UsageStatus } from "./log";
 import { estimateComboCost, estimateRequestCost } from "./cost";
@@ -160,13 +161,47 @@ interface UsageAttribution {
   totalTokens?: number;
 }
 
+
+/**
+ * Usage row identity for model breakdowns.
+ * Google Antigravity collapses wire/compat/suffix ids to picker/call base models so
+ * historical effort-variant logs merge with current base-model invocations.
+ */
+function usageModelIdentity(
+  provider: string,
+  model: string,
+  resolvedModel?: string,
+): { model: string; resolvedModel?: string } {
+  if (baseProviderLabel(provider) !== "google-antigravity") {
+    return resolvedModel ? { model, resolvedModel } : { model };
+  }
+  const fromModel = canonicalAntigravityUsageModel(model);
+  const fromResolved = resolvedModel
+    ? canonicalAntigravityUsageModel(resolvedModel)
+    : undefined;
+  // Prefer an explicit base mapping from model; if model is unknown but resolved maps
+  // to a known base, use that (covers base call + upstream wire resolvedModel pairs).
+  const canonical = fromModel !== model
+    ? fromModel
+    : (fromResolved && fromResolved !== resolvedModel ? fromResolved : fromModel);
+  return { model: canonical };
+}
+
+function usageModelKey(providerKey: string, model: string): string {
+  return `${providerKey}/${model}`;
+}
+
+function antigravityUsageModel(provider: string, model: string): string {
+  if (baseProviderLabel(provider) !== "google-antigravity") return model;
+  return canonicalAntigravityUsageModel(model);
+}
+
 function usageAttributions(entry: PersistedUsageEntry): UsageAttribution[] {
   if (!entry.attempts?.length) {
     return [{
       requestId: entry.requestId,
       provider: entry.provider,
-      model: entry.model,
-      ...(entry.resolvedModel ? { resolvedModel: entry.resolvedModel } : {}),
+      ...usageModelIdentity(entry.provider, entry.model, entry.resolvedModel),
       usageStatus: entry.usageStatus,
       ...(entry.usage ? { usage: entry.usage } : {}),
       ...(entry.totalTokens !== undefined ? { totalTokens: entry.totalTokens } : {}),
@@ -175,7 +210,7 @@ function usageAttributions(entry: PersistedUsageEntry): UsageAttribution[] {
   return entry.attempts.map(attempt => ({
     requestId: entry.requestId,
     provider: attempt.provider,
-    model: attempt.model,
+    ...usageModelIdentity(attempt.provider, attempt.model),
     usageStatus: attempt.usageStatus,
     ...(attempt.usage ? { usage: attempt.usage } : {}),
     ...(attempt.totalTokens !== undefined ? { totalTokens: attempt.totalTokens } : {}),
@@ -263,7 +298,7 @@ function buildDayGrid(range: UsageRange, since: number | null, now: number, entr
     let models = dayModels.get(dayKey);
     if (!models) { models = new Map(); dayModels.set(dayKey, models); }
     const providerKey = baseProviderLabel(attribution.provider);
-    const mKey = `${providerKey}/${attribution.model}`;
+    const mKey = usageModelKey(providerKey, attribution.model);
     let m = models.get(mKey);
     if (!m) {
       m = { model: attribution.model, provider: providerKey, requests: 0, attemptCount: 0, totalTokens: 0 };
@@ -310,7 +345,7 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
     for (const attribution of usageAttributions(entry)) {
       const providerKey = baseProviderLabel(attribution.provider);
       // resolvedModel is a routing detail, not a row identity.
-      const key = `${providerKey}${attribution.model}`;
+      const key = usageModelKey(providerKey, attribution.model);
       let model = byKey.get(key);
       if (!model) {
         model = {
@@ -363,14 +398,14 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
       // Combo: attribute each attempt's cost to its own model
       for (const attemptEst of estimate.attempts) {
         const aProviderKey = baseProviderLabel(attemptEst.provider);
-        const aKey = `${aProviderKey}${attemptEst.model}`;
+        const aKey = usageModelKey(aProviderKey, antigravityUsageModel(attemptEst.provider, attemptEst.model));
         const m = byKey.get(aKey);
         if (m) m.estimatedCostUsd = (m.estimatedCostUsd ?? 0) + attemptEst.cost.total;
       }
     } else {
       // Single-target: attribute to the entry's model
       const providerKey = baseProviderLabel(entry.provider);
-      const key = `${providerKey}${entry.model}`;
+      const key = usageModelKey(providerKey, antigravityUsageModel(entry.provider, entry.model));
       const m = byKey.get(key);
       if (m) m.estimatedCostUsd = (m.estimatedCostUsd ?? 0) + estimate.cost.total;
     }