@hienlh/ppm 0.9.0-beta.8 → 0.9.1

package/src/web/stores/panel-utils.ts

@@ -1,5 +1,5 @@
 import { randomId } from "@/lib/utils";
-import type { Tab } from "./tab-store";
+import type { Tab, TabType } from "./tab-store";
 
 // ---------------------------------------------------------------------------
 // Panel types
@@ -69,6 +69,62 @@ export function findPanelPosition(grid: string[][], panelId: string): { row: num
   return null;
 }
 
+// ---------------------------------------------------------------------------
+// Deterministic tab IDs
+// ---------------------------------------------------------------------------
+
+/** Derive deterministic tab ID from type + metadata */
+export function deriveTabId(type: TabType, metadata?: Record<string, unknown>): string {
+  switch (type) {
+    case "editor":
+      return `editor:${metadata?.filePath ?? "untitled"}`;
+    case "chat": {
+      const provider = metadata?.providerId ?? "default";
+      return `chat:${provider}/${metadata?.sessionId ?? randomId()}`;
+    }
+    case "terminal":
+      return `terminal:${metadata?.terminalIndex ?? 1}`;
+    case "database":
+      return `database:${metadata?.connectionId ?? "default"}:${metadata?.tableName ?? ""}`;
+    case "sqlite":
+      return `sqlite:${metadata?.filePath ?? "default"}`;
+    case "postgres":
+      return `postgres:${metadata?.connectionId ?? "default"}:${metadata?.tableName ?? ""}`;
+    case "git-graph":
+      return "git-graph";
+    case "git-diff":
+      return `git-diff:${metadata?.filePath ?? "unknown"}`;
+    case "settings":
+      return "settings";
+    case "browser":
+      return `browser:${metadata?.url ?? "blank"}`;
+    default:
+      return `${type}:${randomId()}`;
+  }
+}
+
+/** Migrate old random tab IDs to deterministic IDs */
+export function migrateTabIds(layout: PanelLayout): PanelLayout {
+  const migrated = { ...layout, panels: { ...layout.panels } };
+  for (const [panelId, panel] of Object.entries(migrated.panels)) {
+    const newTabs = panel.tabs.map((tab) => {
+      if (tab.id.startsWith("tab-")) {
+        const newId = deriveTabId(tab.type, tab.metadata);
+        return { ...tab, id: newId };
+      }
+      return tab;
+    });
+    const idMap = new Map<string, string>();
+    panel.tabs.forEach((old, i) => {
+      if (old.id !== newTabs[i]!.id) idMap.set(old.id, newTabs[i]!.id);
+    });
+    const newActive = idMap.get(panel.activeTabId ?? "") ?? panel.activeTabId;
+    const newHistory = panel.tabHistory.map((h) => idMap.get(h) ?? h);
+    migrated.panels[panelId] = { ...panel, tabs: newTabs, activeTabId: newActive, tabHistory: newHistory };
+  }
+  return migrated;
+}
+
 // ---------------------------------------------------------------------------
 // Persistence
 // ---------------------------------------------------------------------------
@@ -81,20 +137,106 @@ function storageKey(projectName: string): string {
 
 export function savePanelLayout(projectName: string, layout: PanelLayout): void {
   try {
-    localStorage.setItem(storageKey(projectName), JSON.stringify(layout));
+    const withTimestamp = { ...layout, updatedAt: new Date().toISOString() };
+    localStorage.setItem(storageKey(projectName), JSON.stringify(withTimestamp));
+    // Debounced server sync
+    syncWorkspaceToServer(projectName, layout);
   } catch { /* ignore */ }
 }
 
 export function loadPanelLayout(projectName: string): PanelLayout | null {
   try {
     const raw = localStorage.getItem(storageKey(projectName));
-    if (raw) return JSON.parse(raw) as PanelLayout;
+    if (raw) {
+      const layout = JSON.parse(raw) as PanelLayout;
+      return migrateTabIds(layout);
+    }
   } catch { /* ignore */ }
 
   // Migrate from old tab-store format
   return migrateOldTabStore(projectName);
 }
 
+// ---------------------------------------------------------------------------
+// Server sync
+// ---------------------------------------------------------------------------
+
+export interface PanelLayoutWithTimestamp extends PanelLayout {
+  updatedAt: string;
+}
+
+/** Fetch workspace from server */
+export async function fetchWorkspaceFromServer(
+  projectName: string,
+): Promise<PanelLayoutWithTimestamp | null> {
+  try {
+    const headers: Record<string, string> = {};
+    const token = localStorage.getItem("ppm-auth-token");
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+
+    const res = await fetch(`/api/project/${encodeURIComponent(projectName)}/workspace`, { headers });
+    if (!res.ok) return null;
+    const json = await res.json();
+    if (!json.ok || !json.data) return null;
+    return { ...json.data.layout, updatedAt: json.data.updatedAt };
+  } catch {
+    return null;
+  }
+}
+
+/** Save workspace to server (debounced per project) */
+const syncTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+function syncWorkspaceToServer(projectName: string, layout: PanelLayout): void {
+  const existing = syncTimers.get(projectName);
+  if (existing) clearTimeout(existing);
+
+  syncTimers.set(projectName, setTimeout(async () => {
+    syncTimers.delete(projectName);
+    try {
+      const headers: Record<string, string> = { "Content-Type": "application/json" };
+      const token = localStorage.getItem("ppm-auth-token");
+      if (token) headers["Authorization"] = `Bearer ${token}`;
+
+      const res = await fetch(`/api/project/${encodeURIComponent(projectName)}/workspace`, {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ layout }),
+      });
+      if (res.ok) {
+        const json = await res.json();
+        if (json.data?.updatedAt) {
+          const key = `${STORAGE_PREFIX}${projectName}`;
+          const raw = localStorage.getItem(key);
+          if (raw) {
+            const local = JSON.parse(raw);
+            local.updatedAt = json.data.updatedAt;
+            localStorage.setItem(key, JSON.stringify(local));
+          }
+        }
+      }
+    } catch { /* silent fail — localStorage is still the cache */ }
+  }, 1500));
+}
+
+/** Compare local vs server timestamps, return newer layout */
+export function resolveWorkspaceConflict(
+  local: PanelLayoutWithTimestamp | null,
+  server: PanelLayoutWithTimestamp | null,
+): PanelLayoutWithTimestamp | null {
+  if (!local && !server) return null;
+  if (!local) return server!;
+  if (!server) return local;
+
+  const localTime = new Date(local.updatedAt).getTime();
+  const serverTime = new Date(server.updatedAt).getTime();
+  return serverTime >= localTime ? server : local;
+}
+
+// ---------------------------------------------------------------------------
+// Old format migration
+// ---------------------------------------------------------------------------
+
 function migrateOldTabStore(projectName: string): PanelLayout | null {
   try {
     const raw = localStorage.getItem(`${OLD_STORAGE_PREFIX}${projectName}`);

package/src/web/stores/settings-store.ts

@@ -2,7 +2,7 @@ import { create } from "zustand";
 
 export type Theme = "light" | "dark" | "system";
 export type GitStatusViewMode = "flat" | "tree";
-export type SidebarActiveTab = "explorer" | "git" | "settings" | "database" | "search";
+export type SidebarActiveTab = "explorer" | "git" | "settings" | "database" | "search" | `ext:${string}`;
 
 const STORAGE_KEY = "ppm-settings";
 
@@ -44,6 +44,11 @@ function loadPersistedSettings(): PersistedSettings {
   return {};
 }
 
+function isValidSidebarTab(tab: unknown): tab is SidebarActiveTab {
+  if (typeof tab !== "string") return false;
+  return ["explorer", "git", "settings", "database", "search"].includes(tab) || tab.startsWith("ext:");
+}
+
 function persistSettings(update: Partial<PersistedSettings>) {
   const current = loadPersistedSettings();
   localStorage.setItem(STORAGE_KEY, JSON.stringify({ ...current, ...update }));
@@ -79,7 +84,7 @@ export const useSettingsStore = create<SettingsState>((set, get) => ({
   sidebarWidth: _initial.sidebarWidth ?? 280,
   gitStatusViewMode: _initial.gitStatusViewMode === "flat" ? "flat" : "tree",
   wordWrap: _initial.wordWrap ?? false,
-  sidebarActiveTab: (["git", "settings", "database", "search"] as SidebarActiveTab[]).includes(_initial.sidebarActiveTab as SidebarActiveTab) ? _initial.sidebarActiveTab! : "explorer",
+  sidebarActiveTab: isValidSidebarTab(_initial.sidebarActiveTab) ? _initial.sidebarActiveTab : "explorer",
   deviceName: null,
   version: null,
 

package/src/web/stores/tab-store.ts

@@ -11,7 +11,8 @@ export type TabType =
   | "git-graph"
   | "git-diff"
   | "settings"
-  | "browser";
+  | "browser"
+  | "extension-webview";
 
 export interface Tab {
   id: string;

package/test-session-ops.mjs

@@ -0,0 +1,444 @@
+/**
+ * Test script: Advanced Session Operations
+ * Tests: listSessions, getSessionMessages, forkSession (mid-message), deleteSession, resumeSessionAt
+ *
+ * Usage: bun test-session-ops.mjs [test-name]
+ * Tests: list | messages | fork-mid | delete | resume-at | compact-summary | all
+ */
+import {
+  query,
+  listSessions,
+  getSessionMessages,
+  getSessionInfo,
+  forkSession,
+  renameSession,
+  tagSession,
+} from "@anthropic-ai/claude-agent-sdk";
+import { existsSync, unlinkSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+
+// Remove CLAUDECODE to avoid nested session error
+delete process.env.CLAUDECODE;
+
+const PROJECT_DIR = "/Users/hienlh/Projects/ppm";
+const CLAUDE_PROJECTS_DIR = resolve(homedir(), ".claude/projects");
+const testName = process.argv[2] || "all";
+
+// Helpers
+function log(label, data) {
+  console.log(`\n${"=".repeat(60)}`);
+  console.log(`[${label}]`);
+  console.log("=".repeat(60));
+  if (data !== undefined) console.log(typeof data === "string" ? data : JSON.stringify(data, null, 2));
+}
+
+function logOk(msg) { console.log(`  ✅ ${msg}`); }
+function logFail(msg) { console.log(`  ❌ ${msg}`); }
+function logInfo(msg) { console.log(`  ℹ️  ${msg}`); }
+
+// ─── Test 1: List Sessions ──────────────────────────────────────────────────
+async function testListSessions() {
+  log("TEST: listSessions");
+
+  // List all sessions for PPM project
+  const sessions = await listSessions({ dir: PROJECT_DIR, limit: 10 });
+  logInfo(`Found ${sessions.length} sessions for PPM project`);
+
+  for (const s of sessions.slice(0, 5)) {
+    console.log(`  - ${s.sessionId.slice(0, 8)}... | "${s.summary?.slice(0, 50)}" | modified=${new Date(s.lastModified).toISOString().slice(0, 16)} | tag=${s.tag ?? "none"}`);
+  }
+
+  if (sessions.length > 0) logOk("listSessions works");
+  else logFail("No sessions found");
+
+  return sessions;
+}
+
+// ─── Test 2: Get Session Messages ───────────────────────────────────────────
+async function testGetMessages(sessionId) {
+  log("TEST: getSessionMessages");
+
+  if (!sessionId) {
+    const sessions = await listSessions({ dir: PROJECT_DIR, limit: 5 });
+    sessionId = sessions[0]?.sessionId;
+    if (!sessionId) { logFail("No session to test"); return; }
+  }
+
+  logInfo(`Reading messages from session ${sessionId.slice(0, 8)}...`);
+
+  // Test with no limit
+  const allMsgs = await getSessionMessages(sessionId, { dir: PROJECT_DIR });
+  logInfo(`Total messages: ${allMsgs.length}`);
+
+  // Show first few messages with UUIDs (needed for fork-mid test)
+  for (const [i, msg] of allMsgs.slice(0, 6).entries()) {
+    const preview = typeof msg.message === "object"
+      ? JSON.stringify(msg.message).slice(0, 80)
+      : String(msg.message).slice(0, 80);
+    console.log(`  [${i}] type=${msg.type} uuid=${msg.uuid.slice(0, 8)}... | ${preview}`);
+  }
+
+  // Test with limit/offset
+  const page1 = await getSessionMessages(sessionId, { dir: PROJECT_DIR, limit: 2 });
+  const page2 = await getSessionMessages(sessionId, { dir: PROJECT_DIR, limit: 2, offset: 2 });
+  logInfo(`Pagination: page1=${page1.length} msgs, page2=${page2.length} msgs`);
+
+  if (allMsgs.length > 0) logOk(`getSessionMessages works (${allMsgs.length} messages)`);
+  else logFail("No messages found");
+
+  return allMsgs;
+}
+
+// ─── Test 3: Fork at Mid-Message ────────────────────────────────────────────
+async function testForkMid() {
+  log("TEST: forkSession with upToMessageId");
+
+  // Find a session with multiple messages
+  const sessions = await listSessions({ dir: PROJECT_DIR, limit: 20 });
+  let sourceSession = null;
+  let sourceMessages = [];
+
+  for (const s of sessions) {
+    const msgs = await getSessionMessages(s.sessionId, { dir: PROJECT_DIR });
+    if (msgs.length >= 4) {
+      sourceSession = s;
+      sourceMessages = msgs;
+      break;
+    }
+  }
+
+  if (!sourceSession) {
+    logFail("No session with 4+ messages found");
+    return;
+  }
+
+  logInfo(`Source: ${sourceSession.sessionId.slice(0, 8)}... (${sourceMessages.length} messages)`);
+
+  // Fork at the 2nd message (mid-conversation)
+  const forkAtMsg = sourceMessages[1]; // 2nd message
+  logInfo(`Forking at message[1]: uuid=${forkAtMsg.uuid.slice(0, 8)}... type=${forkAtMsg.type}`);
+
+  try {
+    const result = await forkSession(sourceSession.sessionId, {
+      dir: PROJECT_DIR,
+      upToMessageId: forkAtMsg.uuid,
+      title: `[TEST] Fork at msg[1] - ${new Date().toISOString().slice(11, 19)}`,
+    });
+
+    logOk(`Fork created! New sessionId: ${result.sessionId}`);
+
+    // Verify forked session has fewer messages
+    const forkedMsgs = await getSessionMessages(result.sessionId, { dir: PROJECT_DIR });
+    logInfo(`Forked session has ${forkedMsgs.length} messages (source had ${sourceMessages.length})`);
+
+    if (forkedMsgs.length <= sourceMessages.length) {
+      logOk(`Mid-fork works: ${forkedMsgs.length} ≤ ${sourceMessages.length} messages`);
+    } else {
+      logFail(`Fork has more messages than source?!`);
+    }
+
+    // Get info about forked session
+    const info = await getSessionInfo(result.sessionId, { dir: PROJECT_DIR });
+    logInfo(`Fork info: title="${info?.summary}" created=${info?.createdAt ? new Date(info.createdAt).toISOString().slice(0, 16) : "?"}`);
+
+    return result.sessionId;
+  } catch (e) {
+    logFail(`forkSession failed: ${e.message}`);
+    console.error(e);
+  }
+}
+
+// ─── Test 4: Delete Session (JSONL) ─────────────────────────────────────────
+async function testDelete(sessionIdToDelete) {
+  log("TEST: deleteSession (JSONL unlink)");
+
+  // If no specific session, create a disposable one first via forkSession
+  if (!sessionIdToDelete) {
+    logInfo("Creating disposable session via fork for delete test...");
+    const sessions = await listSessions({ dir: PROJECT_DIR, limit: 5 });
+    if (sessions.length === 0) { logFail("No sessions to fork from"); return; }
+
+    const result = await forkSession(sessions[0].sessionId, {
+      dir: PROJECT_DIR,
+      title: "[TEST] Disposable for delete test",
+    });
+    sessionIdToDelete = result.sessionId;
+    logInfo(`Created disposable: ${sessionIdToDelete}`);
+  }
+
+  // Find the JSONL file on disk
+  const projectDirs = readdirSync(CLAUDE_PROJECTS_DIR);
+  let jsonlPath = null;
+
+  for (const dir of projectDirs) {
+    const candidate = resolve(CLAUDE_PROJECTS_DIR, dir, `${sessionIdToDelete}.jsonl`);
+    if (existsSync(candidate)) {
+      jsonlPath = candidate;
+      break;
+    }
+  }
+
+  if (!jsonlPath) {
+    logFail(`JSONL file not found for session ${sessionIdToDelete}`);
+    return;
+  }
+
+  logInfo(`Found JSONL: ${jsonlPath}`);
+
+  // Delete the file
+  unlinkSync(jsonlPath);
+  logInfo("JSONL deleted");
+
+  // Verify it's gone from listSessions
+  const afterSessions = await listSessions({ dir: PROJECT_DIR, limit: 100 });
+  const stillExists = afterSessions.some(s => s.sessionId === sessionIdToDelete);
+
+  if (!stillExists) {
+    logOk("Session deleted successfully — no longer in listSessions");
+  } else {
+    logFail("Session still appears in listSessions after JSONL deletion!");
+  }
+}
+
+// ─── Test 5: resumeSessionAt ────────────────────────────────────────────────
+async function testResumeAt() {
+  log("TEST: resumeSessionAt (resume from specific message)");
+
+  // Find a session with enough messages
+  const sessions = await listSessions({ dir: PROJECT_DIR, limit: 20 });
+  let sourceSession = null;
+  let sourceMessages = [];
+
+  for (const s of sessions) {
+    const msgs = await getSessionMessages(s.sessionId, { dir: PROJECT_DIR });
+    if (msgs.length >= 4) {
+      sourceSession = s;
+      sourceMessages = msgs;
+      break;
+    }
+  }
+
+  if (!sourceSession) {
+    logFail("No session with 4+ messages for resumeAt test");
+    return;
+  }
+
+  // Pick middle message to resume from
+  const midIdx = Math.floor(sourceMessages.length / 2);
+  const resumeAtMsg = sourceMessages[midIdx];
+  logInfo(`Source: ${sourceSession.sessionId.slice(0, 8)}... (${sourceMessages.length} msgs)`);
+  logInfo(`Resuming at message[${midIdx}]: uuid=${resumeAtMsg.uuid.slice(0, 8)}... type=${resumeAtMsg.type}`);
+
+  try {
+    // Use query() with resume + resumeSessionAt + forkSession to test
+    const q = query({
+      prompt: "Just say 'RESUME_AT_TEST_OK' and nothing else.",
+      options: {
+        resume: sourceSession.sessionId,
+        resumeSessionAt: resumeAtMsg.uuid,
+        forkSession: true,
+        cwd: PROJECT_DIR,
+        maxTurns: 1,
+        allowedTools: [],
+        permissionMode: "bypassPermissions",
+        systemPrompt: { type: "custom", value: "You are a test assistant. Reply exactly as instructed." },
+      },
+    });
+
+    let resultSessionId = null;
+    let gotText = false;
+
+    for await (const msg of q) {
+      if (msg.type === "assistant") {
+        const textBlocks = (msg.message?.content || []).filter(b => b.type === "text");
+        if (textBlocks.length > 0) {
+          logInfo(`Assistant replied: "${textBlocks.map(b => b.text).join("").slice(0, 100)}"`);
+          gotText = true;
+        }
+      }
+      if (msg.type === "result") {
+        resultSessionId = msg.session_id;
+        logInfo(`Result: subtype=${msg.subtype} session=${resultSessionId?.slice(0, 8)}... cost=$${msg.total_cost_usd?.toFixed(4)}`);
+      }
+    }
+
+    if (gotText && resultSessionId) {
+      logOk(`resumeSessionAt works! Forked session: ${resultSessionId}`);
+
+      // Check the forked session has truncated history
+      const forkedMsgs = await getSessionMessages(resultSessionId, { dir: PROJECT_DIR });
+      logInfo(`Forked session messages: ${forkedMsgs.length} (original: ${sourceMessages.length})`);
+
+      // Cleanup: delete test session
+      return resultSessionId;
+    } else {
+      logFail("resumeSessionAt did not produce expected output");
+    }
+  } catch (e) {
+    logFail(`resumeSessionAt failed: ${e.message}`);
+    console.error(e);
+  }
+}
+
+// ─── Test 6: Compact/Summary for Merge ──────────────────────────────────────
+async function testCompactSummary() {
+  log("TEST: Generate summary for merge (using query + compact approach)");
+
+  // Find a session with enough content
+  const sessions = await listSessions({ dir: PROJECT_DIR, limit: 20 });
+  let sourceSession = null;
+  let sourceMessages = [];
+
+  for (const s of sessions) {
+    const msgs = await getSessionMessages(s.sessionId, { dir: PROJECT_DIR });
+    if (msgs.length >= 6) {
+      sourceSession = s;
+      sourceMessages = msgs;
+      break;
+    }
+  }
+
+  if (!sourceSession) {
+    logFail("No session with 6+ messages for compact test");
+    return;
+  }
+
+  logInfo(`Source: ${sourceSession.sessionId.slice(0, 8)}... (${sourceMessages.length} msgs)`);
+
+  // Extract conversation text for summary
+  const conversationText = sourceMessages.slice(0, 10).map((msg, i) => {
+    const content = msg.message?.content;
+    let text = "";
+    if (typeof content === "string") {
+      text = content;
+    } else if (Array.isArray(content)) {
+      text = content
+        .filter(b => b.type === "text")
+        .map(b => b.text)
+        .join("\n")
+        .slice(0, 500);
+    }
+    return `[${msg.type}] ${text.slice(0, 300)}`;
+  }).join("\n---\n");
+
+  logInfo(`Conversation excerpt (${conversationText.length} chars):\n${conversationText.slice(0, 500)}...`);
+
+  // Use a cheap query to generate summary
+  logInfo("Generating summary via Claude (short query)...");
+  try {
+    const summaryPrompt = `Summarize this conversation in 3-5 bullet points. Focus on: what was discussed, what decisions were made, what files were modified.
+
+CONVERSATION:
+${conversationText.slice(0, 3000)}
+
+Reply with ONLY the bullet points, no preamble.`;
+
+    const q = query({
+      prompt: summaryPrompt,
+      options: {
+        cwd: PROJECT_DIR,
+        maxTurns: 1,
+        allowedTools: [],
+        permissionMode: "bypassPermissions",
+        model: "haiku",
+        systemPrompt: { type: "custom", value: "You are a concise conversation summarizer." },
+        persistSession: false, // Don't save this summary session
+      },
+    });
+
+    let summary = "";
+    for await (const msg of q) {
+      if (msg.type === "assistant") {
+        const textBlocks = (msg.message?.content || []).filter(b => b.type === "text");
+        summary += textBlocks.map(b => b.text).join("");
+      }
+      if (msg.type === "result") {
+        logInfo(`Summary cost: $${msg.total_cost_usd?.toFixed(4)}`);
+      }
+    }
+
+    if (summary) {
+      logOk("Summary generated successfully:");
+      console.log(`\n${summary}\n`);
+      logInfo("This summary could be injected into a merge session's system prompt");
+    } else {
+      logFail("No summary text produced");
+    }
+  } catch (e) {
+    logFail(`Summary generation failed: ${e.message}`);
+    console.error(e);
+  }
+}
+
+// ─── Test 7: Tag Session ────────────────────────────────────────────────────
+async function testTagSession() {
+  log("TEST: tagSession");
+
+  const sessions = await listSessions({ dir: PROJECT_DIR, limit: 5 });
+  if (sessions.length === 0) { logFail("No sessions"); return; }
+
+  const target = sessions[0];
+  logInfo(`Tagging session ${target.sessionId.slice(0, 8)}... (current tag: ${target.tag ?? "none"})`);
+
+  try {
+    await tagSession(target.sessionId, "test-tag", { dir: PROJECT_DIR });
+    const info = await getSessionInfo(target.sessionId, { dir: PROJECT_DIR });
+    logInfo(`After tag: tag="${info?.tag}"`);
+
+    if (info?.tag === "test-tag") {
+      logOk("tagSession works");
+    } else {
+      logFail(`Expected tag="test-tag", got "${info?.tag}"`);
+    }
+
+    // Clear tag
+    await tagSession(target.sessionId, null, { dir: PROJECT_DIR });
+    logInfo("Tag cleared");
+
+  } catch (e) {
+    logFail(`tagSession failed: ${e.message}`);
+  }
+}
+
+// ─── Runner ─────────────────────────────────────────────────────────────────
+async function main() {
+  console.log(`\n🧪 Session Operations Test Suite`);
+  console.log(`Project: ${PROJECT_DIR}`);
+  console.log(`Test: ${testName}\n`);
+
+  const tests = {
+    list: testListSessions,
+    messages: testGetMessages,
+    "fork-mid": testForkMid,
+    delete: testDelete,
+    "resume-at": testResumeAt,
+    "compact-summary": testCompactSummary,
+    tag: testTagSession,
+  };
+
+  if (testName === "all") {
+    // Run non-destructive tests first
+    await testListSessions();
+    await testGetMessages();
+    await testTagSession();
+    await testForkMid();
+    // resume-at and compact-summary cost API tokens — ask first
+    console.log("\n⚠️  Remaining tests (resume-at, compact-summary) cost API tokens.");
+    console.log("   Run individually: bun test-session-ops.mjs resume-at");
+    console.log("   Run individually: bun test-session-ops.mjs compact-summary");
+    console.log("   Delete test: bun test-session-ops.mjs delete");
+  } else if (tests[testName]) {
+    await tests[testName]();
+  } else {
+    console.log(`Unknown test: ${testName}`);
+    console.log(`Available: ${Object.keys(tests).join(", ")}, all`);
+  }
+
+  log("DONE", `Finished ${testName} test(s)`);
+}
+
+main().catch(e => {
+  console.error("Fatal:", e);
+  process.exit(1);
+});