@hienlh/ppm 0.9.82 → 0.9.83

package/src/providers/claude-agent-sdk.ts

@@ -20,7 +20,7 @@ import { getSessionProjectPath, setSessionMetadata, getSessionTitles } from "../
 import { accountSelector } from "../services/account-selector.service.ts";
 import { accountService, type AccountWithTokens } from "../services/account.service.ts";
 import { resolve } from "node:path";
-import { existsSync, readdirSync, unlinkSync } from "node:fs";
+import { existsSync, readdirSync, unlinkSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 
 const CLAUDE_PROJECTS_DIR = resolve(homedir(), ".claude/projects");
@@ -322,13 +322,30 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       // Overlay DB titles (user-set) over SDK titles
       const ids = sdkSessions.map((s) => s.sessionId);
       const dbTitles = getSessionTitles(ids);
-      return sdkSessions.map((s) => ({
+      const sessions: SessionInfo[] = sdkSessions.map((s) => ({
         id: s.sessionId,
         providerId: this.id,
         title: dbTitles[s.sessionId] ?? s.customTitle ?? s.summary ?? s.firstPrompt ?? "Chat",
         createdAt: new Date(s.lastModified).toISOString(),
         updatedAt: new Date(s.lastModified).toISOString(),
       }));
+
+      // SDK's listSessions drops sessions whose first user message exceeds its
+      // 64KB head buffer (e.g. large pasted docs). Scan JSONL dir to recover them.
+      if (dir && offset === 0) {
+        const knownIds = new Set(sessions.map((s) => s.id));
+        const missing = findMissingSessions(dir, knownIds, this.id);
+        if (missing.length > 0) {
+          const missingIds = missing.map((s) => s.id);
+          const missingDbTitles = getSessionTitles(missingIds);
+          for (const s of missing) {
+            s.title = missingDbTitles[s.id] ?? s.title;
+          }
+          sessions.push(...missing);
+        }
+      }
+
+      return sessions;
     } catch {
       return Array.from(this.activeSessions.values()).map((s) => ({
         id: s.id,
@@ -343,15 +360,28 @@ export class ClaudeAgentSdkProvider implements AIProvider {
   async getSessionInfoById(sessionId: string, dir?: string): Promise<SessionInfo | null> {
     try {
       const info = await sdkGetSessionInfo(sessionId, { dir });
-      if (!info) return null;
-      const dbTitles = getSessionTitles([info.sessionId]);
-      return {
-        id: info.sessionId,
-        providerId: this.id,
-        title: dbTitles[info.sessionId] ?? info.customTitle ?? info.summary ?? info.firstPrompt ?? "Chat",
-        createdAt: new Date(info.lastModified).toISOString(),
-        updatedAt: new Date(info.lastModified).toISOString(),
-      };
+      if (info) {
+        const dbTitles = getSessionTitles([info.sessionId]);
+        return {
+          id: info.sessionId,
+          providerId: this.id,
+          title: dbTitles[info.sessionId] ?? info.customTitle ?? info.summary ?? info.firstPrompt ?? "Chat",
+          createdAt: new Date(info.lastModified).toISOString(),
+          updatedAt: new Date(info.lastModified).toISOString(),
+        };
+      }
+      // SDK can't find the session (large first message, active session, etc.)
+      // — try direct JSONL lookup
+      if (dir) {
+        const missing = findMissingSessions(dir, new Set(), this.id);
+        const match = missing.find((s) => s.id === sessionId);
+        if (match) {
+          const dbTitles = getSessionTitles([sessionId]);
+          match.title = dbTitles[sessionId] ?? match.title;
+          return match;
+        }
+      }
+      return null;
     } catch {
       return null;
     }
@@ -1633,6 +1663,81 @@ function extractText(message: unknown): string {
   return "";
 }
 
+/**
+ * Scan a JSONL project directory for sessions that the SDK's listSessions missed.
+ * The SDK uses a 64KB head buffer; sessions with very large first messages
+ * (e.g., pasted API docs) can't be parsed and are silently dropped.
+ * We extract title from queue-operation content or first user message.
+ */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function findMissingSessions(
+  dir: string,
+  knownIds: Set<string>,
+  providerId: string,
+): SessionInfo[] {
+  let resolvedDir: string;
+  try { resolvedDir = require("node:fs").realpathSync(dir).normalize("NFC"); } catch { resolvedDir = dir; }
+  // Match SDK's path encoding: replace all non-alphanumeric chars with "-"
+  const encodedDir = resolvedDir.replace(/[^a-zA-Z0-9]/g, "-");
+  let jsonlDir = resolve(CLAUDE_PROJECTS_DIR, encodedDir);
+  // SDK truncates to 200 chars + hash for long paths; try prefix match as fallback
+  if (!existsSync(jsonlDir) && encodedDir.length > 200) {
+    const prefix = encodedDir.slice(0, 200);
+    try {
+      const match = readdirSync(CLAUDE_PROJECTS_DIR).find((d) => d.startsWith(prefix + "-"));
+      if (match) jsonlDir = resolve(CLAUDE_PROJECTS_DIR, match);
+      else return [];
+    } catch { return []; }
+  }
+  if (!existsSync(jsonlDir)) return [];
+
+  const results: SessionInfo[] = [];
+  for (const file of readdirSync(jsonlDir)) {
+    if (!file.endsWith(".jsonl")) continue;
+    const id = file.slice(0, -6);
+    if (!UUID_RE.test(id) || knownIds.has(id)) continue;
+
+    try {
+      const filePath = resolve(jsonlDir, file);
+      const stat = statSync(filePath);
+      // Read first 512 bytes — enough to extract title from queue-operation content
+      const buf = Buffer.alloc(512);
+      const { openSync, readSync, closeSync } = require("node:fs") as typeof import("node:fs");
+      const fd = openSync(filePath, "r");
+      const bytesRead = readSync(fd, buf, 0, 512, 0);
+      closeSync(fd);
+      const head = buf.toString("utf-8", 0, bytesRead);
+
+      let title = "Chat";
+      // Extract "content" value via string search (JSON may be truncated)
+      const idx = head.indexOf('"content":"');
+      if (idx >= 0) {
+        const start = idx + 11; // length of '"content":"'
+        // Read up to 120 chars or next unescaped quote
+        let end = start;
+        while (end < head.length && end - start < 200) {
+          if (head[end] === "\\" ) { end += 2; continue; }
+          if (head[end] === '"') break;
+          end++;
+        }
+        const raw = head.slice(start, end).replace(/\\n/g, " ").replace(/\\"/g, '"').trim();
+        if (raw.length > 0) {
+          title = raw.length > 120 ? raw.slice(0, 120) + "…" : raw;
+        }
+      }
+
+      results.push({
+        id,
+        providerId,
+        title,
+        createdAt: new Date(stat.mtime).toISOString(),
+        updatedAt: new Date(stat.mtime).toISOString(),
+      });
+    } catch { /* skip unreadable files */ }
+  }
+  return results;
+}
+
 /** Strip SDK teammate-message XML tags from assistant text */
 const TEAMMATE_MSG_RE = /<teammate-message[^>]*>[\s\S]*?<\/teammate-message>/g;
 function stripTeammateXml(text: string): string {

package/src/server/routes/port-forwarding.ts

@@ -19,11 +19,67 @@ interface ActiveTunnel {
   url: string;
   process: import("bun").Subprocess;
   startedAt: number;
+  probeFailures: number;
 }
 
+const MAX_PROBE_FAILURES = 2;
+
 /** Active tunnels keyed by port — exported for testing */
 export const activeTunnels = new Map<number, ActiveTunnel>();
 
+/** Spawn cloudflared tunnel for a port, extract URL from stderr */
+async function spawnTunnelProcess(port: number): Promise<{ process: import("bun").Subprocess; url: string }> {
+  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 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();
+  });
+
+  return { process: proc, url };
+}
+
+/** Register tunnel in map with auto-cleanup on exit */
+function registerTunnel(port: number, proc: import("bun").Subprocess, url: string) {
+  activeTunnels.set(port, { port, url, process: proc, startedAt: Date.now(), probeFailures: 0 });
+  proc.exited.then(() => activeTunnels.delete(port)).catch(() => activeTunnels.delete(port));
+}
+
 /** Start a tunnel for a localhost port */
 portForwardingRoutes.post("/tunnel", async (c) => {
   const body = await c.req.json<{ port: number }>().catch(() => null);
@@ -39,54 +95,8 @@ portForwardingRoutes.post("/tunnel", async (c) => {
   }
 
   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));
-
+    const { process: proc, url } = await spawnTunnelProcess(port);
+    registerTunnel(port, proc, url);
     console.log(`[preview] tunnel started for port ${port} → ${url}`);
     return c.json(ok({ port, url }));
   } catch (e: any) {
@@ -123,27 +133,68 @@ 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) */
+/** Probe tunnel URL to check if it's still accessible (DNS + connection) */
+async function probeTunnelUrl(url: string): Promise<boolean> {
+  try {
+    await fetch(url, { method: "HEAD", signal: AbortSignal.timeout(8_000), redirect: "follow" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+let cleanupRunning = false;
+
+/** Remove ghost tunnels and auto-restart tunnels with expired URLs */
 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);
+  if (cleanupRunning) return;
+  cleanupRunning = true;
+  try {
+    for (const [port, tunnel] of activeTunnels) {
+      // Check if cloudflared process is still running
+      if (!isProcessAlive(tunnel.process)) {
+        console.log(`[preview] ghost cleanup: 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 {
+        console.log(`[preview] ghost cleanup: port ${port} — port not listening`);
+        try { tunnel.process.kill(); } catch {}
+        activeTunnels.delete(port);
+        continue;
+      }
+
+      // Probe tunnel URL to detect expired Quick Tunnel URLs
+      const alive = await probeTunnelUrl(tunnel.url);
+      if (alive) {
+        tunnel.probeFailures = 0;
+        continue;
+      }
+
+      tunnel.probeFailures++;
+      console.log(`[preview] tunnel probe failed for port ${port} (${tunnel.probeFailures}/${MAX_PROBE_FAILURES})`);
+
+      if (tunnel.probeFailures >= MAX_PROBE_FAILURES) {
+        console.log(`[preview] tunnel URL expired for port ${port}, restarting...`);
+        try { tunnel.process.kill(); } catch {}
+        activeTunnels.delete(port);
+        try {
+          const { process: proc, url } = await spawnTunnelProcess(port);
+          registerTunnel(port, proc, url);
+          console.log(`[preview] tunnel restarted for port ${port} → ${url}`);
+        } catch (e: any) {
+          console.warn(`[preview] tunnel restart failed for port ${port}: ${e.message}`);
+        }
+      }
     }
+  } finally {
+    cleanupRunning = false;
   }
 }
 

package/src/services/supervisor.ts

@@ -504,7 +504,8 @@ async function notifyStateChange(from: string, to: string, reason: string) {
 /** Connect supervisor to Cloud via WebSocket (if device is linked) */
 async function connectCloud(opts: { port: number }, serverArgs: string[], logFd: number): Promise<boolean> {
   try {
-    const { getCloudDevice } = await import("./cloud.service.ts");
+    const { getCloudDevice, saveCloudDevice } = await import("./cloud.service.ts");
+    const { configService } = await import("./config.service.ts");
     const device = getCloudDevice();
     if (!device) return false; // not linked to cloud
 
@@ -520,6 +521,12 @@ async function connectCloud(opts: { port: number }, serverArgs: string[], logFd:
         const status = readStatus();
         // Re-read device file each heartbeat to pick up name changes
         const currentDevice = getCloudDevice();
+        // Sync device name from config if user changed it in settings
+        const configName = configService.get("device_name") as string;
+        if (configName && currentDevice && configName !== currentDevice.name) {
+          currentDevice.name = configName;
+          saveCloudDevice(currentDevice);
+        }
         return {
           type: "heartbeat" as const,
           tunnelUrl,

package/src/web/hooks/use-url-sync.ts

@@ -100,10 +100,12 @@ function buildMetadataFromUrl(
     case "chat": {
       if (!identifier) return null;
       const slashIdx = identifier.indexOf("/");
-      if (slashIdx === -1) return { sessionId: identifier, projectName };
-      const providerId = identifier.slice(0, slashIdx);
-      const sessionId = identifier.slice(slashIdx + 1);
-      return sessionId ? { sessionId, providerId, projectName } : null;
+      const rawSessionId = slashIdx === -1 ? identifier : identifier.slice(slashIdx + 1);
+      const providerId = slashIdx === -1 ? undefined : identifier.slice(0, slashIdx);
+      // Validate UUID format — short/random IDs from tab derivation must not be used as session IDs
+      const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(rawSessionId);
+      const sessionId = isUuid ? rawSessionId : undefined;
+      return { ...(sessionId && { sessionId }), ...(providerId && { providerId }), projectName };
     }
     case "terminal": return { terminalIndex: parseInt(identifier ?? "1", 10), projectName };
     case "git-graph": return { projectName };

package/.opencode/.env.example

@@ -1,98 +0,0 @@
-# Claude Code - Global Environment Variables
-# Location: .claude/.env
-# Priority: LOWEST (overridden by skills/.env and skill-specific .env)
-# Scope: Project-wide configuration, global defaults
-# Setup: Copy to .claude/.env and configure
-
-# ============================================
-# Environment Variable Hierarchy
-# ============================================
-# Priority order (highest to lowest):
-# 1. process.env                    - Runtime environment (HIGHEST)
-# 2. .claude/skills/<skill>/.env    - Skill-specific overrides
-# 3. .claude/skills/.env            - Shared across all skills
-# 4. .claude/.env                   - Global defaults (this file, LOWEST)
-#
-# All skills use centralized resolver: ~/.claude/scripts/resolve_env.py
-# Debug hierarchy: python ~/.claude/scripts/resolve_env.py --show-hierarchy
-
-# ============================================
-# ClaudeKit API Key (for VidCap, ReviewWeb services)
-# ============================================
-# Get your API key from https://claudekit.cc/api-keys
-# Required for accessing ClaudeKit services via skills
-CLAUDEKIT_API_KEY=
-
-# ============================================
-# Claude Code Notification Hooks
-# ============================================
-# Discord Webhook URL (for Discord notifications)
-# Get from: Server Settings → Integrations → Webhooks → New Webhook
-DISCORD_WEBHOOK_URL=
-
-# Telegram Bot Token (for Telegram notifications)
-# Get from: @BotFather in Telegram
-TELEGRAM_BOT_TOKEN=
-
-# Telegram Chat ID (your chat ID or group ID)
-# Get from: https://api.telegram.org/bot<BOT_TOKEN>/getUpdates
-TELEGRAM_CHAT_ID=
-
-# ============================================
-# AI/ML API Keys (Global Defaults)
-# ============================================
-# Google Gemini API (for ai-multimodal, docs-seeker skills)
-# Get from: https://aistudio.google.com/apikey
-GEMINI_API_KEY=
-
-# Vertex AI Configuration (Optional alternative to AI Studio)
-# GEMINI_USE_VERTEX=true
-# VERTEX_PROJECT_ID=
-# VERTEX_LOCATION=us-central1
-
-# OpenAI API Key (if using OpenAI-based skills)
-# OPENAI_API_KEY=
-
-# Anthropic API Key (if using Claude API directly)
-# ANTHROPIC_API_KEY=
-
-# ElevenLabs API Key
-# Get your key at: https://elevenlabs.io/app/settings/api-keys
-# ELEVENLABS_API_KEY=
-
-# ============================================
-# Development & CI/CD
-# ============================================
-# NODE_ENV=development
-# DEBUG=false
-# LOG_LEVEL=info
-
-# ============================================
-# Project Configuration
-# ============================================
-# PROJECT_NAME=claudekit-engineer
-# ENVIRONMENT=local
-
-# ============================================
-# Example Usage Scenarios
-# ============================================
-# Scenario 1: Global default for all skills
-# .claude/.env (this file):                GEMINI_API_KEY=global-dev-key
-# Result: All skills use global-dev-key
-#
-# Scenario 2: Override for all skills
-# .claude/.env (this file):                GEMINI_API_KEY=global-dev-key
-# .claude/skills/.env:                     GEMINI_API_KEY=skills-prod-key
-# Result: All skills use skills-prod-key
-#
-# Scenario 3: Skill-specific override
-# .claude/.env (this file):                GEMINI_API_KEY=global-key
-# .claude/skills/.env:                     GEMINI_API_KEY=shared-key
-# .claude/skills/ai-multimodal/.env:       GEMINI_API_KEY=high-quota-key
-# Result: ai-multimodal uses high-quota-key, other skills use shared-key
-#
-# Scenario 4: Runtime testing
-# export GEMINI_API_KEY=test-key
-# Result: All skills use test-key regardless of config files
-#
-# Priority: runtime > skill-specific > shared > global (this file)

package/.opencode/skills/ads-management/scripts/.env.example

@@ -1,13 +0,0 @@
-# Google Ads API credentials
-GOOGLE_ADS_DEVELOPER_TOKEN=your_developer_token
-GOOGLE_ADS_CLIENT_ID=your_client_id.apps.googleusercontent.com
-GOOGLE_ADS_CLIENT_SECRET=your_client_secret
-GOOGLE_ADS_REFRESH_TOKEN=1//your_refresh_token
-GOOGLE_ADS_CUSTOMER_ID=1234567890
-GOOGLE_ADS_LOGIN_CUSTOMER_ID=your_mcc_id
-
-# Meta/Facebook Ads API credentials
-META_APP_ID=your_app_id
-META_APP_SECRET=your_app_secret
-META_ACCESS_TOKEN=your_system_user_token
-META_AD_ACCOUNT_ID=act_123456789