@nuvin/session 0.1.0-rc.8 → 0.1.0

package/dist/client/index.js

@@ -1,935 +1,1096 @@
 import {
   createSessionViewState,
   reduceSessionEvent
-} from "../chunk-FR3R66RD.js";
+} from "../chunk-WAMOWOCO.js";
 import {
   PROTOCOL_VERSION
-} from "../chunk-3J44LBXZ.js";
+} from "../chunk-WB4FEWBI.js";
 
-// src/client/socket.ts
-function adaptWhatwgSocket(socket) {
-  const on = (event, listener) => {
-    switch (event) {
-      case "open":
-        socket.addEventListener("open", () => listener(void 0));
-        return;
-      case "message":
-        socket.addEventListener("message", (messageEvent) => listener(messageEvent.data));
-        return;
-      case "close":
-        socket.addEventListener("close", () => listener(void 0));
-        return;
-      case "error":
-        socket.addEventListener("error", (errorEvent) => listener(errorEvent));
-        return;
-    }
-  };
-  return {
-    on,
-    send: (data) => socket.send(data),
-    close: () => socket.close()
-  };
-}
-function globalWebSocketConstructor() {
-  const candidate = globalThis.WebSocket;
-  if (typeof candidate !== "function") {
-    throw new Error(
-      "No global WebSocket constructor is available. Pass `socketFactory` (node < 22 callers can wrap the 'ws' package)."
-    );
+// src/client/endpoint.ts
+var TerminalEndpointError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message ?? reason);
+    this.name = "TerminalEndpointError";
+    this.reason = reason;
   }
-  return candidate;
+};
+
+// src/client/http-data-client.ts
+function httpBaseFromWsUrl(wsUrl) {
+  const u = new URL(wsUrl);
+  const scheme = u.protocol === "wss:" ? "https:" : "http:";
+  return `${scheme}//${u.host}`;
 }
-function defaultSocketFactory(url) {
-  const WebSocketCtor = globalWebSocketConstructor();
-  return adaptWhatwgSocket(new WebSocketCtor(url));
+function queryString(params) {
+  const q = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) q.set(key, String(value));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
 }
-
-// src/client/directory.ts
-var toText = (data) => {
-  if (typeof data === "string") return data;
-  if (data instanceof Buffer) return data.toString("utf8");
-  if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
-  if (Array.isArray(data) && data.every((chunk) => chunk instanceof Buffer)) {
-    return Buffer.concat(data).toString("utf8");
+async function throwFromResponse(response, fallback, terminal, onUnauthorized) {
+  const body = await response.json().catch(() => null);
+  if (response.status === 401 || body?.code === "unauthorized") {
+    onUnauthorized?.();
+    throw new TerminalEndpointError(
+      "unauthorized",
+      typeof body?.message === "string" ? body.message : "Authentication required."
+    );
   }
-  return null;
-};
-var parseMessage = (data) => {
-  const text = toText(data);
-  if (text === null) return null;
-  try {
-    const parsed = JSON.parse(text);
-    return typeof parsed === "object" && parsed !== null && typeof parsed.type === "string" ? parsed : null;
-  } catch {
-    return null;
+  const mapped = terminal?.[response.status];
+  if (mapped) {
+    throw new TerminalEndpointError(
+      mapped.reason,
+      typeof body?.message === "string" ? body.message : mapped.message
+    );
   }
-};
-function createServerDirectory(options) {
-  const socketFactory = options.socketFactory ?? defaultSocketFactory;
-  const connectTimeoutMs = options.connectTimeoutMs ?? 5e3;
-  const listeners = /* @__PURE__ */ new Set();
-  const links = /* @__PURE__ */ new Map();
-  let closed = false;
-  let view = { servers: [] };
-  const rebuildView = () => {
-    view = {
-      servers: Array.from(links.values(), (link) => ({
-        name: link.config.name,
-        url: link.resolvedUrl ?? link.config.url ?? "",
-        status: link.status
-      }))
-    };
-    for (const listener of listeners) {
-      try {
-        listener();
-      } catch {
-      }
-    }
-  };
-  const clearTimer = (link) => {
-    if (link.timer !== null) {
-      clearTimeout(link.timer);
-      link.timer = null;
-    }
-  };
-  const rejectPending = (link, message) => {
-    const error = new Error(message);
-    for (const entry of link.pending.values()) {
-      if (entry.kind !== "list") entry.reject(error);
-    }
-    link.pending.clear();
-  };
-  const markOffline = (link, message) => {
-    clearTimer(link);
-    link.ready = false;
-    const current = link.socket;
-    link.socket = null;
-    current?.close();
-    rejectPending(link, message);
-    link.status = { state: "offline", error: message };
-    rebuildView();
+  throw new Error(
+    typeof body?.message === "string" ? body.message : `${fallback} (HTTP ${response.status}).`
+  );
+}
+function createHttpDataClient(options = {}) {
+  const fetchImpl = options.fetchImpl ?? ((...args) => fetch(...args));
+  const baseUrl = (options.baseUrl ?? "").replace(/\/+$/, "");
+  const rows = /* @__PURE__ */ new Map();
+  const resolveToken = async (id) => {
+    const endpoint = rows.get(id)?.endpoint;
+    if (endpoint) return endpoint.token;
+    return options.getToken ? await options.getToken() : null;
   };
-  const sendList = (link) => {
-    if (!link.ready || link.socket === null) return;
-    link.commandCounter += 1;
-    const id = `dir-${link.commandCounter}`;
-    link.pending.set(id, { kind: "list" });
-    link.socket.send(JSON.stringify({ id, type: "list-sessions" }));
+  const resolveBase = (id) => {
+    const endpoint = rows.get(id)?.endpoint;
+    return endpoint ? httpBaseFromWsUrl(endpoint.wsUrl) : baseUrl;
   };
-  const handleMessage = (link, message) => {
-    if (message.type === "rejected") {
-      markOffline(
-        link,
-        message.reason === "auth" ? `Token rejected by "${link.config.name}" \u2014 check the configured token.` : `Protocol version mismatch with "${link.config.name}" \u2014 upgrade the daemon or this client.`
-      );
-      return;
-    }
-    if (message.type === "welcome") {
-      link.ready = true;
-      clearTimer(link);
-      rebuildView();
-      sendList(link);
-      return;
-    }
-    if (message.type === "session-list") {
-      const entry = link.pending.get(message.id);
-      if (entry?.kind !== "list") return;
-      link.pending.delete(message.id);
-      link.status = { state: "online", sessions: message.sessions };
-      rebuildView();
-      return;
-    }
-    if (message.type === "session-created") {
-      const entry = link.pending.get(message.id);
-      if (entry?.kind !== "create" && entry?.kind !== "resume") return;
-      link.pending.delete(message.id);
-      entry.resolve(message.session);
-      if (link.status.state === "online") {
-        const sessions = link.status.sessions.some((existing) => existing.id === message.session.id) ? link.status.sessions : [...link.status.sessions, message.session];
-        link.status = { state: "online", sessions };
-        rebuildView();
+  const daemonFetch = async (id, suffix, init = {}) => {
+    const token = await resolveToken(id);
+    const response = await fetchImpl(
+      `${resolveBase(id)}/api/daemons/${encodeURIComponent(id)}${suffix}`,
+      {
+        ...init,
+        cache: "no-store",
+        headers: {
+          ...init.headers ?? {},
+          ...token !== null ? { Authorization: `Bearer ${token}` } : {}
+        }
       }
-      return;
+    );
+    if (response.status === 401) {
+      await throwFromResponse(
+        response,
+        "Authentication required",
+        void 0,
+        options.onUnauthorized
+      );
     }
-    if (message.type === "ack") {
-      const entry = link.pending.get(message.id);
-      if (!entry || entry.kind === "list") return;
-      link.pending.delete(message.id);
-      if (!message.ok) {
-        entry.reject(new Error(message.error?.message ?? "Command failed."));
-        return;
-      }
-      if (entry.kind === "kill") {
-        entry.resolve();
-        sendList(link);
-        return;
+    return response;
+  };
+  return {
+    async listDaemons() {
+      const token = options.getToken ? await options.getToken() : null;
+      const response = await fetchImpl(`${baseUrl}/api/daemons`, {
+        cache: "no-store",
+        headers: token !== null ? { Authorization: `Bearer ${token}` } : {}
+      });
+      if (response.status === 401) {
+        options.onUnauthorized?.();
+        throw new TerminalEndpointError("unauthorized", "Signed out \u2014 authentication required.");
       }
-      if (entry.kind === "complete") {
-        entry.resolve(
-          Array.isArray(message.result) ? message.result.filter((item) => typeof item === "string") : []
-        );
-        return;
+      if (!response.ok) await throwFromResponse(response, "Failed to fetch the daemon list");
+      const body = await response.json();
+      rows.clear();
+      for (const row of body.daemons) rows.set(row.id, row);
+      return {
+        daemons: body.daemons,
+        ...body.defaultSessionId !== void 0 ? { defaultSessionId: body.defaultSessionId } : {}
+      };
+    },
+    async acquireEndpoint(daemonId) {
+      const endpoint = rows.get(daemonId)?.endpoint;
+      if (endpoint) {
+        return { url: endpoint.wsUrl, credential: { token: endpoint.token } };
       }
-      if (entry.kind === "list-profiles") {
-        entry.resolve(Array.isArray(message.result) ? message.result : []);
-        return;
+      const request = (token) => fetchImpl(`${baseUrl}/api/daemons/${encodeURIComponent(daemonId)}/connect`, {
+        method: "POST",
+        cache: "no-store",
+        headers: token !== null ? { Authorization: `Bearer ${token}` } : {}
+      });
+      const throwUnauthorized = () => {
+        options.onUnauthorized?.();
+        throw new TerminalEndpointError("unauthorized", "Signed out \u2014 authentication required.");
+      };
+      const failedToken = options.getToken ? await options.getToken() : null;
+      let response = await request(failedToken);
+      if (response.status === 401 && options.refreshAccessToken) {
+        let retryToken = null;
+        try {
+          const currentToken = options.getToken ? await options.getToken() : null;
+          retryToken = currentToken && currentToken !== failedToken ? currentToken : null;
+          if (!retryToken) retryToken = await options.refreshAccessToken();
+        } catch {
+          throwUnauthorized();
+        }
+        if (!retryToken) {
+          throwUnauthorized();
+        }
+        response = await request(retryToken);
       }
-      if (entry.kind === "list-providers") {
-        entry.resolve(Array.isArray(message.result) ? message.result : []);
-        return;
+      if (response.status === 401) {
+        throwUnauthorized();
       }
-      if (entry.kind === "provider-mutation") {
-        entry.resolve();
-        return;
+      if (response.status === 404) {
+        throw new TerminalEndpointError(
+          "daemon-revoked",
+          `Daemon "${daemonId}" is no longer registered.`
+        );
       }
-      entry.reject(new Error("Unexpected ack for create-session / resume-session."));
-      return;
-    }
-  };
-  const openLinkSocket = (link, endpoint) => {
-    link.resolvedUrl = endpoint.url;
-    const socket = (link.config.socketFactory ?? socketFactory)(endpoint.url);
-    link.socket = socket;
-    socket.on("open", () => {
-      if (closed || link.socket !== socket) return;
-      socket.send(
-        JSON.stringify({
-          type: "hello",
-          protocolVersion: PROTOCOL_VERSION,
-          ...endpoint.credential
+      if (!response.ok)
+        await throwFromResponse(
+          response,
+          response.status === 409 ? `Daemon "${daemonId}" is offline` : `Connect failed for "${daemonId}"`
+        );
+      const body = await response.json();
+      return { url: body.wsUrl, credential: { grant: body.grant } };
+    },
+    async fetchTranscript(daemonId, historyId, opts) {
+      const suffix = `/transcript/${encodeURIComponent(historyId)}${queryString({
+        workspace: opts?.workspace,
+        profile: opts?.profile
+      })}`;
+      const response = await daemonFetch(daemonId, suffix);
+      if (response.status === 404) {
+        throw new TerminalEndpointError(
+          "transcript-not-found",
+          "This session's transcript is no longer available."
+        );
+      }
+      if (!response.ok) await throwFromResponse(response, "Failed to load the transcript");
+      return await response.json();
+    },
+    async fetchHistory(daemonId, opts) {
+      const suffix = `/history${queryString({
+        profile: opts?.profile,
+        cwd: opts?.cwd,
+        limit: opts?.limit,
+        cursor: opts?.cursor
+      })}`;
+      const response = await daemonFetch(daemonId, suffix);
+      if (!response.ok)
+        await throwFromResponse(response, "Failed to load history", {
+          404: { reason: "daemon-revoked", message: "This daemon is no longer registered." }
+        });
+      return await response.json();
+    },
+    async listWorkspaces(daemonId, opts) {
+      const suffix = `/workspaces${queryString({ profile: opts?.profile })}`;
+      const response = await daemonFetch(daemonId, suffix);
+      if (!response.ok)
+        await throwFromResponse(response, "Failed to load workspaces", {
+          404: { reason: "daemon-revoked", message: "This daemon is no longer registered." }
+        });
+      return await response.json();
+    },
+    async createWorkspace(daemonId, opts) {
+      const response = await daemonFetch(daemonId, "/workspaces", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          name: opts.name,
+          ...opts.root !== void 0 ? { root: opts.root } : {},
+          ...opts.profile !== void 0 ? { profile: opts.profile } : {}
         })
-      );
-    });
-    socket.on("message", (data) => {
-      if (closed || link.socket !== socket) return;
-      const message = parseMessage(data);
-      if (message) handleMessage(link, message);
-    });
-    socket.on("error", () => {
-    });
-    socket.on("close", () => {
-      if (link.socket !== socket) return;
-      link.socket = null;
-      if (closed) return;
-      if (link.status.state !== "offline") {
-        markOffline(link, `Connection to "${link.config.name}" closed.`);
+      });
+      if (!response.ok) await throwFromResponse(response, "Failed to create the workspace");
+      return await response.json();
+    },
+    async deleteSession(daemonId, historyId, opts) {
+      const suffix = `/sessions/${encodeURIComponent(historyId)}${queryString({
+        workspace: opts?.workspace,
+        profile: opts?.profile
+      })}`;
+      const response = await daemonFetch(daemonId, suffix, { method: "DELETE" });
+      if (response.status === 404) {
+        throw new TerminalEndpointError("session-not-found", "This session no longer exists.");
       }
-    });
-  };
-  const connect = (link) => {
-    if (closed) return;
-    link.ready = false;
-    link.status = { state: "connecting" };
-    clearTimer(link);
-    link.timer = setTimeout(() => {
-      link.timer = null;
-      if (!link.ready) {
-        markOffline(link, `Timed out connecting to "${link.config.name}".`);
+      if (!response.ok) await throwFromResponse(response, "Failed to delete the session");
+    },
+    async listProfiles(daemonId) {
+      const response = await daemonFetch(daemonId, "/profiles");
+      if (!response.ok) {
+        await throwFromResponse(response, "Failed to load profiles", {
+          404: { reason: "daemon-revoked", message: "This daemon is no longer registered." }
+        });
       }
-    }, connectTimeoutMs);
-    const getEndpoint = link.config.getEndpoint;
-    if (!getEndpoint) {
-      openLinkSocket(link, {
-        url: link.config.url,
-        credential: { token: link.config.token }
-      });
-      rebuildView();
-      return;
-    }
-    void getEndpoint().then(
-      (endpoint) => {
-        if (closed || link.status.state !== "connecting" || link.socket !== null) return;
-        openLinkSocket(link, endpoint);
-        rebuildView();
-      },
-      (error) => {
-        if (closed || link.status.state !== "connecting") return;
-        markOffline(
-          link,
-          `Endpoint for "${link.config.name}" unavailable: ${error instanceof Error ? error.message : String(error)}`
-        );
+      return await response.json();
+    },
+    async listProviders(daemonId, opts) {
+      const suffix = `/providers${queryString({ profile: opts?.profile })}`;
+      const response = await daemonFetch(daemonId, suffix);
+      if (!response.ok) {
+        await throwFromResponse(response, "Failed to load providers", {
+          404: { reason: "daemon-revoked", message: "This daemon is no longer registered." }
+        });
       }
-    );
-    rebuildView();
-  };
-  const linkFor = (server) => {
-    const link = links.get(server);
-    if (!link) return new Error(`Unknown server "${server}".`);
-    if (closed || !link.ready || link.socket === null) {
-      return new Error(`Server "${server}" is not connected.`);
-    }
-    return link;
-  };
-  for (const config of options.servers) {
-    if (!config.getEndpoint && (config.url === void 0 || config.token === void 0)) {
-      throw new Error(`Server "${config.name}" needs either url+token or a getEndpoint provider.`);
-    }
-    links.set(config.name, {
-      config,
-      status: { state: "connecting" },
-      socket: null,
-      ready: false,
-      pending: /* @__PURE__ */ new Map(),
-      timer: null,
-      commandCounter: 0
-    });
-  }
-  rebuildView();
-  for (const link of links.values()) {
-    connect(link);
-  }
-  return {
-    getView() {
-      return view;
+      return await response.json();
     },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
+    async addProvider(daemonId, input) {
+      const response = await daemonFetch(daemonId, "/providers", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input)
+      });
+      if (!response.ok) await throwFromResponse(response, "Failed to add provider");
+      return await response.json();
     },
-    refresh() {
-      if (closed) return;
-      for (const link of links.values()) {
-        if (link.status.state === "offline") {
-          connect(link);
-        } else if (link.ready) {
-          sendList(link);
+    async removeProvider(daemonId, providerId, opts) {
+      const response = await daemonFetch(daemonId, `/providers/${encodeURIComponent(providerId)}`, {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(opts?.profile !== void 0 ? { profile: opts.profile } : {})
+      });
+      if (!response.ok) await throwFromResponse(response, "Failed to remove provider");
+      return await response.json();
+    },
+    async setDefaultProvider(daemonId, providerId, opts) {
+      const response = await daemonFetch(daemonId, "/providers/default", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          providerId,
+          ...opts?.profile !== void 0 ? { profile: opts.profile } : {}
+        })
+      });
+      if (!response.ok) await throwFromResponse(response, "Failed to set default provider");
+      return await response.json();
+    },
+    async setProviderAuth(daemonId, providerId, credential, opts) {
+      const response = await daemonFetch(
+        daemonId,
+        `/providers/${encodeURIComponent(providerId)}/credential`,
+        {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            credential,
+            ...opts?.profile !== void 0 ? { profile: opts.profile } : {}
+          })
         }
-      }
+      );
+      if (!response.ok) await throwFromResponse(response, "Failed to update provider auth");
+      return await response.json();
     },
-    setServers(configs) {
-      if (closed) return;
-      for (const config of configs) {
-        if (!links.has(config.name) && !config.getEndpoint) {
-          if (config.url === void 0 || config.token === void 0) {
-            throw new Error(
-              `Server "${config.name}" needs either url+token or a getEndpoint provider.`
-            );
-          }
+    async clearProviderAuth(daemonId, providerId, opts) {
+      const response = await daemonFetch(
+        daemonId,
+        `/providers/${encodeURIComponent(providerId)}/credential`,
+        {
+          method: "DELETE",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(opts?.profile !== void 0 ? { profile: opts.profile } : {})
+        }
+      );
+      if (!response.ok) await throwFromResponse(response, "Failed to clear provider auth");
+      return await response.json();
+    },
+    async updateWorkspace(daemonId, name, patch) {
+      const response = await daemonFetch(daemonId, `/workspaces/${encodeURIComponent(name)}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(patch)
+      });
+      if (!response.ok) await throwFromResponse(response, "Failed to update workspace");
+      return await response.json();
+    }
+  };
+}
+
+// src/client/session-client.ts
+var EMPTY_MODEL_COMPLETION = {
+  providers: [],
+  perProvider: {},
+  recentModels: []
+};
+function toModelCompletion(result) {
+  if (typeof result !== "object" || result === null || Array.isArray(result)) {
+    return EMPTY_MODEL_COMPLETION;
+  }
+  const record = result;
+  const providers = Array.isArray(record.providers) ? record.providers.filter((p) => typeof p === "string") : [];
+  const perProvider = {};
+  if (typeof record.perProvider === "object" && record.perProvider !== null) {
+    for (const [provider, models] of Object.entries(
+      record.perProvider
+    )) {
+      if (!Array.isArray(models)) continue;
+      perProvider[provider] = models.flatMap((entry) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
+        const id = entry.id;
+        if (typeof id !== "string") return [];
+        const name = entry.name;
+        return [typeof name === "string" ? { id, name } : { id }];
+      });
+    }
+  }
+  const recentModels = Array.isArray(record.recentModels) ? record.recentModels.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
+    const provider = entry.provider;
+    const model = entry.model;
+    return typeof provider === "string" && typeof model === "string" ? [{ provider, model }] : [];
+  }) : [];
+  return { providers, perProvider, recentModels };
+}
+function createSessionClient(transport) {
+  let state = createSessionViewState();
+  let seq = 0;
+  let closed = false;
+  let notifyScheduled = false;
+  let commandCounter = 0;
+  let serverCommandList = [];
+  const stateListeners = /* @__PURE__ */ new Set();
+  const eventListeners = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  const rejectAllPending = (message) => {
+    if (pending.size === 0) return;
+    const error = new Error(message);
+    for (const { reject } of pending.values()) {
+      reject(error);
+    }
+    pending.clear();
+  };
+  const scheduleNotify = () => {
+    if (notifyScheduled) return;
+    notifyScheduled = true;
+    queueMicrotask(() => {
+      notifyScheduled = false;
+      for (const listener of stateListeners) {
+        try {
+          listener();
+        } catch {
         }
       }
-      const nextNames = new Set(configs.map((config) => config.name));
-      for (const [name, link] of links) {
-        if (nextNames.has(name)) continue;
-        clearTimer(link);
-        rejectPending(link, `Server "${name}" was removed from the directory.`);
-        const socket = link.socket;
-        link.socket = null;
-        socket?.close();
-        links.delete(name);
+    });
+  };
+  const unsubscribe = transport.onFrame((frame) => {
+    if (frame.type === "snapshot") {
+      state = frame.snapshot.state;
+      seq = frame.snapshot.seq;
+      serverCommandList = frame.snapshot.serverCommands;
+      scheduleNotify();
+      return;
+    }
+    if (frame.type === "ack") {
+      const entry = pending.get(frame.id);
+      if (!entry) return;
+      pending.delete(frame.id);
+      if (frame.ok) {
+        entry.resolve(frame.result);
+      } else {
+        entry.reject(new Error(frame.error?.message ?? "Command failed."));
       }
-      const added = [];
-      for (const config of configs) {
-        const existing = links.get(config.name);
-        if (existing) {
-          existing.config = config;
-          continue;
-        }
-        const link = {
-          config,
-          status: { state: "connecting" },
-          socket: null,
-          ready: false,
-          pending: /* @__PURE__ */ new Map(),
-          timer: null,
-          commandCounter: 0
-        };
-        links.set(config.name, link);
-        added.push(link);
+      return;
+    }
+    state = reduceSessionEvent(state, frame);
+    seq = frame.seq;
+    for (const listener of eventListeners) {
+      try {
+        listener(frame);
+      } catch {
       }
-      rebuildView();
-      for (const link of added) {
-        connect(link);
+    }
+    scheduleNotify();
+  });
+  const unsubscribeUndeliverable = transport.onUndeliverable?.(() => {
+    rejectAllPending("Command not delivered: connection lost before acknowledgment.");
+  });
+  const sendCommand = (build) => {
+    if (closed) {
+      return Promise.reject(new Error("SessionClient is closed."));
+    }
+    commandCounter += 1;
+    const id = `cmd-${commandCounter}`;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      const delivered = transport.send(build(id));
+      if (delivered === false) {
+        pending.delete(id);
+        reject(new Error("Command not delivered: transport is not attached."));
       }
+    });
+  };
+  return {
+    getState() {
+      return state;
     },
-    createSession(server, createOptions) {
-      return new Promise((resolve, reject) => {
-        const link = linkFor(server);
-        if (link instanceof Error) {
-          reject(link);
-          return;
-        }
-        link.commandCounter += 1;
-        const id = `dir-${link.commandCounter}`;
-        link.pending.set(id, { kind: "create", resolve, reject });
-        link.socket?.send(
-          JSON.stringify({
-            id,
-            type: "create-session",
-            cwd: createOptions.cwd,
-            ...createOptions.name !== void 0 ? { name: createOptions.name } : {},
-            ...createOptions.workspace !== void 0 ? { workspace: createOptions.workspace } : {},
-            ...createOptions.profile !== void 0 ? { profile: createOptions.profile } : {}
-          })
-        );
-      });
+    getSeq() {
+      return seq;
     },
-    resumeSession(server, historyId, resumeOptions) {
-      return new Promise((resolve, reject) => {
-        const link = linkFor(server);
-        if (link instanceof Error) {
-          reject(link);
-          return;
-        }
-        link.commandCounter += 1;
-        const id = `dir-${link.commandCounter}`;
-        link.pending.set(id, { kind: "resume", resolve, reject });
-        link.socket?.send(
-          JSON.stringify({
-            id,
-            type: "resume-session",
-            historyId,
-            cwd: resumeOptions.cwd,
-            ...resumeOptions.name !== void 0 ? { name: resumeOptions.name } : {},
-            ...resumeOptions.workspace !== void 0 ? { workspace: resumeOptions.workspace } : {},
-            ...resumeOptions.profile !== void 0 ? { profile: resumeOptions.profile } : {}
-          })
-        );
-      });
+    subscribe(listener) {
+      stateListeners.add(listener);
+      return () => stateListeners.delete(listener);
     },
-    killSession(server, sessionId, options2) {
-      return new Promise((resolve, reject) => {
-        const link = linkFor(server);
-        if (link instanceof Error) {
-          reject(link);
-          return;
-        }
-        link.commandCounter += 1;
-        const id = `dir-${link.commandCounter}`;
-        link.pending.set(id, { kind: "kill", resolve, reject });
-        link.socket?.send(
-          JSON.stringify({ id, type: "kill-session", sessionId, delete: options2?.delete })
-        );
-      });
+    onEvent(listener) {
+      eventListeners.add(listener);
+      return () => eventListeners.delete(listener);
     },
-    completePath(server, prefix) {
-      return new Promise((resolve, reject) => {
-        const link = linkFor(server);
-        if (link instanceof Error) {
-          reject(link);
-          return;
-        }
-        link.commandCounter += 1;
-        const id = `dir-${link.commandCounter}`;
-        link.pending.set(id, { kind: "complete", resolve, reject });
-        link.socket?.send(JSON.stringify({ id, type: "complete-path", prefix }));
+    submit(input, opts) {
+      return sendCommand((id) => ({
+        id,
+        type: "submit",
+        input,
+        displayText: opts.displayText,
+        ...opts.attachmentLabels?.length ? { attachmentLabels: opts.attachmentLabels } : {},
+        ...opts.turnId !== void 0 ? { turnId: opts.turnId } : {}
+      })).then(() => {
       });
     },
-    listProfiles(server) {
-      return new Promise((resolve, reject) => {
-        const link = linkFor(server);
-        if (link instanceof Error) {
-          reject(link);
-          return;
-        }
-        link.commandCounter += 1;
-        const id = `dir-${link.commandCounter}`;
-        link.pending.set(id, { kind: "list-profiles", resolve, reject });
-        link.socket?.send(JSON.stringify({ id, type: "list-profiles" }));
+    decideApproval(toolCallId, decision, comment, grantDir) {
+      return sendCommand((id) => ({
+        id,
+        type: "decide-approval",
+        toolCallId,
+        decision,
+        ...comment !== void 0 ? { comment } : {},
+        ...grantDir !== void 0 ? { grantDir } : {}
+      })).then(() => {
       });
     },
-    listProviders(server) {
-      return new Promise((resolve, reject) => {
-        const link = linkFor(server);
-        if (link instanceof Error) {
-          reject(link);
-          return;
+    answerQuestion(questionId, answers) {
+      return sendCommand((id) => ({ id, type: "answer-question", questionId, answers })).then(
+        () => {
         }
-        link.commandCounter += 1;
-        const id = `dir-${link.commandCounter}`;
-        link.pending.set(id, { kind: "list-providers", resolve, reject });
-        link.socket?.send(JSON.stringify({ id, type: "list-providers" }));
+      );
+    },
+    abort() {
+      return sendCommand((id) => ({ id, type: "abort" })).then(() => {
       });
     },
-    setDefaultProvider(server, providerId) {
-      return new Promise((resolve, reject) => {
-        const link = linkFor(server);
-        if (link instanceof Error) {
-          reject(link);
-          return;
-        }
-        link.commandCounter += 1;
-        const id = `dir-${link.commandCounter}`;
-        link.pending.set(id, { kind: "provider-mutation", resolve, reject });
-        link.socket?.send(JSON.stringify({ id, type: "set-default-provider", providerId }));
+    dequeueMessage(queuedId) {
+      return sendCommand((id) => ({ id, type: "dequeue", queuedId })).then(() => {
       });
     },
-    setProviderAuth(server, providerId, credential) {
-      return new Promise((resolve, reject) => {
-        const link = linkFor(server);
-        if (link instanceof Error) {
-          reject(link);
-          return;
-        }
-        link.commandCounter += 1;
-        const id = `dir-${link.commandCounter}`;
-        link.pending.set(id, { kind: "provider-mutation", resolve, reject });
-        link.socket?.send(
-          JSON.stringify({ id, type: "set-provider-auth", providerId, credential })
-        );
+    runSlashCommand(raw) {
+      return sendCommand((id) => ({ id, type: "slash-command", raw })).then(() => {
       });
     },
-    clearProviderAuth(server, providerId) {
-      return new Promise((resolve, reject) => {
-        const link = linkFor(server);
-        if (link instanceof Error) {
-          reject(link);
-          return;
-        }
-        link.commandCounter += 1;
-        const id = `dir-${link.commandCounter}`;
-        link.pending.set(id, { kind: "provider-mutation", resolve, reject });
-        link.socket?.send(JSON.stringify({ id, type: "clear-provider-auth", providerId }));
+    loadHistory(historyId) {
+      return sendCommand((id) => ({ id, type: "load-history", historyId })).then(() => {
       });
     },
-    close() {
-      if (closed) return;
-      closed = true;
-      for (const link of links.values()) {
-        clearTimer(link);
-        rejectPending(link, "ServerDirectory closed.");
-        const socket = link.socket;
-        link.socket = null;
-        socket?.close();
-      }
-      listeners.clear();
-    }
-  };
-}
-
-// src/client/endpoint.ts
-var TerminalEndpointError = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message ?? reason);
-    this.name = "TerminalEndpointError";
-    this.reason = reason;
-  }
-};
-
-// src/client/http-data-client.ts
-function httpBaseFromWsUrl(wsUrl) {
-  const u = new URL(wsUrl);
-  const scheme = u.protocol === "wss:" ? "https:" : "http:";
-  return `${scheme}//${u.host}`;
-}
-function queryString(params) {
-  const q = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== void 0) q.set(key, String(value));
-  }
-  const s = q.toString();
-  return s ? `?${s}` : "";
-}
-async function throwFromResponse(response, fallback, terminal) {
-  const body = await response.json().catch(() => null);
-  const mapped = terminal?.[response.status];
-  if (mapped) throw new TerminalEndpointError(mapped.reason, body?.message ?? mapped.message);
-  throw new Error(body?.message ?? `${fallback} (HTTP ${response.status}).`);
-}
-function createHttpDataClient(options = {}) {
-  const fetchImpl = options.fetchImpl ?? ((...args) => fetch(...args));
-  const baseUrl = (options.baseUrl ?? "").replace(/\/+$/, "");
-  const rows = /* @__PURE__ */ new Map();
-  const resolveToken = async (id) => {
-    const endpoint = rows.get(id)?.endpoint;
-    if (endpoint) return endpoint.token;
-    return options.getToken ? await options.getToken() : null;
-  };
-  const resolveBase = (id) => {
-    const endpoint = rows.get(id)?.endpoint;
-    return endpoint ? httpBaseFromWsUrl(endpoint.wsUrl) : baseUrl;
-  };
-  const daemonFetch = async (id, suffix, init = {}) => {
-    const token = await resolveToken(id);
-    const response = await fetchImpl(
-      `${resolveBase(id)}/api/daemons/${encodeURIComponent(id)}${suffix}`,
-      {
-        ...init,
-        cache: "no-store",
-        headers: {
-          ...init.headers ?? {},
-          ...token !== null ? { Authorization: `Bearer ${token}` } : {}
-        }
-      }
-    );
-    if (response.status === 401) {
-      options.onUnauthorized?.();
-      throw new TerminalEndpointError("unauthorized", "Signed out \u2014 authentication required.");
-    }
-    return response;
-  };
-  return {
-    async listDaemons() {
-      const token = options.getToken ? await options.getToken() : null;
-      const response = await fetchImpl(`${baseUrl}/api/daemons`, {
-        cache: "no-store",
-        headers: token !== null ? { Authorization: `Bearer ${token}` } : {}
+    cancelAuthFlow() {
+      return sendCommand((id) => ({ id, type: "cancel-auth-flow" })).then(() => {
       });
-      if (response.status === 401) {
-        options.onUnauthorized?.();
-        throw new TerminalEndpointError("unauthorized", "Signed out \u2014 authentication required.");
-      }
-      if (!response.ok) await throwFromResponse(response, "Failed to fetch the daemon list");
-      const body = await response.json();
-      rows.clear();
-      for (const row of body.daemons) rows.set(row.id, row);
-      return {
-        daemons: body.daemons,
-        ...body.defaultSessionId !== void 0 ? { defaultSessionId: body.defaultSessionId } : {}
-      };
     },
-    async acquireEndpoint(daemonId) {
-      const endpoint = rows.get(daemonId)?.endpoint;
-      if (endpoint) {
-        return { url: endpoint.wsUrl, credential: { token: endpoint.token } };
-      }
-      const token = options.getToken ? await options.getToken() : null;
-      const response = await fetchImpl(
-        `${baseUrl}/api/daemons/${encodeURIComponent(daemonId)}/connect`,
-        {
-          method: "POST",
-          cache: "no-store",
-          headers: token !== null ? { Authorization: `Bearer ${token}` } : {}
-        }
+    mcpAction(action, serverName) {
+      return sendCommand((id) => ({ id, type: "mcp-action", action, serverName })).then(
+        (result) => result
       );
-      if (response.status === 401) {
-        options.onUnauthorized?.();
-        throw new TerminalEndpointError("unauthorized", "Signed out \u2014 authentication required.");
-      }
-      if (response.status === 404) {
-        throw new TerminalEndpointError(
-          "daemon-revoked",
-          `Daemon "${daemonId}" is no longer registered.`
-        );
-      }
-      if (!response.ok)
-        await throwFromResponse(
-          response,
-          response.status === 409 ? `Daemon "${daemonId}" is offline` : `Connect failed for "${daemonId}"`
-        );
-      const body = await response.json();
-      return { url: body.wsUrl, credential: { grant: body.grant } };
     },
-    async fetchTranscript(daemonId, historyId, opts) {
-      const suffix = `/transcript/${encodeURIComponent(historyId)}${queryString({
-        workspace: opts?.workspace,
-        profile: opts?.profile
-      })}`;
-      const response = await daemonFetch(daemonId, suffix);
-      if (response.status === 404) {
-        throw new TerminalEndpointError(
-          "transcript-not-found",
-          "This session's transcript is no longer available."
-        );
-      }
-      if (!response.ok) await throwFromResponse(response, "Failed to load the transcript");
-      return await response.json();
+    serverCommands() {
+      return serverCommandList;
+    },
+    completePath(prefix) {
+      return sendCommand((id) => ({ id, type: "complete-path", prefix })).then(
+        (result) => Array.isArray(result) ? result.filter((entry) => typeof entry === "string") : []
+      );
+    },
+    completeModels() {
+      return sendCommand((id) => ({ id, type: "complete-models" })).then(toModelCompletion);
+    },
+    setConfig(patches) {
+      return sendCommand((id) => ({ id, type: "set-config", patches })).then(
+        (result) => result
+      );
+    },
+    listSkills() {
+      return sendCommand((id) => ({ id, type: "list-skills" })).then(
+        (result) => Array.isArray(result) ? result : []
+      );
+    },
+    getSkill(skillId) {
+      return sendCommand((id) => ({ id, type: "get-skill", skillId })).then(
+        (result) => result
+      );
+    },
+    listAgents() {
+      return sendCommand((id) => ({ id, type: "list-agents" })).then(
+        (result) => Array.isArray(result) ? result : []
+      );
+    },
+    getAgent(agentId) {
+      return sendCommand((id) => ({ id, type: "get-agent", agentId })).then(
+        (result) => result
+      );
+    },
+    getCommand(name) {
+      return sendCommand((id) => ({ id, type: "get-command", name })).then(
+        (result) => result
+      );
+    },
+    listMcpServers() {
+      return sendCommand((id) => ({ id, type: "list-mcp-servers" })).then(
+        (result) => Array.isArray(result) ? result : []
+      );
     },
-    async fetchHistory(daemonId, opts) {
-      const suffix = `/history${queryString({
-        profile: opts?.profile,
-        cwd: opts?.cwd,
-        limit: opts?.limit,
-        cursor: opts?.cursor
-      })}`;
-      const response = await daemonFetch(daemonId, suffix);
-      if (!response.ok)
-        await throwFromResponse(response, "Failed to load history", {
-          404: { reason: "daemon-revoked", message: "This daemon is no longer registered." }
-        });
-      return await response.json();
+    capabilities() {
+      return transport.capabilities?.() ?? [];
     },
-    async listWorkspaces(daemonId, opts) {
-      const suffix = `/workspaces${queryString({ profile: opts?.profile })}`;
-      const response = await daemonFetch(daemonId, suffix);
-      if (!response.ok)
-        await throwFromResponse(response, "Failed to load workspaces", {
-          404: { reason: "daemon-revoked", message: "This daemon is no longer registered." }
-        });
-      return await response.json();
+    completeProviderAuth(credential) {
+      return sendCommand((id) => ({
+        id,
+        type: "complete-provider-auth",
+        providerId: "openai-codex",
+        credential
+      })).then(() => {
+      });
     },
-    async createWorkspace(daemonId, opts) {
-      const response = await daemonFetch(daemonId, "/workspaces", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          name: opts.name,
-          ...opts.root !== void 0 ? { root: opts.root } : {},
-          ...opts.profile !== void 0 ? { profile: opts.profile } : {}
-        })
+    addCustomProvider(provider) {
+      return sendCommand((id) => ({
+        id,
+        type: "add-custom-provider",
+        provider
+      })).then(() => {
       });
-      if (!response.ok) await throwFromResponse(response, "Failed to create the workspace");
-      return await response.json();
     },
-    async deleteSession(daemonId, historyId, opts) {
-      const suffix = `/sessions/${encodeURIComponent(historyId)}${queryString({
-        workspace: opts?.workspace,
-        profile: opts?.profile
-      })}`;
-      const response = await daemonFetch(daemonId, suffix, { method: "DELETE" });
-      if (response.status === 404) {
-        throw new TerminalEndpointError("session-not-found", "This session no longer exists.");
-      }
-      if (!response.ok) await throwFromResponse(response, "Failed to delete the session");
+    close() {
+      if (closed) return;
+      closed = true;
+      unsubscribe();
+      unsubscribeUndeliverable?.();
+      rejectAllPending("SessionClient closed before the command was acknowledged.");
     }
   };
 }
 
-// src/client/session-client.ts
-var EMPTY_MODEL_COMPLETION = {
-  providers: [],
-  perProvider: {},
-  recentModels: []
+// src/client/socket.ts
+function adaptWhatwgSocket(socket) {
+  const on = (event, listener) => {
+    switch (event) {
+      case "open":
+        socket.addEventListener("open", () => listener(void 0));
+        return;
+      case "message":
+        socket.addEventListener("message", (messageEvent) => listener(messageEvent.data));
+        return;
+      case "close":
+        socket.addEventListener("close", () => listener(void 0));
+        return;
+      case "error":
+        socket.addEventListener("error", (errorEvent) => listener(errorEvent));
+        return;
+    }
+  };
+  return {
+    on,
+    send: (data) => socket.send(data),
+    close: () => socket.close()
+  };
+}
+function globalWebSocketConstructor() {
+  const candidate = globalThis.WebSocket;
+  if (typeof candidate !== "function") {
+    throw new Error(
+      "No global WebSocket constructor is available. Pass `socketFactory` (node < 22 callers can wrap the 'ws' package)."
+    );
+  }
+  return candidate;
+}
+function defaultSocketFactory(url) {
+  const WebSocketCtor = globalWebSocketConstructor();
+  return adaptWhatwgSocket(new WebSocketCtor(url));
+}
+
+// src/client/uds-socket.ts
+import { WebSocket } from "ws";
+function udsUrl(socketPath) {
+  return `ws+unix://${socketPath}:/`;
+}
+function ensureLocalhostNoProxy() {
+  const ga = globalThis.GLOBAL_AGENT;
+  if (!ga) return;
+  const current = ga.NO_PROXY ?? "";
+  const entries = current.split(",").map((s) => s.trim()).filter(Boolean);
+  let changed = false;
+  for (const host of ["localhost", "127.0.0.1"]) {
+    if (!entries.includes(host)) {
+      entries.push(host);
+      changed = true;
+    }
+  }
+  if (changed) {
+    ga.NO_PROXY = entries.join(",");
+  }
+}
+function udsSocketFactory(socketPath) {
+  const target = udsUrl(socketPath);
+  return (_url) => {
+    ensureLocalhostNoProxy();
+    return new WebSocket(target);
+  };
+}
+
+// src/client/websocket.ts
+var toText = (data) => {
+  if (typeof data === "string") return data;
+  if (data instanceof Buffer) return data.toString("utf8");
+  if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+  if (Array.isArray(data) && data.every((chunk) => chunk instanceof Buffer)) {
+    return Buffer.concat(data).toString("utf8");
+  }
+  return null;
 };
-function toModelCompletion(result) {
-  if (typeof result !== "object" || result === null || Array.isArray(result)) {
-    return EMPTY_MODEL_COMPLETION;
+var parseMessage = (data) => {
+  const text = toText(data);
+  if (text === null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed === "object" && parsed !== null && typeof parsed.type === "string" ? parsed : null;
+  } catch {
+    return null;
   }
-  const record = result;
-  const providers = Array.isArray(record.providers) ? record.providers.filter((p) => typeof p === "string") : [];
-  const perProvider = {};
-  if (typeof record.perProvider === "object" && record.perProvider !== null) {
-    for (const [provider, models] of Object.entries(
-      record.perProvider
-    )) {
-      if (!Array.isArray(models)) continue;
-      perProvider[provider] = models.flatMap((entry) => {
-        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
-        const id = entry.id;
-        if (typeof id !== "string") return [];
-        const name = entry.name;
-        return [typeof name === "string" ? { id, name } : { id }];
-      });
+};
+function createWebSocketTransport(options) {
+  if (!options.getEndpoint && (options.url === void 0 || options.token === void 0)) {
+    throw new Error("createWebSocketTransport requires either url+token or getEndpoint.");
+  }
+  const socketFactory = options.socketFactory ?? defaultSocketFactory;
+  const backoffInitialMs = options.backoffInitialMs ?? 500;
+  const backoffMaxMs = options.backoffMaxMs ?? 3e4;
+  const backoffFactor = options.backoffFactor ?? 2;
+  const frameListeners = /* @__PURE__ */ new Set();
+  const stateListeners = /* @__PURE__ */ new Set();
+  const undeliverableListeners = /* @__PURE__ */ new Set();
+  let state = "reconnecting";
+  let phase = "awaiting-welcome";
+  let socket = null;
+  let lastSeq = null;
+  let attempts = 0;
+  let attachCounter = 0;
+  let reconnectTimer = null;
+  let closed = false;
+  let cachedCapabilities = [];
+  const setState = (next) => {
+    if (state === next) return;
+    state = next;
+    for (const listener of stateListeners) {
+      try {
+        listener(next);
+      } catch {
+      }
+    }
+  };
+  const deliver = (frame) => {
+    for (const listener of frameListeners) {
+      try {
+        listener(frame);
+      } catch {
+      }
+    }
+  };
+  const notifyUndeliverable = () => {
+    for (const listener of undeliverableListeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const terminate = () => {
+    const wasAttached = phase === "attached";
+    closed = true;
+    cachedCapabilities = [];
+    if (reconnectTimer !== null) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    const current = socket;
+    socket = null;
+    current?.close();
+    setState("closed");
+    if (wasAttached) notifyUndeliverable();
+  };
+  const scheduleReconnect = () => {
+    if (closed || reconnectTimer !== null) return;
+    setState("reconnecting");
+    const delay = Math.min(backoffInitialMs * backoffFactor ** attempts, backoffMaxMs);
+    attempts += 1;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      connect();
+    }, delay);
+  };
+  const completeAttach = () => {
+    phase = "attached";
+    attempts = 0;
+    setState("connected");
+  };
+  const handleMessage = (message) => {
+    if (message.type === "rejected") {
+      terminate();
+      options.onRejected?.(message.reason);
+      return;
+    }
+    if (message.type === "detached") {
+      terminate();
+      options.onDetached?.(message.reason);
+      return;
+    }
+    if (phase === "awaiting-welcome") {
+      if (message.type !== "welcome") return;
+      cachedCapabilities = Array.isArray(message.capabilities) ? [...message.capabilities] : [];
+      phase = "awaiting-attach";
+      setState("replaying");
+      attachCounter += 1;
+      socket?.send(
+        JSON.stringify({
+          id: `attach-${attachCounter}`,
+          type: "attach",
+          sessionId: options.sessionId,
+          ...lastSeq !== null ? { lastSeq } : {}
+        })
+      );
+      return;
     }
-  }
-  const recentModels = Array.isArray(record.recentModels) ? record.recentModels.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
-    const provider = entry.provider;
-    const model = entry.model;
-    return typeof provider === "string" && typeof model === "string" ? [{ provider, model }] : [];
-  }) : [];
-  return { providers, perProvider, recentModels };
-}
-function createSessionClient(transport) {
-  let state = createSessionViewState();
-  let seq = 0;
-  let closed = false;
-  let notifyScheduled = false;
-  let commandCounter = 0;
-  let serverCommandList = [];
-  const stateListeners = /* @__PURE__ */ new Set();
-  const eventListeners = /* @__PURE__ */ new Set();
-  const pending = /* @__PURE__ */ new Map();
-  const scheduleNotify = () => {
-    if (notifyScheduled) return;
-    notifyScheduled = true;
-    queueMicrotask(() => {
-      notifyScheduled = false;
-      for (const listener of stateListeners) {
-        try {
-          listener();
-        } catch {
+    if (phase === "awaiting-attach") {
+      if (message.type === "replay") {
+        for (const event of message.events) {
+          lastSeq = event.seq;
+          deliver(event);
         }
+        completeAttach();
+        return;
+      }
+      if (message.type === "snapshot") {
+        lastSeq = message.snapshot.seq;
+        deliver(message);
+        completeAttach();
       }
-    });
-  };
-  const unsubscribe = transport.onFrame((frame) => {
-    if (frame.type === "snapshot") {
-      state = frame.snapshot.state;
-      seq = frame.snapshot.seq;
-      serverCommandList = frame.snapshot.serverCommands;
-      scheduleNotify();
       return;
     }
-    if (frame.type === "ack") {
-      const entry = pending.get(frame.id);
-      if (!entry) return;
-      pending.delete(frame.id);
-      if (frame.ok) {
-        entry.resolve(frame.result);
-      } else {
-        entry.reject(new Error(frame.error?.message ?? "Command failed."));
-      }
+    if (message.type === "ack") {
+      deliver(message);
       return;
     }
-    state = reduceSessionEvent(state, frame);
-    seq = frame.seq;
-    for (const listener of eventListeners) {
-      try {
-        listener(frame);
-      } catch {
-      }
+    if (message.type === "snapshot") {
+      lastSeq = message.snapshot.seq;
+      deliver(message);
+      return;
     }
-    scheduleNotify();
-  });
-  const sendCommand = (build) => {
-    if (closed) {
-      return Promise.reject(new Error("SessionClient is closed."));
+    if (message.type === "welcome" || message.type === "replay" || message.type === "session-list" || message.type === "session-created") {
+      return;
     }
-    commandCounter += 1;
-    const id = `cmd-${commandCounter}`;
-    return new Promise((resolve, reject) => {
-      pending.set(id, { resolve, reject });
-      transport.send(build(id));
+    lastSeq = message.seq;
+    deliver(message);
+  };
+  const openSocket = (endpoint) => {
+    if (closed) return;
+    phase = "awaiting-welcome";
+    cachedCapabilities = [];
+    const current = socketFactory(endpoint.url);
+    socket = current;
+    current.on("open", () => {
+      if (closed || socket !== current) return;
+      current.send(
+        JSON.stringify({
+          type: "hello",
+          protocolVersion: PROTOCOL_VERSION,
+          ...endpoint.credential
+        })
+      );
+    });
+    current.on("message", (data) => {
+      if (closed || socket !== current) return;
+      const message = parseMessage(data);
+      if (message) handleMessage(message);
+    });
+    current.on("error", () => {
+    });
+    current.on("close", () => {
+      if (socket !== current) return;
+      socket = null;
+      if (closed) return;
+      const wasAttached = phase === "attached";
+      phase = "awaiting-welcome";
+      if (wasAttached) notifyUndeliverable();
+      scheduleReconnect();
     });
   };
-  return {
-    getState() {
-      return state;
-    },
-    getSeq() {
-      return seq;
-    },
-    subscribe(listener) {
-      stateListeners.add(listener);
-      return () => stateListeners.delete(listener);
-    },
-    onEvent(listener) {
-      eventListeners.add(listener);
-      return () => eventListeners.delete(listener);
-    },
-    submit(input, opts) {
-      return sendCommand((id) => ({
-        id,
-        type: "submit",
-        input,
-        displayText: opts.displayText,
-        ...opts.attachmentLabels?.length ? { attachmentLabels: opts.attachmentLabels } : {}
-      })).then(() => {
-      });
-    },
-    decideApproval(toolCallId, decision, comment, grantDir) {
-      return sendCommand((id) => ({
-        id,
-        type: "decide-approval",
-        toolCallId,
-        decision,
-        ...comment !== void 0 ? { comment } : {},
-        ...grantDir !== void 0 ? { grantDir } : {}
-      })).then(() => {
-      });
-    },
-    answerQuestion(questionId, answers) {
-      return sendCommand((id) => ({ id, type: "answer-question", questionId, answers })).then(
-        () => {
+  const connect = () => {
+    if (closed) return;
+    const getEndpoint = options.getEndpoint;
+    if (!getEndpoint) {
+      openSocket({ url: options.url, credential: { token: options.token } });
+      return;
+    }
+    void getEndpoint().then(
+      (endpoint) => {
+        if (closed) return;
+        openSocket(endpoint);
+      },
+      (error) => {
+        if (closed) return;
+        if (error instanceof TerminalEndpointError) {
+          terminate();
+          options.onDetached?.(error.reason);
+          return;
         }
-      );
-    },
-    abort() {
-      return sendCommand((id) => ({ id, type: "abort" })).then(() => {
-      });
-    },
-    dequeueMessage(queuedId) {
-      return sendCommand((id) => ({ id, type: "dequeue", queuedId })).then(() => {
-      });
-    },
-    runSlashCommand(raw) {
-      return sendCommand((id) => ({ id, type: "slash-command", raw })).then(() => {
-      });
-    },
-    loadHistory(historyId) {
-      return sendCommand((id) => ({ id, type: "load-history", historyId })).then(() => {
-      });
-    },
-    reloadConfig() {
-      return sendCommand((id) => ({ id, type: "reload-config" })).then(() => {
-      });
-    },
-    cancelAuthFlow() {
-      return sendCommand((id) => ({ id, type: "cancel-auth-flow" })).then(() => {
-      });
-    },
-    serverCommands() {
-      return serverCommandList;
-    },
-    completePath(prefix) {
-      return sendCommand((id) => ({ id, type: "complete-path", prefix })).then(
-        (result) => Array.isArray(result) ? result.filter((entry) => typeof entry === "string") : []
-      );
-    },
-    completeModels() {
-      return sendCommand((id) => ({ id, type: "complete-models" })).then(toModelCompletion);
-    },
-    setConfig(patches) {
-      return sendCommand((id) => ({ id, type: "set-config", patches })).then(
-        (result) => result
-      );
-    },
-    listSkills() {
-      return sendCommand((id) => ({ id, type: "list-skills" })).then(
-        (result) => Array.isArray(result) ? result : []
-      );
-    },
-    getSkill(skillId) {
-      return sendCommand((id) => ({ id, type: "get-skill", skillId })).then(
-        (result) => result
-      );
+        scheduleReconnect();
+      }
+    );
+  };
+  connect();
+  return {
+    send(command) {
+      if (closed || phase !== "attached" || socket === null) return false;
+      socket.send(JSON.stringify(command));
+      return true;
     },
-    listAgents() {
-      return sendCommand((id) => ({ id, type: "list-agents" })).then(
-        (result) => Array.isArray(result) ? result : []
-      );
+    onFrame(listener) {
+      frameListeners.add(listener);
+      return () => {
+        frameListeners.delete(listener);
+      };
     },
-    getAgent(agentId) {
-      return sendCommand((id) => ({ id, type: "get-agent", agentId })).then(
-        (result) => result
-      );
+    close() {
+      if (closed) return;
+      terminate();
+      frameListeners.clear();
+      stateListeners.clear();
+      undeliverableListeners.clear();
     },
-    getCommand(name) {
-      return sendCommand((id) => ({ id, type: "get-command", name })).then(
-        (result) => result
-      );
+    connectionState() {
+      return state;
     },
-    listMcpServers() {
-      return sendCommand((id) => ({ id, type: "list-mcp-servers" })).then(
-        (result) => Array.isArray(result) ? result : []
-      );
+    onConnectionState(listener) {
+      stateListeners.add(listener);
+      return () => {
+        stateListeners.delete(listener);
+      };
     },
-    close() {
-      if (closed) return;
-      closed = true;
-      unsubscribe();
-      const error = new Error("SessionClient closed before the command was acknowledged.");
-      for (const { reject } of pending.values()) {
-        reject(error);
-      }
-      pending.clear();
+    onUndeliverable(listener) {
+      undeliverableListeners.add(listener);
+      return () => {
+        undeliverableListeners.delete(listener);
+      };
+    },
+    capabilities() {
+      return [...cachedCapabilities];
     }
   };
 }
 
-// src/client/uds-socket.ts
-import { WebSocket } from "ws";
-function udsUrl(socketPath) {
-  return `ws+unix://${socketPath}:/`;
+// src/client/daemon-client.ts
+var CLOSED_ERROR = "DaemonClient is closed.";
+function throwCollectedErrors(errors, message) {
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1) throw new AggregateError(errors, message);
 }
-function ensureLocalhostNoProxy() {
-  const ga = globalThis.GLOBAL_AGENT;
-  if (!ga) return;
-  const current = ga.NO_PROXY ?? "";
-  const entries = current.split(",").map((s) => s.trim()).filter(Boolean);
-  let changed = false;
-  for (const host of ["localhost", "127.0.0.1"]) {
-    if (!entries.includes(host)) {
-      entries.push(host);
-      changed = true;
-    }
-  }
-  if (changed) {
-    ga.NO_PROXY = entries.join(",");
-  }
+function bindDaemonDataClient(client, daemonId) {
+  return {
+    fetchTranscript: (historyId, opts) => client.fetchTranscript(daemonId, historyId, opts),
+    fetchHistory: (opts) => client.fetchHistory(daemonId, opts),
+    listWorkspaces: (opts) => client.listWorkspaces(daemonId, opts),
+    createWorkspace: (opts) => client.createWorkspace(daemonId, opts),
+    deleteSession: (historyId, opts) => client.deleteSession(daemonId, historyId, opts),
+    listProfiles: () => client.listProfiles(daemonId),
+    listProviders: (opts) => client.listProviders(daemonId, opts),
+    addProvider: (input) => client.addProvider(daemonId, input),
+    removeProvider: (providerId, opts) => client.removeProvider(daemonId, providerId, opts),
+    setDefaultProvider: (providerId, opts) => client.setDefaultProvider(daemonId, providerId, opts),
+    setProviderAuth: (providerId, credential, opts) => client.setProviderAuth(daemonId, providerId, credential, opts),
+    clearProviderAuth: (providerId, opts) => client.clearProviderAuth(daemonId, providerId, opts),
+    updateWorkspace: (name, patch) => client.updateWorkspace(daemonId, name, patch)
+  };
 }
-function udsSocketFactory(socketPath) {
-  const target = udsUrl(socketPath);
-  return (_url) => {
-    ensureLocalhostNoProxy();
-    return new WebSocket(target);
+function createDaemonClient(target, deps = {}) {
+  const dataClient = (() => {
+    switch (target.kind) {
+      case "local": {
+        if (!deps.udsFetch) {
+          throw new Error("A local DaemonClient requires deps.udsFetch.");
+        }
+        return createHttpDataClient({
+          baseUrl: "http://daemon",
+          getToken: async () => target.token,
+          fetchImpl: deps.udsFetch(target.socketPath)
+        });
+      }
+      case "direct":
+        return createHttpDataClient({
+          baseUrl: httpBaseFromWsUrl(target.wsUrl),
+          getToken: async () => target.token,
+          ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
+        });
+      case "relay":
+        return createHttpDataClient({
+          baseUrl: target.apiBaseUrl,
+          getToken: target.getAccessToken,
+          refreshAccessToken: target.refreshAccessToken,
+          ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
+        });
+    }
+  })();
+  const connections = /* @__PURE__ */ new Set();
+  const directorySockets = /* @__PURE__ */ new Set();
+  let closed = false;
+  const socketFactory = target.kind === "local" ? deps.socketFactory ?? udsSocketFactory(target.socketPath) : deps.socketFactory ?? defaultSocketFactory;
+  const requireOpen = () => {
+    if (closed) throw new Error(CLOSED_ERROR);
+  };
+  const directorySocketFactory = (url) => {
+    requireOpen();
+    const socket = socketFactory(url);
+    if (closed) {
+      socket.close();
+      throw new Error(CLOSED_ERROR);
+    }
+    let closeRequested = false;
+    let closeDelivered = false;
+    const closeListeners = /* @__PURE__ */ new Set();
+    let owned;
+    const deliverClose = () => {
+      if (closeDelivered) return;
+      closeDelivered = true;
+      closeRequested = true;
+      directorySockets.delete(owned);
+      const listeners = [...closeListeners];
+      closeListeners.clear();
+      const errors = [];
+      for (const listener of listeners) {
+        try {
+          listener();
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      throwCollectedErrors(errors, "Failed to deliver directory socket close listeners.");
+    };
+    owned = {
+      on(event, listener) {
+        if (event === "close") {
+          closeListeners.add(listener);
+          return owned;
+        }
+        return socket.on(event, listener);
+      },
+      send: (data) => socket.send(data),
+      close() {
+        if (closeRequested) return;
+        closeRequested = true;
+        directorySockets.delete(owned);
+        const errors = [];
+        try {
+          socket.close();
+        } catch (error) {
+          errors.push(error);
+        } finally {
+          try {
+            deliverClose();
+          } catch (error) {
+            errors.push(error);
+          }
+        }
+        throwCollectedErrors(errors, "Failed to close directory socket.");
+      }
+    };
+    directorySockets.add(owned);
+    socket.on("close", deliverClose);
+    return owned;
+  };
+  const acquireEndpoint = async () => {
+    requireOpen();
+    const endpoint = await dataClient.acquireEndpoint(target.id);
+    requireOpen();
+    return endpoint;
+  };
+  const endpointConfig = (selectedSocketFactory) => {
+    switch (target.kind) {
+      case "local":
+        return {
+          url: udsUrl(target.socketPath),
+          token: target.token,
+          socketFactory: selectedSocketFactory
+        };
+      case "direct":
+        return {
+          url: target.wsUrl,
+          token: target.token,
+          socketFactory: selectedSocketFactory
+        };
+      case "relay":
+        return {
+          getEndpoint: acquireEndpoint,
+          socketFactory: selectedSocketFactory
+        };
+    }
+  };
+  return {
+    target,
+    data: bindDaemonDataClient(dataClient, target.id),
+    directoryEndpoint() {
+      requireOpen();
+      return { name: target.name, ...endpointConfig(directorySocketFactory) };
+    },
+    openSession(sessionId, options = {}) {
+      requireOpen();
+      const transport = createWebSocketTransport({
+        ...endpointConfig(socketFactory),
+        sessionId,
+        ...options
+      });
+      const client = createSessionClient(transport);
+      let connectionClosed = false;
+      const connection = {
+        client,
+        transport,
+        close() {
+          if (connectionClosed) return;
+          connectionClosed = true;
+          connections.delete(connection);
+          const errors = [];
+          try {
+            client.close();
+          } catch (error) {
+            errors.push(error);
+          }
+          try {
+            transport.close();
+          } catch (error) {
+            errors.push(error);
+          }
+          throwCollectedErrors(errors, "Failed to close session connection.");
+        }
+      };
+      connections.add(connection);
+      return connection;
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      const errors = [];
+      for (const connection of [...connections]) {
+        try {
+          connection.close();
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      for (const socket of [...directorySockets]) {
+        directorySockets.delete(socket);
+        try {
+          socket.close();
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      connections.clear();
+      directorySockets.clear();
+      throwCollectedErrors(errors, "Failed to close DaemonClient resources.");
+    }
   };
 }
 
-// src/client/websocket.ts
+// src/client/directory.ts
 var toText2 = (data) => {
   if (typeof data === "string") return data;
   if (data instanceof Buffer) return data.toString("utf8");
@@ -949,133 +1110,123 @@ var parseMessage2 = (data) => {
     return null;
   }
 };
-function createWebSocketTransport(options) {
-  if (!options.getEndpoint && (options.url === void 0 || options.token === void 0)) {
-    throw new Error("createWebSocketTransport requires either url+token or getEndpoint.");
-  }
+function createServerDirectory(options) {
   const socketFactory = options.socketFactory ?? defaultSocketFactory;
-  const backoffInitialMs = options.backoffInitialMs ?? 500;
-  const backoffMaxMs = options.backoffMaxMs ?? 3e4;
-  const backoffFactor = options.backoffFactor ?? 2;
-  const frameListeners = /* @__PURE__ */ new Set();
-  const stateListeners = /* @__PURE__ */ new Set();
-  let state = "reconnecting";
-  let phase = "awaiting-welcome";
-  let socket = null;
-  let lastSeq = null;
-  let attempts = 0;
-  let attachCounter = 0;
-  let reconnectTimer = null;
+  const connectTimeoutMs = options.connectTimeoutMs ?? 5e3;
+  const listeners = /* @__PURE__ */ new Set();
+  const links = /* @__PURE__ */ new Map();
   let closed = false;
-  const setState = (next) => {
-    if (state === next) return;
-    state = next;
-    for (const listener of stateListeners) {
+  let view = { servers: [] };
+  const rebuildView = () => {
+    view = {
+      servers: Array.from(links.values(), (link) => ({
+        name: link.config.name,
+        url: link.resolvedUrl ?? link.config.url ?? "",
+        status: link.status
+      }))
+    };
+    for (const listener of listeners) {
       try {
-        listener(next);
+        listener();
       } catch {
       }
     }
   };
-  const deliver = (frame) => {
-    for (const listener of frameListeners) {
-      try {
-        listener(frame);
-      } catch {
-      }
+  const clearTimer = (link) => {
+    if (link.timer !== null) {
+      clearTimeout(link.timer);
+      link.timer = null;
     }
   };
-  const terminate = () => {
-    closed = true;
-    if (reconnectTimer !== null) {
-      clearTimeout(reconnectTimer);
-      reconnectTimer = null;
+  const rejectPending = (link, message) => {
+    const error = new Error(message);
+    for (const entry of link.pending.values()) {
+      if (entry.kind !== "list") entry.reject(error);
     }
-    const current = socket;
-    socket = null;
-    current?.close();
-    setState("closed");
+    link.pending.clear();
   };
-  const scheduleReconnect = () => {
-    if (closed || reconnectTimer !== null) return;
-    setState("reconnecting");
-    const delay = Math.min(backoffInitialMs * backoffFactor ** attempts, backoffMaxMs);
-    attempts += 1;
-    reconnectTimer = setTimeout(() => {
-      reconnectTimer = null;
-      connect();
-    }, delay);
+  const markOffline = (link, message) => {
+    clearTimer(link);
+    link.ready = false;
+    const current = link.socket;
+    link.socket = null;
+    current?.close();
+    rejectPending(link, message);
+    link.status = { state: "offline", error: message };
+    rebuildView();
   };
-  const completeAttach = () => {
-    phase = "attached";
-    attempts = 0;
-    setState("connected");
+  const sendList = (link) => {
+    if (!link.ready || link.socket === null) return;
+    link.commandCounter += 1;
+    const id = `dir-${link.commandCounter}`;
+    link.pending.set(id, { kind: "list" });
+    link.socket.send(JSON.stringify({ id, type: "list-sessions" }));
   };
-  const handleMessage = (message) => {
+  const handleMessage = (link, message) => {
     if (message.type === "rejected") {
-      terminate();
-      options.onRejected?.(message.reason);
+      markOffline(
+        link,
+        message.reason === "auth" ? `Token rejected by "${link.config.name}" \u2014 check the configured token.` : `Protocol version mismatch with "${link.config.name}" \u2014 upgrade the daemon or this client.`
+      );
       return;
     }
-    if (message.type === "detached") {
-      terminate();
-      options.onDetached?.(message.reason);
+    if (message.type === "welcome") {
+      link.ready = true;
+      clearTimer(link);
+      rebuildView();
+      sendList(link);
       return;
     }
-    if (phase === "awaiting-welcome") {
-      if (message.type !== "welcome") return;
-      phase = "awaiting-attach";
-      setState("replaying");
-      attachCounter += 1;
-      socket?.send(
-        JSON.stringify({
-          id: `attach-${attachCounter}`,
-          type: "attach",
-          sessionId: options.sessionId,
-          ...lastSeq !== null ? { lastSeq } : {}
-        })
-      );
+    if (message.type === "session-list") {
+      const entry = link.pending.get(message.id);
+      if (entry?.kind !== "list") return;
+      link.pending.delete(message.id);
+      link.status = { state: "online", sessions: message.sessions };
+      rebuildView();
       return;
     }
-    if (phase === "awaiting-attach") {
-      if (message.type === "replay") {
-        for (const event of message.events) {
-          lastSeq = event.seq;
-          deliver(event);
-        }
-        completeAttach();
-        return;
-      }
-      if (message.type === "snapshot") {
-        lastSeq = message.snapshot.seq;
-        deliver(message);
-        completeAttach();
+    if (message.type === "session-created") {
+      const entry = link.pending.get(message.id);
+      if (entry?.kind !== "create" && entry?.kind !== "resume") return;
+      link.pending.delete(message.id);
+      entry.resolve(message.session);
+      if (link.status.state === "online") {
+        const sessions = link.status.sessions.some((existing) => existing.id === message.session.id) ? link.status.sessions : [...link.status.sessions, message.session];
+        link.status = { state: "online", sessions };
+        rebuildView();
       }
       return;
     }
     if (message.type === "ack") {
-      deliver(message);
-      return;
-    }
-    if (message.type === "snapshot") {
-      lastSeq = message.snapshot.seq;
-      deliver(message);
-      return;
-    }
-    if (message.type === "welcome" || message.type === "replay" || message.type === "session-list" || message.type === "session-created") {
+      const entry = link.pending.get(message.id);
+      if (!entry || entry.kind === "list") return;
+      link.pending.delete(message.id);
+      if (!message.ok) {
+        entry.reject(new Error(message.error?.message ?? "Command failed."));
+        return;
+      }
+      if (entry.kind === "kill") {
+        entry.resolve();
+        sendList(link);
+        return;
+      }
+      if (entry.kind === "complete") {
+        entry.resolve(
+          Array.isArray(message.result) ? message.result.filter((item) => typeof item === "string") : []
+        );
+        return;
+      }
+      entry.reject(new Error("Unexpected ack for create-session / resume-session."));
       return;
     }
-    lastSeq = message.seq;
-    deliver(message);
   };
-  const openSocket = (endpoint) => {
-    if (closed) return;
-    phase = "awaiting-welcome";
-    const current = socketFactory(endpoint.url);
-    socket = current;
-    current.on("open", () => {
-      if (closed || socket !== current) return;
-      current.send(
+  const openLinkSocket = (link, endpoint) => {
+    link.resolvedUrl = endpoint.url;
+    const socket = (link.config.socketFactory ?? socketFactory)(endpoint.url);
+    link.socket = socket;
+    socket.on("open", () => {
+      if (closed || link.socket !== socket) return;
+      socket.send(
         JSON.stringify({
           type: "hello",
           protocolVersion: PROTOCOL_VERSION,
@@ -1083,75 +1234,245 @@ function createWebSocketTransport(options) {
         })
       );
     });
-    current.on("message", (data) => {
-      if (closed || socket !== current) return;
+    socket.on("message", (data) => {
+      if (closed || link.socket !== socket) return;
       const message = parseMessage2(data);
-      if (message) handleMessage(message);
+      if (message) handleMessage(link, message);
     });
-    current.on("error", () => {
+    socket.on("error", () => {
     });
-    current.on("close", () => {
-      if (socket !== current) return;
-      socket = null;
+    socket.on("close", () => {
+      if (link.socket !== socket) return;
+      link.socket = null;
       if (closed) return;
-      scheduleReconnect();
+      if (link.status.state !== "offline") {
+        markOffline(link, `Connection to "${link.config.name}" closed.`);
+      }
     });
   };
-  const connect = () => {
+  const connect = (link) => {
     if (closed) return;
-    const getEndpoint = options.getEndpoint;
+    link.ready = false;
+    link.status = { state: "connecting" };
+    clearTimer(link);
+    link.timer = setTimeout(() => {
+      link.timer = null;
+      if (!link.ready) {
+        markOffline(link, `Timed out connecting to "${link.config.name}".`);
+      }
+    }, connectTimeoutMs);
+    const getEndpoint = link.config.getEndpoint;
     if (!getEndpoint) {
-      openSocket({ url: options.url, credential: { token: options.token } });
+      openLinkSocket(link, {
+        url: link.config.url,
+        credential: { token: link.config.token }
+      });
+      rebuildView();
       return;
     }
     void getEndpoint().then(
       (endpoint) => {
-        if (closed) return;
-        openSocket(endpoint);
+        if (closed || link.status.state !== "connecting" || link.socket !== null) return;
+        openLinkSocket(link, endpoint);
+        rebuildView();
       },
       (error) => {
-        if (closed) return;
-        if (error instanceof TerminalEndpointError) {
-          terminate();
-          options.onDetached?.(error.reason);
-          return;
-        }
-        scheduleReconnect();
+        if (closed || link.status.state !== "connecting") return;
+        markOffline(
+          link,
+          `Endpoint for "${link.config.name}" unavailable: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
     );
+    rebuildView();
   };
-  connect();
+  const linkFor = (server) => {
+    const link = links.get(server);
+    if (!link) return new Error(`Unknown server "${server}".`);
+    if (closed || !link.ready || link.socket === null) {
+      return new Error(`Server "${server}" is not connected.`);
+    }
+    return link;
+  };
+  for (const config of options.servers) {
+    if (!config.getEndpoint && (config.url === void 0 || config.token === void 0)) {
+      throw new Error(`Server "${config.name}" needs either url+token or a getEndpoint provider.`);
+    }
+    links.set(config.name, {
+      config,
+      status: { state: "connecting" },
+      socket: null,
+      ready: false,
+      pending: /* @__PURE__ */ new Map(),
+      timer: null,
+      commandCounter: 0
+    });
+  }
+  rebuildView();
+  for (const link of links.values()) {
+    connect(link);
+  }
   return {
-    send(command) {
-      if (closed || phase !== "attached" || socket === null) return;
-      socket.send(JSON.stringify(command));
+    getView() {
+      return view;
     },
-    onFrame(listener) {
-      frameListeners.add(listener);
+    subscribe(listener) {
+      listeners.add(listener);
       return () => {
-        frameListeners.delete(listener);
+        listeners.delete(listener);
       };
     },
-    close() {
+    refresh() {
       if (closed) return;
-      terminate();
-      frameListeners.clear();
-      stateListeners.clear();
+      for (const link of links.values()) {
+        if (link.status.state === "offline") {
+          connect(link);
+        } else if (link.ready) {
+          sendList(link);
+        }
+      }
     },
-    connectionState() {
-      return state;
+    setServers(configs) {
+      if (closed) return;
+      for (const config of configs) {
+        if (!links.has(config.name) && !config.getEndpoint) {
+          if (config.url === void 0 || config.token === void 0) {
+            throw new Error(
+              `Server "${config.name}" needs either url+token or a getEndpoint provider.`
+            );
+          }
+        }
+      }
+      const nextNames = new Set(configs.map((config) => config.name));
+      for (const [name, link] of links) {
+        if (nextNames.has(name)) continue;
+        clearTimer(link);
+        rejectPending(link, `Server "${name}" was removed from the directory.`);
+        const socket = link.socket;
+        link.socket = null;
+        socket?.close();
+        links.delete(name);
+      }
+      const added = [];
+      for (const config of configs) {
+        const existing = links.get(config.name);
+        if (existing) {
+          existing.config = config;
+          continue;
+        }
+        const link = {
+          config,
+          status: { state: "connecting" },
+          socket: null,
+          ready: false,
+          pending: /* @__PURE__ */ new Map(),
+          timer: null,
+          commandCounter: 0
+        };
+        links.set(config.name, link);
+        added.push(link);
+      }
+      rebuildView();
+      for (const link of added) {
+        connect(link);
+      }
     },
-    onConnectionState(listener) {
-      stateListeners.add(listener);
-      return () => {
-        stateListeners.delete(listener);
-      };
+    createSession(server, createOptions) {
+      return new Promise((resolve, reject) => {
+        const link = linkFor(server);
+        if (link instanceof Error) {
+          reject(link);
+          return;
+        }
+        link.commandCounter += 1;
+        const id = `dir-${link.commandCounter}`;
+        link.pending.set(id, { kind: "create", resolve, reject });
+        link.socket?.send(
+          JSON.stringify({
+            id,
+            type: "create-session",
+            cwd: createOptions.cwd,
+            ...createOptions.name !== void 0 ? { name: createOptions.name } : {},
+            ...createOptions.workspace !== void 0 ? { workspace: createOptions.workspace } : {},
+            ...createOptions.profile !== void 0 ? { profile: createOptions.profile } : {},
+            ...createOptions.headless === true ? { headless: true } : {},
+            ...createOptions.approvalMode !== void 0 ? { approvalMode: createOptions.approvalMode } : {},
+            ...createOptions.activeProvider !== void 0 ? { activeProvider: createOptions.activeProvider } : {},
+            ...createOptions.activeModel !== void 0 ? { activeModel: createOptions.activeModel } : {}
+          })
+        );
+      });
+    },
+    resumeSession(server, historyId, resumeOptions) {
+      return new Promise((resolve, reject) => {
+        const link = linkFor(server);
+        if (link instanceof Error) {
+          reject(link);
+          return;
+        }
+        link.commandCounter += 1;
+        const id = `dir-${link.commandCounter}`;
+        link.pending.set(id, { kind: "resume", resolve, reject });
+        link.socket?.send(
+          JSON.stringify({
+            id,
+            type: "resume-session",
+            historyId,
+            cwd: resumeOptions.cwd,
+            ...resumeOptions.name !== void 0 ? { name: resumeOptions.name } : {},
+            ...resumeOptions.workspace !== void 0 ? { workspace: resumeOptions.workspace } : {},
+            ...resumeOptions.profile !== void 0 ? { profile: resumeOptions.profile } : {}
+          })
+        );
+      });
+    },
+    killSession(server, sessionId, options2) {
+      return new Promise((resolve, reject) => {
+        const link = linkFor(server);
+        if (link instanceof Error) {
+          reject(link);
+          return;
+        }
+        link.commandCounter += 1;
+        const id = `dir-${link.commandCounter}`;
+        link.pending.set(id, { kind: "kill", resolve, reject });
+        link.socket?.send(
+          JSON.stringify({ id, type: "kill-session", sessionId, delete: options2?.delete })
+        );
+      });
+    },
+    completePath(server, prefix) {
+      return new Promise((resolve, reject) => {
+        const link = linkFor(server);
+        if (link instanceof Error) {
+          reject(link);
+          return;
+        }
+        link.commandCounter += 1;
+        const id = `dir-${link.commandCounter}`;
+        link.pending.set(id, { kind: "complete", resolve, reject });
+        link.socket?.send(JSON.stringify({ id, type: "complete-path", prefix }));
+      });
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      for (const link of links.values()) {
+        clearTimer(link);
+        rejectPending(link, "ServerDirectory closed.");
+        const socket = link.socket;
+        link.socket = null;
+        socket?.close();
+      }
+      listeners.clear();
     }
   };
 }
 export {
   TerminalEndpointError,
   adaptWhatwgSocket,
+  bindDaemonDataClient,
+  createDaemonClient,
   createHttpDataClient,
   createServerDirectory,
   createSessionClient,