local-operator-ui 0.20.1 → 0.21.1

package/out/main/index.js

@@ -6,11 +6,11 @@ const utils = require("@electron-toolkit/utils");
 const electron = require("electron");
 const posthogNode = require("posthog-node");
 const path = require("path");
+const zod = require("zod");
 const node_child_process = require("node:child_process");
 const node_crypto = require("node:crypto");
 const os = require("node:os");
 const node_util = require("node:util");
-const zod = require("zod");
 const dotenv = require("dotenv");
 const electronLog = require("electron-log");
 const https = require("node:https");
@@ -35,291 +35,6 @@ const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path$1);
 const https__namespace = /* @__PURE__ */ _interopNamespaceDefault(https);
 const icon = path.join(__dirname, "../../resources/icon.png");
 const id$1 = zod.z.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/);
-const MAX_UPLOAD_BYTES = 16 * 1024 * 1024;
-const MAX_DOWNLOAD_BYTES = 32 * 1024 * 1024;
-const mediaRequestSchema = zod.z.discriminatedUnion("op", [
-  zod.z.object({
-    op: zod.z.literal("speech.create"),
-    request: zod.z.record(zod.z.unknown())
-  }).strict(),
-  zod.z.object({
-    op: zod.z.literal("speech.agent"),
-    agentId: id$1,
-    request: zod.z.record(zod.z.unknown())
-  }).strict(),
-  zod.z.object({
-    op: zod.z.literal("transcription.create"),
-    fileName: zod.z.string().min(1).max(255),
-    mimeType: zod.z.string().min(1).max(128),
-    fields: zod.z.record(zod.z.string().max(4096))
-  }).strict(),
-  zod.z.object({
-    op: zod.z.literal("agent.import"),
-    fileName: zod.z.string().min(1).max(255)
-  }).strict(),
-  // Export is a gated GET that answers with a ZIP, so it belongs on this relay
-  // rather than the JSON transport: `desktopEndpoint`'s envelope has nowhere to
-  // put binary. It is the only read here, which is why `endpoint()` below
-  // returns a method instead of assuming POST.
-  zod.z.object({ op: zod.z.literal("agent.export"), agentId: id$1 }).strict(),
-  // A durable transcript row references an image by content digest with the
-  // payload stripped, so rendering a screenshot after a reload means fetching
-  // bytes. That cannot go through the JSON transport (its envelope has nowhere
-  // to put them), which is what puts it on this relay.
-  //
-  // Both identifiers are shape-constrained here as well as by the backend
-  // route: this file's whole premise is that renderer code cannot pick a URL,
-  // and a digest that reaches `endpoint()` unvalidated is renderer-controlled
-  // path text.
-  zod.z.object({
-    op: zod.z.literal("sessions.attachment"),
-    sessionId: zod.z.string().regex(/^[a-f0-9]{12}$/),
-    digest: zod.z.string().regex(/^[a-f0-9]{32}$/)
-  }).strict()
-]);
-function endpoint(request) {
-  switch (request.op) {
-    case "speech.create":
-      return { path: "/v1/tools/speech", method: "POST" };
-    case "speech.agent":
-      return { path: `/v1/agents/${request.agentId}/speech`, method: "POST" };
-    case "transcription.create":
-      return { path: "/v1/transcriptions", method: "POST" };
-    case "agent.import":
-      return { path: "/v1/agents/import", method: "POST" };
-    case "agent.export":
-      return { path: `/v1/agents/${request.agentId}/export`, method: "GET" };
-    case "sessions.attachment":
-      return {
-        path: `/v1/desktop/sessions/${request.sessionId}/attachments/${request.digest}`,
-        method: "GET"
-      };
-  }
-}
-async function requestDesktopMedia(input, bytes, backendUrl, token) {
-  const parsed = mediaRequestSchema.safeParse(input);
-  if (!parsed.success) {
-    return { status: 422, kind: "error", detail: "Invalid media operation." };
-  }
-  if (!token) {
-    return {
-      status: 503,
-      kind: "error",
-      detail: "Restart with a desktop-managed backend to use these controls."
-    };
-  }
-  const request = parsed.data;
-  if (bytes && bytes.byteLength > MAX_UPLOAD_BYTES) {
-    return { status: 413, kind: "error", detail: "This file is too large." };
-  }
-  const target2 = endpoint(request);
-  let body;
-  let contentType;
-  if (request.op === "agent.export" || request.op === "sessions.attachment") {
-    body = void 0;
-  } else if (request.op === "speech.create" || request.op === "speech.agent") {
-    body = JSON.stringify(request.request);
-    contentType = "application/json";
-  } else {
-    if (!bytes) {
-      return { status: 422, kind: "error", detail: "A file is required." };
-    }
-    const form = new FormData();
-    const blob = new Blob([bytes], {
-      type: request.op === "transcription.create" ? request.mimeType : "application/zip"
-    });
-    form.append("file", blob, request.fileName);
-    if (request.op === "transcription.create") {
-      for (const [key, value] of Object.entries(request.fields)) {
-        form.append(key, value);
-      }
-    }
-    body = form;
-  }
-  try {
-    const response = await fetch(new URL(target2.path, backendUrl), {
-      method: target2.method,
-      headers: {
-        Accept: "application/json, audio/*, image/*, application/octet-stream",
-        ...contentType ? { "Content-Type": contentType } : {},
-        Authorization: `Bearer ${token}`
-      },
-      body,
-      redirect: "error",
-      signal: AbortSignal.timeout(12e4)
-    });
-    const responseType = response.headers.get("content-type") ?? "";
-    if (!response.ok) {
-      let detail = "The media request failed.";
-      if (responseType.includes("application/json")) {
-        try {
-          const parsedError = await response.json();
-          const text = parsedError.detail ?? parsedError.message;
-          if (typeof text === "string") detail = text.slice(0, 512);
-        } catch {
-        }
-      }
-      return { status: response.status, kind: "error", detail };
-    }
-    if (responseType.includes("application/json")) {
-      return {
-        status: response.status,
-        kind: "json",
-        body: await response.json()
-      };
-    }
-    const buffer = new Uint8Array(await response.arrayBuffer());
-    if (buffer.byteLength > MAX_DOWNLOAD_BYTES) {
-      return {
-        status: 502,
-        kind: "error",
-        detail: "The backend returned too much data."
-      };
-    }
-    return {
-      status: response.status,
-      kind: "bytes",
-      mimeType: responseType || "application/octet-stream",
-      data: buffer
-    };
-  } catch {
-    return {
-      status: 503,
-      kind: "error",
-      detail: "The backend could not complete this request. Check its connection and try again."
-    };
-  }
-}
-const SESSION_ID = /^[a-f0-9]{12}$/;
-const SAFE_ID = /^[a-zA-Z0-9_-]{1,128}$/;
-const MAX_FRAME_BYTES = 8 * 1024 * 1024;
-class DesktopStreamRelay {
-  constructor(backendUrl, token) {
-    this.backendUrl = backendUrl;
-    this.token = token;
-  }
-  streams = /* @__PURE__ */ new Map();
-  /** Frame observer for main-owned side effects (notifications). It sees
-   * every parsed frame before the renderer does, on the same subscription. */
-  observer = null;
-  observe(observer) {
-    this.observer = observer;
-  }
-  /** True when this relay can authenticate; a false answer is why the UI
-   * shows the pairing/setup state rather than a dead transcript. */
-  get available() {
-    return Boolean(this.token);
-  }
-  subscribe(args, emit) {
-    if (!SESSION_ID.test(args.sessionId)) {
-      throw new Error("Invalid session for streaming.");
-    }
-    if (args.epoch !== void 0 && !SAFE_ID.test(args.epoch)) {
-      throw new Error("Invalid stream epoch.");
-    }
-    if (args.afterSeq !== void 0 && (!Number.isInteger(args.afterSeq) || args.afterSeq < 0)) {
-      throw new Error("Invalid stream cursor.");
-    }
-    if (!this.token) {
-      throw new Error("This backend was not started with desktop controls.");
-    }
-    const streamId = node_crypto.randomBytes(16).toString("hex");
-    const controller = new AbortController();
-    this.streams.set(streamId, controller);
-    const query = new URLSearchParams();
-    if (args.epoch) query.set("epoch", args.epoch);
-    if (args.afterSeq !== void 0)
-      query.set("after_seq", String(args.afterSeq));
-    const suffix = query.size > 0 ? `?${query}` : "";
-    const url = new URL(
-      `/v1/desktop/sessions/${args.sessionId}/events${suffix}`,
-      this.backendUrl
-    );
-    void this.pump(
-      streamId,
-      args.sessionId,
-      url,
-      controller.signal,
-      emit
-    ).finally(() => {
-      this.streams.delete(streamId);
-    });
-    return { streamId };
-  }
-  async pump(streamId, sessionId2, url, signal, emit) {
-    try {
-      const response = await fetch(url, {
-        headers: {
-          Accept: "text/event-stream",
-          Authorization: `Bearer ${this.token}`
-        },
-        redirect: "error",
-        signal
-      });
-      if (!response.ok || !response.body) {
-        emit({
-          streamId,
-          kind: "error",
-          detail: `The event stream was refused (${response.status}).`
-        });
-        return;
-      }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        for (; ; ) {
-          const boundary = buffer.indexOf("\n\n");
-          if (boundary < 0) {
-            if (buffer.length > MAX_FRAME_BYTES) {
-              emit({
-                streamId,
-                kind: "error",
-                detail: "The event stream exceeded its frame budget."
-              });
-              reader.cancel().catch(() => void 0);
-              return;
-            }
-            break;
-          }
-          const record = buffer.slice(0, boundary);
-          buffer = buffer.slice(boundary + 2);
-          for (const line of record.split("\n")) {
-            if (line.startsWith("data:")) {
-              const data = line.slice(5).replace(/^ /, "");
-              this.observer?.(sessionId2, data);
-              emit({ streamId, kind: "data", data });
-            }
-          }
-        }
-      }
-      emit({ streamId, kind: "end" });
-    } catch (error) {
-      if (signal.aborted) {
-        emit({ streamId, kind: "end" });
-        return;
-      }
-      emit({
-        streamId,
-        kind: "error",
-        detail: error instanceof Error && error.name === "AbortError" ? "The event stream ended." : "The event stream connection failed."
-      });
-    }
-  }
-  unsubscribe(streamId) {
-    if (!/^[a-f0-9]{32}$/.test(streamId)) return;
-    this.streams.get(streamId)?.abort();
-    this.streams.delete(streamId);
-  }
-  dispose() {
-    for (const controller of this.streams.values()) controller.abort();
-    this.streams.clear();
-  }
-}
-const id = zod.z.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/);
 const settingKey = zod.z.string().min(1).max(256).regex(/^[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/);
 const secret = zod.z.string().min(1).max(32768);
 const sessionId = zod.z.string().regex(/^[a-f0-9]{12}$/);
@@ -418,11 +133,37 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
     cwd: zod.z.string().min(1).max(4096),
     target: target.optional()
   }).strict(),
+  /*
+   * What a NEW conversation's readings would be, without creating anything.
+   *
+   * The composer's status strip needs a model, an effort ladder and a window
+   * BEFORE a session exists, and every honest way to get them was rejected: a
+   * `sessions.create` on pane open writes a directory and a marker, so every
+   * abandoned new-chat pane would leave a visible empty row in the sidebar,
+   * and composing it in the renderer from `config.get` + `models.catalogue`
+   * moves model RESOLUTION (Python policy) into the app and reports nothing
+   * when the pair is absent from the catalogue. This op runs the backend's own
+   * cold resolution and returns the same canonical projection a cold session
+   * publishes, so the strip keeps one arithmetic path and the draft cannot
+   * disagree with the session the first send creates.
+   *
+   * Body and response mirror `sessions.create` deliberately: same `cwd`, same
+   * optional `target`, same 422 for an unresolvable profile. The response is a
+   * `CanonicalFrontendSync` — the wire shape `sessions.watch` streams — whose
+   * `snapshot.session_id` is EMPTY, because there is no session. The renderer
+   * passes it to the strip and never into the canonical sessions store.
+   */
+  zod.z.object({
+    op: zod.z.literal("sessions.preview"),
+    requestId,
+    cwd: zod.z.string().min(1).max(4096),
+    target: target.optional()
+  }).strict(),
   zod.z.object({ op: zod.z.literal("sessions.get"), sessionId }).strict(),
   zod.z.object({
     op: zod.z.literal("sessions.history"),
     sessionId,
-    beforeId: id.optional(),
+    beforeId: id$1.optional(),
     limit: zod.z.number().int().min(1).max(500).optional()
   }).strict(),
   zod.z.object({
@@ -444,8 +185,8 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
   zod.z.object({
     op: zod.z.literal("sessions.answer"),
     sessionId,
-    epoch: id,
-    requestId: id,
+    epoch: id$1,
+    requestId: id$1,
     value: zod.z.string().max(32768).optional(),
     approved: zod.z.boolean().optional(),
     questionIndex: zod.z.number().int().min(0).optional()
@@ -494,8 +235,8 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
   zod.z.object({ op: zod.z.literal("legacy.models.providers") }).strict(),
   // Reachability is checked only when the user asks for it: a probe is a real
   // network round trip, and nothing behind first paint may make one.
-  zod.z.object({ op: zod.z.literal("auth.probe"), provider: id }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.agent.upload"), agentId: id }).strict(),
+  zod.z.object({ op: zod.z.literal("auth.probe"), provider: id$1 }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.agent.upload"), agentId: id$1 }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agents.list"),
     page: zod.z.number().int().min(1).optional(),
@@ -504,19 +245,19 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
     sort: zod.z.string().max(64).optional(),
     direction: zod.z.enum(["asc", "desc"]).optional()
   }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.agent.get"), agentId: id }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.agent.get"), agentId: id$1 }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agent.history"),
-    agentId: id,
+    agentId: id$1,
     page: zod.z.number().int().min(1).optional(),
     perPage: zod.z.number().int().min(1).max(500).optional()
   }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.jobs.list"),
-    agentId: id.optional(),
+    agentId: id$1.optional(),
     status: zod.z.string().max(64).optional()
   }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.job.get"), jobId: id }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.job.get"), jobId: id$1 }).strict(),
   // The schedules surface. Gated in managed mode not because a schedule is
   // sensitive to READ but because both writes hand their `prompt` to the
   // scheduler, which later runs it as the user's own agent -- so a bare
@@ -528,13 +269,13 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
   }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agent.schedules.list"),
-    agentId: id,
+    agentId: id$1,
     page: zod.z.number().int().min(1).optional(),
     perPage: zod.z.number().int().min(1).max(100).optional()
   }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agent.schedule.create"),
-    agentId: id,
+    agentId: id$1,
     // Passed through as the request body. Declared field-by-field rather
     // than as a passthrough object so the renderer cannot smuggle keys the
     // backend model would silently accept.
@@ -544,10 +285,10 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
       unit: scheduleUnit
     })
   }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.schedule.get"), scheduleId: id }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.schedule.get"), scheduleId: id$1 }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.schedule.edit"),
-    scheduleId: id,
+    scheduleId: id$1,
     // Every field optional: the backend applies `exclude_unset`, so sending
     // a key the user did not touch would overwrite it with a default.
     schedule: scheduleWrite.extend({
@@ -556,7 +297,7 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
       unit: scheduleUnit.nullish()
     })
   }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.schedule.remove"), scheduleId: id }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.schedule.remove"), scheduleId: id$1 }).strict(),
   // The remaining gated legacy writes and reads the renderer still issued as
   // bare same-origin `fetch`. `apiConfig.baseUrl` points AT THE BACKEND, not
   // through the main-process relay, so in managed mode these went out with no
@@ -572,52 +313,52 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
   }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agent.update"),
-    agentId: id,
+    agentId: id$1,
     update: zod.z.record(zod.z.unknown())
   }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.agent.delete"), agentId: id }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.agent.conversation.clear"), agentId: id }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.agent.systemPrompt.get"), agentId: id }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.agent.delete"), agentId: id$1 }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.agent.conversation.clear"), agentId: id$1 }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.agent.systemPrompt.get"), agentId: id$1 }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agent.systemPrompt.update"),
-    agentId: id,
+    agentId: id$1,
     systemPrompt: zod.z.string().max(DESKTOP_SYSTEM_PROMPT_MAX_CHARS)
   }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.agent.download"), agentId: id }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.agent.variables.list"), agentId: id }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.agent.download"), agentId: id$1 }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.agent.variables.list"), agentId: id$1 }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agent.variables.create"),
-    agentId: id,
+    agentId: id$1,
     variable: zod.z.record(zod.z.unknown())
   }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agent.variables.get"),
-    agentId: id,
+    agentId: id$1,
     key: variableKey
   }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agent.variables.update"),
-    agentId: id,
+    agentId: id$1,
     key: variableKey,
     variable: zod.z.record(zod.z.unknown())
   }).strict(),
   zod.z.object({
     op: zod.z.literal("legacy.agent.variables.delete"),
-    agentId: id,
+    agentId: id$1,
     key: variableKey
   }).strict(),
-  zod.z.object({ op: zod.z.literal("legacy.job.cancel"), jobId: id }).strict(),
+  zod.z.object({ op: zod.z.literal("legacy.job.cancel"), jobId: id$1 }).strict(),
   zod.z.object({ op: zod.z.literal("commands.list") }).strict(),
   zod.z.object({
     op: zod.z.literal("commands.entities"),
     sessionId,
-    command: id,
+    command: id$1,
     name: zod.z.string().max(128).optional()
   }).strict(),
   zod.z.object({ op: zod.z.literal("models.catalogue"), live: zod.z.boolean().optional() }).strict(),
   zod.z.object({
     op: zod.z.literal("usage.get"),
-    provider: id.optional(),
+    provider: id$1.optional(),
     live: zod.z.boolean().optional(),
     refresh: zod.z.boolean().optional()
   }).strict(),
@@ -628,7 +369,7 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
     untilMs: zod.z.number().int().nonnegative().optional(),
     days: zod.z.number().int().min(1).max(366).optional()
   }).strict(),
-  zod.z.object({ op: zod.z.literal("skills.list"), sessionId, name: id.optional() }).strict(),
+  zod.z.object({ op: zod.z.literal("skills.list"), sessionId, name: id$1.optional() }).strict(),
   zod.z.object({ op: zod.z.literal("sessions.failovers"), sessionId }).strict(),
   zod.z.object({
     op: zod.z.literal("sessions.credential"),
@@ -737,10 +478,10 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
         "account.agents"
       ]),
       request_id: requestId.optional(),
-      tenant_id: id.optional(),
-      account_id: id.optional(),
-      agent_id: id.optional(),
-      comment_id: id.optional(),
+      tenant_id: id$1.optional(),
+      account_id: id$1.optional(),
+      agent_id: id$1.optional(),
+      comment_id: id$1.optional(),
       query: zod.z.record(zod.z.union([zod.z.string().max(1024), zod.z.number().int()])).optional(),
       payload: zod.z.record(zod.z.unknown()).optional(),
       confirmed: zod.z.boolean().optional()
@@ -753,12 +494,12 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
     accountId: zod.z.number().int().positive(),
     confirmed: zod.z.literal(true)
   }).strict(),
-  zod.z.object({ op: zod.z.literal("auth.start"), provider: id }).strict(),
-  zod.z.object({ op: zod.z.literal("auth.status"), id }).strict(),
-  zod.z.object({ op: zod.z.literal("auth.input"), id, promptId: id, value: secret }).strict(),
-  zod.z.object({ op: zod.z.literal("auth.cancel"), id }).strict(),
-  zod.z.object({ op: zod.z.literal("auth.key"), provider: id, value: secret }).strict(),
-  zod.z.object({ op: zod.z.literal("auth.logout"), provider: id }).strict(),
+  zod.z.object({ op: zod.z.literal("auth.start"), provider: id$1 }).strict(),
+  zod.z.object({ op: zod.z.literal("auth.status"), id: id$1 }).strict(),
+  zod.z.object({ op: zod.z.literal("auth.input"), id: id$1, promptId: id$1, value: secret }).strict(),
+  zod.z.object({ op: zod.z.literal("auth.cancel"), id: id$1 }).strict(),
+  zod.z.object({ op: zod.z.literal("auth.key"), provider: id$1, value: secret }).strict(),
+  zod.z.object({ op: zod.z.literal("auth.logout"), provider: id$1 }).strict(),
   zod.z.object({ op: zod.z.literal("settings.list") }).strict(),
   zod.z.object({
     op: zod.z.literal("settings.edit"),
@@ -876,6 +617,16 @@ function desktopEndpoint(request) {
           ...request.target ? { target: request.target } : {}
         }
       };
+    case "sessions.preview":
+      return {
+        path: "/v1/desktop/sessions/preview",
+        method: "POST",
+        body: {
+          request_id: request.requestId,
+          cwd: request.cwd,
+          ...request.target ? { target: request.target } : {}
+        }
+      };
     case "sessions.get":
       return {
         path: `/v1/desktop/sessions/${request.sessionId}`,
@@ -1262,18 +1013,305 @@ function desktopEndpoint(request) {
       return { path: "/v1/config/system-prompt", method: "GET" };
     case "instructions.update":
       return {
-        path: "/v1/config/system-prompt",
-        method: "PATCH",
-        body: { content: request.content }
+        path: "/v1/config/system-prompt",
+        method: "PATCH",
+        body: { content: request.content }
+      };
+    case "credentials.list":
+      return { path: "/v1/credentials", method: "GET" };
+    case "credentials.update":
+      return {
+        path: "/v1/credentials",
+        method: "PATCH",
+        body: { key: request.key, value: request.value }
+      };
+  }
+}
+const MAX_PROBE_PATHS = 64;
+const MAX_FILE_READ_BYTES = 64 * 1024 * 1024;
+const id = zod.z.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/);
+const MAX_UPLOAD_BYTES = 16 * 1024 * 1024;
+const MAX_DOWNLOAD_BYTES = 32 * 1024 * 1024;
+const mediaRequestSchema = zod.z.discriminatedUnion("op", [
+  zod.z.object({
+    op: zod.z.literal("speech.create"),
+    request: zod.z.record(zod.z.unknown())
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("speech.agent"),
+    agentId: id,
+    request: zod.z.record(zod.z.unknown())
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("transcription.create"),
+    fileName: zod.z.string().min(1).max(255),
+    mimeType: zod.z.string().min(1).max(128),
+    fields: zod.z.record(zod.z.string().max(4096))
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("agent.import"),
+    fileName: zod.z.string().min(1).max(255)
+  }).strict(),
+  // Export is a gated GET that answers with a ZIP, so it belongs on this relay
+  // rather than the JSON transport: `desktopEndpoint`'s envelope has nowhere to
+  // put binary. It is the only read here, which is why `endpoint()` below
+  // returns a method instead of assuming POST.
+  zod.z.object({ op: zod.z.literal("agent.export"), agentId: id }).strict(),
+  // A durable transcript row references an image by content digest with the
+  // payload stripped, so rendering a screenshot after a reload means fetching
+  // bytes. That cannot go through the JSON transport (its envelope has nowhere
+  // to put them), which is what puts it on this relay.
+  //
+  // Both identifiers are shape-constrained here as well as by the backend
+  // route: this file's whole premise is that renderer code cannot pick a URL,
+  // and a digest that reaches `endpoint()` unvalidated is renderer-controlled
+  // path text.
+  zod.z.object({
+    op: zod.z.literal("sessions.attachment"),
+    sessionId: zod.z.string().regex(/^[a-f0-9]{12}$/),
+    digest: zod.z.string().regex(/^[a-f0-9]{32}$/)
+  }).strict()
+]);
+function endpoint(request) {
+  switch (request.op) {
+    case "speech.create":
+      return { path: "/v1/tools/speech", method: "POST" };
+    case "speech.agent":
+      return { path: `/v1/agents/${request.agentId}/speech`, method: "POST" };
+    case "transcription.create":
+      return { path: "/v1/transcriptions", method: "POST" };
+    case "agent.import":
+      return { path: "/v1/agents/import", method: "POST" };
+    case "agent.export":
+      return { path: `/v1/agents/${request.agentId}/export`, method: "GET" };
+    case "sessions.attachment":
+      return {
+        path: `/v1/desktop/sessions/${request.sessionId}/attachments/${request.digest}`,
+        method: "GET"
+      };
+  }
+}
+async function requestDesktopMedia(input, bytes, backendUrl, token) {
+  const parsed = mediaRequestSchema.safeParse(input);
+  if (!parsed.success) {
+    return { status: 422, kind: "error", detail: "Invalid media operation." };
+  }
+  if (!token) {
+    return {
+      status: 503,
+      kind: "error",
+      detail: "Restart with a desktop-managed backend to use these controls."
+    };
+  }
+  const request = parsed.data;
+  if (bytes && bytes.byteLength > MAX_UPLOAD_BYTES) {
+    return { status: 413, kind: "error", detail: "This file is too large." };
+  }
+  const target2 = endpoint(request);
+  let body;
+  let contentType;
+  if (request.op === "agent.export" || request.op === "sessions.attachment") {
+    body = void 0;
+  } else if (request.op === "speech.create" || request.op === "speech.agent") {
+    body = JSON.stringify(request.request);
+    contentType = "application/json";
+  } else {
+    if (!bytes) {
+      return { status: 422, kind: "error", detail: "A file is required." };
+    }
+    const form = new FormData();
+    const blob = new Blob([bytes], {
+      type: request.op === "transcription.create" ? request.mimeType : "application/zip"
+    });
+    form.append("file", blob, request.fileName);
+    if (request.op === "transcription.create") {
+      for (const [key, value] of Object.entries(request.fields)) {
+        form.append(key, value);
+      }
+    }
+    body = form;
+  }
+  try {
+    const response = await fetch(new URL(target2.path, backendUrl), {
+      method: target2.method,
+      headers: {
+        Accept: "application/json, audio/*, image/*, application/octet-stream",
+        ...contentType ? { "Content-Type": contentType } : {},
+        Authorization: `Bearer ${token}`
+      },
+      body,
+      redirect: "error",
+      signal: AbortSignal.timeout(12e4)
+    });
+    const responseType = response.headers.get("content-type") ?? "";
+    if (!response.ok) {
+      let detail = "The media request failed.";
+      if (responseType.includes("application/json")) {
+        try {
+          const parsedError = await response.json();
+          const text = parsedError.detail ?? parsedError.message;
+          if (typeof text === "string") detail = text.slice(0, 512);
+        } catch {
+        }
+      }
+      return { status: response.status, kind: "error", detail };
+    }
+    if (responseType.includes("application/json")) {
+      return {
+        status: response.status,
+        kind: "json",
+        body: await response.json()
       };
-    case "credentials.list":
-      return { path: "/v1/credentials", method: "GET" };
-    case "credentials.update":
+    }
+    const buffer = new Uint8Array(await response.arrayBuffer());
+    if (buffer.byteLength > MAX_DOWNLOAD_BYTES) {
       return {
-        path: "/v1/credentials",
-        method: "PATCH",
-        body: { key: request.key, value: request.value }
+        status: 502,
+        kind: "error",
+        detail: "The backend returned too much data."
       };
+    }
+    return {
+      status: response.status,
+      kind: "bytes",
+      mimeType: responseType || "application/octet-stream",
+      data: buffer
+    };
+  } catch {
+    return {
+      status: 503,
+      kind: "error",
+      detail: "The backend could not complete this request. Check its connection and try again."
+    };
+  }
+}
+const SESSION_ID = /^[a-f0-9]{12}$/;
+const SAFE_ID = /^[a-zA-Z0-9_-]{1,128}$/;
+const MAX_FRAME_BYTES = 8 * 1024 * 1024;
+class DesktopStreamRelay {
+  constructor(backendUrl, token) {
+    this.backendUrl = backendUrl;
+    this.token = token;
+  }
+  streams = /* @__PURE__ */ new Map();
+  /** Frame observer for main-owned side effects (notifications). It sees
+   * every parsed frame before the renderer does, on the same subscription. */
+  observer = null;
+  observe(observer) {
+    this.observer = observer;
+  }
+  /** True when this relay can authenticate; a false answer is why the UI
+   * shows the pairing/setup state rather than a dead transcript. */
+  get available() {
+    return Boolean(this.token);
+  }
+  subscribe(args, emit) {
+    if (!SESSION_ID.test(args.sessionId)) {
+      throw new Error("Invalid session for streaming.");
+    }
+    if (args.epoch !== void 0 && !SAFE_ID.test(args.epoch)) {
+      throw new Error("Invalid stream epoch.");
+    }
+    if (args.afterSeq !== void 0 && (!Number.isInteger(args.afterSeq) || args.afterSeq < 0)) {
+      throw new Error("Invalid stream cursor.");
+    }
+    if (!this.token) {
+      throw new Error("This backend was not started with desktop controls.");
+    }
+    const streamId = node_crypto.randomBytes(16).toString("hex");
+    const controller = new AbortController();
+    this.streams.set(streamId, controller);
+    const query = new URLSearchParams();
+    if (args.epoch) query.set("epoch", args.epoch);
+    if (args.afterSeq !== void 0)
+      query.set("after_seq", String(args.afterSeq));
+    const suffix = query.size > 0 ? `?${query}` : "";
+    const url = new URL(
+      `/v1/desktop/sessions/${args.sessionId}/events${suffix}`,
+      this.backendUrl
+    );
+    void this.pump(
+      streamId,
+      args.sessionId,
+      url,
+      controller.signal,
+      emit
+    ).finally(() => {
+      this.streams.delete(streamId);
+    });
+    return { streamId };
+  }
+  async pump(streamId, sessionId2, url, signal, emit) {
+    try {
+      const response = await fetch(url, {
+        headers: {
+          Accept: "text/event-stream",
+          Authorization: `Bearer ${this.token}`
+        },
+        redirect: "error",
+        signal
+      });
+      if (!response.ok || !response.body) {
+        emit({
+          streamId,
+          kind: "error",
+          detail: `The event stream was refused (${response.status}).`
+        });
+        return;
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        for (; ; ) {
+          const boundary = buffer.indexOf("\n\n");
+          if (boundary < 0) {
+            if (buffer.length > MAX_FRAME_BYTES) {
+              emit({
+                streamId,
+                kind: "error",
+                detail: "The event stream exceeded its frame budget."
+              });
+              reader.cancel().catch(() => void 0);
+              return;
+            }
+            break;
+          }
+          const record = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          for (const line of record.split("\n")) {
+            if (line.startsWith("data:")) {
+              const data = line.slice(5).replace(/^ /, "");
+              this.observer?.(sessionId2, data);
+              emit({ streamId, kind: "data", data });
+            }
+          }
+        }
+      }
+      emit({ streamId, kind: "end" });
+    } catch (error) {
+      if (signal.aborted) {
+        emit({ streamId, kind: "end" });
+        return;
+      }
+      emit({
+        streamId,
+        kind: "error",
+        detail: error instanceof Error && error.name === "AbortError" ? "The event stream ended." : "The event stream connection failed."
+      });
+    }
+  }
+  unsubscribe(streamId) {
+    if (!/^[a-f0-9]{32}$/.test(streamId)) return;
+    this.streams.get(streamId)?.abort();
+    this.streams.delete(streamId);
+  }
+  dispose() {
+    for (const controller of this.streams.values()) controller.abort();
+    this.streams.clear();
   }
 }
 async function requestDesktop(input, backendUrl, token) {
@@ -7492,6 +7530,14 @@ function describeWindowLaunch(plan) {
   return `window mode ${plan.mode}: ${plan.width}x${plan.height}, ${behaviour}, page throttling ${plan.backgroundThrottling ? "on" : "off"}`;
 }
 const BASE64_FILE_EXTENSIONS = ["csv", "tsv", "xls", "xlsx", "ods"];
+const resolveUserPath = (filePath, cwd) => {
+  if (filePath === "~") return electron.app.getPath("home");
+  if (filePath.startsWith("~/"))
+    return path$1.join(electron.app.getPath("home"), filePath.slice(2));
+  if (cwd && !filePath.startsWith("/"))
+    return path$1.join(cwd.startsWith("~/") ? resolveUserPath(cwd) : cwd, filePath);
+  return filePath;
+};
 electron.app.setName("Local Operator");
 const image = electron.nativeImage.createFromPath(icon);
 if (process.platform === "darwin" && electron.app.dock) {
@@ -7856,8 +7902,7 @@ electron.app.whenReady().then(async () => {
     "read-file",
     async (_, filePath, encoding = "utf-8") => {
       try {
-        const normalizedPath = filePath.startsWith("~/") ? path$1.join(electron.app.getPath("home"), filePath.slice(2)) : filePath;
-        const data = fs.readFileSync(normalizedPath, encoding);
+        const data = fs.readFileSync(resolveUserPath(filePath), encoding);
         return { success: true, data };
       } catch (error) {
         logger.error("Error reading file:", LogFileType.BACKEND, error);
@@ -7865,6 +7910,82 @@ electron.app.whenReady().then(async () => {
       }
     }
   );
+  electron.ipcMain.handle(
+    "probe-files",
+    async (_, paths, cwd) => {
+      const asked = Array.isArray(paths) ? paths.filter((path2) => typeof path2 === "string") : [];
+      return asked.slice(0, MAX_PROBE_PATHS).map((input) => {
+        let resolved = input;
+        try {
+          resolved = resolveUserPath(input, cwd);
+          const stat = fs.statSync(resolved, { throwIfNoEntry: false });
+          return {
+            input,
+            resolved,
+            exists: stat !== void 0,
+            isFile: stat?.isFile() ?? false,
+            sizeBytes: stat?.isFile() ? stat.size : null,
+            mtimeMs: stat?.isFile() ? stat.mtimeMs : null
+          };
+        } catch (error) {
+          return {
+            input,
+            resolved,
+            exists: false,
+            isFile: false,
+            sizeBytes: null,
+            mtimeMs: null,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      });
+    }
+  );
+  electron.ipcMain.handle(
+    "read-file-bytes",
+    async (_, filePath, maxBytes = MAX_FILE_READ_BYTES) => {
+      const cap = Number.isFinite(maxBytes) && maxBytes > 0 ? Math.min(maxBytes, MAX_FILE_READ_BYTES) : MAX_FILE_READ_BYTES;
+      try {
+        const resolved = resolveUserPath(filePath);
+        const stat = fs.statSync(resolved, { throwIfNoEntry: false });
+        if (!stat) {
+          return {
+            success: false,
+            code: "not-found",
+            error: `No file at ${resolved}`
+          };
+        }
+        if (!stat.isFile()) {
+          return {
+            success: false,
+            code: "not-a-file",
+            error: `${resolved} is not a regular file`
+          };
+        }
+        if (stat.size > cap) {
+          return {
+            success: false,
+            code: "too-large",
+            error: `${resolved} is ${stat.size} bytes, over the ${cap}-byte preview cap`,
+            sizeBytes: stat.size
+          };
+        }
+        const buffer = fs.readFileSync(resolved);
+        return {
+          success: true,
+          data: new Uint8Array(buffer),
+          sizeBytes: buffer.byteLength
+        };
+      } catch (error) {
+        logger.error("Error reading file bytes:", LogFileType.BACKEND, error);
+        return {
+          success: false,
+          code: "unreadable",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+  );
   electron.ipcMain.handle("open-external", async (_, url) => {
     try {
       await electron.shell.openExternal(url);
@@ -7883,8 +8004,7 @@ electron.app.whenReady().then(async () => {
     "save-file",
     async (_, filePath, content, encoding = "utf-8") => {
       try {
-        const normalizedPath = filePath.startsWith("~/") ? path$1.join(electron.app.getPath("home"), filePath.slice(2)) : filePath;
-        fs.writeFileSync(normalizedPath, content, encoding);
+        fs.writeFileSync(resolveUserPath(filePath), content, encoding);
       } catch (error) {
         logger.error("Error saving file:", LogFileType.BACKEND, error);
         throw error;
@@ -7892,14 +8012,13 @@ electron.app.whenReady().then(async () => {
     }
   );
   electron.ipcMain.handle("file-exists", async (_, filePath) => {
-    const normalizedPath = filePath.startsWith("~/") ? path$1.join(electron.app.getPath("home"), filePath.slice(2)) : filePath;
-    return fs.existsSync(normalizedPath);
+    return fs.existsSync(resolveUserPath(filePath));
   });
   electron.ipcMain.handle("directory-exists", async (_, dirPath) => {
-    const home = electron.app.getPath("home");
-    const normalizedPath = dirPath === "~" ? home : dirPath.startsWith("~/") ? path$1.join(home, dirPath.slice(2)) : dirPath;
     try {
-      return fs.statSync(normalizedPath, { throwIfNoEntry: false })?.isDirectory() ?? false;
+      return fs.statSync(resolveUserPath(dirPath), {
+        throwIfNoEntry: false
+      })?.isDirectory() ?? false;
     } catch {
       return false;
     }