@raingor/pi-web-switch 0.4.0 → 0.4.2

package/src/types/chat.ts

@@ -0,0 +1,217 @@
+// Chat-related type definitions — ported and simplified from pi-web's lib/types.ts
+
+export interface TextContent {
+  type: "text";
+  text: string;
+}
+
+export interface ImageContent {
+  type: "image";
+  source: {
+    type: "base64" | "url";
+    media_type?: string;
+    data?: string;
+    url?: string;
+  };
+}
+
+export interface ThinkingContent {
+  type: "thinking";
+  thinking: string;
+  deferred?: boolean;
+}
+
+export interface ToolCallContent {
+  type: "toolCall";
+  toolCallId: string;
+  toolName: string;
+  input: Record<string, unknown>;
+}
+
+export type AssistantContentBlock = TextContent | ImageContent | ThinkingContent | ToolCallContent;
+
+export interface UserMessage {
+  role: "user";
+  content: string | (TextContent | ImageContent)[];
+  timestamp?: number;
+}
+
+export interface AssistantMessage {
+  role: "assistant";
+  content: AssistantContentBlock[];
+  model: string;
+  provider: string;
+  stopReason?: string;
+  errorMessage?: string;
+  timestamp?: number;
+  usage?: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: {
+      input: number;
+      output: number;
+      cacheRead: number;
+      cacheWrite: number;
+      total: number;
+    };
+  };
+}
+
+export interface ToolResultMessage {
+  role: "toolResult";
+  toolCallId: string;
+  toolName?: string;
+  content: (TextContent | ImageContent)[];
+  isError?: boolean;
+  details?: unknown;
+  timestamp?: number;
+}
+
+export interface CustomMessage {
+  role: "custom";
+  customType: string;
+  content: string | (TextContent | ImageContent)[];
+  display: boolean;
+  details?: unknown;
+  timestamp?: number;
+}
+
+export interface BashExecutionMessage {
+  role: "bashExecution";
+  command: string;
+  output: string;
+  exitCode?: number;
+  cancelled?: boolean;
+  truncated?: boolean;
+  fullOutputPath?: string;
+  excludeFromContext?: boolean;
+  timestamp?: number;
+}
+
+export type AgentMessage = UserMessage | AssistantMessage | ToolResultMessage | CustomMessage | BashExecutionMessage;
+
+export interface SessionInfo {
+  path: string;
+  id: string;
+  cwd: string;
+  name?: string;
+  created: string;
+  modified: string;
+  messageCount: number;
+  firstMessage: string;
+  parentSessionId?: string;
+  projectRoot?: string;
+  worktreeBranch?: string;
+}
+
+export interface SessionContext {
+  messages: AgentMessage[];
+  entryIds: string[];
+  thinkingLevel: string;
+  model: { provider: string; modelId: string } | null;
+}
+
+export interface SessionTreeNode {
+  entry: { id: string; type: string };
+  children: SessionTreeNode[];
+  label?: string;
+  compressedEntryIds?: string[];
+}
+
+export interface SessionData {
+  sessionId: string;
+  filePath: string;
+  tree: SessionTreeNode[];
+  leafId: string | null;
+  context: SessionContext;
+}
+
+export interface ContextUsage {
+  percent: number | null;
+  contextWindow: number;
+  tokens: number | null;
+}
+
+export interface SessionStatsInfo {
+  sessionFile?: string;
+  sessionId: string;
+  sessionName?: string;
+  userMessages: number;
+  assistantMessages: number;
+  toolCalls: number;
+  toolResults: number;
+  totalMessages: number;
+  tokens: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+  };
+  cost: number;
+  contextUsage?: ContextUsage;
+}
+
+export interface AttachedImage {
+  data: string;
+  mimeType: string;
+  previewUrl: string;
+}
+
+export interface ChatInputHandle {
+  insertText: (text: string) => void;
+  insertIfEmpty: (content: string) => void;
+  prependText: (text: string) => void;
+  addImages: (files: File[]) => void;
+}
+
+export interface ModelEntry {
+  id: string;
+  name: string;
+  provider: string;
+}
+
+export interface ModelsResponse {
+  models: Record<string, string>;
+  modelList?: ModelEntry[];
+  defaultModel?: { provider: string; modelId: string } | null;
+  thinkingLevels?: Record<string, string[]>;
+  modelError?: string;
+}
+
+export interface AgentStateResponse {
+  isStreaming?: boolean;
+  isPromptRunning?: boolean;
+  isBashRunning?: boolean;
+  isCompacting?: boolean;
+  contextUsage?: ContextUsage | null;
+  systemPrompt?: string;
+  thinkingLevel?: string;
+  model?: { id: string; provider: string };
+}
+
+export interface NoticeItem {
+  id: string;
+  message: string;
+  type: "info" | "success" | "warning" | "error";
+  exiting?: boolean;
+}
+
+export type AgentPhase =
+  | { kind: "waiting_model" }
+  | { kind: "running_command" }
+  | { kind: "running_tools"; tools: { id: string; name: string }[] }
+  | null;
+
+export interface QueuedMessages {
+  steering: string[];
+  followUp: string[];
+}
+
+export interface SlashCommandInfo {
+  name: string;
+  description?: string;
+  source: "extension" | "prompt" | "skill";
+}

package/src/types/index.ts

@@ -19,6 +19,7 @@ export interface ThinkingLevelMap {
 export interface ModelCompat {
   supportsStore?: boolean;
   supportsDeveloperRole?: boolean;
+  supportsFinishReason?: boolean;
   supportsReasoningEffort?: boolean;
   supportsUsageInStreaming?: boolean;
   maxTokensField?: "max_completion_tokens" | "max_tokens";
@@ -109,6 +110,7 @@ export interface PiSettings {
   treeFilterMode?: string;
   doubleEscapeAction?: string;
   enabledModels?: string[];
+  sessionExpiryDays?: number;
 }
 
 export interface PiAuth {

package/vite.config.ts

@@ -18,6 +18,24 @@ function piApiPlugin(): Plugin {
       pi = require("./server/pi-reader");
       builtins = require("./src/data/builtin-providers");
 
+      // Warm the usage cache in the background so the dashboard's first
+      // request doesn't block on scanning ~150MB of session JSONL.
+      setTimeout(() => {
+        try {
+          pi.readAllUsage();
+        } catch {
+          /* ignore warm-up failure */
+        }
+        try {
+          pi.readCopilotUsage();
+        } catch {
+          /* ignore warm-up failure */
+        }
+      }, 0);
+
+      // Start the auto-expiry timer: scan once at startup, then every 24h.
+      try { pi.startAutoExpiryTimer(); } catch { /* ignore */ }
+
       const routes: Record<string, (req: Connect.IncomingMessage, res: any) => void> = {
         "GET /api/pi/settings"(_, res) {
           const data = pi.readSettings();
@@ -115,6 +133,28 @@ function piApiPlugin(): Plugin {
           res.setHeader("Content-Type", "application/json");
           res.end(JSON.stringify(pi.listTrash()));
         },
+        "GET /api/pi/copilot-config"(_, res) {
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify(pi.readCopilotConfig() ?? {}));
+        },
+        "POST /api/pi/copilot-config"(req, res) {
+          let body = "";
+          req.on("data", (chunk: string) => (body += chunk));
+          req.on("end", () => {
+            try {
+              const cfg = JSON.parse(body) as { username?: string; token?: string };
+              const ok = pi.writeCopilotConfig(cfg);
+              // Config changed → drop cached usage so the next view refetches.
+              pi.clearCopilotCaches();
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ success: ok }));
+            } catch {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ success: false, error: "Invalid request body" }));
+            }
+          });
+        },
         "POST /api/pi/session/trash"(req, res) {
           let body = "";
           req.on("data", (chunk: string) => (body += chunk));
@@ -147,6 +187,21 @@ function piApiPlugin(): Plugin {
             }
           });
         },
+        "POST /api/pi/session/auto-expire"(req, res) {
+          let body = "";
+          req.on("data", (chunk: string) => (body += chunk));
+          req.on("end", () => {
+            try {
+              const result = pi.autoExpireSessions();
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ success: true, ...result }));
+            } catch {
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ success: false, error: "Auto-expire failed" }));
+            }
+          });
+        },
         "GET /api/pi/session-preview"(req, res) {
           const parsedUrl = new URL(req.url!, "http://localhost");
           const p = parsedUrl.searchParams.get("path") || "";
@@ -282,8 +337,14 @@ function piApiPlugin(): Plugin {
           const toParam = parsedUrl.searchParams.get("to") || "";
 
           const now = new Date();
+          // Date buckets follow China time (UTC+8) regardless of system timezone
           const localDateStr = (dt: Date) =>
-            `${dt.getFullYear()}-${String(dt.getMonth() + 1).padStart(2, "0")}-${String(dt.getDate()).padStart(2, "0")}`;
+            new Intl.DateTimeFormat("en-CA", {
+              timeZone: "Asia/Shanghai",
+              year: "numeric",
+              month: "2-digit",
+              day: "2-digit",
+            }).format(dt);
           let fromDate: string;
           let toDate = localDateStr(now);
 
@@ -306,6 +367,172 @@ function piApiPlugin(): Plugin {
           return res.end(JSON.stringify(usage));
         }
 
+        // Handle GET /api/pi/cindy-usage-range?range=today|7d|30d|custom&from=...&to=...
+        if (method === "GET" && pathOnly === "/api/pi/cindy-usage-range") {
+          const parsedUrl = new URL(url, "http://localhost");
+          const range = parsedUrl.searchParams.get("range") || "today";
+          const fromParam = parsedUrl.searchParams.get("from") || "";
+          const toParam = parsedUrl.searchParams.get("to") || "";
+
+          const now = new Date();
+          // Date buckets follow China time (UTC+8) regardless of system timezone
+          const localDateStr = (dt: Date) =>
+            new Intl.DateTimeFormat("en-CA", {
+              timeZone: "Asia/Shanghai",
+              year: "numeric",
+              month: "2-digit",
+              day: "2-digit",
+            }).format(dt);
+          let fromDate: string;
+          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;
+          }
+
+          const allRecords = pi.readCindyUsage();
+          const usage = pi.getUsageByRange(allRecords, fromDate, toDate);
+          res.setHeader("Content-Type", "application/json");
+          return res.end(JSON.stringify(usage));
+        }
+
+        // Handle GET /api/pi/claude-usage-range?range=today|7d|30d|custom&from=...&to=...
+        if (method === "GET" && pathOnly === "/api/pi/claude-usage-range") {
+          const parsedUrl = new URL(url, "http://localhost");
+          const range = parsedUrl.searchParams.get("range") || "today";
+          const fromParam = parsedUrl.searchParams.get("from") || "";
+          const toParam = parsedUrl.searchParams.get("to") || "";
+
+          const now = new Date();
+          // Date buckets follow China time (UTC+8) regardless of system timezone
+          const localDateStr = (dt: Date) =>
+            new Intl.DateTimeFormat("en-CA", {
+              timeZone: "Asia/Shanghai",
+              year: "numeric",
+              month: "2-digit",
+              day: "2-digit",
+            }).format(dt);
+          let fromDate: string;
+          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;
+          }
+
+          const allRecords = pi.readClaudeUsage();
+          const usage = pi.getUsageByRange(allRecords, fromDate, toDate);
+          res.setHeader("Content-Type", "application/json");
+          return res.end(JSON.stringify(usage));
+        }
+
+        // Handle GET /api/pi/codex-usage-range?range=today|7d|30d|custom&from=...&to=...
+        if (method === "GET" && pathOnly === "/api/pi/codex-usage-range") {
+          const parsedUrl = new URL(url, "http://localhost");
+          const range = parsedUrl.searchParams.get("range") || "today";
+          const fromParam = parsedUrl.searchParams.get("from") || "";
+          const toParam = parsedUrl.searchParams.get("to") || "";
+
+          const now = new Date();
+          // Date buckets follow China time (UTC+8) regardless of system timezone
+          const localDateStr = (dt: Date) =>
+            new Intl.DateTimeFormat("en-CA", {
+              timeZone: "Asia/Shanghai",
+              year: "numeric",
+              month: "2-digit",
+              day: "2-digit",
+            }).format(dt);
+          let fromDate: string;
+          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;
+          }
+
+          const allRecords = pi.readCodexUsage();
+          const usage = pi.getUsageByRange(allRecords, fromDate, toDate);
+          res.setHeader("Content-Type", "application/json");
+          return res.end(JSON.stringify(usage));
+        }
+
+        // Helper: resolve date range params
+        const resolveDateRange = (range: string, fromParam: string, toParam: string) => {
+          const now = new Date();
+          // Date buckets follow China time (UTC+8) regardless of system timezone
+          const localDateStr = (dt: Date) =>
+            new Intl.DateTimeFormat("en-CA", {
+              timeZone: "Asia/Shanghai",
+              year: "numeric",
+              month: "2-digit",
+              day: "2-digit",
+            }).format(dt);
+          let fromDate: string;
+          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 };
+        };
+
+        // Handle GET /api/pi/all-usage-range
+        if (method === "GET" && pathOnly === "/api/pi/all-usage-range") {
+          const parsedUrl = new URL(url, "http://localhost");
+          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);
+          const allRecords = pi.readAllCombinedUsage();
+          const usage = pi.getUsageByRange(allRecords, fromDate, toDate);
+          res.setHeader("Content-Type", "application/json");
+          return res.end(JSON.stringify(usage));
+        }
+
+        // Handle provider-filtered endpoints: /api/pi/{provider}-usage-range
+        // Copilot is read from the local ~/.copilot/session-store.db (no
+        // GitHub REST API, no PAT), so it shares the same sync pipeline as
+        // the other local sources.
+        const providerMatch = pathOnly.match(/^\/api\/pi\/(atomcode|copilot|opencode|gemini|grok)-usage-range$/);
+        if (method === "GET" && providerMatch) {
+          const providerId = providerMatch[1]!;
+          const parsedUrl = new URL(url, "http://localhost");
+          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);
+          const allRecords = pi.filterByProvider(pi.readAllCombinedUsage(), providerId);
+          const usage = pi.getUsageByRange(allRecords, fromDate, toDate);
+          res.setHeader("Content-Type", "application/json");
+          return res.end(JSON.stringify(usage));
+        }
+
         const key = `${method} ${pathOnly}`;
         const handler = routes[key];
         if (handler) {
@@ -323,6 +550,9 @@ function piApiPlugin(): Plugin {
 // ─── Vite Config ────────────────────────────────────────
 
 export default defineConfig({
+  // Relative base so Electron can loadFile() the built HTML from disk —
+  // absolute "/assets/..." URLs would resolve to the filesystem root.
+  base: './',
   plugins: [
     react(),
     tailwindcss(),
@@ -337,4 +567,13 @@ export default defineConfig({
     port: 5176,
     strictPort: true,
   },
+  build: {
+    rollupOptions: {
+      input: {
+        main: path.resolve(__dirname, "index.html"),
+        // Menu-bar popup (used by the Electron tray app)
+        popup: path.resolve(__dirname, "electron/popup.html"),
+      },
+    },
+  },
 });