@giselles-ai/agent 0.1.22 → 0.1.23

package/dist/chunk-TAQV6ZOB.js

@@ -0,0 +1,75 @@
+// src/hash.ts
+import { createHash } from "crypto";
+function computeConfigHash(config) {
+  const payload = JSON.stringify({
+    agentType: config.agentType ?? "gemini",
+    agentMd: config.agentMd ?? null,
+    files: (config.files ?? []).map((f) => ({
+      path: f.path,
+      content: f.content
+    }))
+  });
+  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+
+// src/request-build.ts
+function trimTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function resolveFiles(agent) {
+  const files = [
+    ...agent.files ?? []
+  ];
+  if (agent.agentMd !== void 0) {
+    files.push(
+      {
+        path: "/home/vercel-sandbox/.codex/AGENTS.md",
+        content: agent.agentMd
+      },
+      {
+        path: "/home/vercel-sandbox/.gemini/GEMINI.md",
+        content: agent.agentMd
+      }
+    );
+  }
+  return files;
+}
+async function requestBuild(agent, options) {
+  const baseUrl = trimTrailingSlash(
+    options?.baseUrl ?? process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api"
+  );
+  const apiUrl = `${baseUrl}/build`;
+  const token = options?.token ?? process.env.GISELLE_AGENT_API_KEY;
+  if (!token) {
+    throw new Error(
+      "Missing API token. Set GISELLE_AGENT_API_KEY or pass options.token."
+    );
+  }
+  const configHash = computeConfigHash(agent);
+  const files = resolveFiles(agent);
+  const requestBody = {
+    config_hash: configHash,
+    agent_type: agent.agentType ?? "gemini",
+    files
+  };
+  const requestHeaders = {
+    "content-type": "application/json",
+    authorization: `Bearer ${token}`,
+    ...options?.headers
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: requestHeaders,
+    body: JSON.stringify(requestBody)
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Build failed (${response.status}): ${body}`);
+  }
+  return await response.json();
+}
+
+export {
+  computeConfigHash,
+  requestBuild
+};

package/dist/index.d.ts

@@ -5,4 +5,18 @@ declare function defineAgent(config: AgentConfig): DefinedAgent;
 
 declare function computeConfigHash(config: AgentConfig): string;
 
-export { AgentConfig, DefinedAgent, computeConfigHash, defineAgent };
+type RequestBuildOptions = {
+    /** Base URL for the agent API. Default: process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api" */
+    baseUrl?: string;
+    /** Bearer token. Default: process.env.GISELLE_AGENT_API_KEY */
+    token?: string;
+    /** Additional headers to include in the build API request */
+    headers?: Record<string, string | undefined>;
+};
+type BuildResult = {
+    snapshot_id: string;
+    cached: boolean;
+};
+declare function requestBuild(agent: AgentConfig, options?: RequestBuildOptions): Promise<BuildResult>;
+
+export { AgentConfig, type BuildResult, DefinedAgent, type RequestBuildOptions, computeConfigHash, defineAgent, requestBuild };

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
-  computeConfigHash
-} from "./chunk-K2DPJIHU.js";
+  computeConfigHash,
+  requestBuild
+} from "./chunk-TAQV6ZOB.js";
 
 // src/define-agent.ts
 function defineAgent(config) {
@@ -21,5 +22,6 @@ function defineAgent(config) {
 }
 export {
   computeConfigHash,
-  defineAgent
+  defineAgent,
+  requestBuild
 };

package/dist/next/index.d.ts

@@ -10,6 +10,6 @@ type GiselleAgentPluginOptions = {
     headers?: Record<string, string | undefined>;
 };
 
-declare function withGiselleAgent(nextConfig: NextConfig, agent: AgentConfig, options?: GiselleAgentPluginOptions): () => Promise<NextConfig>;
+declare function withGiselleAgent(nextConfig: NextConfig, agent: AgentConfig, options?: GiselleAgentPluginOptions): (phase: string) => Promise<NextConfig>;
 
 export { type GiselleAgentPluginOptions, withGiselleAgent };

package/dist/next/index.js

@@ -1,73 +1,112 @@
 import {
-  computeConfigHash
-} from "../chunk-K2DPJIHU.js";
+  requestBuild
+} from "../chunk-TAQV6ZOB.js";
 
 // src/next/with-giselle-agent.ts
-function trimTrailingSlash(url) {
-  return url.replace(/\/+$/, "");
+import crypto from "crypto";
+import fs from "fs";
+import { createRequire } from "module";
+import path from "path";
+var require2 = createRequire(import.meta.url);
+var { version: PKG_VERSION } = require2("../../package.json");
+var bold = (s) => `\x1B[1m${s}\x1B[22m`;
+var green = (s) => `\x1B[32m${s}\x1B[39m`;
+var red = (s) => `\x1B[31m${s}\x1B[39m`;
+var magenta = (s) => `\x1B[35m${s}\x1B[39m`;
+var dim = (s) => `\x1B[2m${s}\x1B[22m`;
+function resolveBaseUrl(options) {
+  return (options?.baseUrl ?? process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api").replace(/\/+$/, "");
+}
+function getSnapshotFile(agent) {
+  const key = {
+    agentType: agent.agentType,
+    agentMd: agent.agentMd,
+    files: agent.files
+  };
+  const hash = crypto.createHash("sha256").update(JSON.stringify(key)).digest("hex").slice(0, 16);
+  return path.join(process.cwd(), ".next", "giselle", hash);
+}
+function hasRunRecently() {
+  const lockFile = path.join(process.cwd(), ".next", "giselle", ".lock");
+  try {
+    const ts = Number(fs.readFileSync(lockFile, "utf-8").trim());
+    if (Date.now() - ts < 2e3) {
+      return true;
+    }
+  } catch {
+  }
+  fs.mkdirSync(path.dirname(lockFile), { recursive: true });
+  fs.writeFileSync(lockFile, String(Date.now()));
+  return false;
 }
 function withGiselleAgent(nextConfig, agent, options) {
   return async () => {
-    const baseUrl = trimTrailingSlash(
-      options?.baseUrl ?? process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api"
-    );
-    const apiUrl = `${baseUrl}/build`;
-    const token = options?.token ?? process.env.GISELLE_AGENT_API_KEY;
-    if (!token) {
-      console.warn("[withGiselleAgent] Skipped snapshot build: missing token.");
+    if (hasRunRecently()) {
       return nextConfig;
     }
-    const configHash = computeConfigHash(agent);
-    const files = [
-      ...agent.files ?? []
-    ];
-    if (agent.agentMd !== void 0) {
-      files.push(
-        {
-          path: "/home/vercel-sandbox/.codex/AGENTS.md",
-          content: agent.agentMd
-        },
-        {
-          path: "/home/vercel-sandbox/.gemini/GEMINI.md",
-          content: agent.agentMd
+    const baseUrl = resolveBaseUrl(options);
+    const snapshotFile = getSnapshotFile(agent);
+    const cached = fs.existsSync(snapshotFile) ? fs.readFileSync(snapshotFile, "utf-8").trim() : void 0;
+    if (cached) {
+      return {
+        ...nextConfig,
+        env: {
+          ...nextConfig.env,
+          GISELLE_AGENT_SNAPSHOT_ID: cached
         }
+      };
+    }
+    console.log("");
+    console.log(`${magenta(bold(`\u2726 Giselle Agent ${PKG_VERSION}`))}`);
+    console.log(`${dim("- Base URL:")} ${baseUrl}`);
+    console.log("");
+    const token = options?.token ?? process.env.GISELLE_AGENT_API_KEY;
+    if (!token) {
+      console.log(`${red("\u2717")} Missing API key`);
+      console.log("");
+      console.log(
+        "  Create an account at https://studio.giselles.ai and generate"
+      );
+      console.log(
+        "  an API key, then set it as GISELLE_AGENT_API_KEY in your environment."
       );
+      console.log("");
+      throw new Error("Missing GISELLE_AGENT_API_KEY");
     }
-    const requestBody = {
-      config_hash: configHash,
-      agent_type: agent.agentType ?? "gemini",
-      files
-    };
-    const requestHeaders = {
-      "content-type": "application/json",
-      authorization: `Bearer ${token}`,
-      ...options?.headers
-    };
-    console.debug("[withGiselleAgent] POST %s", apiUrl);
-    console.debug(
-      "[withGiselleAgent] headers:",
-      JSON.stringify(requestHeaders, null, 2)
-    );
-    console.debug(
-      "[withGiselleAgent] body:",
-      JSON.stringify(requestBody, null, 2)
-    );
-    const response = await fetch(apiUrl, {
+    const authResponse = await fetch(`${baseUrl}/auth`, {
       method: "POST",
-      headers: requestHeaders,
-      body: JSON.stringify(requestBody)
+      headers: {
+        authorization: `Bearer ${token}`,
+        ...options?.headers
+      }
     });
-    if (!response.ok) {
-      const body = await response.text().catch(() => "");
-      throw new Error(
-        `[withGiselleAgent] Build failed (${response.status}): ${body}`
+    if (!authResponse.ok) {
+      console.log(`${red("\u2717")} Authentication failed`);
+      console.log("");
+      console.log(
+        "  Create an account at https://studio.giselles.ai and generate"
+      );
+      console.log(
+        "  an API key, then set it as GISELLE_AGENT_API_KEY in your environment."
       );
+      console.log("");
+      throw new Error("Authentication failed");
     }
-    const result = await response.json();
-    console.debug(
-      "[withGiselleAgent] result:",
-      JSON.stringify(result, null, 2)
-    );
+    console.log(`${green("\u2713")} Authenticated`);
+    const start = performance.now();
+    const result = await requestBuild(agent, {
+      baseUrl: options?.baseUrl,
+      token,
+      headers: options?.headers
+    });
+    fs.mkdirSync(path.dirname(snapshotFile), { recursive: true });
+    fs.writeFileSync(snapshotFile, result.snapshot_id);
+    const elapsed = Math.round(performance.now() - start);
+    const elapsedStr = elapsed < 1e3 ? `${elapsed}ms` : `${(elapsed / 1e3).toFixed(1)}s`;
+    console.log(`${green("\u2713")} Building...`);
+    console.log(`${green("\u2713")} Ready in ${elapsedStr}`);
+    console.log("");
+    console.log("");
     return {
       ...nextConfig,
       env: {

package/dist/server/index.js

@@ -90,7 +90,36 @@ import {
 
 // src/build.ts
 import { Sandbox as Sandbox2 } from "@vercel/sandbox";
-var snapshotCache = /* @__PURE__ */ new Map();
+var CACHE_KEY_PREFIX = "agent-build:snapshot:";
+var CACHE_TTL_SEC = 60 * 60 * 24;
+var memoryCache = /* @__PURE__ */ new Map();
+var MemorySnapshotCache = class {
+  async get(key2) {
+    return memoryCache.get(key2) ?? null;
+  }
+  async set(key2, value) {
+    memoryCache.set(key2, value);
+  }
+};
+var RedisSnapshotCache = class {
+  constructor(redis) {
+    this.redis = redis;
+  }
+  async get(key2) {
+    return this.redis.get(`${CACHE_KEY_PREFIX}${key2}`);
+  }
+  async set(key2, value) {
+    await this.redis.set(
+      `${CACHE_KEY_PREFIX}${key2}`,
+      value,
+      "EX",
+      CACHE_TTL_SEC
+    );
+  }
+};
+function createSnapshotCache(redis) {
+  return redis ? new RedisSnapshotCache(redis) : new MemorySnapshotCache();
+}
 function resolveBaseSnapshotId(configured) {
   const envValue = process.env.GISELLE_AGENT_SANDBOX_BASE_SNAPSHOT_ID?.trim();
   if (envValue) {
@@ -136,6 +165,7 @@ function parseBuildRequest(body) {
   };
 }
 async function buildAgent(input) {
+  const cache = input.cache ?? new MemorySnapshotCache();
   const body = await input.request.json().catch(() => null);
   const parsed = parseBuildRequest(body);
   if (!parsed) {
@@ -155,7 +185,7 @@ async function buildAgent(input) {
     );
   }
   const cacheKey = `${baseSnapshotId}:${parsed.config_hash}`;
-  const cached = snapshotCache.get(cacheKey);
+  const cached = await cache.get(cacheKey);
   if (cached) {
     console.log(
       `[agent-build] cache hit: hash=${cacheKey} -> snapshot=${cached}`
@@ -179,7 +209,7 @@ async function buildAgent(input) {
   }
   const snapshot = await sandbox.snapshot();
   console.log(`[agent-build] snapshot created: ${snapshot.snapshotId}`);
-  snapshotCache.set(cacheKey, snapshot.snapshotId);
+  await cache.set(cacheKey, snapshot.snapshotId);
   const response = {
     snapshot_id: snapshot.snapshotId,
     cached: false
@@ -1328,14 +1358,10 @@ function continueManagedCloudResponseFromLiveConnection(input) {
   return managed.response;
 }
 
-// src/cloud-chat-store.ts
-var CHAT_STATE_TTL_SEC = 60 * 60;
+// src/redis.ts
 var REDIS_URL_ENV_NAME = "REDIS_URL";
-function key(chatId) {
-  return `cloud-chat:${chatId}`;
-}
 function resolveRedisUrl(url) {
-  const resolved = url?.trim() || process.env.REDIS_URL?.trim();
+  const resolved = url?.trim() || process.env[REDIS_URL_ENV_NAME]?.trim();
   if (resolved) {
     return resolved;
   }
@@ -1343,6 +1369,26 @@ function resolveRedisUrl(url) {
     `Missing Redis URL. Set ${REDIS_URL_ENV_NAME} or pass store.url.`
   );
 }
+async function createRedisClient(url) {
+  let RedisCtor;
+  try {
+    const module = await import("ioredis");
+    RedisCtor = module.default;
+  } catch {
+    throw new Error(
+      "Redis store adapter requires `ioredis` to be installed as a peer dependency."
+    );
+  }
+  return new RedisCtor(resolveRedisUrl(url), {
+    maxRetriesPerRequest: 2
+  });
+}
+
+// src/cloud-chat-store.ts
+var CHAT_STATE_TTL_SEC = 60 * 60;
+function key(chatId) {
+  return `cloud-chat:${chatId}`;
+}
 var RedisCloudChatStateStore = class {
   constructor(redis) {
     this.redis = redis;
@@ -1363,25 +1409,12 @@ var RedisCloudChatStateStore = class {
     await this.redis.del(key(chatId));
   }
 };
-async function createRedisStore(url) {
-  let RedisCtor;
-  try {
-    const module = await import("ioredis");
-    RedisCtor = module.default;
-  } catch {
-    throw new Error(
-      "Redis store adapter requires `ioredis` to be installed as a peer dependency."
-    );
-  }
-  const redis = new RedisCtor(resolveRedisUrl(url), {
-    maxRetriesPerRequest: 2
-  });
-  return new RedisCloudChatStateStore(redis);
-}
 async function resolveCloudChatStateStore(store) {
   switch (store.adapter) {
-    case "redis":
-      return createRedisStore(store.url);
+    case "redis": {
+      const redis = await createRedisClient(store.url);
+      return new RedisCloudChatStateStore(redis);
+    }
   }
 }
 
@@ -1413,6 +1446,8 @@ function createAgentApi(options) {
   const relay = createRelayHandler();
   const { basePath, agent: agentOptions } = options;
   let storePromise = null;
+  let snapshotCachePromise = null;
+  const authPath = `${basePath}/auth`;
   const runPath = `${basePath}/run`;
   const buildPath = `${basePath}/build`;
   const relayPrefix = `${basePath}/relay`;
@@ -1420,6 +1455,13 @@ function createAgentApi(options) {
     storePromise ??= resolveCloudChatStateStore(options.store);
     return storePromise;
   }
+  function getSnapshotCache() {
+    snapshotCachePromise ??= (async () => {
+      const redis = await createRedisClient(options.store.url);
+      return createSnapshotCache(redis);
+    })();
+    return snapshotCachePromise;
+  }
   async function handleBuild(request) {
     const baseSnapshotId = process.env.GISELLE_AGENT_SANDBOX_BASE_SNAPSHOT_ID?.trim() || options.build?.baseSnapshotId;
     if (!options.build && !baseSnapshotId) {
@@ -1432,7 +1474,8 @@ function createAgentApi(options) {
       }
       return await buildAgent({
         request,
-        baseSnapshotId
+        baseSnapshotId,
+        cache: await getSnapshotCache()
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Failed to process build request.";
@@ -1478,9 +1521,24 @@ function createAgentApi(options) {
       return errorResponse(500, "INTERNAL_ERROR", message);
     }
   }
+  async function handleAuth(request) {
+    try {
+      const hookResult = await options.hooks?.build?.before?.(request);
+      if (hookResult instanceof Response) {
+        return hookResult;
+      }
+      return Response.json({ ok: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Authentication failed.";
+      return errorResponse(401, "UNAUTHORIZED", message);
+    }
+  }
   function matchSubPath(request) {
     const url = new URL(request.url);
     const pathname = url.pathname;
+    if (pathname === authPath || pathname === `${authPath}/`) {
+      return "auth";
+    }
     if (pathname === runPath || pathname === `${runPath}/`) {
       return "run";
     }
@@ -1502,6 +1560,9 @@ function createAgentApi(options) {
     },
     POST: async (request) => {
       const sub = matchSubPath(request);
+      if (sub === "auth") {
+        return handleAuth(request);
+      }
       if (sub === "run") {
         return handleRun(request);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@giselles-ai/agent",
-	"version": "0.1.22",
+	"version": "0.1.23",
 	"type": "module",
 	"sideEffects": false,
 	"license": "Apache-2.0",
@@ -37,7 +37,7 @@
 		"format": "pnpm exec biome check --write ."
 	},
 	"dependencies": {
-		"@giselles-ai/browser-tool": "0.1.22",
+		"@giselles-ai/browser-tool": "0.1.23",
 		"@vercel/sandbox": "1.6.0",
 		"@iarna/toml": "3.0.0",
 		"zod": "4.3.6"

package/dist/chunk-K2DPJIHU.js

@@ -1,17 +0,0 @@
-// src/hash.ts
-import { createHash } from "crypto";
-function computeConfigHash(config) {
-  const payload = JSON.stringify({
-    agentType: config.agentType ?? "gemini",
-    agentMd: config.agentMd ?? null,
-    files: (config.files ?? []).map((f) => ({
-      path: f.path,
-      content: f.content
-    }))
-  });
-  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
-}
-
-export {
-  computeConfigHash
-};