@hienlh/ppm 0.9.39 → 0.9.41

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 = 13;
+const CURRENT_SCHEMA_VERSION = 12;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -313,80 +313,6 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 12;
     `);
   }
-
-  if (current < 13) {
-    database.exec(`
-      CREATE TABLE IF NOT EXISTS clawbot_sessions (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        telegram_chat_id TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        provider_id TEXT NOT NULL DEFAULT 'claude',
-        project_name TEXT NOT NULL,
-        project_path TEXT NOT NULL,
-        is_active INTEGER NOT NULL DEFAULT 1,
-        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
-        last_message_at INTEGER NOT NULL DEFAULT (unixepoch())
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_clawbot_sessions_chat
-        ON clawbot_sessions(telegram_chat_id, is_active);
-      CREATE INDEX IF NOT EXISTS idx_clawbot_sessions_session
-        ON clawbot_sessions(session_id);
-
-      CREATE TABLE IF NOT EXISTS clawbot_memories (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        project TEXT NOT NULL,
-        content TEXT NOT NULL,
-        category TEXT NOT NULL DEFAULT 'fact',
-        importance REAL NOT NULL DEFAULT 1.0,
-        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
-        updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
-        session_id TEXT,
-        superseded_by INTEGER REFERENCES clawbot_memories(id)
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_clawbot_memories_project
-        ON clawbot_memories(project, superseded_by);
-      CREATE INDEX IF NOT EXISTS idx_clawbot_memories_importance
-        ON clawbot_memories(importance DESC);
-
-      CREATE VIRTUAL TABLE IF NOT EXISTS clawbot_memories_fts USING fts5(
-        content,
-        content='clawbot_memories',
-        content_rowid='id'
-      );
-
-      -- FTS5 sync triggers
-      CREATE TRIGGER IF NOT EXISTS clawbot_memories_ai AFTER INSERT ON clawbot_memories BEGIN
-        INSERT INTO clawbot_memories_fts(rowid, content) VALUES (new.id, new.content);
-      END;
-
-      CREATE TRIGGER IF NOT EXISTS clawbot_memories_ad AFTER DELETE ON clawbot_memories BEGIN
-        INSERT INTO clawbot_memories_fts(clawbot_memories_fts, rowid, content) VALUES('delete', old.id, old.content);
-      END;
-
-      CREATE TRIGGER IF NOT EXISTS clawbot_memories_au AFTER UPDATE ON clawbot_memories BEGIN
-        INSERT INTO clawbot_memories_fts(clawbot_memories_fts, rowid, content) VALUES('delete', old.id, old.content);
-        INSERT INTO clawbot_memories_fts(rowid, content) VALUES (new.id, new.content);
-      END;
-
-      CREATE TABLE IF NOT EXISTS clawbot_paired_chats (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        telegram_chat_id TEXT NOT NULL UNIQUE,
-        telegram_user_id TEXT,
-        display_name TEXT,
-        pairing_code TEXT,
-        status TEXT NOT NULL DEFAULT 'pending',
-        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
-        approved_at INTEGER
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_clawbot_paired_status
-        ON clawbot_paired_chats(status);
-
-      PRAGMA user_version = 13;
-    `);
-  }
 }
 
 // ---------------------------------------------------------------------------
@@ -968,209 +894,5 @@ export function deleteExtensionStorage(extId: string): void {
   getDb().query("DELETE FROM extension_storage WHERE ext_id = ?").run(extId);
 }
 
-// ---------------------------------------------------------------------------
-// PPMBot session helpers
-// ---------------------------------------------------------------------------
-
-import type { PPMBotSessionRow, PPMBotMemoryRow, PPMBotPairedChat } from "../types/ppmbot.ts";
-
-export function getActivePPMBotSession(
-  telegramChatId: string,
-  projectName: string,
-): PPMBotSessionRow | null {
-  return getDb().query(
-    `SELECT * FROM clawbot_sessions
-     WHERE telegram_chat_id = ? AND project_name = ? AND is_active = 1
-     ORDER BY last_message_at DESC LIMIT 1`,
-  ).get(telegramChatId, projectName) as PPMBotSessionRow | null;
-}
-
-export function createPPMBotSession(
-  telegramChatId: string,
-  sessionId: string,
-  providerId: string,
-  projectName: string,
-  projectPath: string,
-): void {
-  getDb().query(
-    `INSERT INTO clawbot_sessions
-     (telegram_chat_id, session_id, provider_id, project_name, project_path)
-     VALUES (?, ?, ?, ?, ?)`,
-  ).run(telegramChatId, sessionId, providerId, projectName, projectPath);
-}
-
-export function deactivatePPMBotSession(sessionId: string): void {
-  getDb().query(
-    "UPDATE clawbot_sessions SET is_active = 0 WHERE session_id = ?",
-  ).run(sessionId);
-}
-
-export function touchPPMBotSession(sessionId: string): void {
-  getDb().query(
-    "UPDATE clawbot_sessions SET last_message_at = unixepoch() WHERE session_id = ?",
-  ).run(sessionId);
-}
-
-export function getRecentPPMBotSessions(
-  telegramChatId: string,
-  limit = 10,
-): PPMBotSessionRow[] {
-  return getDb().query(
-    `SELECT * FROM clawbot_sessions
-     WHERE telegram_chat_id = ?
-     ORDER BY last_message_at DESC LIMIT ?`,
-  ).all(telegramChatId, limit) as PPMBotSessionRow[];
-}
-
-// ---------------------------------------------------------------------------
-// PPMBot memory helpers
-// ---------------------------------------------------------------------------
-
-export function insertPPMBotMemory(
-  project: string,
-  content: string,
-  category: string,
-  importance: number,
-  sessionId?: string,
-): number {
-  const result = getDb().query(
-    `INSERT INTO clawbot_memories (project, content, category, importance, session_id)
-     VALUES (?, ?, ?, ?, ?)`,
-  ).run(project, content, category, importance, sessionId ?? null);
-  return Number(result.lastInsertRowid);
-}
-
-export function searchPPMBotMemories(
-  project: string,
-  query: string,
-  limit = 20,
-): Array<PPMBotMemoryRow & { rank: number }> {
-  return getDb().query(
-    `SELECT m.*, fts.rank
-     FROM clawbot_memories m
-     JOIN clawbot_memories_fts fts ON m.id = fts.rowid
-     WHERE clawbot_memories_fts MATCH ?
-       AND m.project IN (?, '_global')
-       AND m.superseded_by IS NULL
-     ORDER BY fts.rank
-     LIMIT ?`,
-  ).all(query, project, limit) as Array<PPMBotMemoryRow & { rank: number }>;
-}
-
-export function getPPMBotMemories(
-  project: string,
-  limit = 20,
-): PPMBotMemoryRow[] {
-  return getDb().query(
-    `SELECT * FROM clawbot_memories
-     WHERE project IN (?, '_global')
-       AND superseded_by IS NULL
-     ORDER BY importance DESC, updated_at DESC
-     LIMIT ?`,
-  ).all(project, limit) as PPMBotMemoryRow[];
-}
-
-export function supersedePPMBotMemory(
-  oldId: number,
-  newId: number,
-): void {
-  getDb().query(
-    "UPDATE clawbot_memories SET superseded_by = ? WHERE id = ?",
-  ).run(newId, oldId);
-}
-
-export function deletePPMBotMemoriesByTopic(
-  project: string,
-  topic: string,
-): number {
-  const matches = getDb().query(
-    `SELECT m.id FROM clawbot_memories m
-     JOIN clawbot_memories_fts fts ON m.id = fts.rowid
-     WHERE clawbot_memories_fts MATCH ?
-       AND m.project IN (?, '_global')
-       AND m.superseded_by IS NULL`,
-  ).all(topic, project) as { id: number }[];
-
-  for (const row of matches) {
-    getDb().query("DELETE FROM clawbot_memories WHERE id = ?").run(row.id);
-  }
-  return matches.length;
-}
-
-export function decayPPMBotMemories(): void {
-  getDb().query(
-    `UPDATE clawbot_memories
-     SET importance = importance * 0.95,
-         updated_at = unixepoch()
-     WHERE superseded_by IS NULL
-       AND category NOT IN ('preference', 'architecture')
-       AND updated_at < unixepoch() - 604800`,
-  ).run();
-  getDb().query(
-    `DELETE FROM clawbot_memories WHERE importance < 0.1 AND superseded_by IS NULL`,
-  ).run();
-}
-
-// ---------------------------------------------------------------------------
-// PPMBot pairing helpers
-// ---------------------------------------------------------------------------
-
-export function createPairingRequest(
-  chatId: string,
-  userId: string,
-  displayName: string,
-  code: string,
-): void {
-  getDb().query(
-    `INSERT INTO clawbot_paired_chats (telegram_chat_id, telegram_user_id, display_name, pairing_code, status)
-     VALUES (?, ?, ?, ?, 'pending')
-     ON CONFLICT(telegram_chat_id) DO UPDATE SET
-       telegram_user_id = excluded.telegram_user_id,
-       display_name = excluded.display_name,
-       pairing_code = excluded.pairing_code,
-       status = 'pending',
-       approved_at = NULL`,
-  ).run(chatId, userId, displayName, code);
-}
-
-export function approvePairing(chatId: string): void {
-  getDb().query(
-    `UPDATE clawbot_paired_chats
-     SET status = 'approved', pairing_code = NULL, approved_at = unixepoch()
-     WHERE telegram_chat_id = ? AND status = 'pending'`,
-  ).run(chatId);
-}
-
-export function revokePairing(chatId: string): void {
-  getDb().query(
-    "UPDATE clawbot_paired_chats SET status = 'revoked' WHERE telegram_chat_id = ?",
-  ).run(chatId);
-}
-
-export function getPairingByCode(code: string): PPMBotPairedChat | null {
-  return getDb().query(
-    "SELECT * FROM clawbot_paired_chats WHERE pairing_code = ? AND status = 'pending'",
-  ).get(code) as PPMBotPairedChat | null;
-}
-
-export function getPairingByChatId(chatId: string): PPMBotPairedChat | null {
-  return getDb().query(
-    "SELECT * FROM clawbot_paired_chats WHERE telegram_chat_id = ?",
-  ).get(chatId) as PPMBotPairedChat | null;
-}
-
-export function listPairedChats(): PPMBotPairedChat[] {
-  return getDb().query(
-    "SELECT * FROM clawbot_paired_chats WHERE status != 'revoked' ORDER BY created_at DESC",
-  ).all() as PPMBotPairedChat[];
-}
-
-export function isPairedChat(chatId: string): boolean {
-  const row = getDb().query(
-    "SELECT 1 FROM clawbot_paired_chats WHERE telegram_chat_id = ? AND status = 'approved'",
-  ).get(chatId);
-  return row != null;
-}
-
 // Auto-close on process exit
 process.on("beforeExit", closeDb);

package/src/services/git.service.ts

@@ -404,10 +404,10 @@ class GitService {
   // Worktree operations
   // ---------------------------------------------------------------------------
 
-  /** Parse `git worktree list --porcelain -v` output into GitWorktree[]. */
+  /** Parse `git worktree list --porcelain` output into GitWorktree[]. */
   async listWorktrees(projectPath: string): Promise<GitWorktree[]> {
     const git = this.git(projectPath);
-    const raw = await git.raw(["worktree", "list", "--porcelain", "-v"]);
+    const raw = await git.raw(["worktree", "list", "--porcelain"]);
     const worktrees: GitWorktree[] = [];
     // Blocks are separated by blank lines
     const blocks = raw.trim().split(/\n\n+/);

package/src/types/config.ts

@@ -9,17 +9,6 @@ export interface TelegramConfig {
   chat_id: string;
 }
 
-export interface PPMBotConfig {
-  enabled: boolean;
-  default_provider: string;
-  default_project: string;
-  system_prompt: string;
-  show_tool_calls: boolean;
-  show_thinking: boolean;
-  permission_mode: string;
-  debounce_ms: number;
-}
-
 export type ThemeConfig = "light" | "dark" | "system";
 
 export interface PpmConfig {
@@ -32,7 +21,6 @@ export interface PpmConfig {
   ai: AIConfig;
   push?: PushConfig;
   telegram?: TelegramConfig;
-  clawbot?: PPMBotConfig;
   cloud_url?: string;
 }
 
@@ -97,20 +85,6 @@ export const DEFAULT_CONFIG: PpmConfig = {
       },
     },
   },
-  telegram: {
-    bot_token: "",
-    chat_id: "",
-  },
-  clawbot: {
-    enabled: false,
-    default_provider: "claude",
-    default_project: "",
-    system_prompt: "You are PPMBot, a helpful AI coding assistant on Telegram. Keep responses concise and mobile-friendly. Use short paragraphs. When showing code, use compact examples. Be direct and helpful.",
-    show_tool_calls: true,
-    show_thinking: false,
-    permission_mode: "bypassPermissions",
-    debounce_ms: 2000,
-  },
 };
 
 const VALID_TYPES = ["agent-sdk", "cli", "mock"] as const;

package/src/web/components/browser/browser-tab.tsx

@@ -1,45 +1,78 @@
-import { useState, useRef, useCallback } from "react";
-import { ExternalLink, Globe, Loader2, RefreshCw, X } from "lucide-react";
-import { useTabStore } from "@/stores/tab-store";
+import { useState, useEffect, useCallback } from "react";
+import { Check, Copy, ExternalLink, Globe, Loader2, Square, Wifi } from "lucide-react";
 import { api } from "@/lib/api-client";
+import { toast } from "sonner";
 
-interface BrowserTabProps {
-  metadata?: Record<string, unknown>;
-  tabId?: string;
+interface TunnelInfo {
+  port: number;
+  url: string;
+  startedAt: number;
 }
 
-export function BrowserTab({ metadata, tabId }: BrowserTabProps) {
-  const initialPort = (metadata?.port as number) || 0;
-  const [portInput, setPortInput] = useState(initialPort ? String(initialPort) : "");
-  const [tunnelUrl, setTunnelUrl] = useState<string | null>(null);
+export function BrowserTab() {
+  const [portInput, setPortInput] = useState("");
+  const [tunnels, setTunnels] = useState<TunnelInfo[]>([]);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const iframeRef = useRef<HTMLIFrameElement>(null);
-  const updateTab = useTabStore((s) => s.updateTab);
+  const [copiedPort, setCopiedPort] = useState<number | null>(null);
+
+  const fetchTunnels = useCallback(async () => {
+    try {
+      const list = await api.get<TunnelInfo[]>("/api/preview/tunnels");
+      setTunnels(list);
+    } catch (e) {
+      console.warn("[ports] failed to fetch tunnels", e);
+    }
+  }, []);
+
+  // Fetch tunnels on mount + poll every 10s
+  useEffect(() => {
+    fetchTunnels();
+    const interval = setInterval(fetchTunnels, 10_000);
+    return () => clearInterval(interval);
+  }, [fetchTunnels]);
+
+  const startTunnel = async (port: number) => {
+    // Check if already forwarded
+    const existing = tunnels.find((t) => t.port === port);
+    if (existing) {
+      window.open(existing.url, "_blank");
+      setPortInput("");
+      return;
+    }
 
-  const startTunnel = useCallback(async (port: number) => {
     setLoading(true);
     setError(null);
-    setTunnelUrl(null);
-
     try {
       const res = await api.post<{ port: number; url: string }>("/api/preview/tunnel", { port });
-      setTunnelUrl(res.url);
-      if (tabId) updateTab(tabId, { title: `localhost:${port}`, metadata: { ...metadata, port } });
+      window.open(res.url, "_blank");
+      setPortInput("");
+      await fetchTunnels();
     } catch (e: any) {
       setError(e.message || `Failed to start tunnel for port ${port}`);
     } finally {
       setLoading(false);
     }
-  }, [tabId, metadata, updateTab]);
+  };
 
-  const stopTunnel = useCallback(async () => {
-    const port = parseInt(portInput, 10);
-    if (!port) return;
-    try { await api.del(`/api/preview/tunnel/${port}`); } catch {}
-    setTunnelUrl(null);
-    if (tabId) updateTab(tabId, { title: "Browser" });
-  }, [portInput, tabId, updateTab]);
+  const stopTunnel = async (port: number) => {
+    try {
+      await api.del(`/api/preview/tunnel/${port}`);
+      await fetchTunnels();
+    } catch (e: any) {
+      toast.error(e.message || `Failed to stop tunnel for port ${port}`);
+    }
+  };
+
+  const copyUrl = (port: number, url: string) => {
+    navigator.clipboard.writeText(url).then(() => {
+      setCopiedPort(port);
+      toast.success("URL copied");
+      setTimeout(() => setCopiedPort(null), 2000);
+    }).catch(() => {
+      toast.error("Failed to copy URL");
+    });
+  };
 
   const handleSubmit = (e: React.FormEvent) => {
     e.preventDefault();
@@ -48,100 +81,98 @@ export function BrowserTab({ metadata, tabId }: BrowserTabProps) {
     else setError("Port must be 1-65535");
   };
 
-  const reload = () => {
-    if (iframeRef.current) {
-      const src = iframeRef.current.src;
-      iframeRef.current.src = "";
-      requestAnimationFrame(() => { if (iframeRef.current) iframeRef.current.src = src; });
-    }
-  };
-
-  // No tunnel yet — show port input
-  if (!tunnelUrl) {
-    return (
-      <div className="flex flex-col items-center justify-center h-full gap-4 p-6">
-        <Globe className="size-12 text-text-subtle" />
-        <h2 className="text-lg font-medium text-text-primary">Open Localhost</h2>
-        <p className="text-sm text-text-secondary text-center max-w-sm">
-          Enter the port of your local dev server to preview it here.
-        </p>
-        <form onSubmit={handleSubmit} className="flex items-center gap-2 w-full max-w-xs">
-          <div className="flex-1 flex items-center gap-2 px-3 py-2.5 rounded-lg bg-surface border border-border focus-within:border-accent/50 transition-colors">
+  return (
+    <div className="flex flex-col h-full w-full bg-background">
+      {/* Header + form */}
+      <div className="p-4 md:p-6 border-b border-border bg-surface">
+        <div className="flex items-center gap-2 mb-3">
+          <Wifi className="size-5 text-accent" />
+          <h2 className="text-base font-medium text-text-primary">Port Forwarding</h2>
+        </div>
+        <form onSubmit={handleSubmit} className="flex items-center gap-2">
+          <div className="flex-1 flex items-center gap-2 px-3 py-2.5 rounded-lg bg-background border border-border focus-within:border-accent/50 transition-colors">
             <span className="text-sm text-text-subtle shrink-0">localhost:</span>
             <input
               type="number"
               value={portInput}
-              onChange={(e) => setPortInput(e.target.value)}
+              onChange={(e) => { setPortInput(e.target.value); setError(null); }}
               placeholder="3000"
               min={1}
               max={65535}
-              autoFocus
               className="flex-1 bg-transparent text-sm text-text-primary outline-none placeholder:text-text-subtle min-w-0 [appearance:textfield] [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none"
             />
           </div>
           <button
             type="submit"
             disabled={loading || !portInput}
-            className="px-4 py-2.5 rounded-lg bg-accent text-white text-sm font-medium hover:bg-accent/90 disabled:opacity-50 transition-colors shrink-0"
+            className="px-4 py-2.5 rounded-lg bg-accent text-white text-sm font-medium hover:bg-accent/90 disabled:opacity-50 transition-colors shrink-0 min-w-[72px] flex items-center justify-center"
           >
-            {loading ? <Loader2 className="size-4 animate-spin" /> : "Open"}
+            {loading ? <Loader2 className="size-4 animate-spin" /> : "Forward"}
           </button>
         </form>
-        {error && <p className="text-sm text-red-400">{error}</p>}
+        {error && <p className="text-sm text-red-400 mt-2">{error}</p>}
         {loading && (
-          <div className="flex items-center gap-2 text-sm text-text-secondary">
-            <Loader2 className="size-4 animate-spin" />
-            <span>Starting tunnel... (may take a few seconds)</span>
+          <div className="flex items-center gap-2 text-sm text-text-secondary mt-2">
+            <Loader2 className="size-3.5 animate-spin" />
+            <span>Starting tunnel...</span>
           </div>
         )}
       </div>
-    );
-  }
 
-  // Tunnel active — show iframe
-  return (
-    <div className="flex flex-col h-full w-full bg-background">
-      {/* Toolbar */}
-      <div className="flex items-center gap-1.5 px-2 py-1.5 border-b border-border bg-surface shrink-0">
-        <Globe className="size-4 text-text-subtle shrink-0" />
-        <span className="text-xs text-text-primary font-medium">localhost:{portInput}</span>
-        <span className="text-xs text-text-subtle truncate ml-1">({tunnelUrl})</span>
-        <div className="flex-1" />
-        <button
-          onClick={reload}
-          className="p-1.5 rounded hover:bg-surface-elevated transition-colors"
-          title="Reload"
-        >
-          <RefreshCw className="size-3.5" />
-        </button>
-        <button
-          onClick={() => window.open(tunnelUrl, "_blank")}
-          className="p-1.5 rounded hover:bg-surface-elevated transition-colors"
-          title="Open in browser"
-        >
-          <ExternalLink className="size-3.5" />
-        </button>
-        <button
-          onClick={stopTunnel}
-          className="p-1.5 rounded hover:bg-surface-elevated text-red-400 transition-colors"
-          title="Stop tunnel"
-        >
-          <X className="size-3.5" />
-        </button>
-      </div>
+      {/* Tunnel list */}
+      <div className="flex-1 overflow-y-auto p-4 md:p-6">
+        {tunnels.length === 0 ? (
+          <div className="flex flex-col items-center justify-center h-full gap-3 text-center">
+            <Globe className="size-10 text-text-subtle" />
+            <p className="text-sm text-text-secondary max-w-xs">
+              No active ports. Forward a port to access your local dev server from anywhere.
+            </p>
+          </div>
+        ) : (
+          <div className="space-y-2">
+            {tunnels.map((t) => (
+              <div
+                key={t.port}
+                className="flex items-center gap-3 p-3 rounded-lg bg-surface border border-border"
+              >
+                {/* Port badge */}
+                <div className="shrink-0 px-2 py-1 rounded bg-accent/10 text-accent text-xs font-mono font-medium">
+                  :{t.port}
+                </div>
 
-      {/* iframe */}
-      <div className="flex-1 relative min-h-0">
-        <iframe
-          ref={iframeRef}
-          src={tunnelUrl}
-          className="w-full h-full border-0"
-          sandbox="allow-scripts allow-forms allow-same-origin allow-popups allow-modals"
-          onLoad={() => setLoading(false)}
-        />
-        {loading && (
-          <div className="absolute inset-0 flex items-center justify-center bg-background/50">
-            <Loader2 className="size-5 animate-spin text-text-secondary" />
+                {/* URL - truncated */}
+                <span className="flex-1 text-xs text-text-secondary truncate min-w-0">
+                  {t.url}
+                </span>
+
+                {/* Actions — 44px touch targets */}
+                <div className="flex items-center shrink-0">
+                  <button
+                    onClick={() => window.open(t.url, "_blank")}
+                    className="p-2.5 rounded-md hover:bg-surface-elevated transition-colors"
+                    title="Open in browser"
+                  >
+                    <ExternalLink className="size-4 text-text-secondary" />
+                  </button>
+                  <button
+                    onClick={() => copyUrl(t.port, t.url)}
+                    className="p-2.5 rounded-md hover:bg-surface-elevated transition-colors"
+                    title="Copy URL"
+                  >
+                    {copiedPort === t.port
+                      ? <Check className="size-4 text-green-400" />
+                      : <Copy className="size-4 text-text-secondary" />}
+                  </button>
+                  <button
+                    onClick={() => stopTunnel(t.port)}
+                    className="p-2.5 rounded-md hover:bg-red-500/10 transition-colors"
+                    title="Stop tunnel"
+                  >
+                    <Square className="size-4 text-red-400" />
+                  </button>
+                </div>
+              </div>
+            ))}
           </div>
         )}
       </div>

package/src/web/components/chat/chat-history-bar.tsx

@@ -1,5 +1,5 @@
 import { useState, useEffect, useCallback, useRef } from "react";
-import { History, Settings2, Loader2, MessageSquare, RefreshCw, Search, Pencil, Check, X, BellOff, Bug, ClipboardCheck, Pin, PinOff, Trash2, Users, Bot } from "lucide-react";
+import { History, Settings2, Loader2, MessageSquare, RefreshCw, Search, Pencil, Check, X, BellOff, Bug, ClipboardCheck, Pin, PinOff, Trash2, Users } from "lucide-react";
 import { Activity } from "lucide-react";
 import { api, projectUrl } from "@/lib/api-client";
 import { useTabStore } from "@/stores/tab-store";
@@ -398,14 +398,9 @@ export function ChatHistoryBar({
                     <>
                       <button
                         onClick={() => openSession(session)}
-                        className="text-[11px] truncate flex-1 text-left flex items-center gap-1"
+                        className="text-[11px] truncate flex-1 text-left"
                       >
-                        {session.title?.startsWith("[PPM]") && (
-                          <Bot className="size-3 text-muted-foreground shrink-0" />
-                        )}
-                        {session.title?.startsWith("[PPM]")
-                          ? session.title.slice(7)
-                          : session.title || "Untitled"}
+                        {session.title || "Untitled"}
                       </button>
                       <button
                         onClick={(e) => togglePin(e, session)}

package/src/web/components/layout/command-palette.tsx

@@ -161,7 +161,7 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
       { id: "chat", label: "New AI Chat", icon: MessageSquare, action: openNewTab("chat", "AI Chat"), keywords: "ai assistant claude", group: "action", shortcut: formatShortcut(getBinding("open-chat")) },
       { id: "terminal", label: "New Terminal", icon: Terminal, action: openNewTab("terminal", "Terminal"), keywords: "bash shell console", group: "action", shortcut: formatShortcut(getBinding("open-terminal")) },
       { id: "git-graph", label: "Git Graph", icon: GitBranch, action: openNewTab("git-graph", "Git Graph"), keywords: "branch history log", group: "action", shortcut: formatShortcut(getBinding("open-git-graph")) },
-      { id: "browser", label: "Open Browser", icon: Globe, action: openNewTab("browser", "Browser"), keywords: "web preview localhost iframe url", group: "action" },
+      { id: "browser", label: "Port Forwarding", icon: Globe, action: openNewTab("browser", "Ports"), keywords: "web preview localhost port forward tunnel url", group: "action" },
       { id: "postgres", label: "PostgreSQL", icon: Database, action: openNewTab("postgres", "PostgreSQL"), keywords: "database pg sql query", group: "action" },
       { id: "voice-input", label: "Voice Input", icon: Mic, action: () => { window.dispatchEvent(new CustomEvent("toggle-voice-input")); onClose(); }, keywords: "speech microphone dictate voice", group: "action", shortcut: formatShortcut(getBinding("voice-input")) },
       { id: "git-status", label: "Git Status", icon: GitCommitHorizontal, action: () => { setSidebarActiveTab("git"); onClose(); }, keywords: "changes diff staged", group: "action", shortcut: formatShortcut(getBinding("open-git-status")) },