@docyrus/docyrus 0.0.60 → 0.0.63

package/server-loader.js

@@ -43986,6 +43986,199 @@ async function listAllTools(params) {
   return tools;
 }
 
+// src/server/browserToolSchemas.ts
+var BROWSER_TOOL_PREFIX = "docyrus_browser_";
+var BROWSER_TOOL_SCHEMAS = [
+  {
+    name: "docyrus_browser_navigate",
+    description: "Navigate the preview browser to a URL. Use --reload to force reload after navigation.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL to navigate to" },
+        reload: { type: "boolean", description: "Force reload after navigation" }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "docyrus_browser_wait",
+    description: "Wait for a condition before proceeding: network idle, CSS selector appearance, URL pattern match, or fixed delay.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        idle: { type: "boolean", description: "Wait for network idle" },
+        selector: { type: "string", description: "Wait for CSS selector to appear" },
+        url: { type: "string", description: "Wait for URL to match glob pattern" },
+        ms: { type: "number", description: "Wait for fixed milliseconds" },
+        timeout: { type: "number", description: "Maximum wait time in ms (default: 15000)" }
+      }
+    }
+  },
+  {
+    name: "docyrus_browser_snapshot",
+    description: "Get a compact snapshot of interactive page elements with refs (@e1, @e2, ...) for use in click/fill/select. Returns tag, text, type, name, value, placeholder, href for each element.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        all: { type: "boolean", description: "Include all elements, not just interactive ones" },
+        selector: { type: "string", description: "Scope snapshot to a CSS selector subtree" }
+      }
+    }
+  },
+  {
+    name: "docyrus_browser_click",
+    description: "Click an element by snapshot ref (@e1), CSS selector, or x,y coordinates. Coordinate clicks pass through iframes and shadow DOM at the compositor level.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Snapshot ref (@e1), CSS selector, or x coordinate" },
+        x: { type: "number", description: "X coordinate (when using coordinate mode)" },
+        y: { type: "number", description: "Y coordinate (when using coordinate mode)" },
+        timeout: { type: "number", description: "Timeout in ms (default: 5000)" }
+      },
+      required: ["target"]
+    }
+  },
+  {
+    name: "docyrus_browser_fill",
+    description: "Clear and type a value into an input or textarea by snapshot ref or CSS selector.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Snapshot ref (@e1) or CSS selector" },
+        value: { type: "string", description: "Value to type into the element" },
+        timeout: { type: "number", description: "Timeout in ms (default: 5000)" }
+      },
+      required: ["target", "value"]
+    }
+  },
+  {
+    name: "docyrus_browser_select",
+    description: "Select a dropdown option by snapshot ref or CSS selector. Matches by option text or value.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Snapshot ref (@e1) or CSS selector" },
+        value: { type: "string", description: "Option text or value to select" }
+      },
+      required: ["target", "value"]
+    }
+  },
+  {
+    name: "docyrus_browser_eval",
+    description: "Evaluate JavaScript in the preview page and return the result. Supports expressions and multi-statement code with async/await.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: { type: "string", description: "JavaScript code to evaluate" }
+      },
+      required: ["code"]
+    }
+  },
+  {
+    name: "docyrus_browser_screenshot",
+    description: "Capture a screenshot of the preview browser. Returns base64-encoded PNG image.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        full: { type: "boolean", description: "Capture full page instead of just the viewport" }
+      }
+    }
+  },
+  {
+    name: "docyrus_browser_console",
+    description: "Read captured console messages (log, warn, error) from the preview page. Run early in the session to start capturing.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        level: { type: "string", description: "Filter by level: log, warn, error, info, debug" }
+      }
+    }
+  },
+  {
+    name: "docyrus_browser_network",
+    description: "Inspect captured network requests from the preview page. Filter by HTTP method, status code, or URL.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        method: { type: "string", description: "Filter by HTTP method (GET, POST, etc.)" },
+        status: { type: "string", description: "Filter by status code or pattern (200, 4xx, 5xx)" },
+        url: { type: "string", description: "Filter by URL substring" }
+      }
+    }
+  },
+  {
+    name: "docyrus_browser_cookies",
+    description: "List cookies for the preview page, optionally filtered by name or domain.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Filter cookies by exact name" },
+        domain: { type: "string", description: "Filter cookies by domain (substring match)" }
+      }
+    }
+  },
+  {
+    name: "docyrus_browser_content",
+    description: "Extract readable markdown content from the current preview page using Readability.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "docyrus_browser_info",
+    description: "Get current preview page info: URL, title, viewport dimensions, scroll position, page size, and ready state.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "docyrus_browser_devtools",
+    description: "Read @docyrus/devtools runtime diagnostics from the preview page: API errors, usage issues, and console entries.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        subcommand: {
+          type: "string",
+          enum: ["state", "errors", "issues", "console"],
+          description: "What to read: state (full), errors (API errors), issues (usage issues), console (entries)"
+        },
+        level: { type: "string", description: "Filter console entries by level (for console subcommand)" }
+      },
+      required: ["subcommand"]
+    }
+  },
+  {
+    name: "docyrus_browser_open",
+    description: "Open an external website in a new browser window for automation. Returns a webviewId for targeting subsequent commands.",
+    source: "built-in",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL to open in the new browser window" }
+      },
+      required: ["url"]
+    }
+  }
+];
+
 // src/server/sessionConfig.ts
 var import_node_fs12 = require("node:fs");
 var path5 = __toESM(require("node:path"));
@@ -44345,6 +44538,107 @@ function resolveSafePath(cwd, requestPath) {
   }
   return resolved;
 }
+var ALLOWED_UPLOAD_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Text / code
+  ".txt",
+  ".md",
+  ".markdown",
+  ".json",
+  ".jsonl",
+  ".csv",
+  ".tsv",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".log",
+  ".rtf",
+  // Documents
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".odt",
+  ".ods",
+  ".odp",
+  ".pages",
+  ".numbers",
+  ".key",
+  // Images
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".webp",
+  ".svg",
+  ".ico",
+  ".tiff",
+  ".tif",
+  ".heic",
+  ".heif",
+  ".avif",
+  // Audio
+  ".mp3",
+  ".wav",
+  ".ogg",
+  ".flac",
+  ".aac",
+  ".m4a",
+  ".wma",
+  ".opus",
+  // Video
+  ".mp4",
+  ".webm",
+  ".mov",
+  ".avi",
+  ".mkv",
+  ".m4v",
+  ".wmv",
+  // Archives
+  ".zip",
+  ".tar",
+  ".gz",
+  ".7z",
+  ".rar",
+  // Fonts
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot"
+]);
+function sanitizeUploadPath(filePath) {
+  const cleaned = filePath.replace(/[\x00-\x1f\x7f]/g, "");
+  const normalized = cleaned.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+  if (!normalized || normalized === "/") {
+    throw new Error("Invalid upload path");
+  }
+  const ext = normalized.includes(".") ? `.${normalized.split(".").pop().toLowerCase()}` : "";
+  if (!ext || !ALLOWED_UPLOAD_EXTENSIONS.has(ext)) {
+    throw new Error(`File type '${ext || "(none)"}' is not allowed. Allowed: text, images, audio, video, and document files.`);
+  }
+  return normalized;
+}
+async function assertNotSymlink(filePath) {
+  try {
+    const stats = await (0, import_promises18.lstat)(filePath);
+    if (stats.isSymbolicLink()) {
+      throw new Error("Cannot write to symbolic link");
+    }
+  } catch (error48) {
+    if (error48 instanceof Error && "code" in error48 && error48.code === "ENOENT") {
+      return;
+    }
+    throw error48;
+  }
+}
 function globToRegex(pattern) {
   const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*").replace(/\?/g, "[^/]");
   return new RegExp(`^${escaped}$`);
@@ -44425,6 +44719,7 @@ async function walkFiles(params) {
 }
 async function createAgentServer(params) {
   const { port, sessionManager, modelRegistry, authRuntime, context, onCreateSession, onResumeSession, authToken } = params;
+  const extensionUIBridge = params.extensionUIBridge;
   let activeSession = params.session;
   let sessionMode = "normal";
   const pendingAskUserRequests = /* @__PURE__ */ new Map();
@@ -44534,13 +44829,41 @@ async function createAgentServer(params) {
     const encoder = new TextEncoder();
     const stream = new ReadableStream({
       start(controller) {
+        let closed = false;
         function writeChunk(chunk) {
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
+          if (closed) {
+            return;
+          }
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
 
 `));
+          } catch {
+            closed = true;
+          }
+        }
+        function closeController() {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          try {
+            controller.close();
+          } catch {
+          }
         }
         writeChunk({ type: "start" });
         writeChunk({ type: "start-step" });
+        let extensionUICleanup;
+        if (extensionUIBridge) {
+          extensionUIBridge.setRequestHandler((request) => {
+            writeChunk(request);
+          });
+          extensionUICleanup = () => {
+            extensionUIBridge.setRequestHandler(() => {
+            });
+          };
+        }
         const bridge = createEventBridge({
           messageId,
           onChunk: writeChunk,
@@ -44548,15 +44871,17 @@ async function createAgentServer(params) {
             pendingAskUserRequests.set(sessionId, { toolCallId, request });
           },
           onDone: () => {
+            extensionUICleanup?.();
             writeChunk({ type: "finish-step" });
             writeChunk({ type: "finish" });
-            controller.close();
+            closeController();
           },
           onError: (errorText) => {
+            extensionUICleanup?.();
             writeChunk({ type: "error", errorText });
             writeChunk({ type: "finish-step" });
             writeChunk({ type: "finish" });
-            controller.close();
+            closeController();
           }
         });
         const unsubscribe = activeSession.subscribe((event) => {
@@ -44568,17 +44893,19 @@ async function createAgentServer(params) {
         activeSession.prompt(promptText).then(() => {
           if (!activeSession.isStreaming) {
             unsubscribe();
+            extensionUICleanup?.();
             writeChunk({ type: "finish-step" });
             writeChunk({ type: "finish" });
-            controller.close();
+            closeController();
           }
         }).catch((error48) => {
           const errorMessage = error48 instanceof Error ? error48.message : String(error48);
+          extensionUICleanup?.();
           writeChunk({ type: "error", errorText: errorMessage });
           writeChunk({ type: "finish-step" });
           writeChunk({ type: "finish" });
           unsubscribe();
-          controller.close();
+          closeController();
         });
       }
     });
@@ -44723,7 +45050,8 @@ async function createAgentServer(params) {
       agentDir: context.agentDir,
       version: context.version,
       sessionDir: context.sessionDir,
-      thinkingLevel: context.thinkingLevel
+      thinkingLevel: context.thinkingLevel,
+      desktop: context.desktop
     });
   });
   app.get("/api/models", (c) => {
@@ -45412,6 +45740,59 @@ async function createAgentServer(params) {
       return c.json({ error: message }, 400);
     }
   });
+  app.post("/api/fs/upload", async (c) => {
+    const MAX_UPLOAD_SIZE = 50 * 1024 * 1024;
+    const contentLength = parseInt(c.req.header("content-length") || "0", 10);
+    if (contentLength > MAX_UPLOAD_SIZE) {
+      return c.json({ error: `File too large. Maximum upload size is ${MAX_UPLOAD_SIZE / 1024 / 1024} MB` }, 413);
+    }
+    const contentType = c.req.header("content-type") || "";
+    if (contentType.includes("multipart/form-data")) {
+      const formData = await c.req.formData();
+      const file2 = formData.get("file");
+      const targetPath2 = formData.get("path");
+      if (!file2 || !(file2 instanceof File)) {
+        return c.json({ error: "Missing required form field: file" }, 400);
+      }
+      if (file2.size > MAX_UPLOAD_SIZE) {
+        return c.json({ error: `File too large (${(file2.size / 1024 / 1024).toFixed(1)} MB). Maximum is ${MAX_UPLOAD_SIZE / 1024 / 1024} MB` }, 413);
+      }
+      const destPath = typeof targetPath2 === "string" && targetPath2 ? targetPath2 : file2.name;
+      try {
+        const sanitized = sanitizeUploadPath(destPath);
+        const resolved = resolveSafePath(context.cwd, sanitized);
+        await assertNotSymlink(resolved);
+        await (0, import_promises18.mkdir)((0, import_node_path22.join)(resolved, ".."), { recursive: true });
+        const buffer = Buffer.from(await file2.arrayBuffer());
+        await (0, import_promises18.writeFile)(resolved, buffer);
+        const fileStat = await (0, import_promises18.stat)(resolved);
+        return c.json({ ok: true, path: sanitized, name: file2.name, size: fileStat.size, type: file2.type });
+      } catch (error48) {
+        const message = error48 instanceof Error ? error48.message : String(error48);
+        return c.json({ error: message }, 400);
+      }
+    }
+    const targetPath = c.req.query("path") || c.req.header("x-file-path");
+    if (!targetPath) {
+      return c.json({ error: "Missing target path. Use multipart form field 'path', query param 'path', or header 'X-File-Path'" }, 400);
+    }
+    try {
+      const sanitized = sanitizeUploadPath(targetPath);
+      const resolved = resolveSafePath(context.cwd, sanitized);
+      await assertNotSymlink(resolved);
+      await (0, import_promises18.mkdir)((0, import_node_path22.join)(resolved, ".."), { recursive: true });
+      const buffer = Buffer.from(await c.req.arrayBuffer());
+      if (buffer.length > MAX_UPLOAD_SIZE) {
+        return c.json({ error: `File too large (${(buffer.length / 1024 / 1024).toFixed(1)} MB). Maximum is ${MAX_UPLOAD_SIZE / 1024 / 1024} MB` }, 413);
+      }
+      await (0, import_promises18.writeFile)(resolved, buffer);
+      const fileStat = await (0, import_promises18.stat)(resolved);
+      return c.json({ ok: true, path: sanitized, size: fileStat.size });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      return c.json({ error: message }, 400);
+    }
+  });
   app.post("/api/fs/mkdir", async (c) => {
     const body2 = await c.req.json();
     if (!body2.path) {
@@ -46064,6 +46445,20 @@ async function createAgentServer(params) {
       return c.json({ error: message }, 500);
     }
   });
+  app.post("/api/extension-ui-response", async (c) => {
+    if (!extensionUIBridge) {
+      return c.json({ error: "Extension UI bridge not available" }, 404);
+    }
+    const body2 = await c.req.json();
+    if (!body2.id) {
+      return c.json({ error: "Missing required field: id" }, 400);
+    }
+    const handled = extensionUIBridge.handleResponse(body2);
+    if (!handled) {
+      return c.json({ error: `No pending extension UI request for id: ${body2.id}` }, 404);
+    }
+    return c.json({ ok: true });
+  });
   app.get("/api/tools", async (c) => {
     try {
       const tools = await listAllTools({
@@ -46071,11 +46466,15 @@ async function createAgentServer(params) {
         agentDir: context.agentDir,
         cwd: context.cwd
       });
+      if (context.desktop) {
+        tools.push(...BROWSER_TOOL_SCHEMAS);
+      }
       const builtInCount = tools.filter((t) => t.source === "built-in").length;
       const mcpCount = tools.filter((t) => t.source !== "built-in").length;
       return c.json({
         tools,
-        summary: { builtIn: builtInCount, mcp: mcpCount, total: tools.length }
+        summary: { builtIn: builtInCount, mcp: mcpCount, total: tools.length },
+        clientSideToolPrefixes: context.desktop ? [BROWSER_TOOL_PREFIX] : []
       });
     } catch (error48) {
       const message = error48 instanceof Error ? error48.message : String(error48);
@@ -46267,6 +46666,8 @@ async function createAgentServer(params) {
     process.stderr.write(`  GET  /api/fs/read                       \u2014 read file contents
 `);
     process.stderr.write(`  POST /api/fs/write                      \u2014 write file
+`);
+    process.stderr.write(`  POST /api/fs/upload                     \u2014 upload file (multipart or raw)
 `);
     process.stderr.write(`  POST /api/fs/mkdir                      \u2014 create directory
 `);
@@ -46298,6 +46699,12 @@ async function createAgentServer(params) {
 `);
     process.stderr.write(`  GET  /api/tools                         \u2014 list all tools
 `);
+    if (context.desktop) {
+      process.stderr.write(`  POST /api/extension-ui-response          \u2014 submit extension UI response
+`);
+      process.stderr.write(`  Browser tools: docyrus_browser_* (client-side via extension_ui)
+`);
+    }
     process.stderr.write(`  *    /api/cli/**                        \u2014 proxy any docyrus CLI command
 `);
     process.stderr.write(`  WS   /api/terminal                      \u2014 PTY terminal (WebSocket)
@@ -46493,6 +46900,163 @@ function createServerSessionAdapter(params) {
   };
 }
 
+// src/server/extensionUIBridge.ts
+var import_node_crypto7 = require("node:crypto");
+var ExtensionUIBridge = class {
+  pending = /* @__PURE__ */ new Map();
+  requestHandler;
+  defaultTimeout;
+  constructor(options) {
+    this.requestHandler = options.onRequest;
+    this.defaultTimeout = options.defaultTimeout ?? 12e4;
+  }
+  /**
+   * Update the request handler. Used to wire into the active chat stream.
+   */
+  setRequestHandler(handler2) {
+    this.requestHandler = handler2;
+  }
+  /**
+   * Handle an incoming extension_ui_response from the client.
+   * Returns true if the response matched a pending request.
+   */
+  handleResponse(response) {
+    const entry = this.pending.get(response.id);
+    if (!entry) {
+      return false;
+    }
+    if (entry.timer) {
+      clearTimeout(entry.timer);
+    }
+    this.pending.delete(response.id);
+    entry.resolve(response);
+    return true;
+  }
+  /**
+   * Check if there are any pending requests.
+   */
+  hasPending() {
+    return this.pending.size > 0;
+  }
+  /**
+   * Create a dialog promise that sends a request and waits for a response.
+   */
+  createDialogPromise(request, defaultValue, parseResponse, opts) {
+    if (opts?.signal?.aborted) {
+      return Promise.resolve(defaultValue);
+    }
+    const id = (0, import_node_crypto7.randomUUID)();
+    const timeout = opts?.timeout ?? this.defaultTimeout;
+    return new Promise((resolve4, reject) => {
+      const cleanup = () => {
+        if (timer) {
+          clearTimeout(timer);
+        }
+        opts?.signal?.removeEventListener("abort", onAbort);
+        this.pending.delete(id);
+      };
+      const onAbort = () => {
+        cleanup();
+        resolve4(defaultValue);
+      };
+      opts?.signal?.addEventListener("abort", onAbort, { once: true });
+      const timer = timeout > 0 ? setTimeout(() => {
+        cleanup();
+        resolve4(defaultValue);
+      }, timeout) : void 0;
+      this.pending.set(id, {
+        resolve: (response) => {
+          cleanup();
+          resolve4(parseResponse(response));
+        },
+        reject: (error48) => {
+          cleanup();
+          reject(error48);
+        },
+        timer
+      });
+      this.requestHandler({ type: "extension_ui_request", id, ...request });
+    });
+  }
+  /**
+   * Build an ExtensionUIContext compatible with pi agent's extension system.
+   */
+  createUIContext() {
+    return {
+      select: (title, options, opts) => this.createDialogPromise(
+        { method: "select", title, options, timeout: opts?.timeout },
+        void 0,
+        (r) => "cancelled" in r && r.cancelled ? void 0 : r.value,
+        opts
+      ),
+      confirm: (title, message, opts) => this.createDialogPromise(
+        { method: "confirm", title, message, timeout: opts?.timeout },
+        false,
+        (r) => "cancelled" in r && r.cancelled ? false : r.confirmed ?? false,
+        opts
+      ),
+      input: (title, placeholder, opts) => this.createDialogPromise(
+        { method: "input", title, placeholder, timeout: opts?.timeout },
+        void 0,
+        (r) => "cancelled" in r && r.cancelled ? void 0 : r.value,
+        opts
+      ),
+      editor: (title, prefill, opts) => this.createDialogPromise(
+        { method: "editor", title, placeholder: prefill },
+        void 0,
+        (r) => "cancelled" in r && r.cancelled ? void 0 : r.value,
+        opts
+      ),
+      notify: (message, notifyType) => {
+        const id = (0, import_node_crypto7.randomUUID)();
+        this.requestHandler({ type: "extension_ui_request", id, method: "notify", message, placeholder: notifyType });
+      },
+      setStatus: (statusKey, statusText) => {
+        const id = (0, import_node_crypto7.randomUUID)();
+        this.requestHandler({ type: "extension_ui_request", id, method: "setStatus", title: statusKey, message: statusText });
+      },
+      setWidget: (widgetKey, widgetLines) => {
+        const id = (0, import_node_crypto7.randomUUID)();
+        this.requestHandler({ type: "extension_ui_request", id, method: "setWidget", title: widgetKey, options: widgetLines });
+      },
+      setTitle: (title) => {
+        const id = (0, import_node_crypto7.randomUUID)();
+        this.requestHandler({ type: "extension_ui_request", id, method: "setTitle", title });
+      },
+      setEditorText: (text3) => {
+        const id = (0, import_node_crypto7.randomUUID)();
+        this.requestHandler({ type: "extension_ui_request", id, method: "set_editor_text", message: text3 });
+      },
+      // No-op methods for server mode (not applicable without TUI)
+      setWorkingMessage: () => {
+      },
+      setHiddenThinkingLabel: () => {
+      },
+      setFooter: () => {
+      },
+      setHeader: () => {
+      },
+      onTerminalInput: () => () => {
+      },
+      custom: async () => void 0,
+      pasteToEditor: () => {
+      },
+      getEditorText: () => "",
+      setEditorComponent: () => {
+      },
+      get theme() {
+        return { name: "default" };
+      },
+      getAllThemes: () => [],
+      getTheme: () => void 0,
+      setTheme: () => ({ success: false, error: "UI not available in server mode" }),
+      getToolsExpanded: () => false,
+      setToolsExpanded: () => {
+      }
+    };
+  }
+};
+
 // src/services/spinner.ts
 var import_picocolors = __toESM(require_picocolors());
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -46707,8 +47271,17 @@ async function main() {
 `
     );
   }
+  const extensionUIBridge = new ExtensionUIBridge({
+    onRequest: () => {
+    }
+    // Will be wired up by agentServer after the chat stream is created
+  });
+  await session.bindExtensions({
+    uiContext: extensionUIBridge.createUIContext()
+  });
   await createAgentServer({
     session: createServerSessionAdapter({ session, extensionsResult }),
+    extensionUIBridge,
     authToken: request.auth,
     port: request.port,
     sessionManager: {
@@ -46728,7 +47301,8 @@ async function main() {
       agentDir,
       version: version2,
       sessionDir: request.sessionDir ?? null,
-      thinkingLevel: request.thinking ?? null
+      thinkingLevel: request.thinking ?? null,
+      desktop: request.desktop === true
     },
     onCreateSession: async () => {
       const { session: freshSession, extensionsResult: freshExtensionsResult } = await pi.createAgentSession({
@@ -46747,6 +47321,9 @@ async function main() {
         session: freshSession,
         modelRegistry
       });
+      await freshSession.bindExtensions({
+        uiContext: extensionUIBridge.createUIContext()
+      });
       return createServerSessionAdapter({
         session: freshSession,
         extensionsResult: freshExtensionsResult
@@ -46779,6 +47356,9 @@ async function main() {
         session: resumedSession,
         modelRegistry
       });
+      await resumedSession.bindExtensions({
+        uiContext: extensionUIBridge.createUIContext()
+      });
       return createServerSessionAdapter({
         session: resumedSession,
         extensionsResult: resumedExtensionsResult