@researai/deepscientist 1.5.15 → 1.5.17

package/src/ui/dist/assets/useCliAccess-Bnop4mgR.js

@@ -1,957 +0,0 @@
-import { x as supportsSocketIo, D as resolveApiBaseUrl, y as lookup, z as useAuthStore, O as ConnectionState, r as reactExports, Y as checkProjectAccess } from './index-D_E4281X.js';
-
-const SOCKET_CACHE = /* @__PURE__ */ new Map();
-const CLIENT_ID_KEY = "ds_cli_client_id";
-let cachedClientId = null;
-function createNoopCliSocket() {
-  const socket = {
-    connected: false,
-    connect: () => socket,
-    disconnect: () => socket,
-    on: () => socket,
-    off: () => socket,
-    emit: () => true
-  };
-  return socket;
-}
-function getCliClientId() {
-  if (cachedClientId) return cachedClientId;
-  let clientId = "";
-  if (typeof window !== "undefined") {
-    try {
-      clientId = window.localStorage.getItem(CLIENT_ID_KEY) || "";
-    } catch {
-      clientId = "";
-    }
-  }
-  if (!clientId) {
-    try {
-      clientId = crypto.randomUUID();
-    } catch {
-      clientId = `cli-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
-    }
-    if (typeof window !== "undefined") {
-      try {
-        window.localStorage.setItem(CLIENT_ID_KEY, clientId);
-      } catch {
-      }
-    }
-  }
-  cachedClientId = clientId;
-  return clientId;
-}
-function acquireCliSocket(options = {}) {
-  if (!supportsSocketIo()) {
-    return {
-      socket: createNoopCliSocket(),
-      release: () => {
-      }
-    };
-  }
-  const endpoint = resolveApiBaseUrl();
-  const cacheKey = `${endpoint}::user`;
-  let entry = SOCKET_CACHE.get(cacheKey);
-  if (!entry) {
-    const socket = lookup(`${endpoint}/cli`, {
-      path: "/ws/socket.io",
-      autoConnect: false,
-      transports: ["websocket", "polling"],
-      auth: (cb) => {
-        const client_id = getCliClientId();
-        const protocol_version = "cli.v1";
-        const token = useAuthStore.getState().accessToken || (typeof window !== "undefined" ? window.localStorage.getItem("ds_access_token") : null);
-        cb({ token: token || null, client_id, protocol_version });
-      }
-    });
-    entry = { socket, refCount: 0 };
-    SOCKET_CACHE.set(cacheKey, entry);
-  }
-  entry.refCount += 1;
-  if (!entry.socket.connected) {
-    entry.socket.connect();
-  }
-  return {
-    socket: entry.socket,
-    release: () => {
-      const current = SOCKET_CACHE.get(cacheKey);
-      if (!current) return;
-      current.refCount -= 1;
-      if (current.refCount <= 0) {
-        current.socket.disconnect();
-        SOCKET_CACHE.delete(cacheKey);
-      }
-    }
-  };
-}
-function unwrapPayload(data) {
-  if (data && typeof data === "object" && "payload" in data) {
-    return data.payload;
-  }
-  return data;
-}
-
-let seqCounter = 0;
-function nextSeq() {
-  seqCounter += 1;
-  return seqCounter;
-}
-function wrapEnvelope(payload, meta = {}) {
-  return {
-    protocol_version: "cli.v1",
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    payload,
-    ...meta
-  };
-}
-
-const connectionTransitions = {
-  [ConnectionState.DISCONNECTED]: {
-    CONNECT: ConnectionState.CONNECTING
-  },
-  [ConnectionState.CONNECTING]: {
-    AUTH_SUCCESS: ConnectionState.AUTHENTICATING,
-    DISCONNECT: ConnectionState.DISCONNECTED,
-    CONNECTION_LOST: ConnectionState.RECONNECTING
-  },
-  [ConnectionState.AUTHENTICATING]: {
-    AUTH_SUCCESS: ConnectionState.CONNECTED,
-    AUTH_FAILURE: ConnectionState.FAILED,
-    CONNECTION_LOST: ConnectionState.RECONNECTING
-  },
-  [ConnectionState.CONNECTED]: {
-    DISCONNECT: ConnectionState.DISCONNECTED,
-    CONNECTION_LOST: ConnectionState.RECONNECTING,
-    SUSPEND: ConnectionState.SUSPENDED
-  },
-  [ConnectionState.RECONNECTING]: {
-    RECONNECT_SUCCESS: ConnectionState.CONNECTED,
-    MAX_RETRIES_EXCEEDED: ConnectionState.FAILED,
-    DISCONNECT: ConnectionState.DISCONNECTED
-  },
-  [ConnectionState.SUSPENDED]: {
-    RESUME: ConnectionState.CONNECTING,
-    DISCONNECT: ConnectionState.DISCONNECTED
-  },
-  [ConnectionState.FAILED]: {
-    CONNECT: ConnectionState.CONNECTING,
-    DISCONNECT: ConnectionState.DISCONNECTED
-  }
-};
-class ConnectionStateMachine {
-  state = ConnectionState.DISCONNECTED;
-  listeners = /* @__PURE__ */ new Set();
-  getState() {
-    return this.state;
-  }
-  sendEvent(event) {
-    const nextState = connectionTransitions[this.state]?.[event.type];
-    if (!nextState) {
-      console.warn(`Invalid connection transition: ${this.state} -> ${event.type}`);
-      return false;
-    }
-    const prevState = this.state;
-    this.state = nextState;
-    this.notifyListeners(nextState, event);
-    if (prevState !== nextState) {
-      console.debug(`[CLI] Connection state: ${prevState} -> ${nextState} (${event.type})`);
-    }
-    return true;
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  canSendEvent(eventType) {
-    return Boolean(connectionTransitions[this.state]?.[eventType]);
-  }
-  reset() {
-    this.state = ConnectionState.DISCONNECTED;
-  }
-  notifyListeners(state, event) {
-    this.listeners.forEach((listener) => listener(state, event));
-  }
-}
-
-class ConnectionMetricsCollector {
-  metrics = {
-    totalConnections: 0,
-    successfulConnections: 0,
-    failedConnections: 0,
-    reconnectionAttempts: 0,
-    averageReconnectTime: 0,
-    messagesBuffered: 0,
-    messagesDropped: 0
-  };
-  recordConnection() {
-    this.metrics.totalConnections += 1;
-  }
-  recordConnectionSuccess() {
-    this.metrics.successfulConnections += 1;
-  }
-  recordConnectionFailure() {
-    this.metrics.failedConnections += 1;
-  }
-  recordReconnectionAttempt(durationMs) {
-    this.metrics.reconnectionAttempts += 1;
-    const attempts = this.metrics.reconnectionAttempts;
-    this.metrics.averageReconnectTime = (this.metrics.averageReconnectTime * (attempts - 1) + durationMs) / attempts;
-  }
-  recordMessageBuffered(count = 1) {
-    this.metrics.messagesBuffered += count;
-  }
-  recordMessageDropped(count = 1) {
-    this.metrics.messagesDropped += count;
-  }
-  getMetrics() {
-    return { ...this.metrics };
-  }
-}
-
-class MessageBuffer {
-  buffer = [];
-  maxSize;
-  onOverflow;
-  constructor(options = {}) {
-    this.maxSize = options.maxSize ?? 1e3;
-    this.onOverflow = options.onOverflow ?? "drop_oldest";
-  }
-  enqueue(message) {
-    this.pruneExpired();
-    if (this.buffer.length >= this.maxSize) {
-      switch (this.onOverflow) {
-        case "drop_oldest": {
-          this.buffer.sort((a, b) => {
-            const priorityOrder = { high: 0, normal: 1, low: 2 };
-            return priorityOrder[b.priority] - priorityOrder[a.priority] || a.timestamp - b.timestamp;
-          });
-          this.buffer.pop();
-          break;
-        }
-        case "drop_newest":
-          return false;
-        case "reject":
-          throw new Error("Message buffer overflow");
-      }
-    }
-    const bufferedMessage = {
-      ...message,
-      id: crypto.randomUUID(),
-      timestamp: Date.now()
-    };
-    this.buffer.push(bufferedMessage);
-    return true;
-  }
-  flush() {
-    this.pruneExpired();
-    const messages = [...this.buffer].sort((a, b) => {
-      const priorityOrder = { high: 0, normal: 1, low: 2 };
-      const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
-      return priorityDiff !== 0 ? priorityDiff : a.timestamp - b.timestamp;
-    });
-    this.buffer = [];
-    return messages;
-  }
-  getStatus() {
-    return {
-      size: this.buffer.length,
-      maxSize: this.maxSize,
-      oldestTimestamp: this.buffer.length > 0 ? Math.min(...this.buffer.map((message) => message.timestamp)) : null
-    };
-  }
-  clear() {
-    this.buffer = [];
-  }
-  countByPriority(priority) {
-    return this.buffer.filter((message) => message.priority === priority).length;
-  }
-  pruneExpired() {
-    const now = Date.now();
-    this.buffer = this.buffer.filter((message) => {
-      if (!message.maxAge) return true;
-      return now - message.timestamp < message.maxAge;
-    });
-  }
-}
-
-const DEFAULT_RECONNECTION_CONFIG = {
-  initialDelay: 1e3,
-  maxDelay: 3e5,
-  maxRetries: 30,
-  backoffMultiplier: 1.5,
-  jitterFactor: 0.2
-};
-class ReconnectionManager {
-  config;
-  retryCount = 0;
-  currentTimeout = null;
-  listeners = /* @__PURE__ */ new Set();
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_RECONNECTION_CONFIG, ...config };
-  }
-  calculateDelay() {
-    const baseDelay = Math.min(
-      this.config.initialDelay * Math.pow(this.config.backoffMultiplier, this.retryCount),
-      this.config.maxDelay
-    );
-    const jitter = baseDelay * this.config.jitterFactor * (Math.random() * 2 - 1);
-    return Math.max(0, Math.floor(baseDelay + jitter));
-  }
-  scheduleReconnect(onReconnect) {
-    if (this.retryCount >= this.config.maxRetries) {
-      this.notifyListeners({
-        status: "failed",
-        message: `Max retries reached (${this.config.maxRetries})`
-      });
-      return;
-    }
-    const delay = this.calculateDelay();
-    this.retryCount += 1;
-    this.notifyListeners({
-      status: "waiting",
-      retryCount: this.retryCount,
-      maxRetries: this.config.maxRetries,
-      nextRetryIn: delay
-    });
-    this.currentTimeout = setTimeout(async () => {
-      this.notifyListeners({ status: "reconnecting", retryCount: this.retryCount });
-      try {
-        const success = await onReconnect();
-        if (success) {
-          this.reset();
-          this.notifyListeners({ status: "connected" });
-          return;
-        }
-      } catch (error) {
-        console.error("[CLI] Reconnect failed:", error);
-      }
-      this.scheduleReconnect(onReconnect);
-    }, delay);
-  }
-  reset() {
-    this.retryCount = 0;
-    if (this.currentTimeout) {
-      clearTimeout(this.currentTimeout);
-      this.currentTimeout = null;
-    }
-  }
-  cancel() {
-    this.reset();
-    this.notifyListeners({ status: "cancelled" });
-  }
-  retryNow(onReconnect) {
-    this.cancel();
-    this.retryCount = 0;
-    this.scheduleReconnect(onReconnect);
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  getRetryCount() {
-    return this.retryCount;
-  }
-  notifyListeners(state) {
-    this.listeners.forEach((listener) => listener(state));
-  }
-}
-
-const CLI_OFFLINE_MESSAGE = "CLI server offline. Please ensure the CLI is running.";
-const normalizeGatewayError = (message) => {
-  const lower = message.toLowerCase();
-  if (lower.includes("cli server") && (lower.includes("not connected") || lower.includes("offline")) || lower.includes("cli_server_not_connected") || lower.includes("cli_server_offline")) {
-    return CLI_OFFLINE_MESSAGE;
-  }
-  return message;
-};
-function useCliSocket(options) {
-  const { projectId, serverId, handlers } = options;
-  const clientIdRef = reactExports.useRef(getCliClientId());
-  const reconnectRef = reactExports.useRef(new ReconnectionManager());
-  const reconnectingRef = reactExports.useRef(false);
-  const bufferRef = reactExports.useRef(new MessageBuffer());
-  const stateMachineRef = reactExports.useRef(new ConnectionStateMachine());
-  const metricsRef = reactExports.useRef(new ConnectionMetricsCollector());
-  const reconnectStartedAtRef = reactExports.useRef(null);
-  const subscribedRef = reactExports.useRef(false);
-  const subscribeInFlightRef = reactExports.useRef(null);
-  const scheduleReconnectRef = reactExports.useRef(() => {
-  });
-  const [status, setStatus] = reactExports.useState(() => ({
-    state: stateMachineRef.current.getState(),
-    bufferedMessages: 0,
-    metrics: metricsRef.current.getMetrics()
-  }));
-  const { socket, release } = reactExports.useMemo(() => acquireCliSocket(), []);
-  const syncMetrics = reactExports.useCallback(() => {
-    setStatus((prev) => ({
-      ...prev,
-      metrics: metricsRef.current.getMetrics()
-    }));
-  }, []);
-  const updateBufferedStatus = reactExports.useCallback(() => {
-    const bufferStatus = bufferRef.current.getStatus();
-    setStatus((prev) => ({
-      ...prev,
-      bufferedMessages: bufferStatus.size,
-      metrics: metricsRef.current.getMetrics()
-    }));
-  }, []);
-  const emitEnvelope = reactExports.useCallback(
-    (event, payload, meta = {}, options2) => {
-      if (!projectId || !serverId) return;
-      const envelope = wrapEnvelope(payload, {
-        project_id: projectId,
-        server_id: serverId,
-        client_id: clientIdRef.current,
-        ...meta
-      });
-      if (!socket.connected) {
-        try {
-          const accepted = bufferRef.current.enqueue({
-            type: event,
-            payload: envelope,
-            priority: options2?.priority ?? "normal",
-            maxAge: options2?.maxAge
-          });
-          if (!accepted) {
-            metricsRef.current.recordMessageDropped();
-            syncMetrics();
-            handlers?.onError?.("Message buffer full; dropping newest message");
-          } else {
-            metricsRef.current.recordMessageBuffered();
-          }
-        } catch (error) {
-          metricsRef.current.recordMessageDropped();
-          syncMetrics();
-          handlers?.onError?.(error instanceof Error ? error.message : "Message buffer error");
-        }
-        updateBufferedStatus();
-        return;
-      }
-      socket.emit(event, envelope);
-    },
-    [projectId, serverId, socket, handlers, updateBufferedStatus, syncMetrics]
-  );
-  const flushBuffer = reactExports.useCallback(() => {
-    if (!socket.connected) return;
-    const messages = bufferRef.current.flush();
-    messages.forEach((message) => socket.emit(message.type, message.payload));
-    updateBufferedStatus();
-  }, [socket, updateBufferedStatus]);
-  const subscribe = reactExports.useCallback(async () => {
-    if (!projectId || !serverId) return false;
-    if (subscribeInFlightRef.current) {
-      return subscribeInFlightRef.current;
-    }
-    const startedAt = Date.now();
-    const envelope = wrapEnvelope({}, {
-      project_id: projectId,
-      server_id: serverId,
-      client_id: clientIdRef.current
-    });
-    metricsRef.current.recordConnection();
-    syncMetrics();
-    const promise = new Promise((resolve) => {
-      socket.timeout(3e3).emit("cli:subscribe", envelope, (err) => {
-        subscribeInFlightRef.current = null;
-        if (err) {
-          subscribedRef.current = false;
-          metricsRef.current.recordConnectionFailure();
-          syncMetrics();
-          const currentState2 = stateMachineRef.current.getState();
-          if (currentState2 === ConnectionState.AUTHENTICATING && stateMachineRef.current.canSendEvent("AUTH_FAILURE")) {
-            stateMachineRef.current.sendEvent({ type: "AUTH_FAILURE", error: err.message });
-          }
-          if (currentState2 === ConnectionState.RECONNECTING) {
-            scheduleReconnectRef.current();
-          }
-          setStatus((prev) => ({ ...prev, lastError: err.message }));
-          resolve(false);
-          return;
-        }
-        const latencyMs = Date.now() - startedAt;
-        const currentState = stateMachineRef.current.getState();
-        if (currentState === ConnectionState.RECONNECTING) {
-          stateMachineRef.current.sendEvent({ type: "RECONNECT_SUCCESS" });
-        } else if (currentState === ConnectionState.AUTHENTICATING) {
-          stateMachineRef.current.sendEvent({ type: "AUTH_SUCCESS" });
-        }
-        subscribedRef.current = true;
-        metricsRef.current.recordConnectionSuccess();
-        syncMetrics();
-        reconnectRef.current.reset();
-        reconnectingRef.current = false;
-        setStatus((prev) => ({
-          ...prev,
-          latencyMs,
-          lastConnectedAt: Date.now()
-        }));
-        resolve(true);
-      });
-    });
-    subscribeInFlightRef.current = promise;
-    return promise;
-  }, [projectId, serverId, socket, syncMetrics]);
-  const attemptReconnect = reactExports.useCallback(async () => {
-    if (socket.connected && subscribedRef.current) return true;
-    if (!socket.connected) {
-      const connected = await new Promise((resolve) => {
-        let settled = false;
-        const timeout = window.setTimeout(() => {
-          if (settled) return;
-          settled = true;
-          cleanup();
-          resolve(false);
-        }, 4e3);
-        const handleConnect = () => {
-          if (settled) return;
-          settled = true;
-          cleanup();
-          resolve(true);
-        };
-        const handleError = () => {
-          if (settled) return;
-          settled = true;
-          cleanup();
-          resolve(false);
-        };
-        const cleanup = () => {
-          window.clearTimeout(timeout);
-          socket.off("connect", handleConnect);
-          socket.off("connect_error", handleError);
-        };
-        socket.once("connect", handleConnect);
-        socket.once("connect_error", handleError);
-        socket.connect();
-      });
-      if (!connected) return false;
-    }
-    const subscribed = await subscribe();
-    if (subscribed) {
-      flushBuffer();
-    }
-    return subscribed;
-  }, [socket, subscribe, flushBuffer]);
-  const scheduleReconnect = reactExports.useCallback(() => {
-    if (reconnectingRef.current) return;
-    reconnectingRef.current = true;
-    reconnectRef.current.scheduleReconnect(attemptReconnect);
-  }, [attemptReconnect]);
-  scheduleReconnectRef.current = scheduleReconnect;
-  reactExports.useEffect(() => {
-    const stateMachine = stateMachineRef.current;
-    const unsubscribeState = stateMachine.subscribe((nextState, event) => {
-      setStatus((prev) => ({
-        ...prev,
-        state: nextState,
-        lastError: event.type === "AUTH_FAILURE" ? event.error : prev.lastError
-      }));
-    });
-    const unsubscribeReconnect = reconnectRef.current.subscribe((reconnectState) => {
-      if (reconnectState.status === "waiting") {
-        reconnectStartedAtRef.current = null;
-        setStatus((prev) => ({
-          ...prev,
-          reconnectAttempts: reconnectState.retryCount,
-          nextRetryIn: reconnectState.nextRetryIn
-        }));
-        return;
-      }
-      if (reconnectState.status === "reconnecting") {
-        if (!reconnectStartedAtRef.current) {
-          reconnectStartedAtRef.current = Date.now();
-        }
-        setStatus((prev) => ({
-          ...prev,
-          reconnectAttempts: reconnectState.retryCount,
-          nextRetryIn: void 0
-        }));
-        return;
-      }
-      if (reconnectState.status === "failed") {
-        reconnectingRef.current = false;
-        metricsRef.current.recordConnectionFailure();
-        syncMetrics();
-        if (stateMachine.canSendEvent("MAX_RETRIES_EXCEEDED")) {
-          stateMachine.sendEvent({ type: "MAX_RETRIES_EXCEEDED" });
-        }
-        setStatus((prev) => ({
-          ...prev,
-          lastError: reconnectState.message
-        }));
-        return;
-      }
-      if (reconnectState.status === "connected") {
-        reconnectingRef.current = false;
-        if (reconnectStartedAtRef.current) {
-          metricsRef.current.recordReconnectionAttempt(
-            Date.now() - reconnectStartedAtRef.current
-          );
-          syncMetrics();
-          reconnectStartedAtRef.current = null;
-        }
-        setStatus((prev) => ({
-          ...prev,
-          reconnectAttempts: 0,
-          nextRetryIn: void 0
-        }));
-        return;
-      }
-      if (reconnectState.status === "cancelled") {
-        reconnectingRef.current = false;
-        reconnectStartedAtRef.current = null;
-        setStatus((prev) => ({
-          ...prev,
-          reconnectAttempts: 0,
-          nextRetryIn: void 0
-        }));
-      }
-    });
-    return () => {
-      unsubscribeState();
-      unsubscribeReconnect();
-    };
-  }, [syncMetrics]);
-  reactExports.useEffect(() => {
-    if (!projectId || !serverId) return;
-    const stateMachine = stateMachineRef.current;
-    if (stateMachine.canSendEvent("CONNECT")) {
-      stateMachine.sendEvent({ type: "CONNECT" });
-    }
-    const handleConnect = async () => {
-      const currentState = stateMachine.getState();
-      if (currentState === ConnectionState.CONNECTING && stateMachine.canSendEvent("AUTH_SUCCESS")) {
-        stateMachine.sendEvent({ type: "AUTH_SUCCESS" });
-      }
-      if (currentState !== ConnectionState.RECONNECTING) {
-        const subscribed = await subscribe();
-        if (subscribed) {
-          flushBuffer();
-        }
-      }
-    };
-    const handleDisconnect = (reason) => {
-      subscribedRef.current = false;
-      if (stateMachine.canSendEvent("CONNECTION_LOST")) {
-        stateMachine.sendEvent({ type: "CONNECTION_LOST" });
-      }
-      if (reason) {
-        setStatus((prev) => ({ ...prev, lastError: `Disconnected: ${reason}` }));
-      }
-      scheduleReconnect();
-    };
-    const handleError = (error) => {
-      subscribedRef.current = false;
-      const message = error instanceof Error ? error.message : "Connection error";
-      setStatus((prev) => ({ ...prev, lastError: message }));
-      handlers?.onError?.(message);
-      metricsRef.current.recordConnectionFailure();
-      syncMetrics();
-      if (stateMachine.canSendEvent("CONNECTION_LOST")) {
-        stateMachine.sendEvent({ type: "CONNECTION_LOST" });
-      }
-      scheduleReconnect();
-    };
-    const handleTerminalOutput = (payload) => {
-      handlers?.onTerminalOutput?.(payload);
-    };
-    const handleStatusUpdate = (payload) => {
-      handlers?.onStatusUpdate?.(payload);
-    };
-    const handleFileResponse = (payload) => {
-      handlers?.onFileResponse?.(payload);
-    };
-    const handleConfirm = (payload) => {
-      handlers?.onConfirmRequired?.(payload);
-    };
-    const handleBlocked = (payload) => {
-      handlers?.onBlocked?.(payload);
-    };
-    const handleSessionCreated = (payload) => {
-      handlers?.onSessionCreated?.(payload);
-    };
-    const handleSessionAttached = (payload) => {
-      handlers?.onSessionAttached?.(payload);
-    };
-    const handleSessionDetached = (payload) => {
-      handlers?.onSessionDetached?.(payload);
-    };
-    const handleSessionClosed = (payload) => {
-      handlers?.onSessionClosed?.(payload);
-    };
-    const handleSessionError = (payload) => {
-      handlers?.onSessionError?.(payload);
-    };
-    const handleMethodStatus = (payload) => {
-      handlers?.onMethodStatus?.(payload);
-    };
-    const handleMethodDone = (payload) => {
-      handlers?.onMethodDone?.(payload);
-    };
-    const handleMethodError = (payload) => {
-      handlers?.onMethodError?.(payload);
-    };
-    const handleMethodListResponse = (payload) => {
-      handlers?.onMethodListResponse?.(payload);
-    };
-    const handleMethodGetResponse = (payload) => {
-      handlers?.onMethodGetResponse?.(payload);
-    };
-    const handleGatewayError = (payload) => {
-      const message = typeof payload?.message === "string" && payload.message ? payload.message : "CLI server error";
-      const eventLabel = typeof payload?.event === "string" && payload.event ? ` (${payload.event})` : "";
-      const normalized = normalizeGatewayError(message);
-      handlers?.onError?.(`${normalized}${eventLabel}`);
-    };
-    socket.on("connect", handleConnect);
-    socket.on("disconnect", handleDisconnect);
-    socket.on("connect_error", handleError);
-    socket.on("cli:terminal:output", handleTerminalOutput);
-    socket.on("cli:status:update", handleStatusUpdate);
-    socket.on("cli:file:list:response", handleFileResponse);
-    socket.on("cli:file:content:response", handleFileResponse);
-    socket.on("cli:file:download:response", handleFileResponse);
-    socket.on("cli:file:write:response", handleFileResponse);
-    socket.on("cli:file:delete:response", handleFileResponse);
-    socket.on("cli:terminal:confirm_required", handleConfirm);
-    socket.on("cli:terminal:blocked", handleBlocked);
-    socket.on("cli:session:created", handleSessionCreated);
-    socket.on("cli:session:attached", handleSessionAttached);
-    socket.on("cli:session:detached", handleSessionDetached);
-    socket.on("cli:session:closed", handleSessionClosed);
-    socket.on("cli:session:error", handleSessionError);
-    socket.on("cli:method:status", handleMethodStatus);
-    socket.on("cli:method:done", handleMethodDone);
-    socket.on("cli:method:error", handleMethodError);
-    socket.on("cli:method:list:response", handleMethodListResponse);
-    socket.on("cli:method:get:response", handleMethodGetResponse);
-    socket.on("cli:error", handleGatewayError);
-    if (!socket.connected) {
-      socket.connect();
-    }
-    return () => {
-      socket.off("connect", handleConnect);
-      socket.off("disconnect", handleDisconnect);
-      socket.off("connect_error", handleError);
-      socket.off("cli:terminal:output", handleTerminalOutput);
-      socket.off("cli:status:update", handleStatusUpdate);
-      socket.off("cli:file:list:response", handleFileResponse);
-      socket.off("cli:file:content:response", handleFileResponse);
-      socket.off("cli:file:download:response", handleFileResponse);
-      socket.off("cli:file:write:response", handleFileResponse);
-      socket.off("cli:file:delete:response", handleFileResponse);
-      socket.off("cli:terminal:confirm_required", handleConfirm);
-      socket.off("cli:terminal:blocked", handleBlocked);
-      socket.off("cli:session:created", handleSessionCreated);
-      socket.off("cli:session:attached", handleSessionAttached);
-      socket.off("cli:session:detached", handleSessionDetached);
-      socket.off("cli:session:closed", handleSessionClosed);
-      socket.off("cli:session:error", handleSessionError);
-      socket.off("cli:method:status", handleMethodStatus);
-      socket.off("cli:method:done", handleMethodDone);
-      socket.off("cli:method:error", handleMethodError);
-      socket.off("cli:method:list:response", handleMethodListResponse);
-      socket.off("cli:method:get:response", handleMethodGetResponse);
-      socket.off("cli:error", handleGatewayError);
-      reconnectRef.current.cancel();
-      release();
-    };
-  }, [projectId, serverId, socket, release, subscribe, flushBuffer, handlers, scheduleReconnect, syncMetrics]);
-  const sendTerminalInput = reactExports.useCallback(
-    (payload) => {
-      const inputPayload = {
-        data: payload.data,
-        confirmed: payload.confirmed
-      };
-      if (payload.mode) {
-        inputPayload.mode = payload.mode;
-      }
-      emitEnvelope(
-        "cli:terminal:input",
-        inputPayload,
-        {
-          session_id: payload.sessionId,
-          seq: payload.seq,
-          operation_id: payload.operationId
-        },
-        { priority: "high" }
-      );
-    },
-    [emitEnvelope]
-  );
-  const sendTerminalResize = reactExports.useCallback(
-    (payload) => {
-      emitEnvelope(
-        "cli:terminal:resize",
-        { cols: payload.cols, rows: payload.rows },
-        { session_id: payload.sessionId },
-        { priority: "low", maxAge: 2e3 }
-      );
-    },
-    [emitEnvelope]
-  );
-  const sendFileRequest = reactExports.useCallback(
-    (event, payload, meta) => {
-      emitEnvelope(event, payload, meta);
-    },
-    [emitEnvelope]
-  );
-  return {
-    socket,
-    status,
-    emitEnvelope,
-    sendTerminalInput,
-    sendTerminalResize,
-    sendFileRequest,
-    unwrapPayload
-  };
-}
-
-const CLI_SESSION_NAMESPACE = "6f07d9a4-0e31-4f69-9ad4-b6295b6e4d2e";
-function uuidToBytes(uuid) {
-  const hex = uuid.replace(/-/g, "");
-  const bytes = new Uint8Array(16);
-  for (let i = 0; i < 16; i += 1) {
-    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-function bytesToUuid(bytes) {
-  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
-}
-function fnv1a(input, seed) {
-  let hash = 2166136261 ^ seed;
-  for (let i = 0; i < input.length; i += 1) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-function fallbackUuid(input) {
-  const h1 = fnv1a(input, 1).toString(16).padStart(8, "0");
-  const h2 = fnv1a(input, 2).toString(16).padStart(8, "0");
-  const h3 = fnv1a(input, 3).toString(16).padStart(8, "0");
-  const h4 = fnv1a(input, 4).toString(16).padStart(8, "0");
-  const raw = `${h1}${h2}${h3}${h4}`.slice(0, 32);
-  return `${raw.slice(0, 8)}-${raw.slice(8, 12)}-5${raw.slice(13, 16)}-a${raw.slice(17, 20)}-${raw.slice(20, 32)}`;
-}
-async function uuidV5(name, namespace = CLI_SESSION_NAMESPACE) {
-  const nsBytes = uuidToBytes(namespace);
-  const nameBytes = new TextEncoder().encode(name);
-  const data = new Uint8Array(nsBytes.length + nameBytes.length);
-  data.set(nsBytes, 0);
-  data.set(nameBytes, nsBytes.length);
-  if (typeof crypto !== "undefined" && crypto.subtle?.digest) {
-    const hash = new Uint8Array(await crypto.subtle.digest("SHA-1", data));
-    const bytes = hash.slice(0, 16);
-    bytes[6] = bytes[6] & 15 | 80;
-    bytes[8] = bytes[8] & 63 | 128;
-    return bytesToUuid(bytes);
-  }
-  return fallbackUuid(`${namespace}:${name}`);
-}
-async function buildDefaultSessionId(projectId, serverId) {
-  return uuidV5(`${projectId}:${serverId}:default`);
-}
-async function buildConversationSessionId(projectId, serverId, conversationId) {
-  return uuidV5(`${projectId}:${serverId}:${conversationId}`);
-}
-async function buildChatSessionId(projectId, serverId, chatSessionId) {
-  return uuidV5(`${projectId}:${serverId}:${chatSessionId}`);
-}
-
-function mapProjectRoleToPermission(role) {
-  if (!role) return "none";
-  if (role === "owner") return "owner";
-  if (role === "admin") return "admin";
-  if (role === "editor") return "edit";
-  if (role === "viewer") return "view";
-  return "none";
-}
-function resolveCliCapabilities(level, granularity) {
-  const allowTerminalInput = granularity?.allowTerminalInput ?? true;
-  const allowFileEdit = granularity?.allowFileEdit ?? true;
-  const isEdit = level === "edit";
-  const isAdmin = level === "admin" || level === "owner";
-  const baseView = {
-    view_server_status: level !== "none",
-    view_terminal_output: level !== "none",
-    view_operation_logs: level !== "none",
-    view_files: level !== "none",
-    view_tasks: level !== "none",
-    view_findings: level !== "none"
-  };
-  const editCaps = {
-    terminal_input: level !== "none" && level !== "view" && allowTerminalInput,
-    file_upload: level !== "none" && level !== "view" && allowFileEdit,
-    file_download: isAdmin || isEdit && allowFileEdit,
-    file_edit: level !== "none" && level !== "view" && allowFileEdit,
-    file_delete: level !== "none" && level !== "view" && allowFileEdit
-  };
-  const adminCaps = {
-    manage_sessions: level === "admin" || level === "owner",
-    manage_permissions: level === "admin" || level === "owner",
-    disconnect_server: level === "admin" || level === "owner",
-    view_all_user_logs: level === "admin" || level === "owner",
-    delete_server: level === "owner"
-  };
-  return {
-    ...baseView,
-    ...editCaps,
-    ...adminCaps
-  };
-}
-
-function useCliAccess(options) {
-  const { projectId, serverId, readOnly } = options;
-  const [permission, setPermission] = reactExports.useState("none");
-  const [granularity, setGranularity] = reactExports.useState(null);
-  const [isLoading, setIsLoading] = reactExports.useState(false);
-  const [error, setError] = reactExports.useState(null);
-  reactExports.useEffect(() => {
-    if (!projectId || !serverId) {
-      setPermission("none");
-      setGranularity(null);
-      return;
-    }
-    if (readOnly) {
-      setPermission("view");
-      setGranularity(null);
-      return;
-    }
-    let cancelled = false;
-    setIsLoading(true);
-    setError(null);
-    const resolveAccess = async () => {
-      try {
-        const access = await checkProjectAccess(projectId);
-        if (cancelled) return;
-        const rolePermission = mapProjectRoleToPermission(access?.role);
-        setPermission(rolePermission);
-        setGranularity(null);
-      } catch (err) {
-        if (cancelled) return;
-        setPermission("none");
-        setGranularity(null);
-        setError("Failed to resolve CLI permissions");
-      } finally {
-        if (!cancelled) setIsLoading(false);
-      }
-    };
-    void resolveAccess();
-    return () => {
-      cancelled = true;
-    };
-  }, [projectId, readOnly, serverId]);
-  const capabilities = reactExports.useMemo(() => resolveCliCapabilities(permission, granularity), [permission, granularity]);
-  return {
-    permission,
-    granularity,
-    capabilities,
-    isLoading,
-    error
-  };
-}
-
-export { useCliSocket as a, buildChatSessionId as b, acquireCliSocket as c, unwrapPayload as d, buildDefaultSessionId as e, buildConversationSessionId as f, getCliClientId as g, nextSeq as n, useCliAccess as u, wrapEnvelope as w };