@nuvin/session 0.1.0-rc.10

package/dist/client/index.js

@@ -0,0 +1,1418 @@
+import {
+  createSessionViewState,
+  reduceSessionEvent
+} from "../chunk-3S4DZMX3.js";
+import {
+  PROTOCOL_VERSION
+} from "../chunk-HJ666YLF.js";
+
+// 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, 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."
+    );
+  }
+  const mapped = terminal?.[response.status];
+  if (mapped) {
+    throw new TerminalEndpointError(
+      mapped.reason,
+      typeof body?.message === "string" ? body.message : mapped.message
+    );
+  }
+  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 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) {
+      await throwFromResponse(
+        response,
+        "Authentication required",
+        void 0,
+        options.onUnauthorized
+      );
+    }
+    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 (!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 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 (response.status === 401) {
+        throwUnauthorized();
+      }
+      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();
+    },
+    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 } : {}
+        })
+      });
+      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");
+    },
+    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." }
+        });
+      }
+      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." }
+        });
+      }
+      return await response.json();
+    },
+    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();
+    },
+    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();
+    },
+    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 scheduleNotify = () => {
+    if (notifyScheduled) return;
+    notifyScheduled = true;
+    queueMicrotask(() => {
+      notifyScheduled = false;
+      for (const listener of stateListeners) {
+        try {
+          listener();
+        } catch {
+        }
+      }
+    });
+  };
+  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."));
+      }
+      return;
+    }
+    state = reduceSessionEvent(state, frame);
+    seq = frame.seq;
+    for (const listener of eventListeners) {
+      try {
+        listener(frame);
+      } catch {
+      }
+    }
+    scheduleNotify();
+  });
+  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 });
+      transport.send(build(id));
+    });
+  };
+  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(
+        () => {
+        }
+      );
+    },
+    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(() => {
+      });
+    },
+    cancelAuthFlow() {
+      return sendCommand((id) => ({ id, type: "cancel-auth-flow" })).then(() => {
+      });
+    },
+    mcpAction(action, serverName) {
+      return sendCommand((id) => ({ id, type: "mcp-action", action, serverName })).then(
+        (result) => result
+      );
+    },
+    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 : []
+      );
+    },
+    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();
+    }
+  };
+}
+
+// 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;
+};
+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;
+  }
+};
+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();
+  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;
+  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 terminate = () => {
+    closed = true;
+    if (reconnectTimer !== null) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    const current = socket;
+    socket = null;
+    current?.close();
+    setState("closed");
+  };
+  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;
+      phase = "awaiting-attach";
+      setState("replaying");
+      attachCounter += 1;
+      socket?.send(
+        JSON.stringify({
+          id: `attach-${attachCounter}`,
+          type: "attach",
+          sessionId: options.sessionId,
+          ...lastSeq !== null ? { lastSeq } : {}
+        })
+      );
+      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();
+      }
+      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") {
+      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(
+        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;
+      scheduleReconnect();
+    });
+  };
+  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;
+        }
+        scheduleReconnect();
+      }
+    );
+  };
+  connect();
+  return {
+    send(command) {
+      if (closed || phase !== "attached" || socket === null) return;
+      socket.send(JSON.stringify(command));
+    },
+    onFrame(listener) {
+      frameListeners.add(listener);
+      return () => {
+        frameListeners.delete(listener);
+      };
+    },
+    close() {
+      if (closed) return;
+      terminate();
+      frameListeners.clear();
+      stateListeners.clear();
+    },
+    connectionState() {
+      return state;
+    },
+    onConnectionState(listener) {
+      stateListeners.add(listener);
+      return () => {
+        stateListeners.delete(listener);
+      };
+    }
+  };
+}
+
+// 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 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 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/directory.ts
+var toText2 = (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;
+};
+var parseMessage2 = (data) => {
+  const text = toText2(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;
+  }
+};
+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();
+  };
+  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 = (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();
+      }
+      return;
+    }
+    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;
+      }
+      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;
+    }
+  };
+  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
+        })
+      );
+    });
+    socket.on("message", (data) => {
+      if (closed || link.socket !== socket) return;
+      const message = parseMessage2(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.`);
+      }
+    });
+  };
+  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}".`);
+      }
+    }, 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)}`
+        );
+      }
+    );
+    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;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    refresh() {
+      if (closed) return;
+      for (const link of links.values()) {
+        if (link.status.state === "offline") {
+          connect(link);
+        } else if (link.ready) {
+          sendList(link);
+        }
+      }
+    },
+    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);
+      }
+    },
+    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 } : {}
+          })
+        );
+      });
+    },
+    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,
+  createWebSocketTransport,
+  defaultSocketFactory,
+  httpBaseFromWsUrl,
+  udsSocketFactory,
+  udsUrl
+};