@hienlh/ppm 0.18.2 → 0.18.4

package/src/web/hooks/use-terminal-command-queue.ts

@@ -0,0 +1,108 @@
+import { useEffect, useRef, useState, useCallback } from "react";
+import { usePanelStore } from "@/stores/panel-store";
+import {
+  RUN_IN_TERMINAL_EVENT,
+  RUN_IN_TERMINAL_ACK_EVENT,
+  type RunInTerminalDetail,
+} from "@/lib/run-in-terminal";
+
+interface UseTerminalCommandQueueOptions {
+  /** Tab ID — used to drop `pendingCommand` from persisted metadata once consumed. */
+  tabId?: string;
+  metadata?: Record<string, unknown>;
+  /** From `useTerminal` — the shell has printed its prompt and can take input. */
+  shellReady: boolean;
+  sendData: (data: string) => void;
+  focusTerminal: () => void;
+  containerRef: React.RefObject<HTMLDivElement | null>;
+}
+
+/**
+ * Smallest box treated as a real terminal. Not `> 0`: a terminal parked in the
+ * zero-sized tab pool (dock closed, tab inactive) still measures 8×8 from its own
+ * padding, and a hidden terminal claiming the command would swallow it silently.
+ */
+const MIN_VISIBLE_PX = 40;
+
+/** On screen? Must be laid out at a usable size and inside the viewport. */
+function isOnScreen(el: HTMLElement | null): boolean {
+  if (!el) return false;
+  // `visibility: hidden` on the tab pool is the crisp signal where supported.
+  if (typeof el.checkVisibility === "function" && !el.checkVisibility({ visibilityProperty: true })) {
+    return false;
+  }
+  const r = el.getBoundingClientRect();
+  if (r.width < MIN_VISIBLE_PX || r.height < MIN_VISIBLE_PX) return false;
+  return r.bottom > 0 && r.right > 0 && r.top < window.innerHeight && r.left < window.innerWidth;
+}
+
+/**
+ * Type a command into this terminal, deferred until the shell can accept it.
+ *
+ * Fed from two directions: `metadata.pendingCommand` on a terminal that was just
+ * opened to carry the command, and the `ppm:run-in-terminal` event for a terminal
+ * already on screen. Both land in the same one-slot queue, which flushes once
+ * `shellReady` turns true — a shell still running its startup files drops
+ * anything typed at it, which is why the command cannot be sent on connect.
+ *
+ * The command is typed WITHOUT a trailing newline: the user reads it and presses
+ * Enter. Same semantics as a paste, so a multi-line block behaves like pasting one.
+ */
+export function useTerminalCommandQueue({
+  tabId,
+  metadata,
+  shellReady,
+  sendData,
+  focusTerminal,
+  containerRef,
+}: UseTerminalCommandQueueOptions): void {
+  /** Latest command awaiting a ready shell — latest wins, since queued commands
+   *  typed back-to-back without a newline would merge into one garbled line. */
+  const pendingRef = useRef<string | null>(null);
+  /** Incremented per queued command so the flush effect re-runs on repeat clicks. */
+  const [revision, setRevision] = useState(0);
+
+  const queue = useCallback((command: string) => {
+    pendingRef.current = command;
+    setRevision((n) => n + 1);
+  }, []);
+
+  // Command handed over by whoever opened this tab. Stripped from the tab's
+  // metadata immediately: metadata is persisted to localStorage, and a page
+  // reload must not re-inject a command the user already dealt with.
+  const pendingCommand = metadata?.pendingCommand;
+  useEffect(() => {
+    if (typeof pendingCommand !== "string" || !pendingCommand) return;
+    queue(pendingCommand);
+    if (tabId) {
+      const rest = { ...(metadata ?? {}) };
+      delete rest.pendingCommand;
+      usePanelStore.getState().updateTab(tabId, { metadata: rest });
+    }
+    // `metadata` is intentionally not a dependency — the strip above already
+    // makes this fire exactly once per handed-over command.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [pendingCommand, tabId, queue]);
+
+  // Claim commands aimed at "whatever terminal the user is looking at".
+  useEffect(() => {
+    const onRun = (event: Event) => {
+      const detail = (event as CustomEvent<RunInTerminalDetail>).detail;
+      if (!detail?.command) return;
+      if (!isOnScreen(containerRef.current)) return;
+      queue(detail.command);
+      window.dispatchEvent(new Event(RUN_IN_TERMINAL_ACK_EVENT));
+    };
+    window.addEventListener(RUN_IN_TERMINAL_EVENT, onRun);
+    return () => window.removeEventListener(RUN_IN_TERMINAL_EVENT, onRun);
+  }, [containerRef, queue]);
+
+  useEffect(() => {
+    if (!shellReady) return;
+    const command = pendingRef.current;
+    if (!command) return;
+    pendingRef.current = null;
+    sendData(command);
+    focusTerminal();
+  }, [shellReady, revision, sendData, focusTerminal]);
+}

package/src/web/hooks/use-terminal.ts

@@ -1,5 +1,6 @@
 import { useEffect, useRef, useCallback, useState } from "react";
 import { Terminal, type ITheme } from "@xterm/xterm";
+import { withWsAuth } from "@/lib/ws-auth";
 import { FitAddon } from "@xterm/addon-fit";
 import { WebLinksAddon } from "@xterm/addon-web-links";
 import { WebglAddon } from "@xterm/addon-webgl";
@@ -21,6 +22,8 @@ function currentXtermTheme(): ITheme {
 interface UseTerminalOptions {
   sessionId: string;
   projectName?: string;
+  /** Absolute start directory for a brand-new shell; ignored when re-attaching to a session. */
+  cwd?: string;
   containerRef: React.RefObject<HTMLDivElement | null>;
   /** Stable tab ID for persisting session across reload */
   tabId?: string;
@@ -30,10 +33,14 @@ interface UseTerminalReturn {
   connected: boolean;
   reconnecting: boolean;
   exited: boolean;
+  /** True once the shell has printed its prompt and stopped writing — safe to inject input. */
+  shellReady: boolean;
   sendData: (data: string) => void;
   getSelection: () => string;
   /** Read buffer from last command start to current cursor (for "Send to Chat"). */
   getLastCommandOutput: () => string;
+  /** The prompt line the last command was typed on, empty until one is entered. */
+  getLastCommand: () => string;
   /** URLs present in the scrollback, most recent first. */
   getBufferUrls: () => string[];
   restart: () => void;
@@ -47,6 +54,11 @@ const URL_SCAN_MAX_ROWS = 5000;
 /** Quiet period before refitting to a new container size, in ms. */
 const RESIZE_SETTLE_MS = 100;
 
+/** Quiet period after the last PTY output that means the prompt is printed and the shell is idle. */
+const SHELL_READY_QUIET_MS = 250;
+/** Upper bound on waiting for that prompt — a shell that prints nothing must not block input forever. */
+const SHELL_READY_MAX_MS = 3000;
+
 const RESIZE_PREFIX = "\x01RESIZE:";
 const PING_MSG = "\x01PING";
 const PONG_MSG = "\x01PONG";
@@ -72,6 +84,10 @@ export function useTerminal(
   const [connected, setConnected] = useState(false);
   const [reconnecting, setReconnecting] = useState(false);
   const [exited, setExited] = useState(false);
+  /** A brand-new shell needs to finish booting before it accepts injected input. */
+  const [shellReady, setShellReady] = useState(false);
+  const readyQuietTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const readyMaxTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
   // Restore persisted session ID from localStorage (survives page reload)
   const storageKey = options.tabId ? `ppm:terminal-session:${options.tabId}` : null;
   const initialSessionId = (() => {
@@ -83,6 +99,9 @@ export function useTerminal(
   const actualSessionId = useRef(initialSessionId);
   /** Absolute row where last command output starts (set when user presses Enter) */
   const commandStartRow = useRef(0);
+  /** Absolute row of the prompt line that command was typed on, -1 before any Enter.
+   *  Output alone reads as an orphan in chat — the command is what gives it meaning. */
+  const commandRow = useRef(-1);
 
   const sendData = useCallback((data: string) => {
     const ws = wsRef.current;
@@ -91,6 +110,12 @@ export function useTerminal(
     }
   }, []);
 
+  /** Debounce PTY output: the shell counts as booted once it goes quiet. */
+  const noteOutput = useCallback(() => {
+    if (readyQuietTimer.current) clearTimeout(readyQuietTimer.current);
+    readyQuietTimer.current = setTimeout(() => setShellReady(true), SHELL_READY_QUIET_MS);
+  }, []);
+
   const getSelection = useCallback(() => {
     return termRef.current?.getSelection() ?? "";
   }, []);
@@ -111,6 +136,12 @@ export function useTerminal(
     return lines.join("\n");
   }, []);
 
+  const getLastCommand = useCallback(() => {
+    const term = termRef.current;
+    if (!term || commandRow.current < 0) return "";
+    return term.buffer.active.getLine(commandRow.current)?.translateToString(true).trimEnd() ?? "";
+  }, []);
+
   /**
    * Collect URLs from the scrollback.
    *
@@ -172,6 +203,7 @@ export function useTerminal(
     if (storageKey) { try { localStorage.removeItem(storageKey); } catch { /* */ } }
     reconnectAttempts.current = 0;
     setExited(false);
+    setShellReady(false);
     setConnected(false);
     setReconnecting(false);
     // connectWs will be called after this via setTimeout to allow state to settle
@@ -198,7 +230,8 @@ export function useTerminal(
     const projectName = options.projectName ?? "";
     // Use actual session ID from server on reconnect (not "new")
     const sid = actualSessionId.current;
-    const path = `/ws/project/${encodeURIComponent(projectName)}/terminal/${sid}`;
+    const cwdQuery = sid === "new" && options.cwd ? `?cwd=${encodeURIComponent(options.cwd)}` : "";
+    const path = withWsAuth(`/ws/project/${encodeURIComponent(projectName)}/terminal/${sid}${cwdQuery}`);
     // Local dev over http: connect directly to backend (port 8081) to bypass
     // Vite's dev proxy which has unreliable WebSocket upgrade handling. Over https
     // (e.g. a Cloudflare tunnel) port 8081 isn't reachable and ws:// is blocked as
@@ -220,6 +253,11 @@ export function useTerminal(
       setConnected(true);
       setReconnecting(false);
       reconnectAttempts.current = 0;
+      // A re-attach lands on a shell that booted long ago; only a fresh session
+      // has to wait for a prompt.
+      if (actualSessionId.current === "new") setShellReady(false);
+      if (readyMaxTimer.current) clearTimeout(readyMaxTimer.current);
+      readyMaxTimer.current = setTimeout(() => setShellReady(true), SHELL_READY_MAX_MS);
       sendResize();
     };
 
@@ -255,6 +293,7 @@ export function useTerminal(
             // Not JSON, write as terminal output
           }
         }
+        noteOutput();
         term.write(event.data);
       }
     };
@@ -347,7 +386,8 @@ export function useTerminal(
       // When user presses Enter, mark next row as command output start
       if (data.includes("\r") || data.includes("\n")) {
         const buf = term.buffer.active;
-        commandStartRow.current = buf.baseY + buf.cursorY + 1;
+        commandRow.current = buf.baseY + buf.cursorY;
+        commandStartRow.current = commandRow.current + 1;
       }
       const ws = wsRef.current;
       if (ws?.readyState === WebSocket.OPEN) {
@@ -399,6 +439,8 @@ export function useTerminal(
       clearInterval(heartbeatInterval);
       document.removeEventListener("visibilitychange", onVisibility);
       if (reconnectTimer.current) clearTimeout(reconnectTimer.current);
+      if (readyQuietTimer.current) clearTimeout(readyQuietTimer.current);
+      if (readyMaxTimer.current) clearTimeout(readyMaxTimer.current);
       wsRef.current?.close();
       wsRef.current = null;
       term.dispose();
@@ -407,5 +449,5 @@ export function useTerminal(
     };
   }, []); // eslint-disable-line react-hooks/exhaustive-deps
 
-  return { connected, reconnecting, exited, sendData, getSelection, getLastCommandOutput, getBufferUrls, restart };
+  return { connected, reconnecting, exited, shellReady, sendData, getSelection, getLastCommandOutput, getLastCommand, getBufferUrls, restart };
 }

package/src/web/lib/fs-api.ts

@@ -182,4 +182,13 @@ export const fsApi = {
     });
     return `/api/fs/raw?path=${q(path)}&download=true&dl_token=${q(token)}`;
   },
+
+  /**
+   * Target for a streamed `PUT` upload — `path` is the full destination file path. Not used
+   * through `request()`: the upload helper needs `XMLHttpRequest` for progress events, which
+   * `fetch` cannot give.
+   */
+  uploadUrl(path: string, overwrite: boolean): string {
+    return `/api/fs/upload?path=${q(path)}&overwrite=${overwrite ? "1" : "0"}`;
+  },
 };

package/src/web/lib/fs-upload-xhr.ts

@@ -0,0 +1,62 @@
+/**
+ * Single-file upload over `XMLHttpRequest`. `fetch` gives no upload progress events, so the
+ * queue needs XHR for the per-file percentage the toast shows; everything else about the
+ * request (auth header, error shape) mirrors `fs-api.ts`'s `request()`.
+ */
+
+import { getAuthToken } from "./api-client";
+import { fsApi, FsError } from "./fs-api";
+
+export interface UploadProgress {
+  loaded: number;
+  total: number;
+}
+
+interface UploadResponseBody {
+  ok?: boolean;
+  data?: { path: string; size: number };
+  error?: string;
+  code?: string;
+}
+
+/**
+ * Resolves with the uploaded `{ path, size }`. Rejects with `FsError` for a server refusal
+ * (409 `EEXIST`, 403 `EDENIED`, …) and a plain `Error` for a network failure — the caller
+ * tells them apart with `instanceof FsError`, same as every other `fs-api` call.
+ */
+export function uploadFileXhr(
+  path: string,
+  file: File,
+  overwrite: boolean,
+  onProgress: (progress: UploadProgress) => void,
+): Promise<{ path: string; size: number }> {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("PUT", fsApi.uploadUrl(path, overwrite));
+    const token = getAuthToken();
+    if (token) xhr.setRequestHeader("Authorization", `Bearer ${token}`);
+    xhr.setRequestHeader("x-ppm-client", "web");
+
+    xhr.upload.onprogress = (e) => {
+      if (e.lengthComputable) onProgress({ loaded: e.loaded, total: e.total });
+    };
+
+    xhr.onload = () => {
+      let json: UploadResponseBody = {};
+      try {
+        json = JSON.parse(xhr.responseText);
+      } catch {
+        // Falls through to the status-based rejection below.
+      }
+      if (xhr.status >= 200 && xhr.status < 300 && json.ok !== false && json.data) {
+        resolve(json.data);
+        return;
+      }
+      reject(new FsError(json.error ?? `HTTP ${xhr.status}`, json.code ?? "EUNKNOWN", xhr.status));
+    };
+    xhr.onerror = () => reject(new Error("Network error during upload"));
+    xhr.onabort = () => reject(new DOMException("Upload aborted", "AbortError"));
+
+    xhr.send(file);
+  });
+}

package/src/web/lib/media-url.ts

@@ -0,0 +1,51 @@
+/**
+ * URL builders for media the browser fetches on its own (`<video src>`, `<audio src>`).
+ *
+ * Those elements cannot send an Authorization header, so the session token rides in
+ * the query string — the server only accepts `?token=` on these exact routes.
+ * Streaming straight from the URL (instead of fetching a blob first) lets the browser
+ * issue Range requests, so a multi-GB file starts playing immediately and seeking
+ * costs one small request.
+ */
+import { api, getAuthToken, projectUrl } from "@/lib/api-client";
+
+/** Absolute (`/x`, `C:\x`) paths belong to the whole-disk `/api/fs` routes, relative ones to the project. */
+export function isExternalPath(filePath: string): boolean {
+  return /^(\/|[A-Za-z]:[/\\])/.test(filePath);
+}
+
+/** `/api/fs/<route>` or `/api/project/<name>/files/<route>` depending on the path kind. */
+function mediaBase(route: "raw" | "transcode" | "probe", filePath: string, projectName: string): string {
+  const prefix = isExternalPath(filePath) ? "/api/fs" : `${projectUrl(projectName)}/files`;
+  return `${prefix}/${route}?path=${encodeURIComponent(filePath)}`;
+}
+
+function withToken(url: string): string {
+  const token = getAuthToken();
+  return token ? `${url}&token=${encodeURIComponent(token)}` : url;
+}
+
+/** Direct, Range-capable URL of the file as stored on disk. */
+export function rawMediaUrl(filePath: string, projectName: string): string {
+  return withToken(mediaBase("raw", filePath, projectName));
+}
+
+/** Live ffmpeg → fragmented-MP4 stream starting at `start` seconds. */
+export function transcodeMediaUrl(filePath: string, projectName: string, start = 0): string {
+  const base = mediaBase("transcode", filePath, projectName);
+  return withToken(start > 0 ? `${base}&start=${start.toFixed(3)}` : base);
+}
+
+export interface MediaProbeInfo {
+  transcodable: boolean;
+  encoder: string | null;
+  duration: number | null;
+  container: string | null;
+  video: { codec: string; width?: number; height?: number } | null;
+  audio: { codec: string } | null;
+}
+
+/** Ask the server what the file contains and whether it can transcode it. */
+export function probeMedia(filePath: string, projectName: string): Promise<MediaProbeInfo> {
+  return api.get<MediaProbeInfo>(mediaBase("probe", filePath, projectName));
+}

package/src/web/lib/open-terminal-at.ts

@@ -0,0 +1,22 @@
+import { usePanelStore } from "@/stores/panel-store";
+import { basename } from "@/lib/utils";
+
+/**
+ * Open a shell in the bottom dock that starts in `dir` (absolute host path).
+ *
+ * Used by "Open in Terminal" in the OS explorer and the project tree. The dock
+ * reveals itself and the tab is titled after the folder so several folder
+ * terminals stay distinguishable. `projectName` keeps the tab scoped to the
+ * project when the folder belongs to one; explorer folders outside any project
+ * pass none and the server only receives the start directory.
+ */
+export function openTerminalAt(dir: string, projectName?: string | null): string {
+  const title = basename(dir) || dir;
+  return usePanelStore.getState().openInDock({
+    type: "terminal",
+    title,
+    projectId: projectName ?? null,
+    closable: true,
+    metadata: { cwd: dir, ...(projectName ? { projectName } : {}) },
+  });
+}

package/src/web/lib/run-in-terminal.ts

@@ -0,0 +1,55 @@
+import { usePanelStore } from "@/stores/panel-store";
+
+/**
+ * Deliver a shell command to a terminal.
+ *
+ * Two delivery paths, because a shell that is still booting cannot accept input:
+ *  1. A terminal already on screen answers the event synchronously and types the
+ *     command right away — its shell is long past the prompt.
+ *  2. Nobody answers ⇒ open a terminal in the dock and hand the command over via
+ *     `metadata.pendingCommand`. The tab holds it until its shell has printed a
+ *     prompt (see `use-terminal-command-queue`), so the text is never swallowed
+ *     by shell startup.
+ */
+export const RUN_IN_TERMINAL_EVENT = "ppm:run-in-terminal";
+export const RUN_IN_TERMINAL_ACK_EVENT = "ppm:run-in-terminal:ack";
+
+export interface RunInTerminalDetail {
+  command: string;
+  projectName?: string | null;
+}
+
+/**
+ * Normalize a copied code block into terminal input: drop `$ ` prompt markers and
+ * the trailing newline, so the last line waits on the user's Enter instead of
+ * running itself.
+ */
+export function normalizeTerminalCommand(text: string): string {
+  // A space after the `$` is required: `$HOME/bin/tool` starting a line is part of
+  // the command, not a prompt.
+  return text.replace(/^[ \t]*\$[ \t]+/gm, "").replace(/\s+$/, "");
+}
+
+export function runInTerminal(rawCommand: string, projectName?: string | null): void {
+  const command = normalizeTerminalCommand(rawCommand);
+  if (!command) return;
+
+  // Offer it to a live terminal first (dispatch is synchronous, so the ack lands
+  // before this returns).
+  let handled = false;
+  const onAck = () => { handled = true; };
+  window.addEventListener(RUN_IN_TERMINAL_ACK_EVENT, onAck);
+  window.dispatchEvent(
+    new CustomEvent<RunInTerminalDetail>(RUN_IN_TERMINAL_EVENT, { detail: { command, projectName } }),
+  );
+  window.removeEventListener(RUN_IN_TERMINAL_ACK_EVENT, onAck);
+  if (handled) return;
+
+  usePanelStore.getState().openInDock({
+    type: "terminal",
+    title: "Terminal",
+    projectId: projectName ?? null,
+    closable: true,
+    metadata: { ...(projectName ? { projectName } : {}), pendingCommand: command },
+  });
+}

package/src/web/lib/send-to-chat.ts

@@ -0,0 +1,118 @@
+import { usePanelStore } from "@/stores/panel-store";
+import type { Tab } from "@/stores/tab-store";
+
+/**
+ * Deliver text (terminal output, and anything else worth quoting) to ONE chat:
+ * the one the user last selected.
+ *
+ * The event is addressed with `targetTabId` because every chat tab stays mounted
+ * — an unaddressed event is answered by all of them at once, so the same output
+ * lands as an attachment in every open chat.
+ */
+export const SEND_TO_CHAT_EVENT = "ppm:send-to-chat";
+export const SEND_TO_CHAT_ACK_EVENT = "ppm:send-to-chat:ack";
+
+export interface SendToChatDetail {
+  text: string;
+  label?: string;
+  projectName?: string | null;
+  /** Only the chat tab with this id may consume the event. */
+  targetTabId?: string;
+}
+
+/** Wall-clock activation stamp written by the panel store on every tab activation. */
+function lastActiveAt(tab: Tab): number {
+  return typeof tab.metadata?.lastActiveAt === "number" ? (tab.metadata.lastActiveAt as number) : -1;
+}
+
+/**
+ * The chat tab the user last selected.
+ *
+ * Ranked, highest first:
+ *  1. selected AND in the focused panel — with a split, the chat being worked in.
+ *  2. selected — its panel's active tab, so it is a chat actually on screen. The
+ *     activation stamp alone is not enough: a chat opened programmatically carries
+ *     a fresh stamp the user never chose, and a chat left behind another tab in its
+ *     panel keeps its stamp long after it stopped being the one in view.
+ *  3. newest activation — the only ordering that compares across panels, and the
+ *     answer when no chat is on screen at all.
+ *
+ * Chats of the given project always win over other projects' chats.
+ */
+export function resolveSelectedChatTabId(projectName?: string | null): string | null {
+  const { panels, focusedPanelId } = usePanelStore.getState();
+
+  const chats = Object.values(panels).flatMap((p) =>
+    p.tabs
+      .filter((t) => t.type === "chat")
+      .map((t) => ({
+        tab: t,
+        selected: p.activeTabId === t.id,
+        focusedPanel: p.id === focusedPanelId,
+      })),
+  );
+  if (chats.length === 0) return null;
+
+  const sameProject = projectName
+    ? chats.filter((c) => c.tab.projectId === projectName || c.tab.metadata?.projectName === projectName)
+    : [];
+  const pool = sameProject.length > 0 ? sameProject : chats;
+
+  // Panel focus only separates chats that are BOTH on screen. For chats nobody has
+  // in view, the panel it happens to live in says nothing about which one the user
+  // picked last — only the stamp does.
+  const rank = (c: (typeof pool)[number]): [number, number] => [
+    c.selected ? (c.focusedPanel ? 2 : 1) : 0,
+    lastActiveAt(c.tab),
+  ];
+  const best = pool.reduce((a, b) => {
+    const [ra, rb] = [rank(a), rank(b)];
+    for (let i = 0; i < ra.length; i++) {
+      if (ra[i]! !== rb[i]!) return ra[i]! > rb[i]! ? a : b;
+    }
+    return a;
+  });
+  return best.tab.id;
+}
+
+/**
+ * Send `text` to the chat the user last selected, as an attachment chip, focusing
+ * that chat so the user sees it arrive.
+ *
+ * Falls back through: live tab answers the event → tab exists but is not mounted
+ * yet, so hand the text over as `pendingMessage` → no chat open at all, open one.
+ */
+export function sendToChat(opts: { text: string; label?: string; projectName?: string | null }): void {
+  const { text, label, projectName } = opts;
+  if (!text.trim()) return;
+
+  const targetTabId = resolveSelectedChatTabId(projectName);
+  const store = usePanelStore.getState();
+
+  if (targetTabId) {
+    store.setActiveTab(targetTabId);
+
+    let handled = false;
+    const onAck = () => { handled = true; };
+    window.addEventListener(SEND_TO_CHAT_ACK_EVENT, onAck);
+    window.dispatchEvent(
+      new CustomEvent<SendToChatDetail>(SEND_TO_CHAT_EVENT, { detail: { text, label, projectName, targetTabId } }),
+    );
+    window.removeEventListener(SEND_TO_CHAT_ACK_EVENT, onAck);
+    if (handled) return;
+
+    // Lazy-mounted tab: it has no listener yet, so leave the text in its metadata
+    // for the composer to pick up on mount.
+    const tab = Object.values(store.panels).flatMap((p) => p.tabs).find((t) => t.id === targetTabId);
+    store.updateTab(targetTabId, { metadata: { ...tab?.metadata, pendingMessage: text } });
+    return;
+  }
+
+  store.openTab({
+    type: "chat",
+    title: "Chat",
+    projectId: null,
+    metadata: { ...(projectName ? { projectName } : {}), pendingMessage: text },
+    closable: true,
+  });
+}

package/src/web/lib/ws-auth.ts

@@ -0,0 +1,13 @@
+import { getAuthToken } from "@/lib/api-client";
+
+/**
+ * Append the session token to a `/ws/...` path so the server can authenticate
+ * the upgrade. Browsers cannot set headers on WebSocket handshakes, so every
+ * socket (global, extensions, terminal, chat, group) carries it as a query
+ * parameter — one helper keeps the spelling identical to what the server reads.
+ */
+export function withWsAuth(path: string): string {
+  const token = getAuthToken();
+  if (!token || /[?&]token=/.test(path)) return path;
+  return `${path}${path.includes("?") ? "&" : "?"}token=${encodeURIComponent(token)}`;
+}

package/src/web/lib/ws-client.ts

@@ -1,3 +1,5 @@
+import { withWsAuth } from "@/lib/ws-auth";
+
 type MessageHandler = (data: MessageEvent) => void;
 
 const MAX_RECONNECT_DELAY = 30_000;
@@ -33,17 +35,20 @@ export class WsClient {
     this.cleanup();
 
     const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    // Every app socket is authenticated at upgrade time; the token is read fresh
+    // on each (re)connect so a re-login mid-session is picked up.
+    const path = this.url.startsWith("ws") ? this.url : withWsAuth(this.url);
     let fullUrl: string;
-    if (this.url.startsWith("ws")) {
-      fullUrl = this.url;
-    } else if (import.meta.env.DEV && this.url.startsWith("/ws/") && window.location.protocol !== "https:") {
+    if (path.startsWith("ws")) {
+      fullUrl = path;
+    } else if (import.meta.env.DEV && path.startsWith("/ws/") && window.location.protocol !== "https:") {
       // Local dev over http: connect directly to backend (port 8081) to bypass
       // Vite's dev proxy which has unreliable WebSocket upgrade handling.
       // Over https (e.g. a Cloudflare tunnel) port 8081 isn't reachable and ws://
       // is blocked as mixed content, so fall through to same-origin wss:// proxy.
-      fullUrl = `ws://${window.location.hostname}:8081${this.url}`;
+      fullUrl = `ws://${window.location.hostname}:8081${path}`;
     } else {
-      fullUrl = `${protocol}//${window.location.host}${this.url}`;
+      fullUrl = `${protocol}//${window.location.host}${path}`;
     }
 
     this.ws = new WebSocket(fullUrl);

package/.release-run.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Temporary runner: invokes the release script with bun on PATH. Deleted after use.
-export PATH="$HOME/.bun/bin:$PATH"
-cd /c/Users/PC/ppm || exit 1
-exec bash scripts/release.sh 0.18.2

package/dist/web/assets/api-client-CaRE4HYh.js

@@ -1 +0,0 @@
-import"./vendor-markdown-Ls5AcU91.js";import"./vendor-ui-CaeeFO0B.js";import{i as e,n as t}from"./api-client-rTAGdEKo.js";export{t as api,e as projectUrl};

package/dist/web/assets/api-settings-DBcXfeJ8.js

@@ -1 +0,0 @@
-import"./vendor-markdown-Ls5AcU91.js";import"./vendor-ui-CaeeFO0B.js";import"./api-client-rTAGdEKo.js";import{v as e}from"./api-settings-CAhcNpj5.js";export{e as updateDeviceName};

package/dist/web/assets/architecture-PBZL5I3N-B4J2-O8Q.js

@@ -1 +0,0 @@
-import{K as e}from"./vendor-mermaid-C977xNeE.js";export{e as createArchitectureServices};

package/dist/web/assets/audio-preview-BkNAEqcB.js

@@ -1 +0,0 @@
-import{x as e}from"./vendor-markdown-Ls5AcU91.js";import"./vendor-ui-CaeeFO0B.js";import{t}from"./createLucideIcon-D8pyde1A.js";import{t as n}from"./file-exclamation-point-COAwgNGw.js";import"./api-client-rTAGdEKo.js";import{t as r}from"./utils-B9H0d3Fh.js";import{Hn as i}from"./index-wd3FSHHn.js";import{t as a}from"./use-blob-url-DYtOHK7u.js";var o=t(`music`,[[`path`,{d:`M9 18V5l12-2v13`,key:`1jmyc2`}],[`circle`,{cx:`6`,cy:`18`,r:`3`,key:`fqmcym`}],[`circle`,{cx:`18`,cy:`16`,r:`3`,key:`1hluhg`}]]),s=e();function c({filePath:e,projectName:t}){let{blobUrl:c,error:l}=a(e,t);return l?(0,s.jsxs)(`div`,{className:`flex flex-col items-center justify-center h-full gap-3 text-text-secondary`,children:[(0,s.jsx)(n,{className:`size-10 text-text-subtle`}),(0,s.jsx)(`p`,{className:`text-sm`,children:`Failed to load audio.`})]}):c?(0,s.jsxs)(`div`,{className:`flex flex-col items-center justify-center h-full gap-4 p-4 bg-surface`,children:[(0,s.jsx)(o,{className:`size-16 text-text-subtle`}),(0,s.jsx)(`p`,{className:`text-sm text-text-secondary truncate max-w-xs`,children:r(e)}),(0,s.jsx)(`audio`,{src:c,controls:!0,className:`w-full max-w-md`})]}):(0,s.jsx)(`div`,{className:`flex items-center justify-center h-full`,children:(0,s.jsx)(i,{className:`size-5 animate-spin text-text-subtle`})})}export{c as AudioPreview};