vite-plugin-opencode-assistant 1.0.3 → 1.0.5

package/es/client/index.d.ts

@@ -0,0 +1 @@
+import "@vite-plugin-opencode-assistant/components/style.css";

package/es/client/index.js

@@ -0,0 +1,328 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { createApp, ref, watch, onMounted, h, computed } from "vue";
+import { OpenCodeWidget } from "@vite-plugin-opencode-assistant/components";
+import "@vite-plugin-opencode-assistant/components/style.css";
+import { CONFIG_DATA_ATTR } from "@vite-plugin-opencode-assistant/shared";
+let config = {};
+const scriptTag = document.querySelector(`script[${CONFIG_DATA_ATTR}]`);
+if (scriptTag) {
+  const configBase64 = scriptTag.getAttribute(CONFIG_DATA_ATTR);
+  if (configBase64) {
+    try {
+      config = JSON.parse(atob(configBase64));
+    } catch (e) {
+      console.error("[OpenCode] Failed to parse config:", e);
+    }
+  }
+}
+const App = {
+  setup() {
+    const open = ref(false);
+    const selectMode = ref(false);
+    const sessionListCollapsed = ref(true);
+    const loading = ref(false);
+    const loadingSessionList = ref(void 0);
+    const iframeSrc = ref("");
+    const currentSessionId = ref(null);
+    const sessions = ref([]);
+    const selectedElements = ref([]);
+    const widgetRef = ref(null);
+    const {
+      webUrl = "",
+      position = "bottom-right",
+      theme = "auto",
+      open: autoOpen = false,
+      sessionUrl: initialSessionUrl = "",
+      lazy = false,
+      hotkey = "ctrl+k",
+      cwd = ""
+    } = config;
+    const isWaitingForSession = ref(!initialSessionUrl);
+    const computedLoading = computed(() => loading.value || isWaitingForSession.value);
+    let servicesStarted = !lazy;
+    const extractSessionId = (url) => {
+      if (!url) return null;
+      const match = url.match(/\/session\/([^/?]+)/);
+      return match ? match[1] : null;
+    };
+    currentSessionId.value = extractSessionId(initialSessionUrl);
+    if (servicesStarted && initialSessionUrl) {
+      iframeSrc.value = initialSessionUrl;
+    }
+    try {
+      const stored = sessionStorage.getItem("__opencode_selected_elements__");
+      if (stored) {
+        selectedElements.value = JSON.parse(stored);
+      }
+    } catch (e) {
+    }
+    watch(
+      selectedElements,
+      (val) => {
+        sessionStorage.setItem("__opencode_selected_elements__", JSON.stringify(val));
+      },
+      { deep: true }
+    );
+    const showNotification = (msg) => {
+      var _a, _b;
+      (_b = (_a = widgetRef.value) == null ? void 0 : _a.showNotification) == null ? void 0 : _b.call(_a, msg);
+    };
+    const loadSessions = () => __async(null, null, function* () {
+      loadingSessionList.value = true;
+      try {
+        const response = yield fetch("/__opencode_sessions__");
+        const data = yield response.json();
+        sessions.value = data.filter((s) => s.directory === cwd && s.title !== "__chrome_mcp_warmup__").map((s) => {
+          var _a;
+          return __spreadProps(__spreadValues({}, s), {
+            updatedAt: ((_a = s.time) == null ? void 0 : _a.updated) || Date.now()
+          });
+        });
+      } catch (e) {
+        console.error("[OpenCode] Failed to load sessions:", e);
+      } finally {
+        loadingSessionList.value = false;
+      }
+    });
+    const createSession = () => __async(null, null, function* () {
+      try {
+        const response = yield fetch("/__opencode_sessions__", { method: "POST" });
+        const newSession = yield response.json();
+        yield loadSessions();
+        currentSessionId.value = newSession.id;
+        iframeSrc.value = `${webUrl}/${btoa(cwd)}/session/${newSession.id}`;
+      } catch (e) {
+        showNotification("\u521B\u5EFA\u4F1A\u8BDD\u5931\u8D25");
+      }
+    });
+    const deleteSession = (session) => __async(null, null, function* () {
+      try {
+        yield fetch(`/__opencode_sessions__?id=${session.id}`, { method: "DELETE" });
+        yield loadSessions();
+        showNotification("\u4F1A\u8BDD\u5DF2\u5220\u9664");
+        if (currentSessionId.value === session.id) {
+          if (sessions.value.length > 0) {
+            const nextSession = sessions.value[0];
+            currentSessionId.value = nextSession.id;
+            iframeSrc.value = `${webUrl}/${btoa(cwd)}/session/${nextSession.id}`;
+          } else {
+            currentSessionId.value = null;
+            iframeSrc.value = "";
+          }
+        }
+      } catch (e) {
+        showNotification("\u5220\u9664\u4F1A\u8BDD\u5931\u8D25");
+      }
+    });
+    const selectSession = (session) => {
+      if (currentSessionId.value === session.id) return;
+      currentSessionId.value = session.id;
+      loading.value = true;
+      iframeSrc.value = `${webUrl}/${btoa(cwd)}/session/${session.id}`;
+      setTimeout(() => {
+        loading.value = false;
+      }, 500);
+    };
+    let sseConnection = null;
+    const setupSSE = () => {
+      if (!servicesStarted || sseConnection) return;
+      sseConnection = new EventSource("/__opencode_events__");
+      sseConnection.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          if (data.type === "CONNECTED") {
+            updateContext(true);
+          } else if (data.type === "SESSION_READY") {
+            if (data.sessionUrl && !iframeSrc.value) {
+              iframeSrc.value = data.sessionUrl;
+              currentSessionId.value = extractSessionId(data.sessionUrl);
+            }
+            isWaitingForSession.value = false;
+          } else if (data.type === "CLEAR_ELEMENTS") {
+            selectedElements.value = [];
+          }
+        } catch (e) {
+        }
+      };
+    };
+    let currentPageUrl = "";
+    let currentPageTitle = "";
+    const updateContext = (force = false) => {
+      if (!servicesStarted) return;
+      const newUrl = window.location.href;
+      const newTitle = document.title;
+      if (force || newUrl !== currentPageUrl || newTitle !== currentPageTitle) {
+        currentPageUrl = newUrl;
+        currentPageTitle = newTitle;
+        fetch("/__opencode_context__", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            url: newUrl,
+            title: newTitle,
+            selectedElements: selectedElements.value
+          })
+        }).catch(() => {
+        });
+      }
+    };
+    const ensureServicesStarted = () => __async(null, null, function* () {
+      if (servicesStarted) return true;
+      try {
+        const res = yield fetch("/__opencode_start__");
+        const data = yield res.json();
+        if (data.success) {
+          servicesStarted = true;
+          if (data.sessionUrl) {
+            iframeSrc.value = data.sessionUrl;
+            currentSessionId.value = extractSessionId(data.sessionUrl);
+            isWaitingForSession.value = false;
+          }
+          setupSSE();
+          return true;
+        }
+      } catch (e) {
+      }
+      return false;
+    });
+    onMounted(() => {
+      if (servicesStarted) {
+        loadSessions();
+        setupSSE();
+        updateContext(true);
+      }
+      if (autoOpen && servicesStarted) {
+        setTimeout(() => {
+          open.value = true;
+        }, 1e3);
+      }
+      const originalPushState = history.pushState;
+      const originalReplaceState = history.replaceState;
+      history.pushState = function(...args) {
+        originalPushState.apply(this, args);
+        setTimeout(updateContext, 0);
+      };
+      history.replaceState = function(...args) {
+        originalReplaceState.apply(this, args);
+        setTimeout(updateContext, 0);
+      };
+      window.addEventListener("popstate", () => setTimeout(updateContext, 0));
+      window.addEventListener("hashchange", () => setTimeout(updateContext, 0));
+      const titleObserver = new MutationObserver(() => {
+        if (document.title !== currentPageTitle) updateContext();
+      });
+      if (document.head) {
+        titleObserver.observe(document.head, { childList: true, subtree: true });
+      }
+    });
+    const handleToggle = (val) => __async(null, null, function* () {
+      if (lazy && !servicesStarted && val) {
+        loading.value = true;
+        const started = yield ensureServicesStarted();
+        loading.value = false;
+        if (!started) {
+          showNotification("\u670D\u52A1\u542F\u52A8\u5931\u8D25");
+          return;
+        }
+      }
+      open.value = val;
+      if (val) updateContext();
+    });
+    const handleSelectNode = (element) => {
+      const exists = selectedElements.value.some(
+        (el) => el.filePath === element.filePath && el.line === element.line
+      );
+      if (!exists) {
+        selectedElements.value.push(element);
+        showNotification(`\u5DF2\u9009\u4E2D\u5143\u7D20 (${selectedElements.value.length}\u4E2A)`);
+        updateContext(true);
+      } else {
+        showNotification("\u8BE5\u5143\u7D20\u5DF2\u9009\u4E2D");
+      }
+    };
+    const handleClearSelected = () => {
+      selectedElements.value = [];
+      updateContext(true);
+      showNotification("\u5DF2\u6E05\u9664\u6240\u6709\u9009\u4E2D\u5143\u7D20");
+    };
+    return () => {
+      return h(OpenCodeWidget, {
+        ref: widgetRef,
+        position,
+        theme,
+        open: open.value,
+        selectMode: selectMode.value,
+        sessionListCollapsed: sessionListCollapsed.value,
+        loading: computedLoading.value,
+        loadingSessionList: loadingSessionList.value,
+        iframeSrc: iframeSrc.value,
+        currentSessionId: currentSessionId.value,
+        sessions: sessions.value,
+        selectedElements: selectedElements.value,
+        hotkeyLabel: hotkey,
+        "onUpdate:open": handleToggle,
+        "onUpdate:selectMode": (val) => {
+          selectMode.value = val;
+        },
+        "onUpdate:sessionListCollapsed": (val) => {
+          sessionListCollapsed.value = val;
+        },
+        "onCreate-session": createSession,
+        "onDelete-session": deleteSession,
+        "onSelect-session": selectSession,
+        "onClick-selected-node": handleSelectNode,
+        "onClear-selected-nodes": handleClearSelected,
+        "onRemove-selected-node": ({ index }) => {
+          selectedElements.value.splice(index, 1);
+          updateContext(true);
+        },
+        "onEmpty-action": createSession
+      });
+    };
+  }
+};
+const INIT_MARKER = "__OPENCODE_INITIALIZED__";
+if (!window[INIT_MARKER]) {
+  window[INIT_MARKER] = true;
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  createApp(App).mount(container);
+}

package/es/core/api.d.ts

@@ -0,0 +1,14 @@
+import type { SessionInfo } from "@vite-plugin-opencode-assistant/shared";
+export declare class OpenCodeAPI {
+    private hostname;
+    private getPort;
+    private warmupChromeMcpConfig;
+    constructor(hostname: string, getPort: () => number, warmupChromeMcpConfig?: boolean);
+    private createHttpRequest;
+    getSessions(retries?: number): Promise<SessionInfo[]>;
+    createSession(retries?: number, title?: string): Promise<SessionInfo>;
+    deleteSession(sessionId: string, retries?: number): Promise<void>;
+    getToolIds(retries?: number): Promise<string[]>;
+    warmupChromeMcp(viteOrigin?: string): Promise<void>;
+    getOrCreateSession(): Promise<string>;
+}

package/es/core/api.js

@@ -0,0 +1,294 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import http from "http";
+import {
+  PerformanceTimer,
+  createLogger,
+  DEFAULT_RETRIES,
+  RETRY_DELAY
+} from "@vite-plugin-opencode-assistant/shared";
+const log = createLogger("API");
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function base64Encode(str) {
+  return Buffer.from(str).toString("base64");
+}
+class OpenCodeAPI {
+  constructor(hostname, getPort, warmupChromeMcpConfig = false) {
+    __publicField(this, "hostname", hostname);
+    __publicField(this, "getPort", getPort);
+    __publicField(this, "warmupChromeMcpConfig", warmupChromeMcpConfig);
+  }
+  createHttpRequest(options, body) {
+    const timer = new PerformanceTimer("HTTP Request", {
+      operation: `${options.method || "GET"} ${options.path}`
+    });
+    return new Promise((resolve, reject) => {
+      const req = http.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => data += chunk);
+        res.on("end", () => {
+          try {
+            const result = JSON.parse(data);
+            timer.end(`\u2713 Status: ${res.statusCode}`);
+            resolve(result);
+          } catch (e) {
+            timer.end("\u274C JSON parse error");
+            reject(new Error(`JSON parse error: ${data.substring(0, 100)}`));
+          }
+        });
+      });
+      req.on("error", (e) => {
+        timer.end("\u274C Request failed");
+        reject(e);
+      });
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+  getSessions() {
+    return __async(this, arguments, function* (retries = DEFAULT_RETRIES) {
+      const timer = log.timer("getSessions", { retries });
+      let lastError = null;
+      for (let i = 0; i < retries; i++) {
+        try {
+          log.debug(`Attempt ${i + 1}/${retries}`, { operation: "getSessions" });
+          const sessions = yield this.createHttpRequest({
+            hostname: this.hostname,
+            port: this.getPort(),
+            path: "/session"
+          });
+          timer.end(`Found ${sessions.length} sessions`);
+          return sessions;
+        } catch (e) {
+          lastError = e instanceof Error ? e : new Error(String(e));
+          log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+            operation: "getSessions"
+          });
+          if (i < retries - 1) {
+            log.debug(`Retrying in ${RETRY_DELAY}ms...`, {
+              operation: "getSessions"
+            });
+            yield sleep(RETRY_DELAY);
+          }
+        }
+      }
+      timer.end("\u274C All retries exhausted");
+      throw lastError;
+    });
+  }
+  createSession() {
+    return __async(this, arguments, function* (retries = DEFAULT_RETRIES, title) {
+      const timer = log.timer("createSession", { retries, title });
+      let lastError = null;
+      for (let i = 0; i < retries; i++) {
+        try {
+          log.debug(`Attempt ${i + 1}/${retries}`, {
+            operation: "createSession",
+            title
+          });
+          const requestBody = title ? JSON.stringify({ title }) : void 0;
+          const session = yield this.createHttpRequest(
+            {
+              hostname: this.hostname,
+              port: this.getPort(),
+              path: "/session",
+              method: "POST",
+              headers: requestBody ? { "Content-Type": "application/json" } : void 0
+            },
+            requestBody
+          );
+          timer.end(`Created session: ${session.id}`);
+          return session;
+        } catch (e) {
+          lastError = e instanceof Error ? e : new Error(String(e));
+          log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+            operation: "createSession"
+          });
+          if (i < retries - 1) {
+            log.debug(`Retrying in ${RETRY_DELAY}ms...`, {
+              operation: "createSession"
+            });
+            yield sleep(RETRY_DELAY);
+          }
+        }
+      }
+      timer.end("\u274C All retries exhausted");
+      throw lastError;
+    });
+  }
+  deleteSession(_0) {
+    return __async(this, arguments, function* (sessionId, retries = DEFAULT_RETRIES) {
+      const timer = log.timer("deleteSession", { sessionId, retries });
+      let lastError = null;
+      for (let i = 0; i < retries; i++) {
+        try {
+          log.debug(`Attempt ${i + 1}/${retries}`, {
+            operation: "deleteSession",
+            sessionId
+          });
+          yield this.createHttpRequest({
+            hostname: this.hostname,
+            port: this.getPort(),
+            path: `/session/${sessionId}`,
+            method: "DELETE"
+          });
+          timer.end(`Deleted session: ${sessionId}`);
+          return;
+        } catch (e) {
+          lastError = e instanceof Error ? e : new Error(String(e));
+          log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+            operation: "deleteSession",
+            sessionId
+          });
+          if (i < retries - 1) {
+            log.debug(`Retrying in ${RETRY_DELAY}ms...`, {
+              operation: "deleteSession",
+              sessionId
+            });
+            yield sleep(RETRY_DELAY);
+          }
+        }
+      }
+      timer.end("\u274C All retries exhausted");
+      throw lastError;
+    });
+  }
+  getToolIds() {
+    return __async(this, arguments, function* (retries = DEFAULT_RETRIES) {
+      const timer = log.timer("getToolIds", { retries });
+      let lastError = null;
+      for (let i = 0; i < retries; i++) {
+        try {
+          log.debug(`Attempt ${i + 1}/${retries}`, {
+            operation: "getToolIds"
+          });
+          const toolIds = yield this.createHttpRequest({
+            hostname: this.hostname,
+            port: this.getPort(),
+            path: "/experimental/tool/ids"
+          });
+          timer.end(`Found ${toolIds.length} tools`);
+          return toolIds;
+        } catch (e) {
+          lastError = e instanceof Error ? e : new Error(String(e));
+          log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+            operation: "getToolIds"
+          });
+          if (i < retries - 1) {
+            log.debug(`Retrying in ${RETRY_DELAY}ms...`, {
+              operation: "getToolIds"
+            });
+            yield sleep(RETRY_DELAY);
+          }
+        }
+      }
+      timer.end("\u274C All retries exhausted");
+      throw lastError;
+    });
+  }
+  warmupChromeMcp(viteOrigin) {
+    return __async(this, null, function* () {
+      if (!this.warmupChromeMcpConfig) return;
+      const timer = log.timer("warmupChromeMcp", { viteOrigin });
+      let warmupSessionId = null;
+      try {
+        const warmupSession = yield this.createSession(DEFAULT_RETRIES, "__chrome_mcp_warmup__");
+        warmupSessionId = warmupSession.id;
+        let chromeToolIds;
+        try {
+          const toolIds = yield this.getToolIds();
+          chromeToolIds = toolIds.filter((toolId) => /chrome[-_]?devtools/i.test(toolId));
+          log.debug("Resolved Chrome MCP tool ids", {
+            chromeToolIds
+          });
+        } catch (e) {
+          log.debug("Failed to resolve Chrome MCP tool ids", { error: e });
+        }
+        const prompt = [
+          "Call the browser tool list_pages immediately to establish the Chrome DevTools MCP connection.",
+          viteOrigin ? `If there are no pages, call new_page with ${viteOrigin}.` : "If there are no pages, call new_page with about:blank.",
+          "Do not read or modify project files.",
+          "Do not use any non-browser tools.",
+          "After the tool call is complete, reply with exactly: ready"
+        ].join(" ");
+        yield this.createHttpRequest(
+          {
+            hostname: this.hostname,
+            port: this.getPort(),
+            path: `/session/${warmupSessionId}/message`,
+            method: "POST",
+            headers: { "Content-Type": "application/json" }
+          },
+          JSON.stringify({
+            system: "You are warming up Chrome DevTools MCP during startup. You must use the available browser tools immediately before replying.",
+            tools: (chromeToolIds == null ? void 0 : chromeToolIds.length) ? chromeToolIds : void 0,
+            parts: [{ type: "text", text: prompt }]
+          })
+        );
+        timer.end("Chrome MCP warmed up");
+      } catch (e) {
+        log.warn("Failed to warm up Chrome MCP", { error: e });
+        timer.end("Chrome MCP warmup skipped");
+      } finally {
+        if (warmupSessionId) {
+          try {
+            yield this.deleteSession(warmupSessionId, 5);
+          } catch (e) {
+            log.warn("Failed to delete warmup session after retries", {
+              error: e,
+              warmupSessionId
+            });
+          }
+        }
+      }
+    });
+  }
+  getOrCreateSession() {
+    return __async(this, null, function* () {
+      const timer = log.timer("getOrCreateSession");
+      const projectDir = process.cwd();
+      log.debug("Getting sessions...", { projectDir });
+      const sessions = yield this.getSessions();
+      log.debug(`Found ${sessions.length} sessions`, {
+        sessions: sessions.map((s) => ({ id: s.id, directory: s.directory }))
+      });
+      const matchingSession = sessions.find((s) => s.directory === projectDir);
+      if (matchingSession) {
+        const url2 = `http://${this.hostname}:${this.getPort()}/${base64Encode(projectDir)}/session/${matchingSession.id}`;
+        timer.end(`Using existing session: ${matchingSession.id}`);
+        return url2;
+      }
+      log.debug("Creating new session...", { projectDir });
+      const newSession = yield this.createSession();
+      const url = `http://${this.hostname}:${this.getPort()}/${base64Encode(projectDir)}/session/${newSession.id}`;
+      timer.end(`Created new session: ${newSession.id}`);
+      return url;
+    });
+  }
+}
+export {
+  OpenCodeAPI
+};

package/es/core/injector.d.ts

@@ -0,0 +1,2 @@
+import type { WidgetOptions } from "@vite-plugin-opencode-assistant/shared";
+export declare function injectWidget(options: WidgetOptions): string;

package/es/core/injector.js

@@ -0,0 +1,11 @@
+import { CONFIG_DATA_ATTR, WIDGET_SCRIPT_PATH } from "@vite-plugin-opencode-assistant/shared";
+function injectWidget(options) {
+  const configBase64 = Buffer.from(JSON.stringify(options)).toString("base64");
+  const scriptTag = `<script type="module" src="${WIDGET_SCRIPT_PATH}" ${CONFIG_DATA_ATTR}="${configBase64}"></script>`;
+  const styleTag = `<link rel="stylesheet" href="/__opencode_widget__.css" />`;
+  return `${styleTag}
+${scriptTag}`;
+}
+export {
+  injectWidget
+};

package/es/core/service.d.ts

@@ -0,0 +1,18 @@
+import type { ResultPromise } from "execa";
+import type http from "http";
+import type { OpenCodeOptions } from "@vite-plugin-opencode-assistant/shared";
+import type { OpenCodeAPI } from "./api.js";
+export declare class OpenCodeService {
+    private config;
+    private api;
+    private sseClients;
+    private onPortAllocated;
+    webProcess: ResultPromise | null;
+    actualWebPort: number;
+    isStarted: boolean;
+    private startPromise;
+    sessionUrl: string | null;
+    constructor(config: Required<OpenCodeOptions>, api: OpenCodeAPI, sseClients: Set<http.ServerResponse>, onPortAllocated: (port: number) => void);
+    start(corsOrigins?: string[], contextApiUrl?: string, viteOrigin?: string): Promise<void>;
+    stop(): Promise<void>;
+}