tmux-ide 2.9.14 → 2.9.16

package/packages/daemon/src/lib/native-browser-rpc.ts

@@ -0,0 +1,118 @@
+import { randomUUID } from "node:crypto";
+import { lstat } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { connect } from "node:net";
+import {
+  NativeBrowserCommandSchemaZ,
+  NativeBrowserStateSchemaZ,
+  type NativeBrowserCommand,
+  type NativeBrowserState,
+} from "@tmux-ide/contracts";
+import { z } from "zod";
+
+export const NativeBrowserEndpointSchema = z
+  .object({
+    version: z.literal(1),
+    pid: z.number().int().positive(),
+    instance: z.uuid(),
+    pane: z
+      .string()
+      .regex(/^%[0-9]+$/u)
+      .max(32),
+    socket: z.string().min(1).max(1024).refine(isAbsolute),
+  })
+  .strict();
+export type NativeBrowserEndpoint = z.infer<typeof NativeBrowserEndpointSchema>;
+export class NativeBrowserUnavailable extends Error {
+  constructor() {
+    super("Native browser controls are unavailable");
+  }
+}
+const responseSchema = z.discriminatedUnion("ok", [
+  z
+    .object({ id: z.string(), ok: z.literal(true), data: NativeBrowserStateSchemaZ.nullable() })
+    .strict(),
+  z.object({ id: z.string(), ok: z.literal(false), error: z.string().max(4096) }).strict(),
+]);
+
+/** One request, one bounded response. Mutations are never retried or refreshed. */
+export async function nativeBrowserRpc(
+  endpoint: NativeBrowserEndpoint,
+  command: NativeBrowserCommand | null,
+  signal: AbortSignal,
+): Promise<NativeBrowserState | null> {
+  const target = NativeBrowserEndpointSchema.parse(endpoint);
+  const payload = command ? NativeBrowserCommandSchemaZ.parse(command) : null;
+  if (payload && (payload.instance !== target.instance || payload.pane !== target.pane))
+    throw new NativeBrowserUnavailable();
+  signal.throwIfAborted();
+  const info = await lstat(target.socket);
+  if (!info.isSocket() || info.uid !== process.getuid?.() || (info.mode & 0o022) !== 0)
+    throw new NativeBrowserUnavailable();
+  try {
+    process.kill(target.pid, 0);
+  } catch {
+    throw new NativeBrowserUnavailable();
+  }
+  signal.throwIfAborted();
+  const id = randomUUID();
+  const request =
+    JSON.stringify({
+      id,
+      cmd: payload ? "native/1/command" : "native/1/state",
+      ...(payload ? { payload } : {}),
+    }) + "\n";
+  return new Promise((resolve, reject) => {
+    const socket = connect(target.socket);
+    let finished = false;
+    let size = 0;
+    const chunks: Buffer[] = [];
+    const finish = (error?: Error, state: NativeBrowserState | null = null) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", abort);
+      socket.destroy();
+      if (error) reject(error);
+      else resolve(state);
+    };
+    const abort = () => finish(new NativeBrowserUnavailable());
+    const timer = setTimeout(abort, 1500);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) {
+      abort();
+      return;
+    }
+    socket.once("connect", () => socket.write(request));
+    socket.on("error", abort);
+    socket.once("end", () => {
+      if (!finished) abort();
+    });
+    socket.on("data", (chunk: Buffer) => {
+      size += chunk.length;
+      if (size > 128 * 1024) {
+        abort();
+        return;
+      }
+      chunks.push(chunk);
+      if (!chunk.includes(10)) return;
+      try {
+        const bytes = Buffer.concat(chunks);
+        const newline = bytes.indexOf(10);
+        if (newline !== bytes.length - 1) throw new NativeBrowserUnavailable();
+        const reply = responseSchema.parse(
+          JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, newline))),
+        );
+        if (reply.id !== id || !reply.ok) throw new NativeBrowserUnavailable();
+        if (
+          reply.data &&
+          (reply.data.instance !== target.instance || reply.data.pane !== target.pane)
+        )
+          throw new NativeBrowserUnavailable();
+        finish(undefined, reply.data);
+      } catch {
+        abort();
+      }
+    });
+  });
+}

package/packages/daemon/src/lib/session-favicon.ts

@@ -0,0 +1,185 @@
+import { constants, type Stats } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { extname, isAbsolute, join } from "node:path";
+import {
+  TMUX_SERVER_SESSION_FAVICON_MAX_BYTES,
+  type TmuxServerSessionFaviconMime,
+} from "@tmux-ide/contracts";
+
+/** Project-relative favicon locations, first match wins. */
+export const SESSION_FAVICON_CANDIDATES = [
+  "favicon.svg",
+  "favicon.png",
+  "favicon.ico",
+  "public/favicon.svg",
+  "public/favicon.png",
+  "public/favicon.ico",
+  "app/icon.svg",
+  "app/icon.png",
+  "app/favicon.ico",
+  "src/app/icon.svg",
+  "src/app/icon.png",
+  "src/app/favicon.ico",
+  "static/favicon.svg",
+  "static/favicon.png",
+  "static/favicon.ico",
+  "assets/favicon.svg",
+  "assets/favicon.png",
+  "assets/favicon.ico",
+  "apple-touch-icon.png",
+  "public/apple-touch-icon.png",
+  "icon.svg",
+  "icon.png",
+] as const;
+
+const MIME_BY_EXTENSION: Readonly<Record<string, TmuxServerSessionFaviconMime>> = {
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+};
+
+export interface SessionFavicon {
+  readonly mime: TmuxServerSessionFaviconMime;
+  /** Base64 of the raw file bytes. */
+  readonly data: string;
+  /** Raw byte count. */
+  readonly size: number;
+}
+
+export interface SessionFaviconIo {
+  lstat(path: string): Promise<Stats>;
+  /** Reads a regular file without following a final symlink; null when refused or too large. */
+  readNoFollow(path: string, maxBytes: number): Promise<Buffer | null>;
+}
+
+export const defaultSessionFaviconIo: SessionFaviconIo = {
+  lstat: (path) => lstat(path),
+  readNoFollow: async (path, maxBytes) => {
+    let handle;
+    try {
+      handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    } catch {
+      return null;
+    }
+    try {
+      const stats = await handle.stat();
+      if (!stats.isFile() || stats.size > maxBytes) return null;
+      const bytes = await handle.readFile();
+      return bytes.byteLength > maxBytes ? null : bytes;
+    } catch {
+      return null;
+    } finally {
+      await handle.close().catch(() => undefined);
+    }
+  },
+};
+
+type CacheEntry =
+  | {
+      readonly kind: "hit";
+      readonly file: string;
+      readonly mtimeMs: number;
+      readonly size: number;
+      readonly favicon: SessionFavicon;
+    }
+  | { readonly kind: "miss"; readonly at: number };
+
+export interface SessionFaviconResolverOptions {
+  readonly io?: SessionFaviconIo;
+  readonly now?: () => number;
+  readonly missTtlMs?: number;
+  readonly maxEntries?: number;
+}
+
+async function lstatOrNull(io: SessionFaviconIo, path: string): Promise<Stats | null> {
+  try {
+    return await io.lstat(path);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Finds a session's project favicon from its working directory. Only regular
+ * files and real directories inside the session path are considered; symlinks
+ * are never followed. Hits are revalidated by mtime and size, misses are
+ * remembered briefly, and the cache is bounded (least recently used first).
+ */
+export function createSessionFaviconResolver(options: SessionFaviconResolverOptions = {}) {
+  const io = options.io ?? defaultSessionFaviconIo;
+  const now = options.now ?? Date.now;
+  const missTtlMs = options.missTtlMs ?? 30_000;
+  const maxEntries = options.maxEntries ?? 256;
+  const cache = new Map<string, CacheEntry>();
+
+  const remember = (sessionPath: string, entry: CacheEntry) => {
+    cache.delete(sessionPath);
+    cache.set(sessionPath, entry);
+    while (cache.size > maxEntries) cache.delete(cache.keys().next().value!);
+  };
+
+  const scan = async (sessionPath: string): Promise<CacheEntry> => {
+    const directories = new Map<string, boolean>();
+    for (const candidate of SESSION_FAVICON_CANDIDATES) {
+      const mime = MIME_BY_EXTENSION[extname(candidate)];
+      if (!mime) continue;
+      const slash = candidate.lastIndexOf("/");
+      if (slash >= 0) {
+        const parts = candidate.slice(0, slash).split("/");
+        let real = true;
+        for (let index = 1; index <= parts.length && real; index += 1) {
+          const directory = parts.slice(0, index).join("/");
+          let known = directories.get(directory);
+          if (known === undefined) {
+            const stats = await lstatOrNull(io, join(sessionPath, directory));
+            known = stats !== null && stats.isDirectory() && !stats.isSymbolicLink();
+            directories.set(directory, known);
+          }
+          real = known;
+        }
+        if (!real) continue;
+      }
+      const file = join(sessionPath, candidate);
+      const stats = await lstatOrNull(io, file);
+      if (!stats || !stats.isFile() || stats.size > TMUX_SERVER_SESSION_FAVICON_MAX_BYTES) continue;
+      const bytes = await io.readNoFollow(file, TMUX_SERVER_SESSION_FAVICON_MAX_BYTES);
+      if (!bytes) continue;
+      return {
+        kind: "hit",
+        file,
+        mtimeMs: stats.mtimeMs,
+        size: stats.size,
+        favicon: { mime, data: bytes.toString("base64"), size: bytes.byteLength },
+      };
+    }
+    return { kind: "miss", at: now() };
+  };
+
+  return async (sessionPath: string): Promise<SessionFavicon | null> => {
+    if (!sessionPath || !isAbsolute(sessionPath) || sessionPath.includes("\0")) return null;
+    const cached = cache.get(sessionPath);
+    if (cached?.kind === "miss" && now() - cached.at < missTtlMs) {
+      remember(sessionPath, cached);
+      return null;
+    }
+    if (cached?.kind === "hit") {
+      const stats = await lstatOrNull(io, cached.file);
+      if (
+        stats &&
+        stats.isFile() &&
+        stats.mtimeMs === cached.mtimeMs &&
+        stats.size === cached.size
+      ) {
+        remember(sessionPath, cached);
+        return cached.favicon;
+      }
+    }
+    const entry = await scan(sessionPath);
+    remember(sessionPath, entry);
+    return entry.kind === "hit" ? entry.favicon : null;
+  };
+}

package/packages/daemon/src/lib/skill-sync.ts

@@ -13,8 +13,8 @@ import { resolveRuntimeNamespace } from "./runtime-namespace.ts";
  *
  * The dir is FULLY MANAGED: overwriting our own `~/.claude/skills/tmux-ide` is
  * correct, and this NEVER touches anything outside it (user-authored skills in
- * sibling dirs are safe). The version marker is line 2 of SKILL.md, an HTML
- * comment ({@link VERSION_MARKER_RE}); {@link parseSkillVersion} reads it and
+ * sibling dirs are safe). The version marker is an HTML comment under
+ * SKILL.md's frontmatter ({@link VERSION_MARKER_RE}); {@link parseSkillVersion} reads it and
  * {@link rewriteVersionMarker} substitutes it at copy time.
  *
  * The parse/render helpers are PURE and tested against fixtures; {@link syncSkill}
@@ -73,7 +73,7 @@ export function defaultSkillSource(): string {
 // ---------------------------------------------------------------------------
 
 /**
- * The version marker line (an HTML comment on line 2 of SKILL.md). The sync
+ * The version marker line (an HTML comment under SKILL.md's frontmatter). The sync
  * machinery reads it to know which version an installed copy is, and rewrites it
  * to the installed package version at copy time.
  */

package/packages/daemon/src/lib/tmux-native-browser.ts

@@ -0,0 +1,100 @@
+import { PaneEditorContextTargetSchemaZ, NativeBrowserCommandSchemaZ } from "@tmux-ide/contracts";
+import { z } from "zod";
+import type { LiveSessionSummary } from "../command-center/discovery.ts";
+import type { WorkspaceTerminalInventoryRuntime } from "../terminal/attachments/native-runtime.ts";
+import type { WorkspaceRegistry } from "./workspace-registry.ts";
+import { decodeTmuxArgument } from "../terminal/protocol/session-descriptor-discovery.ts";
+import {
+  NativeBrowserEndpointSchema,
+  NativeBrowserUnavailable,
+  nativeBrowserRpc,
+} from "./native-browser-rpc.ts";
+
+export const NativeBrowserRequestSchema = z
+  .object({
+    target: PaneEditorContextTargetSchemaZ,
+    command: NativeBrowserCommandSchemaZ.nullable(),
+  })
+  .strict();
+export function createNativeBrowserResolver(options: {
+  generation: string;
+  assertOpen(): void;
+  registry: Pick<WorkspaceRegistry, "get">;
+  catalog(): Promise<LiveSessionSummary[]>;
+  inventory: Pick<WorkspaceTerminalInventoryRuntime, "discoverTerminalInventory">;
+  run(args: readonly string[], signal: AbortSignal): Promise<string>;
+}) {
+  let readers = 0;
+  return async (input: unknown, cancellation: AbortSignal) => {
+    const { target, command } = NativeBrowserRequestSchema.parse(input);
+    const signal = AbortSignal.any([cancellation, AbortSignal.timeout(2500)]);
+    const workspace = options.registry.get(target.workspaceName);
+    const assertCurrent = () => {
+      options.assertOpen();
+      signal.throwIfAborted();
+      if (
+        target.generation !== options.generation ||
+        !workspace ||
+        options.registry.get(target.workspaceName) !== workspace
+      )
+        throw new NativeBrowserUnavailable();
+    };
+    assertCurrent();
+    if (readers >= 8) throw new NativeBrowserUnavailable();
+    readers++;
+    try {
+      const sessions = await options.catalog();
+      assertCurrent();
+      const matching = sessions.filter((s) => s.liveSessionId === target.liveSessionId);
+      if (matching.length !== 1 || matching[0]!.sessionName !== workspace!.sessionName)
+        throw new NativeBrowserUnavailable();
+      const snapshot = await options.inventory.discoverTerminalInventory(signal);
+      assertCurrent();
+      if (
+        snapshot.catalog.invalidRuntimeProof ||
+        snapshot.catalog.duplicateSemanticStamp ||
+        snapshot.catalog.duplicateRuntimePaneBinding
+      )
+        throw new NativeBrowserUnavailable();
+      const matches = snapshot.panes.filter(
+        (p) =>
+          p.workspaceName === target.workspaceName &&
+          p.semanticPaneId === target.semanticPaneId &&
+          p.sessionName === workspace!.sessionName,
+      );
+      if (matches.length !== 1) throw new NativeBrowserUnavailable();
+      const pane = { ...matches[0]! };
+      if (!pane.nativePaneBirthId || !/^%[0-9]+$/u.test(pane.runtimePaneId))
+        throw new NativeBrowserUnavailable();
+      const observe = async () => {
+        const raw = await options.run(
+          [
+            "display-message",
+            "-p",
+            "-t",
+            pane.runtimePaneId,
+            "#{qa:@tmux_ide_pane_id}\t#{qa:pane_birth_id}\t#{qa:@tmux_ide_browser_control}",
+          ],
+          signal,
+        );
+        assertCurrent();
+        if (raw.length > 8192) throw new NativeBrowserUnavailable();
+        const [semantic, birth, endpoint] = raw.trimEnd().split("\t").map(decodeTmuxArgument);
+        if (semantic !== target.semanticPaneId || birth !== pane.nativePaneBirthId)
+          throw new NativeBrowserUnavailable();
+        const parsed = NativeBrowserEndpointSchema.parse(JSON.parse(endpoint ?? "null"));
+        if (parsed.pane !== pane.runtimePaneId) throw new NativeBrowserUnavailable();
+        return parsed;
+      };
+      const endpoint = await observe();
+      const result = await nativeBrowserRpc(endpoint, command, signal);
+      assertCurrent();
+      const current = await observe();
+      if (JSON.stringify(current) !== JSON.stringify(endpoint))
+        throw new NativeBrowserUnavailable();
+      return result;
+    } finally {
+      readers--;
+    }
+  };
+}

package/packages/daemon/src/lib/tmux-server-owner.ts

@@ -1,3 +1,4 @@
+import { createNativeBrowserResolver } from "./tmux-native-browser.ts";
 import { createNativeSurfaceContextResolver } from "./native-surface-context.ts";
 import type { LocalImageOwner } from "../terminal/graphics/local-image-owner.ts";
 import { shellEscape } from "./shell.ts";
@@ -96,13 +97,23 @@ function discoveredWorkspaceName(registry: WorkspaceRegistry, sessionName: strin
   throw new Error("Unable to allocate discovered workspace identity");
 }
 
+/** A live session row with the facts the native app's Home shows beside it. */
+export interface NativeLiveSessionSummary extends LiveSessionSummary {
+  /** Distinct tmux windows of the session (at least one). */
+  readonly windowCount: number;
+  /** tmux `#{session_activity}` in epoch seconds, or null when tmux reports none. */
+  readonly lastActivity: number | null;
+  /** tmux `#{session_path}`, the session's working directory. */
+  readonly sessionPath: string;
+}
+
 /** Refresh discovered live membership without changing durable workspace intent or aliases. */
 export function createNativeTmuxServerCatalog(
   workspaceRegistry: WorkspaceRegistry,
   run: (args: readonly string[], signal?: AbortSignal) => Promise<string>,
   assertOpen: () => void = () => undefined,
-): () => Promise<LiveSessionSummary[]> {
-  return async (): Promise<LiveSessionSummary[]> => {
+): () => Promise<NativeLiveSessionSummary[]> {
+  return async (): Promise<NativeLiveSessionSummary[]> => {
     assertOpen();
     const raw = await run(
       [
@@ -115,7 +126,8 @@ export function createNativeTmuxServerCatalog(
           "list-panes",
           "-a",
           "-F",
-          "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}\t#{pane_id}\t#{session_path}",
+          // session_path stays last: tmux rejects tabs in session names but not in paths.
+          "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}\t#{pane_id}\t#{window_id}\t#{session_activity}\t#{session_path}",
         ]
           .map(shellEscape)
           .join(" "),
@@ -125,13 +137,20 @@ export function createNativeTmuxServerCatalog(
     assertOpen();
     const rows = new Map<
       string,
-      { summary: LiveSessionSummary; panes: Set<string>; dir: string }
+      {
+        summary: LiveSessionSummary;
+        panes: Set<string>;
+        windows: Set<string>;
+        dir: string;
+        activity: number | null;
+      }
     >();
     // Only the successful server-side zero-session branch proves emptiness.
     // Command errors, unsupported formats and unwitnessed blank output stay failures.
     const lines = raw.trim() === "tmux-ide-empty-catalog-v1" ? [] : raw.trim().split("\n");
     for (const line of lines) {
-      const [pid, id, created, name, pane, dir] = line.split("\t");
+      const [pid, id, created, name, pane, window, activity, ...pathParts] = line.split("\t");
+      const dir = pathParts.join("\t");
       if (
         !pid ||
         !/^\d+$/.test(pid) ||
@@ -142,6 +161,8 @@ export function createNativeTmuxServerCatalog(
         !name ||
         !pane ||
         !/^%\d+$/.test(pane) ||
+        !window ||
+        !/^@\d+$/.test(window) ||
         !dir
       )
         throw new Error("Invalid native server catalog");
@@ -150,9 +171,12 @@ export function createNativeTmuxServerCatalog(
       const row = rows.get(liveSessionId) ?? {
         summary: { liveSessionId, sessionName: name, paneCount: 0 },
         panes: new Set<string>(),
+        windows: new Set<string>(),
         dir,
+        activity: activity && /^\d+$/.test(activity) ? Number(activity) : null,
       };
       row.panes.add(pane);
+      row.windows.add(window);
       rows.set(liveSessionId, row);
     }
     const names = new Set([...rows.values()].map(({ summary }) => summary.sessionName));
@@ -169,7 +193,13 @@ export function createNativeTmuxServerCatalog(
           projectDir: dir,
           persistence: "volatile",
         });
-    return [...rows.values()].map(({ summary, panes }) => ({ ...summary, paneCount: panes.size }));
+    return [...rows.values()].map(({ summary, panes, windows, dir, activity }) => ({
+      ...summary,
+      paneCount: panes.size,
+      windowCount: windows.size,
+      lastActivity: activity,
+      sessionPath: dir,
+    }));
   };
 }
 
@@ -619,6 +649,14 @@ export async function createNativeTmuxServerOwner(options: NativeTmuxServerOwner
       run: (args, signal) => generationRunAsync(args, signal),
     }),
     resolvePaneEditorContext,
+    nativeBrowser: createNativeBrowserResolver({
+      generation,
+      assertOpen,
+      registry: workspaceRegistry,
+      catalog,
+      inventory: terminalInventoryRuntime,
+      run: generationRunAsync,
+    }),
     catalog,
     readWindowSplitLayout: async (workspaceName: string, input: WindowLinkTarget) => {
       assertOpen();