@gea-ai/cli 0.1.260920-alpha.1 → 0.1.260925-alpha.0

package/package.json

@@ -12,17 +12,32 @@
     "directory": "packages/gea-cli"
   },
   "type": "module",
-  "version": "0.1.260920-alpha.1",
+  "version": "0.1.260925-alpha.0",
   "bin": {
     "gea": "gea-launcher.cjs"
   },
   "files": [
     "gea-launcher.cjs",
+    "vite.mjs",
+    "vite.d.ts",
+    "runtime.mjs",
+    "runtime.d.ts",
     "LICENSE"
   ],
+  "exports": {
+    "./package.json": "./package.json",
+    "./vite": {
+      "types": "./vite.d.ts",
+      "import": "./vite.mjs"
+    },
+    "./runtime": {
+      "types": "./runtime.d.ts",
+      "import": "./runtime.mjs"
+    }
+  },
   "name": "@gea-ai/cli",
   "optionalDependencies": {
-    "@gea-ai/cli-darwin-arm64": "0.1.260920-alpha.1",
+    "@gea-ai/cli-darwin-arm64": "0.1.260925-alpha.0",
     "@gea-ai/cli-win32-x64": "0.1.260920-alpha.1"
   },
   "os": [

package/runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function geaInstallation(environment?: NodeJS.ProcessEnv): { cli: string; runtime: string; systemWorkers: string };
+export declare function developmentEnvironment(root: string): NodeJS.ProcessEnv;

package/runtime.mjs

@@ -0,0 +1,48 @@
+// src/vite-env.ts
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { parseEnv } from "node:util";
+function developmentEnvironment(root) {
+  const file = join(root, ".dev.vars");
+  return {
+    ...existsSync(file) ? parseEnv(readFileSync(file, "utf8")) : {},
+    ...process.env
+  };
+}
+function geaInstallation(environment = process.env) {
+  let distributionRoot = environment.GEA_CLI_DISTRIBUTION_ROOT;
+  if (!distributionRoot && (!environment.GEA_CLI_BINARY || !environment.GEA_WORKER_RUNTIME_BINARY || !environment.WORKER_RUNTIME_SYSTEM_WORKER_ROOT)) {
+    const cliRequire = createRequire(import.meta.url);
+    const target = process.platform === "darwin" && process.arch === "arm64" ? "darwin-arm64" : process.platform === "win32" && process.arch === "x64" ? "win32-x64" : null;
+    if (!target)
+      throw new Error(
+        "Set GEA_CLI_BINARY, GEA_WORKER_RUNTIME_BINARY and WORKER_RUNTIME_SYSTEM_WORKER_ROOT for this platform."
+      );
+    distributionRoot = dirname(
+      cliRequire.resolve(`@gea-ai/cli-${target}/package.json`)
+    );
+  }
+  const cli = environment.GEA_CLI_BINARY ?? join(
+    distributionRoot,
+    process.platform === "win32" ? "gea-windows-x64.exe" : "gea-darwin-arm64"
+  );
+  const runtime = environment.GEA_WORKER_RUNTIME_BINARY ?? join(
+    distributionRoot,
+    process.platform === "win32" ? "gea-worker-runtime.exe" : "gea-worker-runtime"
+  );
+  const systemWorkers = environment.WORKER_RUNTIME_SYSTEM_WORKER_ROOT ?? join(distributionRoot, "system-workers");
+  for (const path of [cli, runtime, join(systemWorkers, "filesystem.mjs")]) {
+    if (!existsSync(path))
+      throw new Error(`GEA installation is incomplete: ${path}`);
+  }
+  return {
+    cli: resolve(cli),
+    runtime: resolve(runtime),
+    systemWorkers: resolve(systemWorkers)
+  };
+}
+export {
+  developmentEnvironment,
+  geaInstallation
+};

package/vite.d.ts

@@ -0,0 +1 @@
+export declare function geaWorker(): import("vite").Plugin;

package/vite.mjs

@@ -0,0 +1,255 @@
+// src/vite.ts
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { createServer, request as proxyRequest } from "node:http";
+
+// src/vite-env.ts
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { parseEnv } from "node:util";
+function developmentEnvironment(root) {
+  const file = join(root, ".dev.vars");
+  return {
+    ...existsSync(file) ? parseEnv(readFileSync(file, "utf8")) : {},
+    ...process.env
+  };
+}
+function geaInstallation(environment = process.env) {
+  let distributionRoot = environment.GEA_CLI_DISTRIBUTION_ROOT;
+  if (!distributionRoot && (!environment.GEA_CLI_BINARY || !environment.GEA_WORKER_RUNTIME_BINARY || !environment.WORKER_RUNTIME_SYSTEM_WORKER_ROOT)) {
+    const cliRequire = createRequire(import.meta.url);
+    const target = process.platform === "darwin" && process.arch === "arm64" ? "darwin-arm64" : process.platform === "win32" && process.arch === "x64" ? "win32-x64" : null;
+    if (!target)
+      throw new Error(
+        "Set GEA_CLI_BINARY, GEA_WORKER_RUNTIME_BINARY and WORKER_RUNTIME_SYSTEM_WORKER_ROOT for this platform."
+      );
+    distributionRoot = dirname(
+      cliRequire.resolve(`@gea-ai/cli-${target}/package.json`)
+    );
+  }
+  const cli = environment.GEA_CLI_BINARY ?? join(
+    distributionRoot,
+    process.platform === "win32" ? "gea-windows-x64.exe" : "gea-darwin-arm64"
+  );
+  const runtime = environment.GEA_WORKER_RUNTIME_BINARY ?? join(
+    distributionRoot,
+    process.platform === "win32" ? "gea-worker-runtime.exe" : "gea-worker-runtime"
+  );
+  const systemWorkers = environment.WORKER_RUNTIME_SYSTEM_WORKER_ROOT ?? join(distributionRoot, "system-workers");
+  for (const path of [cli, runtime, join(systemWorkers, "filesystem.mjs")]) {
+    if (!existsSync(path))
+      throw new Error(`GEA installation is incomplete: ${path}`);
+  }
+  return {
+    cli: resolve(cli),
+    runtime: resolve(runtime),
+    systemWorkers: resolve(systemWorkers)
+  };
+}
+
+// src/vite.ts
+async function reservePort() {
+  const listener = createServer();
+  listener.listen(0, "127.0.0.1");
+  await once(listener, "listening");
+  const address = listener.address();
+  if (!address || typeof address === "string")
+    throw new Error("Could not allocate development port.");
+  await new Promise((resolve2) => listener.close(() => resolve2()));
+  return address.port;
+}
+function geaWorker() {
+  let stopWorker;
+  return {
+    async closeBundle() {
+      await stopWorker?.();
+    },
+    name: "gea-worker",
+    enforce: "pre",
+    transform(code, id) {
+      if (id.endsWith(".md"))
+        return { code: `export default ${JSON.stringify(code)};`, map: null };
+    },
+    config() {
+      return {
+        environments: {
+          ssr: {
+            resolve: {
+              noExternal: true,
+              external: [
+                "@gea-ai/agent-sdk",
+                "ai",
+                "cloudflare:workers",
+                "node:async_hooks",
+                "node:stream",
+                "node:stream/web"
+              ],
+              conditions: ["workerd", "worker", "browser"]
+            },
+            build: {
+              rollupOptions: {
+                input: "worker.ts",
+                external: [
+                  /^@gea-ai\/agent-sdk(?:\/|$)/,
+                  "ai",
+                  "cloudflare:workers",
+                  "node:async_hooks",
+                  "node:stream",
+                  "node:stream/web"
+                ],
+                output: {
+                  inlineDynamicImports: true,
+                  entryFileNames: "index.js"
+                }
+              }
+            }
+          }
+        }
+      };
+    },
+    async configureServer(server) {
+      const environment = developmentEnvironment(server.config.root);
+      const installation = geaInstallation(environment);
+      const port = await reservePort();
+      const apiPort = await reservePort();
+      const origin = `http://127.0.0.1:${port}`;
+      const agentEnvironment = environment.AGENT_ENVIRONMENT ?? "local";
+      if (agentEnvironment === "local" && server.config.server.host !== "127.0.0.1")
+        throw new Error(
+          "Local Agents API development must bind Vite to 127.0.0.1."
+        );
+      const child = spawn(
+        installation.cli,
+        [
+          "agent",
+          "dev",
+          "--json",
+          JSON.stringify({
+            cwd: server.config.root,
+            host: "127.0.0.1",
+            port,
+            apiPort,
+            vite: false
+          })
+        ],
+        {
+          cwd: server.config.root,
+          env: {
+            ...environment,
+            APP_ORIGIN: environment.APP_ORIGIN ?? `http://127.0.0.1:${server.config.server.port ?? 4e3}`,
+            AGENT_ENVIRONMENT: agentEnvironment,
+            ...agentEnvironment === "local" ? { LOCAL_AGENTS_API_URL: `http://127.0.0.1:${apiPort}` } : {},
+            NODE_ENV: "production",
+            GEA_WORKER_RUNTIME_BINARY: installation.runtime,
+            WORKER_RUNTIME_SYSTEM_WORKER_ROOT: installation.systemWorkers
+          },
+          stdio: ["ignore", "pipe", "pipe"]
+        }
+      );
+      let output = "";
+      let stopping;
+      const stop = () => stopping ??= (async () => {
+        if (!child.pid || child.exitCode !== null || child.signalCode !== null)
+          return;
+        const exited = once(child, "exit");
+        child.kill("SIGTERM");
+        await exited;
+      })();
+      stopWorker = stop;
+      const restart = server.restart.bind(server);
+      server.restart = async (force) => {
+        await stop();
+        await restart(force);
+      };
+      server.httpServer?.once("close", () => {
+        void stop();
+      });
+      child.stdout.on("data", (chunk) => process.stdout.write(chunk));
+      child.stderr.on("data", (chunk) => {
+        process.stderr.write(chunk);
+        output += chunk;
+        const lines = output.split("\n");
+        output = lines.pop();
+        if (lines.some(
+          (line) => line.startsWith("[gea] Agent Worker reloaded at deployment ") || line === "[gea] Agent Worker Runtime restarted."
+        ))
+          server.ws.send({ type: "full-reload" });
+      });
+      let startupError;
+      child.once("error", (error) => {
+        startupError = error;
+      });
+      try {
+        const deadline = Date.now() + 6e4;
+        while (true) {
+          if (startupError) throw startupError;
+          if (child.exitCode !== null || child.signalCode !== null)
+            throw new Error(
+              "GEA development process exited. See its output above."
+            );
+          try {
+            const response = await fetch(`${origin}/gea/agents/run`, {
+              method: "OPTIONS"
+            });
+            await response.body?.cancel();
+            if (response.ok) break;
+          } catch {
+          }
+          if (Date.now() > deadline)
+            throw new Error("GEA development startup timed out.");
+          await new Promise((resolve2) => setTimeout(resolve2, 200));
+        }
+      } catch (error) {
+        await stop();
+        throw error;
+      }
+      server.middlewares.use((request, response, next) => {
+        const pathname = new URL(request.url ?? "/", origin).pathname;
+        if (pathname.startsWith("/@vite/") || pathname.startsWith("/@id/") || pathname.startsWith("/node_modules/") && pathname.endsWith("/vite/dist/client/env.mjs"))
+          return next();
+        const upstream = proxyRequest(
+          new URL(request.url ?? "/", origin),
+          {
+            method: request.method,
+            headers: {
+              ...request.headers,
+              "x-forwarded-host": request.headers.host ?? "",
+              "x-forwarded-proto": "http"
+            }
+          },
+          (incoming) => {
+            incoming.on("error", (error) => response.destroy(error));
+            const html = incoming.headers["content-type"]?.includes("text/html");
+            const headers = { ...incoming.headers };
+            if (html) delete headers["content-length"];
+            response.writeHead(incoming.statusCode ?? 502, headers);
+            if (!html) return void incoming.pipe(response);
+            const chunks = [];
+            incoming.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+            incoming.on(
+              "end",
+              () => response.end(
+                Buffer.concat(chunks).toString("utf8").replace(
+                  "</head>",
+                  '<script type="module" src="/@vite/client"></script></head>'
+                )
+              )
+            );
+          }
+        );
+        upstream.on("error", (error) => {
+          if (response.headersSent) response.destroy(error);
+          else response.writeHead(502).end("GEA Worker is unavailable.");
+        });
+        response.once("close", () => {
+          if (!response.writableEnded) upstream.destroy();
+        });
+        request.pipe(upstream);
+      });
+    }
+  };
+}
+export {
+  geaWorker
+};