@hienlh/ppm 0.8.85 → 0.8.86

package/src/server/routes/browser-preview.ts

@@ -1,159 +0,0 @@
-import { Hono } from "hono";
-import { ok, err } from "../../types/api.ts";
-import { ensureCloudflared } from "../../services/cloudflared.service.ts";
-
-/**
- * Browser preview API — starts per-port Cloudflare Quick Tunnels so the
- * frontend can iframe any localhost dev server without CORS/path issues.
- *
- * POST /api/preview/tunnel { port: 3000 } → { url: "https://xxx.trycloudflare.com" }
- * DELETE /api/preview/tunnel/:port → stops tunnel for that port
- * GET /api/preview/tunnels → list active tunnels
- */
-export const browserPreviewRoutes = new Hono();
-
-const TUNNEL_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
-
-interface ActiveTunnel {
-  port: number;
-  url: string;
-  process: import("bun").Subprocess;
-  startedAt: number;
-}
-
-/** Active tunnels keyed by port — exported for testing */
-export const activeTunnels = new Map<number, ActiveTunnel>();
-
-/** Start a tunnel for a localhost port */
-browserPreviewRoutes.post("/tunnel", async (c) => {
-  const body = await c.req.json<{ port: number }>().catch(() => null);
-  const port = body?.port;
-  if (!port || port < 1 || port > 65535) {
-    return c.json(err("Invalid port (1-65535)"), 400);
-  }
-
-  // Return existing tunnel if already running
-  const existing = activeTunnels.get(port);
-  if (existing) {
-    return c.json(ok({ port, url: existing.url }));
-  }
-
-  try {
-    const bin = await ensureCloudflared();
-    const proc = Bun.spawn(
-      [bin, "tunnel", "--url", `http://127.0.0.1:${port}`],
-      { stderr: "pipe", stdout: "ignore", stdin: "ignore" },
-    );
-
-    // Read stderr to find tunnel URL
-    const reader = proc.stderr.getReader();
-    const decoder = new TextDecoder();
-    const url = await new Promise<string>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        try { proc.kill(); } catch {}
-        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 tunnel URL"));
-          }
-        } catch (e) {
-          if (!found) { clearTimeout(timeout); reject(e); }
-        }
-      };
-      read();
-    });
-
-    activeTunnels.set(port, { port, url, process: proc, startedAt: Date.now() });
-
-    // Auto-cleanup when process exits
-    proc.exited.then(() => activeTunnels.delete(port)).catch(() => activeTunnels.delete(port));
-
-    console.log(`[preview] tunnel started for port ${port} → ${url}`);
-    return c.json(ok({ port, url }));
-  } catch (e: any) {
-    return c.json(err(e.message || "Failed to start tunnel"), 500);
-  }
-});
-
-/** Stop a tunnel */
-browserPreviewRoutes.delete("/tunnel/:port{[0-9]+}", (c) => {
-  const port = parseInt(c.req.param("port"), 10);
-  const tunnel = activeTunnels.get(port);
-  if (!tunnel) {
-    return c.json(err("No tunnel running for this port"), 404);
-  }
-
-  try { tunnel.process.kill(); } catch {}
-  activeTunnels.delete(port);
-  console.log(`[preview] tunnel stopped for port ${port}`);
-  return c.json(ok({ port }));
-});
-
-/** List active tunnels */
-browserPreviewRoutes.get("/tunnels", (c) => {
-  const list = Array.from(activeTunnels.values()).map((t) => ({
-    port: t.port,
-    url: t.url,
-    startedAt: t.startedAt,
-  }));
-  return c.json(ok(list));
-});
-
-/** Check if a cloudflared process is still alive */
-function isProcessAlive(proc: import("bun").Subprocess): boolean {
-  try { process.kill(proc.pid, 0); return true; } catch { return false; }
-}
-
-/** Remove ghost tunnels (process died or target port no longer listening) */
-async function cleanupGhostTunnels() {
-  for (const [port, tunnel] of activeTunnels) {
-    // Check if cloudflared process is still running
-    if (!isProcessAlive(tunnel.process)) {
-      console.log(`[preview] ghost cleanup: tunnel for port ${port} — process dead`);
-      activeTunnels.delete(port);
-      continue;
-    }
-    // Check if target port is still listening
-    try {
-      const conn = await Bun.connect({ hostname: "127.0.0.1", port, socket: {
-        data() {}, open(s) { s.end(); }, error() {}, close() {},
-      }});
-      conn.end();
-    } catch {
-      // Port not listening — kill tunnel
-      console.log(`[preview] ghost cleanup: tunnel for port ${port} — port not listening`);
-      try { tunnel.process.kill(); } catch {}
-      activeTunnels.delete(port);
-    }
-  }
-}
-
-// Run ghost cleanup every 30s
-setInterval(cleanupGhostTunnels, 30_000);
-
-/** Cleanup all tunnels on server shutdown */
-export function stopAllPreviewTunnels() {
-  for (const [port, tunnel] of activeTunnels) {
-    try { tunnel.process.kill(); } catch {}
-    activeTunnels.delete(port);
-  }
-}

package/src/server/routes/workspace.ts

@@ -1,35 +0,0 @@
-import { Hono } from "hono";
-import { getWorkspace, setWorkspace } from "../../services/db.service.ts";
-import { ok, err } from "../../types/api.ts";
-
-type Env = { Variables: { projectPath: string; projectName: string } };
-
-export const workspaceRoutes = new Hono<Env>();
-
-/** GET /workspace — load saved workspace layout */
-workspaceRoutes.get("/", (c) => {
-  try {
-    const projectName = c.get("projectName");
-    const row = getWorkspace(projectName);
-    if (!row) return c.json(ok(null));
-    return c.json(ok({
-      layout: JSON.parse(row.layout_json),
-      updatedAt: row.updated_at,
-    }));
-  } catch (e) {
-    return c.json(err((e as Error).message), 500);
-  }
-});
-
-/** PUT /workspace — save workspace layout */
-workspaceRoutes.put("/", async (c) => {
-  try {
-    const projectName = c.get("projectName");
-    const body = await c.req.json<{ layout: unknown }>();
-    if (!body.layout) return c.json(err("Missing layout"), 400);
-    const updatedAt = setWorkspace(projectName, JSON.stringify(body.layout));
-    return c.json(ok({ updatedAt }));
-  } catch (e) {
-    return c.json(err((e as Error).message), 500);
-  }
-});

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

@@ -1,227 +0,0 @@
-/**
- * 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;
-}
-
-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/web/components/chat/account-rotation-settings.tsx

@@ -1,163 +0,0 @@
-import { useState, useEffect, useSyncExternalStore } from "react";
-import { Settings, X } from "lucide-react";
-import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog";
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
-import { cn } from "@/lib/utils";
-import {
-  getAccountSettings,
-  updateAccountSettings,
-  type AccountSettings,
-} from "../../lib/api-settings";
-
-interface AccountRotationSettingsProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-}
-
-const mdQuery = typeof window !== "undefined" ? window.matchMedia("(min-width: 768px)") : null;
-function subscribeMedia(cb: () => void) {
-  mdQuery?.addEventListener("change", cb);
-  return () => mdQuery?.removeEventListener("change", cb);
-}
-function getIsDesktop() {
-  return mdQuery?.matches ?? true;
-}
-
-function SettingsContent() {
-  const [settings, setSettings] = useState<AccountSettings | null>(null);
-  const [loading, setLoading] = useState(true);
-
-  useEffect(() => {
-    setLoading(true);
-    getAccountSettings()
-      .then(setSettings)
-      .finally(() => setLoading(false));
-  }, []);
-
-  if (loading) {
-    return <p className="text-xs text-text-subtle py-4 text-center">Loading...</p>;
-  }
-  if (!settings) {
-    return <p className="text-xs text-text-subtle py-4 text-center">Failed to load settings</p>;
-  }
-
-  return (
-    <div className="space-y-4">
-      {/* Strategy */}
-      <div className="space-y-1.5">
-        <label className="text-xs font-medium text-text-primary">Rotation Strategy</label>
-        <Select
-          value={settings.strategy}
-          onValueChange={async (v) => {
-            const updated = await updateAccountSettings({ strategy: v as AccountSettings["strategy"] });
-            setSettings(updated);
-          }}
-        >
-          <SelectTrigger className="w-full h-9 text-xs">
-            <SelectValue />
-          </SelectTrigger>
-          <SelectContent>
-            <SelectItem value="round-robin">Round-robin</SelectItem>
-            <SelectItem value="fill-first">Fill-first</SelectItem>
-            <SelectItem value="lowest-usage">Lowest usage</SelectItem>
-          </SelectContent>
-        </Select>
-        <p className="text-[10px] text-text-subtle">
-          {settings.strategy === "round-robin" && "Cycles through accounts evenly"}
-          {settings.strategy === "fill-first" && "Uses one account until its limit, then moves on"}
-          {settings.strategy === "lowest-usage" && "Picks the account with the lowest current usage"}
-        </p>
-      </div>
-
-      {/* Max Retry */}
-      <div className="space-y-1.5">
-        <label className="text-xs font-medium text-text-primary">Max Retry</label>
-        <input
-          type="number"
-          min={0}
-          value={settings.maxRetry}
-          className="w-full h-9 text-xs border rounded-md px-3 bg-background"
-          onChange={async (e) => {
-            const v = parseInt(e.target.value, 10);
-            if (!isNaN(v) && v >= 0) {
-              const updated = await updateAccountSettings({ maxRetry: v });
-              setSettings(updated);
-            }
-          }}
-        />
-        <p className="text-[10px] text-text-subtle">
-          How many accounts to try on failure. 0 = try all available accounts.
-        </p>
-      </div>
-
-      {/* Active accounts */}
-      <div className="flex items-center justify-between text-xs border-t border-border pt-3">
-        <span className="text-text-subtle">Active accounts</span>
-        <span className="font-medium text-text-primary">{settings.activeCount}</span>
-      </div>
-    </div>
-  );
-}
-
-export function AccountRotationSettings({ open, onOpenChange }: AccountRotationSettingsProps) {
-  const isDesktop = useSyncExternalStore(subscribeMedia, getIsDesktop);
-
-  if (!open) return null;
-
-  // Desktop: Dialog
-  if (isDesktop) {
-    return (
-      <Dialog open={open} onOpenChange={onOpenChange}>
-        <DialogContent className="sm:max-w-sm">
-          <DialogHeader>
-            <DialogTitle className="text-sm flex items-center gap-2">
-              <Settings className="size-4" /> Rotation & Retry
-            </DialogTitle>
-          </DialogHeader>
-          <SettingsContent />
-        </DialogContent>
-      </Dialog>
-    );
-  }
-
-  // Mobile: Bottom sheet
-  return (
-    <>
-      <div
-        className="fixed inset-0 z-50 transition-opacity duration-200 opacity-100"
-        onClick={() => onOpenChange(false)}
-        style={{ backgroundColor: "rgba(0,0,0,0.5)" }}
-      />
-      <div
-        className={cn(
-          "fixed bottom-0 left-0 right-0 z-50 bg-background rounded-t-2xl border-t border-border shadow-2xl",
-          "transition-transform duration-300 ease-out max-h-[85vh] overflow-y-auto",
-          "translate-y-0",
-        )}
-      >
-        {/* Drag handle */}
-        <div className="flex justify-center pt-3 pb-1">
-          <div className="w-10 h-1 rounded-full bg-border" />
-        </div>
-
-        {/* Header */}
-        <div className="flex items-center justify-between px-4 py-2 border-b border-border">
-          <span className="text-sm font-semibold flex items-center gap-2">
-            <Settings className="size-4" /> Rotation & Retry
-          </span>
-          <button
-            onClick={() => onOpenChange(false)}
-            className="flex items-center justify-center size-7 rounded-md hover:bg-surface-elevated transition-colors"
-          >
-            <X className="size-4" />
-          </button>
-        </div>
-
-        {/* Content */}
-        <div className="px-4 py-4 pb-8">
-          <SettingsContent />
-        </div>
-      </div>
-    </>
-  );
-}