@hienlh/ppm 0.8.84 → 0.8.86

package/src/services/account.service.ts

@@ -69,14 +69,9 @@ const OAUTH_TOKEN_URL = "https://api.anthropic.com/v1/oauth/token";
 const OAUTH_SCOPE = "org:create_api_key user:profile user:inference";
 const OAUTH_PLATFORM_REDIRECT = "https://platform.claude.com/oauth/code/callback";
 
-// Survive Bun --hot reloads: persist timer ref across module re-evaluations
-const ACCT_HOT_KEY = "__PPM_ACCT_REFRESH__" as const;
-const acctHotState = ((globalThis as any)[ACCT_HOT_KEY] ??= {
-  refreshTimer: null as ReturnType<typeof setInterval> | null,
-}) as { refreshTimer: ReturnType<typeof setInterval> | null };
-
 class AccountService {
   private pendingStates = new Map<string, { verifier: string; createdAt: number }>();
+  private refreshTimer: ReturnType<typeof setInterval> | null = null;
 
   private toAccount(row: AccountRow): Account {
     let profileData: OAuthProfileData | null = null;
@@ -535,7 +530,6 @@ class AccountService {
         client_id: OAUTH_CLIENT_ID,
         refresh_token: account.refreshToken,
       }),
-      signal: AbortSignal.timeout(15_000),
     });
     if (!res.ok) {
       const errorBody = await res.text().catch(() => "");
@@ -623,13 +617,13 @@ class AccountService {
       if (!row.id || !row.access_token) continue;
       const hasRefresh = !!row.refresh_token && row.refresh_token !== "";
 
-      // Duplicate handling: update existing account tokens from import
+      // Duplicate handling: if existing account has no refresh token but import does, upgrade it
       const existingById = getAccountById(row.id);
       const existingByEmail = row.email ? this.list().find((a) => a.email === row.email) : null;
       const existing = existingById ?? (existingByEmail ? getAccountById(existingByEmail.id) : null);
       if (existing) {
-        if (hasRefresh) {
-          // Always update tokens when import has refresh token (handles expired/invalid tokens too)
+        if (hasRefresh && !this.hasRefreshToken(existing.id)) {
+          // Upgrade: import has refresh token, existing doesn't → update tokens
           let accessToken = row.access_token;
           if (!looksEncrypted(accessToken)) accessToken = encrypt(accessToken);
           const refreshToken = looksEncrypted(row.refresh_token) ? row.refresh_token : encrypt(row.refresh_token);
@@ -641,9 +635,9 @@ class AccountService {
           });
           imported++;
           fullTransferIds.push(existing.id);
-          console.log(`[accounts] Updated ${row.email ?? existing.id} tokens from import`);
+          console.log(`[accounts] Upgraded ${row.email ?? existing.id} with refresh token from import`);
         }
-        continue; // skip if import doesn't have refresh token
+        continue; // skip if existing already has refresh token or import doesn't
       }
 
       // New account — insert
@@ -694,7 +688,7 @@ class AccountService {
   // ---------------------------------------------------------------------------
 
   startAutoRefresh(): void {
-    if (acctHotState.refreshTimer) return;
+    if (this.refreshTimer) return;
     const CHECK_INTERVAL_MS = 5 * 60_000;
     const REFRESH_BUFFER_S = 5 * 60;
 
@@ -734,20 +728,20 @@ class AccountService {
     // Run immediately on startup, then every 5 minutes
     refreshExpiring().catch(() => {});
     cleanupExpiredTemporary();
-    acctHotState.refreshTimer = setInterval(() => {
+    this.refreshTimer = setInterval(() => {
       refreshExpiring().catch(() => {});
       cleanupExpiredTemporary();
     }, CHECK_INTERVAL_MS);
 
-    if (typeof acctHotState.refreshTimer === "object" && acctHotState.refreshTimer !== null && "unref" in acctHotState.refreshTimer) {
-      (acctHotState.refreshTimer as NodeJS.Timeout).unref();
+    if (typeof this.refreshTimer === "object" && this.refreshTimer !== null && "unref" in this.refreshTimer) {
+      (this.refreshTimer as NodeJS.Timeout).unref();
     }
   }
 
   stopAutoRefresh(): void {
-    if (acctHotState.refreshTimer) {
-      clearInterval(acctHotState.refreshTimer);
-      acctHotState.refreshTimer = null;
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
     }
   }
 }

package/src/services/claude-usage.service.ts

@@ -47,19 +47,10 @@ const POLL_INTERVAL = 300_000; // 5min
 const ACCOUNT_STAGGER_MS = 1_000; // 1s between accounts
 
 let inMemoryCostUsd = 0;
-
-// Survive Bun --hot reloads: module-level vars reset on reload, globalThis persists.
-// Without this, each hot-reload creates a NEW polling timer without clearing the old one,
-// leading to N concurrent timers after N reloads (observed: 221 timers → 38k 429 errors/day).
-const HOT_KEY = "__PPM_USAGE_POLL__" as const;
-const hotState = ((globalThis as any)[HOT_KEY] ??= {
-  pollTimer: null as ReturnType<typeof setTimeout> | null,
-  inflightPoll: null as Promise<void> | null,
-}) as { pollTimer: ReturnType<typeof setTimeout> | null; inflightPoll: Promise<void> | null };
+let pollTimer: ReturnType<typeof setInterval> | null = null;
 
 // Per-token cooldown map: token prefix → earliest allowed fetch time
 const tokenCooldowns = new Map<string, number>();
-const MIN_COOLDOWN_MS = 60_000; // floor: at least 60s cooldown on 429
 
 // Legacy: Keychain token cache for users without accounts in DB
 let tokenCache: { token: string; timestamp: number } | null = null;
@@ -122,10 +113,9 @@ async function fetchUsageForToken(token: string): Promise<ClaudeUsage> {
   });
   if (res.status === 429) {
     const retryAfter = parseInt(res.headers.get("retry-after") ?? "60", 10);
-    const cooldownMs = Math.max(retryAfter * 1000, MIN_COOLDOWN_MS);
     const cooldownKey = token.substring(0, 20);
-    tokenCooldowns.set(cooldownKey, Date.now() + cooldownMs);
-    throw new Error(`Usage API 429 — cooldown ${Math.ceil(cooldownMs / 1000)}s`);
+    tokenCooldowns.set(cooldownKey, Date.now() + retryAfter * 1000);
+    throw new Error(`Usage API 429 — cooldown ${retryAfter}s`);
   }
   if (!res.ok) throw new Error(`Usage API returned ${res.status}`);
   const raw = (await res.json()) as Record<string, any>;
@@ -238,7 +228,7 @@ async function fetchLegacySingleAccount(): Promise<void> {
   } catch {}
 }
 
-async function pollOnceInternal(): Promise<void> {
+async function pollOnce(): Promise<void> {
   try {
     const hasAccounts = accountService.list().length > 0;
     if (hasAccounts) {
@@ -251,18 +241,6 @@ async function pollOnceInternal(): Promise<void> {
   }
 }
 
-/** Deduped: concurrent callers share a single in-flight fetch */
-async function pollOnce(): Promise<void> {
-  if (hotState.inflightPoll) return hotState.inflightPoll;
-  const thisPoll = pollOnceInternal().finally(() => {
-    // Only clear if still the current poll — prevents a stale .finally() from
-    // clearing a newer poll after timeout handler force-nulled inflightPoll.
-    if (hotState.inflightPoll === thisPoll) hotState.inflightPoll = null;
-  });
-  hotState.inflightPoll = thisPoll;
-  return thisPoll;
-}
-
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -319,26 +297,20 @@ export function getCachedUsage(): ClaudeUsage & { activeAccountId?: string; acti
 }
 
 export function startUsagePolling(): void {
-  if (hotState.pollTimer) return;
-  const POLL_TIMEOUT = 60_000; // max 60s per poll iteration
+  if (pollTimer) return;
+  // Use recursive setTimeout instead of setInterval to prevent overlap
+  // and ensure polling continues even if a single iteration errors
   const scheduleNext = () => {
-    hotState.pollTimer = setTimeout(async () => {
-      const timeout = new Promise<"timeout">(r => setTimeout(() => r("timeout"), POLL_TIMEOUT));
-      const result = await Promise.race([
-        pollOnce().then(() => "done" as const),
-        timeout,
-      ]).catch(() => "error" as const);
-      // If the poll timed out, force-clear inflightPoll so next scheduled poll
-      // starts a fresh fetch instead of reusing the stale hanging promise.
-      if (result === "timeout") hotState.inflightPoll = null;
+    pollTimer = setTimeout(async () => {
+      await pollOnce();
       scheduleNext();
     }, POLL_INTERVAL);
   };
-  pollOnce().then(scheduleNext, scheduleNext);
+  pollOnce().then(scheduleNext);
 }
 
 export function stopUsagePolling(): void {
-  if (hotState.pollTimer) { clearTimeout(hotState.pollTimer); hotState.pollTimer = null; }
+  if (pollTimer) { clearTimeout(pollTimer); pollTimer = null; }
 }
 
 export function updateFromSdkEvent(_rateLimitType?: string, _utilization?: number, costUsd?: number): void {
@@ -349,12 +321,3 @@ export async function refreshUsageNow(): Promise<ClaudeUsage & { activeAccountId
   await pollOnce();
   return getCachedUsage();
 }
-
-/** @internal Test-only: reset module-level state between tests */
-export function _resetForTesting(): void {
-  inMemoryCostUsd = 0;
-  if (hotState.pollTimer) { clearTimeout(hotState.pollTimer); hotState.pollTimer = null; }
-  tokenCooldowns.clear();
-  hotState.inflightPoll = null;
-  tokenCache = null;
-}

package/src/services/cloud.service.ts

@@ -362,16 +362,12 @@ export async function sendHeartbeat(tunnelUrl: string): Promise<boolean> {
   }
 }
 
-// Survive Bun --hot reloads: persist timer ref across module re-evaluations
-const CLOUD_HOT_KEY = "__PPM_CLOUD_HEARTBEAT__" as const;
-const cloudHotState = ((globalThis as any)[CLOUD_HOT_KEY] ??= {
-  heartbeatTimer: null as ReturnType<typeof setInterval> | null,
-}) as { heartbeatTimer: ReturnType<typeof setInterval> | null };
+let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
 
 /** Start periodic heartbeat (call once after tunnel URL is obtained) */
 export function startHeartbeat(tunnelUrl: string): void {
   // Clear any existing heartbeat to prevent duplicates on restart
-  if (cloudHotState.heartbeatTimer) clearInterval(cloudHotState.heartbeatTimer);
+  if (heartbeatTimer) clearInterval(heartbeatTimer);
 
   // Initial heartbeat immediately
   sendHeartbeat(tunnelUrl).then((ok) => {
@@ -380,16 +376,16 @@ export function startHeartbeat(tunnelUrl: string): void {
   });
 
   // Periodic heartbeat every 5 minutes
-  cloudHotState.heartbeatTimer = setInterval(() => {
+  heartbeatTimer = setInterval(() => {
     sendHeartbeat(tunnelUrl).catch(() => {});
   }, HEARTBEAT_INTERVAL_MS);
 }
 
 /** Stop periodic heartbeat */
 export function stopHeartbeat(): void {
-  if (cloudHotState.heartbeatTimer) {
-    clearInterval(cloudHotState.heartbeatTimer);
-    cloudHotState.heartbeatTimer = null;
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
   }
 }
 

package/src/services/db.service.ts

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { mkdirSync, existsSync } from "node:fs";
 
 const PPM_DIR = process.env.PPM_HOME || resolve(homedir(), ".ppm");
-const CURRENT_SCHEMA_VERSION = 10;
+const CURRENT_SCHEMA_VERSION = 5;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -228,65 +228,6 @@ function runMigrations(database: Database): void {
     }
     database.exec(`PRAGMA user_version = 7`);
   }
-
-  if (current < 8) {
-    database.exec(`
-      CREATE TABLE IF NOT EXISTS session_titles (
-        session_id TEXT PRIMARY KEY,
-        title TEXT NOT NULL,
-        updated_at TEXT DEFAULT (datetime('now'))
-      );
-
-      PRAGMA user_version = 8;
-    `);
-  }
-
-  if (current < 9) {
-    database.exec(`
-      CREATE TABLE IF NOT EXISTS session_pins (
-        session_id TEXT PRIMARY KEY,
-        pinned_at TEXT DEFAULT (datetime('now'))
-      );
-
-      PRAGMA user_version = 9;
-    `);
-  }
-
-  if (current < 10) {
-    database.exec(`
-      CREATE TABLE IF NOT EXISTS workspace_state (
-        project_name TEXT PRIMARY KEY,
-        layout_json  TEXT NOT NULL,
-        updated_at   TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      PRAGMA user_version = 10;
-    `);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Workspace helpers
-// ---------------------------------------------------------------------------
-
-export interface WorkspaceRow {
-  project_name: string;
-  layout_json: string;
-  updated_at: string;
-}
-
-export function getWorkspace(projectName: string): WorkspaceRow | null {
-  return getDb().query(
-    "SELECT project_name, layout_json, updated_at FROM workspace_state WHERE project_name = ?",
-  ).get(projectName) as WorkspaceRow | null;
-}
-
-export function setWorkspace(projectName: string, layoutJson: string): string {
-  const now = new Date().toISOString();
-  getDb().query(
-    "INSERT INTO workspace_state (project_name, layout_json, updated_at) VALUES (?, ?, ?) ON CONFLICT(project_name) DO UPDATE SET layout_json = excluded.layout_json, updated_at = excluded.updated_at",
-  ).run(projectName, layoutJson, now);
-  return now;
 }
 
 // ---------------------------------------------------------------------------
@@ -370,52 +311,6 @@ export function getAllSessionMappings(): Record<string, string> {
   return result;
 }
 
-// ---------------------------------------------------------------------------
-// Session title helpers (user-set titles persisted in PPM DB)
-// ---------------------------------------------------------------------------
-
-export function getSessionTitle(sessionId: string): string | null {
-  const row = getDb().query("SELECT title FROM session_titles WHERE session_id = ?").get(sessionId) as { title: string } | null;
-  return row?.title ?? null;
-}
-
-export function setSessionTitle(sessionId: string, title: string): void {
-  getDb().query(
-    "INSERT INTO session_titles (session_id, title, updated_at) VALUES (?, ?, datetime('now')) ON CONFLICT(session_id) DO UPDATE SET title = excluded.title, updated_at = excluded.updated_at",
-  ).run(sessionId, title);
-}
-
-/** Bulk-fetch DB titles for a list of session IDs. Returns map of id → title. */
-export function getSessionTitles(sessionIds: string[]): Record<string, string> {
-  if (sessionIds.length === 0) return {};
-  const placeholders = sessionIds.map(() => "?").join(", ");
-  const rows = getDb().query(
-    `SELECT session_id, title FROM session_titles WHERE session_id IN (${placeholders})`,
-  ).all(...sessionIds) as { session_id: string; title: string }[];
-  const result: Record<string, string> = {};
-  for (const r of rows) result[r.session_id] = r.title;
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Session pin helpers
-// ---------------------------------------------------------------------------
-
-export function pinSession(sessionId: string): void {
-  getDb().query(
-    "INSERT INTO session_pins (session_id, pinned_at) VALUES (?, datetime('now')) ON CONFLICT(session_id) DO UPDATE SET pinned_at = datetime('now')",
-  ).run(sessionId);
-}
-
-export function unpinSession(sessionId: string): void {
-  getDb().query("DELETE FROM session_pins WHERE session_id = ?").run(sessionId);
-}
-
-export function getPinnedSessionIds(): Set<string> {
-  const rows = getDb().query("SELECT session_id FROM session_pins ORDER BY pinned_at DESC").all() as { session_id: string }[];
-  return new Set(rows.map((r) => r.session_id));
-}
-
 // ---------------------------------------------------------------------------
 // Push subscription helpers
 // ---------------------------------------------------------------------------
@@ -546,13 +441,13 @@ export function insertLimitSnapshot(data: Omit<LimitSnapshotRow, "id" | "recorde
 
 export function getLatestLimitSnapshot(): LimitSnapshotRow | null {
   return getDb().query(
-    "SELECT * FROM claude_limit_snapshots ORDER BY recorded_at DESC, id DESC LIMIT 1",
+    "SELECT * FROM claude_limit_snapshots ORDER BY recorded_at DESC LIMIT 1",
   ).get() as LimitSnapshotRow | null;
 }
 
 export function getLatestSnapshotForAccount(accountId: string): LimitSnapshotRow | null {
   return getDb().query(
-    "SELECT * FROM claude_limit_snapshots WHERE account_id = ? ORDER BY recorded_at DESC, id DESC LIMIT 1",
+    "SELECT * FROM claude_limit_snapshots WHERE account_id = ? ORDER BY recorded_at DESC LIMIT 1",
   ).get(accountId) as LimitSnapshotRow | null;
 }
 
@@ -560,17 +455,17 @@ export function getAllLatestSnapshots(): LimitSnapshotRow[] {
   return getDb().query(
     `SELECT s.* FROM claude_limit_snapshots s
      INNER JOIN (
-       SELECT account_id, MAX(id) as max_id
+       SELECT account_id, MAX(recorded_at) as max_recorded
        FROM claude_limit_snapshots WHERE account_id IS NOT NULL
        GROUP BY account_id
-     ) latest ON s.id = latest.max_id`,
+     ) latest ON s.account_id = latest.account_id AND s.recorded_at = latest.max_recorded`,
   ).all() as LimitSnapshotRow[];
 }
 
 export function touchSnapshotTimestamp(accountId: string): void {
   getDb().query(
     `UPDATE claude_limit_snapshots SET recorded_at = datetime('now')
-     WHERE id = (SELECT id FROM claude_limit_snapshots WHERE account_id = ? ORDER BY recorded_at DESC, id DESC LIMIT 1)`,
+     WHERE id = (SELECT id FROM claude_limit_snapshots WHERE account_id = ? ORDER BY recorded_at DESC LIMIT 1)`,
   ).run(accountId);
 }
 

package/src/services/port-tunnel.service.ts

@@ -0,0 +1,97 @@
+import type { Subprocess } from "bun";
+import { ensureCloudflared } from "./cloudflared.service.ts";
+
+const TUNNEL_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+const decoder = new TextDecoder();
+
+interface PortTunnel {
+  port: number;
+  url: string;
+  process: Subprocess;
+}
+
+/**
+ * Manages cloudflare Quick Tunnels for arbitrary local ports.
+ * Each port gets its own cloudflared process and public URL.
+ */
+class PortTunnelService {
+  private tunnels = new Map<number, PortTunnel>();
+
+  /** Start a tunnel for a given port. Returns the public URL. */
+  async start(port: number): Promise<string> {
+    const existing = this.tunnels.get(port);
+    if (existing) return existing.url;
+
+    const bin = await ensureCloudflared();
+    const proc = Bun.spawn(
+      [bin, "tunnel", "--url", `http://127.0.0.1:${port}`],
+      { stderr: "pipe", stdout: "ignore", stdin: "ignore" },
+    );
+
+    const reader = proc.stderr.getReader();
+    const url = await new Promise<string>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        proc.kill();
+        reject(new Error("Tunnel timed out after 30s"));
+      }, 30_000);
+
+      let buffer = "";
+      let found = false;
+      const read = async () => {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (found) continue;
+            buffer += decoder.decode(value, { stream: true });
+            const match = buffer.match(TUNNEL_URL_REGEX);
+            if (match) {
+              found = true;
+              buffer = "";
+              clearTimeout(timeout);
+              resolve(match[0]);
+            }
+          }
+          if (!found) {
+            clearTimeout(timeout);
+            reject(new Error("cloudflared exited without providing tunnel URL"));
+          }
+        } catch (err) {
+          if (!found) { clearTimeout(timeout); reject(err); }
+        }
+      };
+      read();
+    });
+
+    this.tunnels.set(port, { port, url, process: proc });
+    console.log(`[port-tunnel] Started tunnel for port ${port} → ${url}`);
+    return url;
+  }
+
+  /** Stop a tunnel for a given port */
+  stop(port: number): boolean {
+    const tunnel = this.tunnels.get(port);
+    if (!tunnel) return false;
+    try { tunnel.process.kill(); } catch {}
+    this.tunnels.delete(port);
+    console.log(`[port-tunnel] Stopped tunnel for port ${port}`);
+    return true;
+  }
+
+  /** Get tunnel URL for a port (null if not running) */
+  getUrl(port: number): string | null {
+    return this.tunnels.get(port)?.url ?? null;
+  }
+
+  /** List all active port tunnels */
+  list(): { port: number; url: string }[] {
+    return Array.from(this.tunnels.values()).map(({ port, url }) => ({ port, url }));
+  }
+
+  /** Stop all tunnels (cleanup) */
+  stopAll(): void {
+    for (const [port] of this.tunnels) this.stop(port);
+  }
+}
+
+export const portTunnelService = new PortTunnelService();

package/src/services/proxy.service.ts

@@ -60,6 +60,12 @@ class ProxyService {
 
     // Ensure token is fresh for OAuth accounts
     let token = account.accessToken;
+    if (!token) {
+      return new Response(
+        JSON.stringify({ type: "error", error: { type: "authentication_error", message: "Account has no access token (decryption may have failed)" } }),
+        { status: 401, headers: { "Content-Type": "application/json" } },
+      );
+    }
     if (token.startsWith("sk-ant-oat")) {
       const fresh = await accountService.ensureFreshToken(account.id);
       if (fresh) token = fresh.accessToken;
@@ -108,14 +114,22 @@ class ProxyService {
       } else if (upstream.status === 401) {
         accountSelector.onAuthError(account.id);
         console.log(`[proxy] 401 from Anthropic — account ${account.email ?? account.id} auth error`);
+      } else if (upstream.status >= 400) {
+        console.log(`[proxy] ${upstream.status} from Anthropic — account ${account.email ?? account.id} (OAuth=${token.startsWith("sk-ant-oat")})`);
       } else if (upstream.status >= 200 && upstream.status < 300) {
         accountSelector.onSuccess(account.id);
       }
 
       // Stream response back as-is (preserves SSE for streaming)
       const responseHeaders = new Headers();
-      // Forward key response headers
-      for (const key of ["content-type", "x-request-id", "request-id"]) {
+      // Forward all relevant response headers from Anthropic
+      for (const key of [
+        "content-type", "x-request-id", "request-id",
+        "anthropic-ratelimit-requests-limit", "anthropic-ratelimit-requests-remaining",
+        "anthropic-ratelimit-requests-reset", "anthropic-ratelimit-tokens-limit",
+        "anthropic-ratelimit-tokens-remaining", "anthropic-ratelimit-tokens-reset",
+        "retry-after",
+      ]) {
         const val = upstream.headers.get(key);
         if (val) responseHeaders.set(key, val);
       }
@@ -127,9 +141,10 @@ class ProxyService {
         headers: responseHeaders,
       });
     } catch (e) {
-      console.error(`[proxy] Error forwarding to Anthropic:`, (e as Error).message);
+      const msg = e instanceof Error ? e.message : String(e);
+      console.error(`[proxy] Error forwarding to Anthropic:`, msg);
       return new Response(
-        JSON.stringify({ type: "error", error: { type: "api_error", message: (e as Error).message } }),
+        JSON.stringify({ type: "error", error: { type: "api_error", message: msg || "Unknown proxy error" } }),
         { status: 502, headers: { "Content-Type": "application/json" } },
       );
     }