vite-plugin-aipanel 1.2.0-beta.0

package/lib/index.cjs

@@ -0,0 +1,361 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lib_exports = {};
+__export(lib_exports, {
+  default: () => aipanelPlugin
+});
+module.exports = __toCommonJS(lib_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_vite = __toESM(require("unplugin-vue-inspector/vite"));
+var import_core = require("@aipanel/core");
+var import_node = require("@aipanel/core/node");
+var import_endpoints = require("./endpoints/index.cjs");
+var import_injector = require("./core/injector.cjs");
+var import_provider_loader = require("./core/provider-loader.cjs");
+var import_service = require("./core/service.cjs");
+var import_mcp_proxy = require("./core/mcp-proxy.cjs");
+var import_paths = require("./utils/paths.cjs");
+var import_system = require("./utils/system.cjs");
+const DEVTOOLS_BRIDGE_IMPORTEE = "virtual:aipanel-vue-devtools-bridge";
+const DEVTOOLS_BRIDGE_QUERY = "aipanel_vue_devtools_bridge";
+const BRIDGE_SOURCE_PATH = (0, import_paths.resolveVueDevtoolsBridgePath)();
+const SILENT_CONTEXT_SCRIPT = `<script>
+(function () {
+  var API = "/__aipanel_context__";
+  var last = "";
+  function report(force) {
+    if (document.visibilityState !== "visible") return;
+    var url = location.href;
+    var title = document.title;
+    var key = url + "|" + title;
+    if (!force && key === last) return;
+    last = key;
+    var sessionId = "";
+    try { sessionId = sessionStorage.getItem("_aipanel_pk") || ""; } catch (e) {}
+    fetch(API, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ url: url, title: title, sessionId: sessionId }),
+    }).catch(function () {});
+  }
+  var push = history.pushState.bind(history);
+  var replace = history.replaceState.bind(history);
+  history.pushState = function () { push.apply(this, arguments); setTimeout(function () { report(false); }, 0); };
+  history.replaceState = function () { replace.apply(this, arguments); setTimeout(function () { report(false); }, 0); };
+  window.addEventListener("popstate", function () { report(false); });
+  window.addEventListener("hashchange", function () { report(false); });
+  document.addEventListener("visibilitychange", function () {
+    // \u5207\u56DE\u672C\u6807\u7B7E\u65F6\u5F3A\u5236\u4E0A\u62A5\uFF1A\u672C\u9875 url/title \u672A\u53D8\uFF0C\u4F46\u670D\u52A1\u7AEF\u4E0A\u4E0B\u6587\u53EF\u80FD\u5DF2\u88AB\u5176\u4ED6\u6807\u7B7E\u8986\u76D6
+    if (document.visibilityState === "visible") report(true);
+  });
+  window.addEventListener("focus", function () {
+    // \u591A\u7A97\u53E3\uFF08\u5206\u5C4F/\u591A\u663E\u793A\u5668\uFF09\u4E0B\u6240\u6709\u6807\u7B7E\u9875\u90FD visible\uFF0Cvisibilitychange \u4E0D\u89E6\u53D1\uFF1B
+    // \u7A97\u53E3\u83B7\u5F97\u7126\u70B9\u662F"\u7528\u6237\u6B63\u5728\u770B\u8FD9\u4E2A\u9875\u9762"\u7684\u6700\u51C6\u786E\u4FE1\u53F7
+    report(true);
+  });
+  try {
+    new MutationObserver(function () { report(false); })
+      .observe(document.head, { childList: true, subtree: true });
+  } catch (e) {}
+  report(false);
+})();
+</script>`;
+function aipanelPlugin(options = {}) {
+  const plugins = [];
+  plugins.push(
+    ...(0, import_vite.default)({
+      enabled: false,
+      toggleButtonVisibility: "never",
+      toggleComboKey: false
+    })
+  );
+  plugins.push(createAIPanelPlugin(options));
+  return plugins;
+}
+function createAIPanelPlugin(options = {}) {
+  const config = (0, import_core.resolvePluginConfig)(options);
+  (0, import_core.setVerbose)(config.verbose);
+  (0, import_node.initProcessLogCapture)({ maxSize: 500 });
+  const log = (0, import_node.createLogger)("Plugin");
+  let actualWebPort = config.webPort;
+  let actualProxyPort = config.proxyPort ?? import_core.DEFAULT_PROXY_PORT;
+  let projectRoot = "";
+  let vueDevtoolsApiUrl = "";
+  const pageContext = { url: "", title: "" };
+  const DEFAULT_TAB = "default";
+  const pageContexts = /* @__PURE__ */ new Map([[DEFAULT_TAB, pageContext]]);
+  let activeTabId = DEFAULT_TAB;
+  const serviceInstanceId = import_crypto.default.randomUUID();
+  const sseClients = /* @__PURE__ */ new Set();
+  const mcpProxy = new import_mcp_proxy.McpProxy({ idleTimeout: 5 * 60 * 1e3 });
+  let provider = null;
+  const service = new import_service.AIPanelService(
+    config,
+    sseClients,
+    (port) => {
+      actualWebPort = port;
+    },
+    (port) => {
+      actualProxyPort = port;
+    }
+  );
+  service.workspaceRoot = (0, import_system.findGitRoot)(process.cwd());
+  return {
+    name: "vite-plugin-aipanel",
+    apply(_viteConfig, env) {
+      if (!config.enabled) return false;
+      return env.command === "serve" && process.env.NODE_ENV !== "test";
+    },
+    async configureServer(server) {
+      const timer = log.timer("configureServer");
+      projectRoot = server.config.root;
+      let viteOrigin = "";
+      (0, import_endpoints.setupMiddlewares)(
+        server,
+        {
+          get webUrl() {
+            return actualWebPort ? `http://${config.hostname}:${actualWebPort}` : null;
+          },
+          get sseClients() {
+            return sseClients;
+          },
+          getPageContext() {
+            return pageContexts.get(activeTabId) || pageContexts.get(DEFAULT_TAB) || { url: "", title: "" };
+          },
+          setPageContext(tabId, ctx) {
+            pageContexts.set(tabId || DEFAULT_TAB, ctx);
+          },
+          setActiveTabId(tabId) {
+            activeTabId = tabId;
+          },
+          clearSelectedElements() {
+            const ctx = pageContexts.get(activeTabId);
+            if (ctx) {
+              ctx.selectedElements = [];
+              pageContexts.set(activeTabId, ctx);
+            }
+            const defaultCtx = pageContexts.get(DEFAULT_TAB);
+            if (defaultCtx) {
+              defaultCtx.selectedElements = [];
+            }
+          },
+          get isServiceStarted() {
+            return service.isStarted;
+          },
+          get currentTask() {
+            return service.currentTask;
+          },
+          get actualProxyPort() {
+            return actualProxyPort;
+          },
+          get actualWebPort() {
+            return actualWebPort;
+          },
+          get serviceInstanceId() {
+            return serviceInstanceId;
+          },
+          getSessions: () => {
+            if (!provider) return Promise.reject(new Error("Provider \u672A\u521D\u59CB\u5316"));
+            return provider.listSessions(service.workspaceRoot);
+          },
+          createSession: () => {
+            if (!provider) return Promise.reject(new Error("Provider \u672A\u521D\u59CB\u5316"));
+            return provider.createSession(service.workspaceRoot);
+          },
+          deleteSession: (id) => {
+            if (!provider) return Promise.reject(new Error("Provider \u672A\u521D\u59CB\u5316"));
+            return provider.deleteSession ? provider.deleteSession(id) : Promise.reject(new Error("\u5F53\u524D Provider \u4E0D\u652F\u6301\u5220\u9664\u4F1A\u8BDD"));
+          },
+          getCapabilities: () => provider?.capabilities ?? {},
+          resolveWidgetPath: import_paths.resolveWidgetPath,
+          resolveWidgetStylePath: import_paths.resolveWidgetStylePath,
+          retryWarmupChromeMcp: () => service.retryWarmupChromeMcp()
+        },
+        mcpProxy,
+        config.logFiles
+      );
+      if (!config.mcpOnly) {
+        try {
+          provider = await (0, import_provider_loader.loadProvider)(config.provider, {
+            hostname: config.hostname,
+            chromeDevtoolsPort: config.chromeDevtoolsPort,
+            getWebPort: () => actualWebPort,
+            getProxyPort: () => actualProxyPort,
+            options: config
+          });
+        } catch (e) {
+          log.error("\u52A0\u8F7D Web Provider \u5931\u8D25", {
+            provider: config.provider,
+            error: e instanceof Error ? e.message : String(e)
+          });
+          service.currentTask = {
+            task: "provider_not_installed",
+            data: { error: e instanceof Error ? e.message : String(e) }
+          };
+          timer.end("\u274C Provider \u52A0\u8F7D\u5931\u8D25");
+          return;
+        }
+        provider.applyConfig?.({ theme: config.theme });
+        service.setProvider(provider);
+      }
+      server.httpServer?.on("listening", async () => {
+        log.debug("Vite server listening event fired");
+        const address = server.httpServer?.address();
+        let vitePort;
+        let viteHost;
+        if (address && typeof address === "object") {
+          vitePort = address.port;
+          const addr = address.address;
+          if (addr === "::" || addr === "::1" || addr === "0.0.0.0" || !addr) {
+            viteHost = "localhost";
+          } else {
+            viteHost = addr;
+          }
+        } else {
+          const host = server.config.server.host;
+          vitePort = server.config.server.port || 5173;
+          viteHost = typeof host === "string" && host !== "0.0.0.0" && host !== "::" && host !== "::1" ? host : "localhost";
+        }
+        viteOrigin = `http://${viteHost}:${vitePort}`;
+        const contextApiUrl = `http://${viteHost}:${vitePort}${import_core.CONTEXT_API_PATH}`;
+        const logsApiUrl = `http://${viteHost}:${vitePort}${import_endpoints.LOGS_API_PATH}`;
+        vueDevtoolsApiUrl = `http://${viteHost}:${vitePort}${import_endpoints.VUE_DEVTOOLS_API_PATH}`;
+        const mcpApiUrl = `http://${viteHost}:${vitePort}${import_core.MCP_API_PATH}`;
+        log.debug("Vite server ready", {
+          vitePort,
+          viteHost,
+          viteOrigin,
+          contextApiUrl,
+          logsApiUrl,
+          vueDevtoolsApiUrl,
+          mcpApiUrl
+        });
+        log.info(`MCP endpoint: ${mcpApiUrl}`);
+        try {
+          await mcpProxy.start();
+          if (config.warmupChromeMcp) {
+            const warmup = await mcpProxy.verify();
+            if (!warmup.ok) {
+              log.debug("Chrome MCP warmup failed", { error: warmup.error });
+            }
+          }
+          if (config.mcpOnly) {
+            return;
+          }
+          await service.start(
+            vitePort,
+            [viteOrigin],
+            contextApiUrl,
+            logsApiUrl,
+            viteOrigin,
+            mcpProxy,
+            vueDevtoolsApiUrl
+          );
+        } catch (e) {
+          log.error("Failed to start services", { error: e });
+        }
+      });
+      server.httpServer?.on("close", () => {
+        log.debug("HTTP server closing");
+        service.stop();
+        mcpProxy.stop();
+      });
+      const cleanup = async () => {
+        log.debug("Process cleanup triggered");
+        mcpProxy.stop();
+        await service.stop();
+        process.exit(0);
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+      timer.end("\u2713 Server configured");
+    },
+    resolveId(id) {
+      if (id === DEVTOOLS_BRIDGE_IMPORTEE) {
+        return `${BRIDGE_SOURCE_PATH}?${DEVTOOLS_BRIDGE_QUERY}`;
+      }
+      return void 0;
+    },
+    load(id) {
+      const [filePath, query] = id.split("?", 2);
+      if (query === DEVTOOLS_BRIDGE_QUERY) {
+        return import_fs.default.readFileSync(filePath, "utf-8");
+      }
+      return void 0;
+    },
+    transformIndexHtml(html) {
+      const timer = log.timer("transformIndexHtml");
+      const tags = [
+        {
+          tag: "script",
+          injectTo: "head-prepend",
+          attrs: {
+            type: "module",
+            src: `/@id/${DEVTOOLS_BRIDGE_IMPORTEE}`
+          }
+        }
+      ];
+      const titleInject = `<script>
+        (function () {
+          var KEY = "_aipanel_pk";
+          if (!sessionStorage.getItem(KEY)) {
+            sessionStorage.setItem(KEY, "[" + Math.random().toString(36).slice(2, 10) + "]");
+          }
+        })();
+      </script>`;
+      if (config.mcpOnly) {
+        timer.end("\u2713 mcp-only (skip widget bubble, keep vue-devtools bridge + context report)");
+        return {
+          html: html.replace("</body>", `${titleInject}
+${SILENT_CONTEXT_SCRIPT}</body>`),
+          tags
+        };
+      }
+      const widget = (0, import_injector.injectWidget)({
+        theme: config.theme,
+        open: config.open,
+        hotkey: config.hotkey,
+        proxyPort: actualProxyPort,
+        proxyHost: config.hostname,
+        displayMode: config.displayMode === "extension" ? "extension-selector" : config.displayMode,
+        splitMode: config.splitMode,
+        serviceInstanceId,
+        webPort: actualWebPort,
+        projectRoot,
+        verbose: config.verbose
+      });
+      timer.end();
+      return {
+        html: html.replace("</body>", `${titleInject}
+${widget}</body>`),
+        tags
+      };
+    }
+  };
+}

package/lib/index.d.ts

@@ -0,0 +1,22 @@
+import type { Plugin } from "vite";
+import type { PluginOptions } from "@aipanel/core";
+import { type ProviderId } from "./core/provider-loader";
+import type { OpenCodeProviderOptions } from "@aipanel/provider-opencode";
+import type { DeepSeekProviderOptions } from "@aipanel/provider-deepseek";
+export type { PluginOptions } from "@aipanel/core";
+export type { OpenCodeProviderOptions } from "@aipanel/provider-opencode";
+export type { DeepSeekProviderOptions } from "@aipanel/provider-deepseek";
+export type { ProviderId };
+/**
+ * 编译期映射：provider id → providerOptions schema
+ * 与 provider-loader 的运行时包名映射对应；未知 provider 回退为宽松对象。
+ */
+type ProviderOptionsSchema<ID extends ProviderId> = ID extends "default" | "opencode" ? OpenCodeProviderOptions : ID extends "deepseek" ? DeepSeekProviderOptions : Record<string, unknown>;
+/**
+ * AIPanel Vite 插件
+ * provider 字段收窄为已登记的 ProviderId 联合类型（拼写错误在编译期报错）；
+ * providerOptions 的类型根据 options.provider 自动推断（未配置时默认 "default" → opencode）。
+ */
+export default function aipanelPlugin<const P extends ProviderId = "default">(options?: Omit<PluginOptions<ProviderOptionsSchema<P>>, "provider"> & {
+    provider?: P;
+}): Plugin[];

package/lib/utils/format-bridge.cjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_fs = __toESM(require("fs"));
+var import_http = __toESM(require("http"));
+var import_path = __toESM(require("path"));
+const filePath = process.argv[2];
+if (!filePath) {
+  console.error("Usage: node format-bridge.cjs <filePath>");
+  process.exit(1);
+}
+const absPath = import_path.default.resolve(filePath);
+const PORT = parseInt(process.env.AIPANEL_VSCODE_PORT || "", 10) || 51939;
+function touchFile() {
+  const now = /* @__PURE__ */ new Date();
+  import_fs.default.utimesSync(absPath, now, now);
+}
+function probeHealth() {
+  return new Promise((resolve) => {
+    const req = import_http.default.get(`http://127.0.0.1:${PORT}/health`, (res) => {
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+    req.setTimeout(500, () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.on("error", () => resolve(false));
+  });
+}
+function formatViaExtension() {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ filePath: absPath });
+    const req = import_http.default.request(
+      {
+        hostname: "127.0.0.1",
+        port: PORT,
+        path: "/format",
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        timeout: 5e3
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          try {
+            const result = JSON.parse(Buffer.concat(chunks).toString());
+            if (result.error) {
+              reject(new Error(result.error));
+            } else {
+              resolve(result);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Timeout"));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+async function main() {
+  const healthy = await probeHealth();
+  if (!healthy) {
+    touchFile();
+    process.exit(0);
+  }
+  try {
+    await formatViaExtension();
+  } catch {
+  }
+  touchFile();
+  process.exit(0);
+}
+main();

package/lib/utils/format-bridge.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * OpenCode VS Code 格式化桥接脚本
+ *
+ * VS Code 扩展可用时通过 HTTP API 格式化，不可用时直接返回（由 OpenCode 内置 prettier 兜底）。
+ *
+ * 用法: node format-bridge.cjs <filePath>
+ */
+export {};

package/lib/utils/paths.cjs

@@ -0,0 +1,80 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var paths_exports = {};
+__export(paths_exports, {
+  resolveVueDevtoolsBridgePath: () => resolveVueDevtoolsBridgePath,
+  resolveWidgetPath: () => resolveWidgetPath,
+  resolveWidgetStylePath: () => resolveWidgetStylePath
+});
+module.exports = __toCommonJS(paths_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_node = require("@aipanel/core/node");
+const packageDir = (0, import_node.resolvePackageDir)("vite-plugin-aipanel");
+function resolveWidgetPath() {
+  const candidatePaths = [
+    import_path.default.join(packageDir, "es", "client.js"),
+    import_path.default.join(packageDir, "lib", "client.js")
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (import_fs.default.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return candidatePaths[0];
+}
+function resolveWidgetStylePath() {
+  const candidatePaths = [
+    import_path.default.join(packageDir, "es", "client.css"),
+    import_path.default.join(packageDir, "lib", "client.css")
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (import_fs.default.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return candidatePaths[0];
+}
+function resolveVueDevtoolsBridgePath() {
+  const candidatePaths = [
+    import_path.default.join(packageDir, "es", "client", "vue-devtools-bridge.mjs"),
+    import_path.default.join(packageDir, "lib", "client", "vue-devtools-bridge.cjs")
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (import_fs.default.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return candidatePaths[0];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveVueDevtoolsBridgePath,
+  resolveWidgetPath,
+  resolveWidgetStylePath
+});

package/lib/utils/paths.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveWidgetPath(): string;
+export declare function resolveWidgetStylePath(): string;
+export declare function resolveVueDevtoolsBridgePath(): string;

package/lib/utils/system.cjs

@@ -0,0 +1,110 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var system_exports = {};
+__export(system_exports, {
+  findGitRoot: () => findGitRoot,
+  waitForServer: () => waitForServer
+});
+module.exports = __toCommonJS(system_exports);
+var import_fs = __toESM(require("fs"));
+var import_http = __toESM(require("http"));
+var import_path = __toESM(require("path"));
+var import_core = require("@aipanel/core");
+var import_node = require("@aipanel/core/node");
+const log = (0, import_node.createLogger)("Utils");
+function waitForServer(url, timeout = 1e4, process) {
+  const timer = new import_node.PerformanceTimer("waitForServer", { url, timeout });
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    let attempts = 0;
+    const check = () => {
+      attempts++;
+      log.debug(`Checking server availability (attempt ${attempts})`, { url });
+      if (process?.exitCode !== null && process?.exitCode !== void 0) {
+        timer.end(`\u274C Process exited with code ${process.exitCode}`);
+        reject(new Error(`Process exited with code ${process.exitCode}`));
+        return;
+      }
+      const req = import_http.default.get(url, (res) => {
+        if (res.statusCode && res.statusCode < 500) {
+          timer.end(`\u2713 Server ready after ${attempts} attempts`);
+          resolve();
+        } else {
+          log.debug(`Server returned status ${res.statusCode}, retrying...`);
+          retryOrReject();
+        }
+      });
+      req.on("error", (err) => {
+        log.debug(`Server check failed: ${err.message}`);
+        retryOrReject();
+      });
+    };
+    const retryOrReject = () => {
+      const elapsed = Date.now() - startTime;
+      if (elapsed < timeout) {
+        setTimeout(check, import_core.SERVER_CHECK_INTERVAL);
+      } else {
+        timer.end("\u274C Timeout");
+        reject(new Error(`Server not ready after ${timeout}ms (${attempts} attempts)`));
+      }
+    };
+    check();
+  });
+}
+function findGitRoot(startDir, maxDepth = 10) {
+  const timer = log.timer("findGitRoot", { startDir, maxDepth });
+  let currentDir = startDir;
+  let depth = 0;
+  while (depth < maxDepth) {
+    const gitDir = import_path.default.join(currentDir, ".git");
+    try {
+      if (import_fs.default.existsSync(gitDir)) {
+        timer.end(`\u2713 Found git root at depth ${depth}: ${currentDir}`);
+        return currentDir;
+      }
+    } catch (err) {
+      log.debug(`Error checking .git directory at ${currentDir}`, {
+        error: err.message
+      });
+    }
+    const parentDir = import_path.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      log.debug("Reached filesystem root");
+      break;
+    }
+    currentDir = parentDir;
+    depth++;
+  }
+  timer.end(`\u274C No git root found after ${depth} levels, using start directory`);
+  return startDir;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findGitRoot,
+  waitForServer
+});