@tokscale/cli 1.2.1 → 1.2.3

package/src/native.ts

@@ -10,6 +10,7 @@ import type {
   GraphOptions as TSGraphOptions,
   SourceType,
 } from "./graph-types.js";
+import { loadSettings } from "./tui/config/settings.js";
 
 // =============================================================================
 // Types matching Rust exports
@@ -152,8 +153,9 @@ interface NativeParsedMessages {
   codexCount: number;
   geminiCount: number;
   ampCount: number;
-  droidCount?: number;
-  openclawCount?: number;
+  droidCount: number;
+  openclawCount: number;
+  piCount: number;
   processingTimeMs: number;
 }
 
@@ -354,6 +356,7 @@ export interface ParsedMessages {
   ampCount: number;
   droidCount: number;
   openclawCount: number;
+  piCount: number;
   processingTimeMs: number;
 }
 
@@ -381,25 +384,21 @@ export interface FinalizeOptions {
 
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { writeFileSync, readFileSync, unlinkSync, mkdirSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const DEFAULT_TIMEOUT_MS = 300_000;
-const NATIVE_TIMEOUT_MS = parseInt(
-  process.env.TOKSCALE_NATIVE_TIMEOUT_MS || String(DEFAULT_TIMEOUT_MS),
-  10
-);
-
 const SIGKILL_GRACE_MS = 500;
-const DEFAULT_MAX_OUTPUT_BYTES = 100 * 1024 * 1024;
-const MAX_OUTPUT_BYTES = parseInt(
-  process.env.TOKSCALE_MAX_OUTPUT_BYTES || String(DEFAULT_MAX_OUTPUT_BYTES),
-  10
-);
+
+function getNativeTimeoutMs(): number {
+  const settings = loadSettings();
+  return process.env.TOKSCALE_NATIVE_TIMEOUT_MS
+    ? parseInt(process.env.TOKSCALE_NATIVE_TIMEOUT_MS, 10)
+    : (settings.nativeTimeoutMs ?? 300_000);
+}
 
 interface BunSubprocess {
   stdout: { text: () => Promise<string> };
@@ -411,8 +410,8 @@ interface BunSubprocess {
 }
 
 interface BunSpawnOptions {
-  stdout: string;
-  stderr: string;
+  stdout: "pipe" | "ignore";
+  stderr: "pipe" | "ignore";
 }
 
 interface BunGlobalType {
@@ -426,89 +425,46 @@ function safeKill(proc: unknown, signal?: string): void {
 }
 
 async function runInSubprocess<T>(method: string, args: unknown[]): Promise<T> {
+  const NATIVE_TIMEOUT_MS = getNativeTimeoutMs();
   const runnerPath = join(__dirname, "native-runner.js");
   const input = JSON.stringify({ method, args });
 
   const tmpDir = join(tmpdir(), "tokscale");
   mkdirSync(tmpDir, { recursive: true });
-  const inputFile = join(tmpDir, `input-${randomUUID()}.json`);
-  
+  const id = randomUUID();
+  const inputFile = join(tmpDir, `input-${id}.json`);
+  const outputFile = join(tmpDir, `output-${id}.json`);
+
   writeFileSync(inputFile, input, "utf-8");
 
   const BunGlobal = (globalThis as Record<string, unknown>).Bun as BunGlobalType;
 
   let proc: BunSubprocess;
   try {
-    proc = BunGlobal.spawn([process.execPath, runnerPath, inputFile], {
-      stdout: "pipe",
+    proc = BunGlobal.spawn([process.execPath, runnerPath, inputFile, outputFile], {
+      stdout: "ignore",
       stderr: "pipe",
     });
   } catch (e) {
-    unlinkSync(inputFile);
+    try { unlinkSync(inputFile); } catch {}
     throw new Error(`Failed to spawn subprocess: ${(e as Error).message}`);
   }
 
   let timeoutId: ReturnType<typeof setTimeout> | null = null;
   let sigkillId: ReturnType<typeof setTimeout> | null = null;
   let weInitiatedKill = false;
-  let aborted = false;
 
   const cleanup = async () => {
     if (timeoutId) clearTimeout(timeoutId);
     if (sigkillId) clearTimeout(sigkillId);
     try { unlinkSync(inputFile); } catch {}
-    if (aborted) {
-      safeKill(proc, "SIGKILL");
-      await proc.exited.catch(() => {});
-    }
-  };
-
-  const abort = () => {
-    aborted = true;
-    weInitiatedKill = true;
+    try { unlinkSync(outputFile); } catch {}
   };
 
   try {
-    const stdoutChunks: Uint8Array[] = [];
-    const stderrChunks: Uint8Array[] = [];
-    let stdoutBytes = 0;
-    let stderrBytes = 0;
-
-    const readStream = async (
-      stream: BunSubprocess["stdout"],
-      chunks: Uint8Array[],
-      getBytesRef: () => number,
-      setBytesRef: (n: number) => void
-    ): Promise<string> => {
-      const reader = (stream as unknown as ReadableStream<Uint8Array>).getReader();
-      try {
-        while (!aborted) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          const newTotal = getBytesRef() + value.length;
-          if (newTotal > MAX_OUTPUT_BYTES) {
-            abort();
-            throw new Error(`Output exceeded ${MAX_OUTPUT_BYTES} bytes`);
-          }
-          setBytesRef(newTotal);
-          chunks.push(value);
-        }
-      } finally {
-        await reader.cancel().catch(() => {});
-        reader.releaseLock();
-      }
-      const combined = new Uint8Array(getBytesRef());
-      let offset = 0;
-      for (const chunk of chunks) {
-        combined.set(chunk, offset);
-        offset += chunk.length;
-      }
-      return new TextDecoder().decode(combined);
-    };
-
     const timeoutPromise = new Promise<never>((_, reject) => {
       timeoutId = setTimeout(() => {
-        abort();
+        weInitiatedKill = true;
         safeKill(proc, "SIGTERM");
         sigkillId = setTimeout(() => {
           safeKill(proc, "SIGKILL");
@@ -519,15 +475,10 @@ async function runInSubprocess<T>(method: string, args: unknown[]): Promise<T> {
       }, NATIVE_TIMEOUT_MS);
     });
 
-    const workPromise = Promise.all([
-      readStream(proc.stdout, stdoutChunks, () => stdoutBytes, (n) => { stdoutBytes = n; }),
-      readStream(proc.stderr, stderrChunks, () => stderrBytes, (n) => { stderrBytes = n; }),
-      proc.exited,
-    ]);
+    const exitCode = await Promise.race([proc.exited, timeoutPromise]);
 
-    const [stdout, stderr, exitCode] = await Promise.race([workPromise, timeoutPromise]);
+    if (timeoutId) clearTimeout(timeoutId);
 
-    // Note: proc.killed is always true after exit in Bun (even for normal exits), so we only check signalCode
     if (weInitiatedKill || proc.signalCode) {
       throw new Error(
         `Subprocess '${method}' was killed (signal: ${proc.signalCode || "SIGTERM"})`
@@ -535,6 +486,7 @@ async function runInSubprocess<T>(method: string, args: unknown[]): Promise<T> {
     }
 
     if (exitCode !== 0) {
+      const stderr = await proc.stderr.text();
       let errorMsg = stderr || `Process exited with code ${exitCode}`;
       try {
         const parsed = JSON.parse(stderr);
@@ -543,11 +495,16 @@ async function runInSubprocess<T>(method: string, args: unknown[]): Promise<T> {
       throw new Error(`Subprocess '${method}' failed: ${errorMsg}`);
     }
 
+    if (!existsSync(outputFile)) {
+      throw new Error(`Subprocess '${method}' did not produce output file`);
+    }
+
     try {
-      return JSON.parse(stdout) as T;
+      const output = readFileSync(outputFile, "utf-8");
+      return JSON.parse(output) as T;
     } catch (e) {
       throw new Error(
-        `Failed to parse subprocess output: ${(e as Error).message}\nstdout: ${stdout.slice(0, 500)}`
+        `Failed to parse subprocess output: ${(e as Error).message}`
       );
     }
   } finally {

package/src/sessions/types.ts

@@ -22,7 +22,7 @@ export interface UnifiedMessage {
   agent?: string;
 }
 
-export type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor" | "amp" | "droid" | "openclaw";
+export type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor" | "amp" | "droid" | "openclaw" | "pi";
 
 /**
  * Convert Unix milliseconds timestamp to YYYY-MM-DD date string

package/src/submit.ts

@@ -25,6 +25,7 @@ interface SubmitOptions {
   amp?: boolean;
   droid?: boolean;
   openclaw?: boolean;
+  pi?: boolean;
   since?: string;
   until?: string;
   year?: string;
@@ -50,7 +51,7 @@ interface SubmitResponse {
   details?: string[];
 }
 
-type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor" | "amp" | "droid" | "openclaw";
+type SourceType = "opencode" | "claude" | "codex" | "gemini" | "cursor" | "amp" | "droid" | "openclaw" | "pi";
 
 async function checkGhCliExists(): Promise<boolean> {
   try {
@@ -193,7 +194,7 @@ export async function submit(options: SubmitOptions = {}): Promise<void> {
 
   console.log(pc.gray("  Scanning local session data..."));
 
-  const hasFilter = options.opencode || options.claude || options.codex || options.gemini || options.cursor || options.amp || options.droid || options.openclaw;
+  const hasFilter = options.opencode || options.claude || options.codex || options.gemini || options.cursor || options.amp || options.droid || options.openclaw || options.pi;
   let sources: SourceType[] | undefined;
   let includeCursor = true;
   if (hasFilter) {
@@ -206,6 +207,7 @@ export async function submit(options: SubmitOptions = {}): Promise<void> {
     if (options.amp) sources.push("amp");
     if (options.droid) sources.push("droid");
     if (options.openclaw) sources.push("openclaw");
+    if (options.pi) sources.push("pi");
     includeCursor = sources.includes("cursor");
   }
 

package/src/tui/App.tsx

@@ -288,6 +288,7 @@ export function App(props: AppProps) {
     if (key.name === "6") { handleSourceToggle("amp"); return; }
     if (key.name === "7") { handleSourceToggle("droid"); return; }
     if (key.name === "8") { handleSourceToggle("openclaw"); return; }
+    if (key.name === "9") { handleSourceToggle("pi"); return; }
 
     if (key.name === "up") {
       if (activeTab() === "overview") {

package/src/tui/config/settings.ts

@@ -14,11 +14,16 @@ const MIN_AUTO_REFRESH_MS = 30000;
 const MAX_AUTO_REFRESH_MS = 3600000;
 const DEFAULT_AUTO_REFRESH_MS = 60000;
 
+const DEFAULT_NATIVE_TIMEOUT_MS = 300_000; // 5 minutes
+const MIN_NATIVE_TIMEOUT_MS = 5_000; // 5 seconds
+const MAX_NATIVE_TIMEOUT_MS = 3_600_000; // 1 hour
+
 export interface TokscaleSettings {
   colorPalette: string;
   autoRefreshEnabled?: boolean;
   autoRefreshMs?: number;
   includeUnusedModels?: boolean;
+  nativeTimeoutMs?: number;
 }
 
 function validateSettings(raw: unknown): TokscaleSettings {
@@ -27,6 +32,7 @@ function validateSettings(raw: unknown): TokscaleSettings {
     autoRefreshEnabled: false, 
     autoRefreshMs: DEFAULT_AUTO_REFRESH_MS,
     includeUnusedModels: false,
+    nativeTimeoutMs: DEFAULT_NATIVE_TIMEOUT_MS,
   };
   
   if (!raw || typeof raw !== "object") return defaults;
@@ -43,7 +49,12 @@ function validateSettings(raw: unknown): TokscaleSettings {
   
   const includeUnusedModels = typeof obj.includeUnusedModels === "boolean" ? obj.includeUnusedModels : defaults.includeUnusedModels;
   
-  return { colorPalette, autoRefreshEnabled, autoRefreshMs, includeUnusedModels };
+  let nativeTimeoutMs = defaults.nativeTimeoutMs;
+  if (typeof obj.nativeTimeoutMs === "number" && Number.isFinite(obj.nativeTimeoutMs)) {
+    nativeTimeoutMs = Math.min(MAX_NATIVE_TIMEOUT_MS, Math.max(MIN_NATIVE_TIMEOUT_MS, obj.nativeTimeoutMs));
+  }
+  
+  return { colorPalette, autoRefreshEnabled, autoRefreshMs, includeUnusedModels, nativeTimeoutMs };
 }
 
 interface CachedTUIData {
@@ -66,7 +77,7 @@ export function loadSettings(): TokscaleSettings {
     }
   } catch {
   }
-  return { colorPalette: "blue", autoRefreshEnabled: false, autoRefreshMs: DEFAULT_AUTO_REFRESH_MS, includeUnusedModels: false };
+  return { colorPalette: "blue", autoRefreshEnabled: false, autoRefreshMs: DEFAULT_AUTO_REFRESH_MS, includeUnusedModels: false, nativeTimeoutMs: DEFAULT_NATIVE_TIMEOUT_MS };
 }
 
 export function saveSettings(updates: Partial<TokscaleSettings>): void {

package/src/tui/hooks/useData.ts

@@ -158,8 +158,8 @@ async function loadData(
   const phase1Results = await Promise.allSettled([
     includeCursor && isCursorLoggedIn() ? syncCursorCache() : Promise.resolve({ synced: false, rows: 0, error: undefined }),
     localSources.length > 0
-      ? parseLocalSourcesAsync({ sources: localSources as ("opencode" | "claude" | "codex" | "gemini" | "amp" | "droid" | "openclaw")[], since, until, year })
-      : Promise.resolve({ messages: [], opencodeCount: 0, claudeCount: 0, codexCount: 0, geminiCount: 0, ampCount: 0, droidCount: 0, openclawCount: 0, processingTimeMs: 0 } as ParsedMessages),
+      ? parseLocalSourcesAsync({ sources: localSources as ("opencode" | "claude" | "codex" | "gemini" | "amp" | "droid" | "openclaw" | "pi")[], since, until, year })
+      : Promise.resolve({ messages: [], opencodeCount: 0, claudeCount: 0, codexCount: 0, geminiCount: 0, ampCount: 0, droidCount: 0, openclawCount: 0, piCount: 0, processingTimeMs: 0 } as ParsedMessages),
   ]);
 
   const cursorSync = phase1Results[0].status === "fulfilled" 
@@ -184,6 +184,7 @@ async function loadData(
     ampCount: 0,
     droidCount: 0,
     openclawCount: 0,
+    piCount: 0,
     processingTimeMs: 0,
   };
 

package/src/tui/types/index.ts

@@ -2,7 +2,7 @@ import type { ColorPaletteName } from "../config/themes.js";
 
 export type TabType = "overview" | "model" | "daily" | "stats";
 export type SortType = "cost" | "tokens" | "date";
-export type SourceType = "opencode" | "claude" | "codex" | "cursor" | "gemini" | "amp" | "droid" | "openclaw";
+export type SourceType = "opencode" | "claude" | "codex" | "cursor" | "gemini" | "amp" | "droid" | "openclaw" | "pi";
 
 export type { ColorPaletteName };
 
@@ -163,7 +163,8 @@ export const SOURCE_LABELS: Record<SourceType, string> = {
   amp: "AM",
   droid: "DR",
   openclaw: "CL",
+  pi: "PI",
 } as const;
 
 export const TABS: readonly TabType[] = ["overview", "model", "daily", "stats"] as const;
-export const ALL_SOURCES: readonly SourceType[] = ["opencode", "claude", "codex", "cursor", "gemini", "amp", "droid", "openclaw"] as const;
+export const ALL_SOURCES: readonly SourceType[] = ["opencode", "claude", "codex", "cursor", "gemini", "amp", "droid", "openclaw", "pi"] as const;

package/src/tui/utils/colors.ts

@@ -61,6 +61,7 @@ export const SOURCE_COLORS: Record<SourceType, string> = {
   amp: "#EC4899",
   droid: "#10b981",
   openclaw: "#ef4444",
+  pi: "#f97316",
 };
 
 export function getSourceColor(source: SourceType | string): string {
@@ -70,5 +71,6 @@ export function getSourceColor(source: SourceType | string): string {
 export function getSourceDisplayName(source: string): string {
   if (source === "droid") return "Droid";
   if (source === "openclaw") return "OpenClaw";
+  if (source === "pi") return "Pi";
   return source.charAt(0).toUpperCase() + source.slice(1);
 }

package/src/wrapped.ts

@@ -65,6 +65,7 @@ const SOURCE_DISPLAY_NAMES: Record<string, string> = {
   amp: "Amp",
   droid: "Droid",
   openclaw: "OpenClaw",
+  pi: "Pi",
 };
 
 const ASSETS_BASE_URL = "https://tokscale.ai/assets/logos";
@@ -97,6 +98,7 @@ const CLIENT_LOGO_URLS: Record<string, string> = {
   "Amp": `${ASSETS_BASE_URL}/amp.png`,
   "Droid": `${ASSETS_BASE_URL}/droid.png`,
   "OpenClaw": `${ASSETS_BASE_URL}/openclaw.png`,
+  "Pi": `${ASSETS_BASE_URL}/pi.png`,
 };
 
 const PROVIDER_LOGO_URLS: Record<string, string> = {
@@ -214,8 +216,8 @@ async function ensureFontsLoaded(): Promise<void> {
 
 async function loadWrappedData(options: WrappedOptions): Promise<WrappedData> {
   const year = options.year || new Date().getFullYear().toString();
-  const sources = options.sources || ["opencode", "claude", "codex", "gemini", "cursor", "amp", "droid", "openclaw"];
-  const localSources = sources.filter(s => s !== "cursor") as ("opencode" | "claude" | "codex" | "gemini" | "amp" | "droid" | "openclaw")[];
+  const sources = options.sources || ["opencode", "claude", "codex", "gemini", "cursor", "amp", "droid", "openclaw", "pi"];
+  const localSources = sources.filter(s => s !== "cursor") as ("opencode" | "claude" | "codex" | "gemini" | "amp" | "droid" | "openclaw" | "pi")[];
   const includeCursor = sources.includes("cursor");
 
   const since = `${year}-01-01`;
@@ -225,7 +227,7 @@ async function loadWrappedData(options: WrappedOptions): Promise<WrappedData> {
     includeCursor && isCursorLoggedIn() ? syncCursorCache() : Promise.resolve({ synced: false, rows: 0, error: undefined }),
     localSources.length > 0
       ? parseLocalSourcesAsync({ sources: localSources, since, until, year })
-      : Promise.resolve({ messages: [], opencodeCount: 0, claudeCount: 0, codexCount: 0, geminiCount: 0, ampCount: 0, droidCount: 0, openclawCount: 0, processingTimeMs: 0 } as ParsedMessages),
+      : Promise.resolve({ messages: [], opencodeCount: 0, claudeCount: 0, codexCount: 0, geminiCount: 0, ampCount: 0, droidCount: 0, openclawCount: 0, piCount: 0, processingTimeMs: 0 } as ParsedMessages),
   ]);
 
   const cursorSync = phase1Results[0].status === "fulfilled" 
@@ -249,6 +251,7 @@ async function loadWrappedData(options: WrappedOptions): Promise<WrappedData> {
     ampCount: 0,
     droidCount: 0,
     openclawCount: 0,
+    piCount: 0,
     processingTimeMs: 0,
   };