@nuvin/session 0.1.0-rc.5

package/dist/client/index.js

@@ -0,0 +1,1060 @@
+import {
+  createSessionViewState,
+  reduceSessionEvent
+} from "../chunk-FR3R66RD.js";
+import {
+  PROTOCOL_VERSION
+} from "../chunk-7G3R25NS.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)."
+    );
+  }
+  return candidate;
+}
+function defaultSocketFactory(url) {
+  const WebSocketCtor = globalWebSocketConstructor();
+  return adaptWhatwgSocket(new WebSocketCtor(url));
+}
+
+// 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");
+  }
+  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 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 === "history-list") {
+      const entry = link.pending.get(message.id);
+      if (entry?.kind !== "history") return;
+      link.pending.delete(message.id);
+      entry.resolve({ sessions: message.sessions, currentWorkspace: message.currentWorkspace });
+      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 === "delete-history") {
+        entry.resolve();
+        sendList(link);
+        return;
+      }
+      if (entry.kind === "complete") {
+        entry.resolve(
+          Array.isArray(message.result) ? message.result.filter((item) => typeof item === "string") : []
+        );
+        return;
+      }
+      if (entry.kind === "list-workspaces") {
+        entry.resolve(Array.isArray(message.result) ? message.result : []);
+        return;
+      }
+      if (entry.kind === "create-workspace") {
+        entry.resolve(message.result);
+        return;
+      }
+      if (entry.kind === "list-profiles") {
+        entry.resolve(Array.isArray(message.result) ? message.result : []);
+        return;
+      }
+      if (entry.kind === "list-providers") {
+        entry.resolve(Array.isArray(message.result) ? message.result : []);
+        return;
+      }
+      if (entry.kind === "provider-mutation") {
+        entry.resolve();
+        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 = 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.`);
+      }
+    });
+  };
+  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 }));
+      });
+    },
+    listWorkspaces(server, opts) {
+      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-workspaces", resolve, reject });
+        link.socket?.send(
+          JSON.stringify({
+            id,
+            type: "list-workspaces",
+            ...opts?.profile !== void 0 ? { profile: opts.profile } : {}
+          })
+        );
+      });
+    },
+    createWorkspace(server, opts) {
+      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-workspace", resolve, reject });
+        link.socket?.send(
+          JSON.stringify({
+            id,
+            type: "create-workspace",
+            name: opts.name,
+            ...opts.root !== void 0 ? { root: opts.root } : {},
+            ...opts.profile !== void 0 ? { profile: opts.profile } : {}
+          })
+        );
+      });
+    },
+    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" }));
+      });
+    },
+    listProviders(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-providers", resolve, reject });
+        link.socket?.send(JSON.stringify({ id, type: "list-providers" }));
+      });
+    },
+    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 }));
+      });
+    },
+    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 })
+        );
+      });
+    },
+    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 }));
+      });
+    },
+    listHistory(server, opts) {
+      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: "history", resolve, reject });
+          link.socket?.send(
+            JSON.stringify({
+              id,
+              type: "list-history",
+              ...opts?.profile !== void 0 ? { profile: opts.profile } : {},
+              ...opts?.cwd !== void 0 ? { cwd: opts.cwd } : {}
+            })
+          );
+        }
+      );
+    },
+    deleteHistory(server, historyId, opts) {
+      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: "delete-history", resolve, reject });
+        link.socket?.send(
+          JSON.stringify({
+            id,
+            type: "delete-history",
+            historyId,
+            workspace: opts.workspace,
+            ...opts.profile !== void 0 ? { profile: opts.profile } : {}
+          })
+        );
+      });
+    },
+    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/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(() => {
+      });
+    },
+    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);
+    },
+    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/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 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 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" || message.type === "history-list") {
+      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 = parseMessage2(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);
+      };
+    }
+  };
+}
+export {
+  TerminalEndpointError,
+  adaptWhatwgSocket,
+  createServerDirectory,
+  createSessionClient,
+  createWebSocketTransport,
+  defaultSocketFactory,
+  udsSocketFactory,
+  udsUrl
+};