@hienlh/ppm 0.9.0-beta.9 → 0.9.1

package/src/server/ws/extensions.ts

@@ -0,0 +1,175 @@
+/**
+ * WebSocket handler for extension UI bridge.
+ * Routes messages between browser clients and the extension host.
+ */
+import { contributionRegistry } from "../../services/contribution-registry.ts";
+import type { ExtServerMsg, ExtClientMsg } from "../../types/extension-messages.ts";
+
+type ExtWsSocket = {
+  data: { type: string };
+  send: (data: string) => void;
+};
+
+/** All connected extension WS clients */
+const clients = new Set<ExtWsSocket>();
+
+/** Pending request resolvers for quickpick/inputbox responses from browser */
+const pendingRequests = new Map<string, (value: unknown) => void>();
+
+// --- Public API for extension service to push UI updates ---
+
+/** Broadcast a message to all connected extension WS clients */
+export function broadcastExtMsg(msg: ExtServerMsg): void {
+  const data = JSON.stringify(msg);
+  for (const ws of clients) {
+    try { ws.send(data); } catch {}
+  }
+}
+
+/**
+ * Send a request to browser and wait for response (quickpick, inputbox, notification).
+ * The `trackingId` is the key used to match the response.
+ * Returns the resolved value or undefined on timeout.
+ */
+export function requestFromBrowser<T = unknown>(
+  msg: ExtServerMsg,
+  trackingId: string,
+  timeoutMs = 30_000,
+): Promise<T | undefined> {
+  broadcastExtMsg(msg);
+  return new Promise<T | undefined>((resolve) => {
+    const timer = setTimeout(() => {
+      pendingRequests.delete(trackingId);
+      resolve(undefined);
+    }, timeoutMs);
+    pendingRequests.set(trackingId, (value) => {
+      clearTimeout(timer);
+      resolve(value as T);
+    });
+  });
+}
+
+/** Get the number of connected extension WS clients */
+export function getExtClientCount(): number {
+  return clients.size;
+}
+
+// --- WS lifecycle handlers ---
+
+function handleOpen(ws: ExtWsSocket): void {
+  clients.add(ws);
+  console.log(`[ExtWS] Client connected (${clients.size} total)`);
+}
+
+async function handleMessage(ws: ExtWsSocket, raw: string | Buffer): Promise<void> {
+  let msg: ExtClientMsg;
+  try {
+    msg = JSON.parse(typeof raw === "string" ? raw : raw.toString()) as ExtClientMsg;
+  } catch {
+    return;
+  }
+
+  switch (msg.type) {
+    case "ready": {
+      // Send current contributions on connect
+      const contributions = contributionRegistry.getAll();
+      ws.send(JSON.stringify({ type: "contributions:update", contributions } satisfies ExtServerMsg));
+      break;
+    }
+
+    case "command:execute": {
+      try {
+        const { extensionService } = await import("../../services/extension.service.ts");
+        // Forward to extension host worker via RPC
+        if (extensionService["rpc"]) {
+          await extensionService["rpc"].sendRequest("ext:command:execute", msg.command, ...(msg.args ?? []));
+        }
+      } catch (e) {
+        console.error(`[ExtWS] command:execute error:`, e);
+      }
+      break;
+    }
+
+    case "tree:click": {
+      if (msg.command) {
+        try {
+          const { extensionService } = await import("../../services/extension.service.ts");
+          if (extensionService["rpc"]) {
+            await extensionService["rpc"].sendRequest("ext:command:execute", msg.command);
+          }
+        } catch (e) {
+          console.error(`[ExtWS] tree:click command error:`, e);
+        }
+      }
+      break;
+    }
+
+    case "quickpick:resolve": {
+      const resolver = pendingRequests.get(msg.requestId);
+      if (resolver) {
+        pendingRequests.delete(msg.requestId);
+        resolver(msg.selected);
+      }
+      break;
+    }
+
+    case "inputbox:resolve": {
+      const resolver = pendingRequests.get(msg.requestId);
+      if (resolver) {
+        pendingRequests.delete(msg.requestId);
+        resolver(msg.value);
+      }
+      break;
+    }
+
+    case "notification:action": {
+      const resolver = pendingRequests.get(msg.id);
+      if (resolver) {
+        pendingRequests.delete(msg.id);
+        resolver(msg.action);
+      }
+      break;
+    }
+
+    case "webview:message": {
+      try {
+        const { extensionService } = await import("../../services/extension.service.ts");
+        if (extensionService["rpc"]) {
+          await extensionService["rpc"].sendRequest("ext:webview:message", msg.panelId, msg.message);
+        }
+      } catch (e) {
+        console.error(`[ExtWS] webview:message error:`, e);
+      }
+      break;
+    }
+
+    case "tree:expand": {
+      try {
+        const { extensionService } = await import("../../services/extension.service.ts");
+        if (extensionService["rpc"]) {
+          const result = await extensionService["rpc"].sendRequest<{ ok: boolean; items?: unknown[] }>(
+            "ext:tree:expand", msg.viewId, msg.itemId,
+          );
+          if (result?.ok && result.items) {
+            // Send children back to the requesting client (parentId distinguishes child updates from root updates)
+            ws.send(JSON.stringify({ type: "tree:update", viewId: msg.viewId, items: result.items as import("../../types/extension-messages.ts").TreeItemMsg[], parentId: msg.itemId } satisfies ExtServerMsg));
+          }
+        }
+      } catch (e) {
+        console.error(`[ExtWS] tree:expand error:`, e);
+      }
+      break;
+    }
+  }
+}
+
+function handleClose(ws: ExtWsSocket): void {
+  clients.delete(ws);
+  console.log(`[ExtWS] Client disconnected (${clients.size} remaining)`);
+}
+
+export const extensionWebSocket = {
+  open: handleOpen,
+  message: handleMessage,
+  close: handleClose,
+};

package/src/services/account-selector.service.ts

@@ -9,6 +9,8 @@ const MAX_RETRY_CONFIG_KEY = "account_max_retry";
 const BACKOFF_BASE_MS = 1_000;
 const BACKOFF_MAX_MS = 30 * 60_000;
 const AUTH_BACKOFF_BASE_MS = 5 * 60_000; // 5min base for auth errors (longer than rate limits)
+/** Skip accounts whose 5-hour utilization >= this threshold (proactive avoidance) */
+const FIVE_HOUR_SKIP_THRESHOLD = 0.95;
 
 class AccountSelectorService {
   private cursor = 0;
@@ -74,18 +76,25 @@ class AccountSelectorService {
       return null;
     }
 
+    // Proactive: skip accounts whose 5-hour utilization >= 95%
+    const usable = active.filter((a) => {
+      const snap = getLatestSnapshotForAccount(a.id);
+      return !snap || (snap.five_hour_util ?? 0) < FIVE_HOUR_SKIP_THRESHOLD;
+    });
+    const candidates = usable.length > 0 ? usable : active; // fallback to all if every account is near limit
+
     let pickedId: string;
     const strategy = this.getStrategy();
     if (strategy === "lowest-usage") {
-      pickedId = this.pickLowestUsage(active);
+      pickedId = this.pickLowestUsage(candidates);
     } else if (strategy === "fill-first") {
-      const sorted = [...active].sort((a, b) => b.priority - a.priority || a.createdAt - b.createdAt);
+      const sorted = [...candidates].sort((a, b) => b.priority - a.priority || a.createdAt - b.createdAt);
       pickedId = sorted[0]!.id;
     } else {
       // Round-robin
-      this.cursor = this.cursor % active.length;
-      pickedId = active[this.cursor]!.id;
-      this.cursor = (this.cursor + 1) % active.length;
+      this.cursor = this.cursor % candidates.length;
+      pickedId = candidates[this.cursor]!.id;
+      this.cursor = (this.cursor + 1) % candidates.length;
     }
     this._lastPickedId = pickedId;
     const result = accountService.getWithTokens(pickedId);

package/src/services/account.service.ts

@@ -139,7 +139,7 @@ class AccountService {
       await this.refreshAccessToken(id, false);
       return this.getWithTokens(id);
     } catch (e) {
-      console.error(`[accounts] Pre-flight refresh failed for ${id}:`, e);
+      console.error(`[accounts] Pre-flight refresh failed for ${id}: ${(e as Error).message ?? e}`);
       return null;
     }
   }
@@ -623,13 +623,13 @@ class AccountService {
       if (!row.id || !row.access_token) continue;
       const hasRefresh = !!row.refresh_token && row.refresh_token !== "";
 
-      // Duplicate handling: if existing account has no refresh token but import does, upgrade it
+      // Duplicate handling: update existing account tokens from import
       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 && !this.hasRefreshToken(existing.id)) {
-          // Upgrade: import has refresh token, existing doesn't → update tokens
+        if (hasRefresh) {
+          // Always update tokens when import has refresh token (handles expired/invalid tokens too)
           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 +641,9 @@ class AccountService {
           });
           imported++;
           fullTransferIds.push(existing.id);
-          console.log(`[accounts] Upgraded ${row.email ?? existing.id} with refresh token from import`);
+          console.log(`[accounts] Updated ${row.email ?? existing.id} tokens from import`);
         }
-        continue; // skip if existing already has refresh token or import doesn't
+        continue; // skip if import doesn't have refresh token
       }
 
       // New account — insert
@@ -709,7 +709,7 @@ class AccountService {
         try {
           await this.refreshAccessToken(acc.id, false);
         } catch (e) {
-          console.error(`[accounts] Auto-refresh failed for ${acc.id}:`, e);
+          console.error(`[accounts] Auto-refresh failed for ${acc.id}: ${(e as Error).message ?? e}`);
         }
       }
     };

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

@@ -273,28 +273,28 @@ export function getUsageForAccount(accountId: string): ClaudeUsage {
   return row ? snapshotToUsage(row) : {};
 }
 
-/** Get usage for all accounts (excludes expired temporary accounts) */
+/** Get usage for all accounts */
 export function getAllAccountUsages(): AccountUsageEntry[] {
-  const nowS = Math.floor(Date.now() / 1000);
-  const accounts = accountService.list().filter(acc => {
-    // Exclude expired accounts without refresh token (temporary/invalid)
-    if (!accountService.hasRefreshToken(acc.id) && acc.expiresAt && acc.expiresAt < nowS) return false;
-    return true;
-  });
+  const accounts = accountService.list();
   const snapshots = getAllLatestSnapshots();
   const snapshotMap = new Map(snapshots.map(s => [s.account_id, s]));
-  return accounts.map(acc => {
+  const nowS = Math.floor(Date.now() / 1000);
+  const result: AccountUsageEntry[] = [];
+  for (const acc of accounts) {
     const withTokens = accountService.getWithTokens(acc.id);
+    // Skip expired accounts without refresh token (temporary/disposable)
+    if (acc.expiresAt && acc.expiresAt < nowS && !withTokens?.refreshToken) continue;
     const isOAuth = withTokens?.accessToken.startsWith("sk-ant-oat") ?? false;
     const row = snapshotMap.get(acc.id);
-    return {
+    result.push({
       accountId: acc.id,
       accountLabel: acc.label,
       accountStatus: acc.status,
       isOAuth,
       usage: row ? snapshotToUsage(row) : {},
-    };
-  });
+    });
+  }
+  return result;
 }
 
 /** Get cached usage for active account (used by chat header) */

package/src/services/cloud-ws.service.ts

@@ -0,0 +1,228 @@
+/**
+ * Cloud WebSocket client — persistent connection from supervisor to PPM Cloud.
+ * Auto-reconnects with exponential backoff + jitter. Queues messages when disconnected.
+ */
+import { appendFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+
+// ─── Types (must match Cloud's ws-types.ts) ─────────
+interface WsMessage {
+  type: string;
+  id?: string;
+  timestamp: string;
+}
+
+interface HeartbeatMsg extends WsMessage {
+  type: "heartbeat";
+  tunnelUrl: string | null;
+  state: string;
+  appVersion: string;
+  availableVersion: string | null;
+  serverPid: number | null;
+  uptime: number;
+  deviceName?: string;
+}
+
+interface StateChangeMsg extends WsMessage {
+  type: "state_change";
+  from: string;
+  to: string;
+  reason: string;
+}
+
+interface CommandAckMsg extends WsMessage {
+  type: "command_ack";
+  id: string;
+}
+
+interface CommandResultMsg extends WsMessage {
+  type: "command_result";
+  id: string;
+  success: boolean;
+  error?: string;
+  data?: Record<string, unknown>;
+}
+
+type OutboundMsg = HeartbeatMsg | StateChangeMsg | CommandAckMsg | CommandResultMsg;
+
+interface CommandMsg extends WsMessage {
+  type: "command";
+  id: string;
+  action: string;
+  params?: Record<string, unknown>;
+}
+
+type CommandHandler = (cmd: CommandMsg) => void;
+
+// ─── Constants ──────────────────────────────────────
+const BACKOFF_STEPS = [1000, 2000, 4000, 8000, 15000, 30000, 60000];
+const MAX_QUEUE_SIZE = 50;
+const HEARTBEAT_INTERVAL_MS = 60_000; // 60s via WS
+
+// ─── State ──────────────────────────────────────────
+let ws: WebSocket | null = null;
+let connected = false;
+let reconnecting = false;
+let reconnectAttempt = 0;
+let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+let commandHandler: CommandHandler | null = null;
+let outboundQueue: OutboundMsg[] = [];
+let wsUrl = "";
+let shouldConnect = false;
+
+// Credentials for first-message auth
+let deviceId = "";
+let secretKey = "";
+
+// For heartbeat payload
+let getHeartbeatData: (() => HeartbeatMsg) | null = null;
+
+// ─── Public API ─────────────────────────────────────
+
+export function connect(opts: {
+  cloudUrl: string;
+  deviceId: string;
+  secretKey: string;
+  heartbeatFn: () => HeartbeatMsg;
+}): void {
+  // No secret_key in URL — auth via first message after connect
+  wsUrl = `${opts.cloudUrl.replace(/^http/, "ws")}/ws/device`;
+  deviceId = opts.deviceId;
+  secretKey = opts.secretKey;
+  getHeartbeatData = opts.heartbeatFn;
+  shouldConnect = true;
+  reconnectAttempt = 0;
+  doConnect();
+}
+
+export function disconnect(): void {
+  shouldConnect = false;
+  if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+  if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+  if (ws) {
+    try { ws.close(1000, "shutdown"); } catch {}
+    ws = null;
+  }
+  connected = false;
+  outboundQueue = [];
+}
+
+export function send(msg: OutboundMsg): void {
+  if (connected && ws?.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(msg));
+  } else {
+    outboundQueue.push(msg);
+    if (outboundQueue.length > MAX_QUEUE_SIZE) outboundQueue.shift();
+  }
+}
+
+export function onCommand(handler: CommandHandler): void {
+  commandHandler = handler;
+}
+
+export function isConnected(): boolean {
+  return connected;
+}
+
+// ─── Internal ───────────────────────────────────────
+
+function doConnect(): void {
+  if (!shouldConnect || reconnecting) return;
+  reconnecting = true;
+
+  // Capture local ref — if a reconnect replaces `ws` before this socket's
+  // handlers fire, stale handlers must not reset module-level state.
+  let sock: WebSocket;
+  try {
+    sock = new WebSocket(wsUrl);
+    ws = sock;
+  } catch {
+    reconnecting = false;
+    scheduleReconnect("constructor");
+    return;
+  }
+
+  sock.onopen = () => {
+    if (ws !== sock) return; // stale — newer connection replaced us
+    reconnecting = false;
+    reconnectAttempt = 0;
+    log("INFO", "Cloud WS connected, sending auth");
+
+    // Send auth as first message — server must process this before any other msg
+    sock.send(JSON.stringify({
+      type: "auth",
+      deviceId,
+      secretKey,
+      timestamp: new Date().toISOString(),
+      version: 1,
+    }));
+
+    // Delay setting connected + sending heartbeat to let server process auth.
+    // Server's authenticateDevice() is async (DB lookup), so messages sent
+    // immediately after auth arrive before authenticated=true → 4002 reject.
+    setTimeout(() => {
+      if (ws !== sock) return; // replaced during delay
+      connected = true;
+
+      // Flush queued messages
+      while (outboundQueue.length > 0 && connected) {
+        const msg = outboundQueue.shift()!;
+        sock.send(JSON.stringify(msg));
+      }
+
+      // Send immediate heartbeat
+      if (getHeartbeatData) send(getHeartbeatData());
+
+      // Start periodic heartbeat
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
+      heartbeatTimer = setInterval(() => {
+        if (getHeartbeatData && connected) send(getHeartbeatData());
+      }, HEARTBEAT_INTERVAL_MS);
+    }, 500); // 500ms for DB auth round-trip
+  };
+
+  sock.onmessage = (event) => {
+    try {
+      const msg = JSON.parse(String(event.data)) as CommandMsg;
+      if (msg.type === "command" && commandHandler) {
+        commandHandler(msg);
+      }
+    } catch {} // ignore malformed
+  };
+
+  sock.onclose = (event) => {
+    if (ws !== sock) return; // stale — ignore close from replaced connection
+    log("WARN", `Cloud WS closed: code=${event.code} reason=${event.reason || ""}`);
+    connected = false;
+    reconnecting = false;
+    ws = null;
+    if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+    if (shouldConnect) scheduleReconnect("onclose");
+  };
+
+  sock.onerror = (event) => {
+    log("ERROR", `Cloud WS error: ${String(event)}`);
+  };
+}
+
+function scheduleReconnect(source = "unknown"): void {
+  if (!shouldConnect || reconnectTimer) return;
+  const base = BACKOFF_STEPS[Math.min(reconnectAttempt, BACKOFF_STEPS.length - 1)]!;
+  // Add ±30% jitter to prevent thundering herd after Cloud deploy
+  const jitter = base * (0.7 + Math.random() * 0.6);
+  const delay = Math.round(jitter);
+  reconnectAttempt++;
+  log("WARN", `Cloud WS reconnect in ${delay}ms (attempt #${reconnectAttempt}) src=${source}`);
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    doConnect();
+  }, delay);
+}
+
+function log(level: string, msg: string): void {
+  const ts = new Date().toISOString();
+  const logFile = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"), "ppm.log");
+  try { appendFileSync(logFile, `[${ts}] [${level}] [cloud-ws] ${msg}\n`); } catch {}
+}

package/src/services/cloud.service.ts

@@ -354,6 +354,7 @@ export async function sendHeartbeat(tunnelUrl: string): Promise<boolean> {
         secret_key: device.secret_key,
         tunnel_url: tunnelUrl,
         status: "online",
+        name: device.name,
       }),
     });
     return res.ok;

package/src/services/contribution-registry.ts

@@ -0,0 +1,110 @@
+import type { ExtensionContributes, ContributedCommand, ContributedView, ContributedMenu } from "../types/extension.ts";
+
+/**
+ * In-memory registry of all contribution points from enabled extensions.
+ * Populated when extensions activate, cleared when they deactivate.
+ */
+class ContributionRegistry {
+  private commands = new Map<string, ContributedCommand & { extId: string }>();
+  private views = new Map<string, Map<string, ContributedView & { extId: string }>>();
+  private configs = new Map<string, Record<string, unknown>>();
+  private menus = new Map<string, Array<ContributedMenu & { extId: string }>>();
+
+  register(extId: string, contributes: ExtensionContributes): void {
+    if (contributes.commands) {
+      for (const cmd of contributes.commands) {
+        this.commands.set(cmd.command, { ...cmd, extId });
+      }
+    }
+    if (contributes.views) {
+      for (const [location, views] of Object.entries(contributes.views)) {
+        if (!this.views.has(location)) this.views.set(location, new Map());
+        const locationMap = this.views.get(location)!;
+        for (const view of views) {
+          locationMap.set(view.id, { ...view, extId });
+        }
+      }
+    }
+    if (contributes.configuration?.properties) {
+      this.configs.set(extId, contributes.configuration.properties);
+    }
+    if (contributes.menus) {
+      for (const [location, items] of Object.entries(contributes.menus)) {
+        if (!this.menus.has(location)) this.menus.set(location, []);
+        const list = this.menus.get(location)!;
+        for (const item of items) {
+          list.push({ ...item, extId });
+        }
+      }
+    }
+  }
+
+  unregister(extId: string): void {
+    for (const [key, cmd] of this.commands) {
+      if (cmd.extId === extId) this.commands.delete(key);
+    }
+    for (const [, locationMap] of this.views) {
+      for (const [key, view] of locationMap) {
+        if (view.extId === extId) locationMap.delete(key);
+      }
+    }
+    for (const [location, items] of this.menus) {
+      this.menus.set(location, items.filter((m) => m.extId !== extId));
+    }
+    this.configs.delete(extId);
+  }
+
+  getCommands(): Array<ContributedCommand & { extId: string }> {
+    return [...this.commands.values()];
+  }
+
+  getViews(location?: string): Array<ContributedView & { extId: string }> {
+    if (location) {
+      return [...(this.views.get(location)?.values() ?? [])];
+    }
+    const all: Array<ContributedView & { extId: string }> = [];
+    for (const locationMap of this.views.values()) {
+      all.push(...locationMap.values());
+    }
+    return all;
+  }
+
+  getViewLocations(): string[] {
+    return [...this.views.keys()];
+  }
+
+  getConfiguration(extId?: string): Record<string, Record<string, unknown>> {
+    if (extId) {
+      const cfg = this.configs.get(extId);
+      return cfg ? { [extId]: cfg } : {};
+    }
+    return Object.fromEntries(this.configs);
+  }
+
+  /** Get all contributions as a single object (for API responses) */
+  getAll() {
+    const viewsByLocation: Record<string, Array<ContributedView & { extId: string }>> = {};
+    for (const location of this.views.keys()) {
+      viewsByLocation[location] = this.getViews(location);
+    }
+    const menusByLocation: Record<string, Array<ContributedMenu & { extId: string }>> = {};
+    for (const [location, items] of this.menus) {
+      menusByLocation[location] = items;
+    }
+    return {
+      commands: this.getCommands(),
+      views: viewsByLocation,
+      menus: menusByLocation,
+      configuration: this.getConfiguration(),
+    };
+  }
+
+  clear(): void {
+    this.commands.clear();
+    this.views.clear();
+    this.configs.clear();
+    this.menus.clear();
+  }
+}
+
+export const contributionRegistry = new ContributionRegistry();