@algolia/wizard 0.5.0-rc.49.19 → 0.5.0-rc.50.20

package/dist/main.js

@@ -1324,7 +1324,18 @@ function App() {
             width: "100%",
             justifyContent: "space-between",
             children: [
-              showLogs ? /* @__PURE__ */ jsx13(Logs, {}) : /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", paddingX: 4, paddingY: 2, width: 70, children: [
+              showLogs ? (
+                // The error also renders here, not just in the main panel — a user
+                // watching the raw log through a long step would otherwise never
+                // see that the workflow failed.
+                /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", flexGrow: 1, children: [
+                  /* @__PURE__ */ jsx13(Logs, {}),
+                  phase === "error" && error && /* @__PURE__ */ jsx13(Box13, { paddingX: 4, paddingBottom: 1, children: /* @__PURE__ */ jsxs12(Text13, { color: COLORS.status.error, children: [
+                    "\u2716 ",
+                    error
+                  ] }) })
+                ] })
+              ) : /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", paddingX: 4, paddingY: 2, width: 70, children: [
                 /* @__PURE__ */ jsx13(Notices, {}),
                 /* @__PURE__ */ jsx13(PromptInput, {}),
                 phase === "running" && showSidebar && /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(CurrentStep, {}) }),
@@ -1353,8 +1364,7 @@ var configFile = () => join5(stateDir(), "config.json");
 var DEFAULT_CONFIG = {
   version: 1,
   aiConsent: false,
-  workflowsRun: [],
-  searchApiKeys: {}
+  workflowsRun: []
 };
 async function loadConfig() {
   try {
@@ -1373,38 +1383,6 @@ async function recordWorkflowRun(workflowId, completedAt) {
   config.workflowsRun.push({ workflowId, completedAt });
   await saveConfig(config);
 }
-function isStoredSearchKey(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const { appId, key } = value;
-  return typeof appId === "string" && !!appId && typeof key === "string" && !!key;
-}
-function storedSearchKeys(config) {
-  const stored = config.searchApiKeys;
-  if (typeof stored !== "object" || stored === null || Array.isArray(stored)) {
-    return {};
-  }
-  return stored;
-}
-async function getStoredSearchKey(index, appId) {
-  const entry = storedSearchKeys(await loadConfig())[index];
-  if (!isStoredSearchKey(entry) || entry.appId !== appId) return void 0;
-  return entry.key;
-}
-async function storeSearchKey(index, appId, key) {
-  const config = await loadConfig();
-  config.searchApiKeys = {
-    ...storedSearchKeys(config),
-    [index]: { appId, key }
-  };
-  await saveConfig(config);
-}
-async function forgetSearchKey(index) {
-  const config = await loadConfig();
-  const remaining = { ...storedSearchKeys(config) };
-  delete remaining[index];
-  config.searchApiKeys = remaining;
-  await saveConfig(config);
-}
 
 // src/lib/telemetry.ts
 function isTelemetryEnabled() {
@@ -1886,7 +1864,12 @@ var selectIndexStep = async (ctx) => {
 };
 
 // src/lib/agent.ts
-import { ToolLoopAgent, hasToolCall, Output as Output2 } from "ai";
+import {
+  ToolLoopAgent,
+  hasToolCall,
+  stepCountIs,
+  Output as Output2
+} from "ai";
 import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
 import "zod";
 
@@ -2479,9 +2462,41 @@ var MODEL_BY_SIZE = {
   medium: "claude-sonnet-4-6",
   large: "claude-opus-4-8"
 };
+var STEP_TIMEOUT_MS = 15e4;
+var CHUNK_TIMEOUT_MS = 45e3;
+var MAX_STEPS = 100;
+function withRollingCacheBreakpoint(messages) {
+  const last = messages.at(-1);
+  if (!last) return messages;
+  return [
+    ...messages.slice(0, -1),
+    {
+      ...last,
+      providerOptions: {
+        ...last.providerOptions,
+        anthropic: {
+          ...last.providerOptions?.anthropic,
+          cacheControl: { type: "ephemeral" }
+        }
+      }
+    }
+  ];
+}
+function asAgentError(name, err) {
+  const aborted = err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+  const message = err instanceof Error ? err.message : String(err);
+  return new Error(
+    aborted ? `${name} agent stalled \u2014 no response for ${STEP_TIMEOUT_MS / 1e3}s, or the stream died mid-response` : `${name} agent failed: ${message}`,
+    { cause: err }
+  );
+}
 async function runAgent(req) {
   const start = Date.now();
-  logger.info({ startedAt: new Date(start).toISOString() }, "runAgent started");
+  const name = req.name ?? "unnamed";
+  logger.info(
+    { agent: name, startedAt: new Date(start).toISOString() },
+    "runAgent started"
+  );
   const token = getAuthToken();
   if (!token) {
     throw new Error("Not authenticated: no user token available");
@@ -2501,11 +2516,16 @@ async function runAgent(req) {
     ] : [],
     "Call notifyUser whenever you start a new phase of work or your focus shifts (e.g. moving from reading code to writing files) \u2014 a short, plain-language, high-level update. Do not call it for every tool use."
   ];
+  let streamError;
+  const logStreamErrors = {
+    onError: ({ error }) => logger.error({ agent: name, err: error }, "agent stream error")
+  };
   const agent = new ToolLoopAgent({
+    ...logStreamErrors,
     model: anthropic2(MODEL_BY_SIZE[req.modelSize ?? "medium"]),
-    // Cache tools + system on the last system block. Tools render before
-    // system, so one breakpoint here caches both, reused on every loop turn
-    // after the first.
+    // Cache the tools and instructions too (see `withRollingCacheBreakpoint`).
+    // Tools are sent ahead of instructions, so one mark on the last instruction
+    // covers both; every step after the first reads them from cache.
     instructions: instructions.map((i, idx, arr) => {
       return {
         role: "system",
@@ -2523,51 +2543,70 @@ async function runAgent(req) {
       tools: req.tools
     }),
     toolChoice: "required",
-    stopWhen: [hasToolCall("reportStatus")]
+    stopWhen: [hasToolCall("reportStatus"), stepCountIs(MAX_STEPS)],
+    prepareStep: ({ messages }) => ({
+      messages: withRollingCacheBreakpoint(messages)
+    })
   });
   const stream = await agent.stream({
-    prompt: "Follow system instructions"
+    prompt: "Follow system instructions",
+    timeout: { stepMs: STEP_TIMEOUT_MS, chunkMs: CHUNK_TIMEOUT_MS }
   });
   let chunks = [];
   const chunkLimit = 5;
-  for await (const chunk of stream.textStream) {
-    if (chunks.length < chunkLimit) {
-      chunks.push(chunk);
-      continue;
+  try {
+    for await (const part of stream.fullStream) {
+      if (part.type === "error") {
+        streamError ??= part.error;
+        continue;
+      }
+      if (part.type !== "text-delta") continue;
+      if (chunks.length < chunkLimit) {
+        chunks.push(part.text);
+        continue;
+      }
+      chunks.push(part.text);
+      logger.debug(chunks.join(""));
+      chunks = [];
     }
-    chunks.push(chunk);
-    logger.debug(chunks.join(""));
-    chunks = [];
+  } catch (err) {
+    throw asAgentError(name, streamError ?? err);
   }
   if (chunks.length) {
     logger.debug(chunks.join(""));
   }
   const end = Date.now();
-  const usage = await stream.totalUsage;
+  let usage;
+  let toolResults;
+  try {
+    usage = await stream.totalUsage;
+    toolResults = await stream.toolResults;
+  } catch (err) {
+    throw asAgentError(name, streamError ?? err);
+  }
   logger.info(
     {
+      agent: name,
       finishedAt: new Date(end).toISOString(),
       durationMs: end - start,
-      // cachedInputTokens > 0 confirms prompt caching engaged. If it stays 0
-      // across turns, the tools+system prefix is under the model's min
-      // cacheable size (2048 tokens for sonnet-4-6) and caching is a no-op.
       usage
     },
     "runAgent finished"
   );
   logger.info(
-    { counts: toolContext.counts, limits: toolContext.limits },
+    { agent: name, counts: toolContext.counts, limits: toolContext.limits },
     "tool usage"
   );
-  const toolResults = await stream.toolResults;
   const report = [...toolResults].reverse().find((r) => r.toolName === "reportStatus");
   if (!report) {
-    throw new Error("Agent finished without calling reportStatus");
+    throw new Error(`${name} agent finished without calling reportStatus`, {
+      cause: streamError
+    });
   }
   const result = report.output;
   if (result.status !== "success") {
     throw new Error(
-      `Agent reported failure: ${result.reason ?? "no reason given"}`
+      `${name} agent reported failure: ${result.reason ?? "no reason given"}`
     );
   }
   return result.output;
@@ -2591,7 +2630,8 @@ var detectLanguage = () => runAgent({
   ],
   tools: ["listFiles", "changeDirectory", "readFile", "searchFiles"],
   outputSchema: detectLanguageSchema,
-  modelSize: "small"
+  modelSize: "small",
+  name: "detect-language"
 });
 
 // src/actions/analyzeCodebase.ts
@@ -2667,7 +2707,8 @@ function runMode(mode, extraInstructions = []) {
   return runAgent({
     instructions: [...instructions, ...extraInstructions],
     tools: READONLY_TOOLS,
-    outputSchema
+    outputSchema,
+    name: `analyze:${mode}`
   });
 }
 async function runAnalysis(mode, extraInstructions = []) {
@@ -2681,7 +2722,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.5.0-rc.49.19",
+  version: "0.5.0-rc.50.20",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2729,7 +2770,7 @@ var package_default = {
   dependencies: {
     "@ai-sdk/anthropic": "^3.0.81",
     "@ai-sdk/openai-compatible": "^2.0.47",
-    "@algolia/cli": "^5.15.0",
+    "@algolia/cli": "^5.11.0",
     "@hono/node-server": "^2.0.10",
     "@mishieck/ink-titled-box": "^0.4.2",
     "@segment/analytics-node": "^3.1.0",
@@ -3076,7 +3117,8 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
     ],
     tools: [],
     outputSchema: reviewSchema,
-    modelSize: "small"
+    modelSize: "small",
+    name: "review"
   });
   ctx.notify({ messages: formatReviewSummary(result) });
   return result;
@@ -3287,23 +3329,6 @@ async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourceP
 function hasEnvVar(content, name) {
   return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
 }
-async function readEnvVar(worktreePath, name) {
-  let content;
-  try {
-    content = await readFile8(join10(worktreePath, ".env"), "utf8");
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-    return void 0;
-  }
-  const match = new RegExp(
-    `^[ \\t]*(?:export[ \\t]+)?${name}[ \\t]*=[ \\t]*(.*)$`,
-    "m"
-  ).exec(content);
-  if (!match) return void 0;
-  const value = match[1].trim().replace(/^(['"])(.*)\1$/, "$2").trim();
-  if (!value || value.startsWith("<")) return void 0;
-  return value;
-}
 async function writeSearchEnvValues(worktreePath, vars) {
   const target = join10(worktreePath, ".env");
   let existing = "";
@@ -3378,72 +3403,50 @@ async function confirmDirtyWorkingTree(ctx, repoRoot) {
 
 // src/lib/algoliaApiKey.ts
 import { z as z23 } from "zod";
+var SAFE_ACLS = /* @__PURE__ */ new Set(["search", "browse", "listIndexes"]);
+var apiKeySchema = z23.object({
+  value: z23.string().min(1),
+  acl: z23.array(z23.string()).default([]),
+  indexes: z23.array(z23.string()).default([])
+});
+var apiKeyListSchema = z23.object({
+  items: z23.array(apiKeySchema).optional(),
+  keys: z23.array(apiKeySchema).optional()
+}).transform((o) => o.items ?? o.keys ?? []);
 var createdKeySchema = z23.object({
   key: z23.string().min(1).optional(),
   value: z23.string().min(1).optional()
-}).transform((o) => o.key ?? o.value);
-async function createSearchOnlyKey(index) {
-  logger.info({ index }, "creating a search-only API key");
+});
+function canReuse(key, index) {
+  return key.acl.includes("search") && key.acl.every((acl) => SAFE_ACLS.has(acl)) && (key.indexes.length === 0 || key.indexes.includes("*") || key.indexes.includes(index));
+}
+async function createSearchKey(index) {
   const stdout = await runAlgoliaCli([
     "apikeys",
     "create",
-    "--acl",
-    "search",
     "--indices",
     index,
+    "--acl",
+    "search,browse",
     "--description",
-    `Algolia Wizard search-only key for ${index}`,
+    `wizard search-only key for ${index}`,
     "-o",
     "json"
   ]);
-  let payload;
-  try {
-    payload = JSON.parse(stdout);
-  } catch {
-    throw new Error("apikeys create returned output that is not valid JSON");
-  }
-  const created = createdKeySchema.parse(payload);
+  const { key, value } = createdKeySchema.parse(JSON.parse(stdout));
+  const created = key ?? value;
   if (!created) throw new Error("apikeys create returned no key value");
   return created;
 }
-async function apiKeyExists(key) {
-  try {
-    await runAlgoliaCli(["apikeys", "get", key, "-o", "json"]);
-    return true;
-  } catch (err) {
-    return !/does not exist|not found|404/i.test(err.message);
-  }
-}
-async function resolveSearchOnlyKey(index, appId, envKey) {
-  if (envKey) {
-    await recordSearchKey(index, appId, envKey);
-    return { key: envKey, source: "env" };
-  }
-  const stored = await getStoredSearchKey(index, appId);
-  if (stored) {
-    if (await apiKeyExists(stored)) {
-      logger.info({ index, appId }, "reusing the stored search-only API key");
-      return { key: stored, source: "config" };
-    }
-    logger.warn(
-      { index, appId },
-      "the stored search-only API key no longer exists; creating a replacement"
-    );
-    await forgetSearchKey(index);
-  }
-  const key = await createSearchOnlyKey(index);
-  await recordSearchKey(index, appId, key);
-  return { key, source: "created" };
-}
-async function recordSearchKey(index, appId, key) {
-  try {
-    await storeSearchKey(index, appId, key);
-  } catch (err) {
-    logger.warn(
-      { err: err.message, index },
-      "could not record the search-only API key; a later run may create another"
-    );
+async function resolveSearchOnlyKey(index) {
+  const stdout = await runAlgoliaCli(["apikeys", "list", "-o", "json"]);
+  const existing = apiKeyListSchema.parse(JSON.parse(stdout)).find((key) => canReuse(key, index))?.value;
+  if (existing) {
+    logger.info({ index }, "reusing existing search-only API key");
+    return existing;
   }
+  logger.info({ index }, "no reusable search-only key found; creating one");
+  return createSearchKey(index);
 }
 
 // src/lib/algoliaDocs.ts
@@ -3598,22 +3601,15 @@ function publicEnvPrefix(language) {
   }
   return "PUBLIC_";
 }
-var APP_ID_VAR_SUFFIX = "ALGOLIA_APP_ID";
-var SEARCH_KEY_VAR_SUFFIX = "ALGOLIA_SEARCH_API_KEY";
-function appIdVar(language) {
-  return `${publicEnvPrefix(language)}${APP_ID_VAR_SUFFIX}`;
-}
-function searchKeyVar(language) {
-  return `${publicEnvPrefix(language)}${SEARCH_KEY_VAR_SUFFIX}`;
-}
 function searchEnvVars(language, appId, searchKey) {
+  const prefix = publicEnvPrefix(language);
   return [
     {
-      name: appIdVar(language),
+      name: `${prefix}ALGOLIA_APP_ID`,
       value: appId ?? "<your-algolia-app-id>"
     },
     {
-      name: searchKeyVar(language),
+      name: `${prefix}ALGOLIA_SEARCH_API_KEY`,
       value: searchKey ?? "<your-algolia-search-only-api-key>"
     }
   ];
@@ -3675,9 +3671,15 @@ function searchInstructions(input) {
     "Follow the Algolia JS SDK reference below for client setup and InstantSearch wiring; prefer it over prior knowledge:",
     doc,
     `Add the search UI at ${input.searchLocation ? `"${input.searchLocation}"` : "the best shared, always-rendered layout location (e.g. a header/nav component)"} so it is reachable across the app \u2014 at least a working SearchBox and Hits against the "${input.targetIndex}" index.`,
-    `Add Algolia App ID "${input.appId}", search-only key ${input.searchKey ? `"${input.searchKey}"` : "(placeholder for the developer to fill in)"}.`,
-    `Use exactly these public env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
     "Read the App ID and a search-only API key from public env vars; never hardcode them. A search-only key is safe to expose client-side.",
+    // appId always resolves (loadActiveProfile throws otherwise); only the
+    // search-only key is best-effort and can fall back to a placeholder.
+    `Values: App ID "${input.appId}", search-only key ${input.searchKey ? `"${input.searchKey}"` : "(placeholder for the developer to fill in)"}.`,
+    // Names are fixed, not the agent's to rename: the wizard writes the
+    // resolved app id / search-only key into ".env" under these exact names
+    // right after this step, so a renamed prefix here would leave the code
+    // reading a var the wizard never wrote.
+    `Use exactly these public env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
     'Add any Algolia/InstantSearch packages you import to package.json "dependencies" with a valid version range; the wizard installs them in the worktree after you finish.',
     "The summary should be extremely concise; do not mention env var setup or manual testing steps \u2014 the wizard writes the resolved credentials to .env and reports that separately."
   ];
@@ -3830,43 +3832,17 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
   let searchKey;
   if (useCases.includes("search")) {
     appId = (await loadActiveProfile()).appId;
+    try {
+      searchKey = await resolveSearchOnlyKey(targetIndex);
+    } catch (err) {
+      logger.warn(
+        { err: err.message },
+        "implement: could not resolve a search-only API key; the agent will scaffold a placeholder"
+      );
+    }
   }
   const worktree = existingWorktreePath ?? (await createWorktree(repoRoot)).path;
   try {
-    const searchKeyNotices = [];
-    let searchKeyError;
-    if (useCases.includes("search") && appId) {
-      const envAppId = await readEnvVar(worktree, appIdVar(language));
-      const envKey = envAppId === appId ? await readEnvVar(worktree, searchKeyVar(language)) : void 0;
-      if (envAppId && envAppId !== appId) {
-        searchKeyNotices.push(
-          `\u26A0\uFE0F .env already sets ${appIdVar(language)}=${envAppId}, but the active Algolia application is ${appId}. The wizard left those values alone \u2014 update ${appIdVar(language)} and ${searchKeyVar(language)} by hand, or searches will fail.`
-        );
-        logger.warn(
-          { envAppId, appId },
-          "implement: .env holds credentials for a different Algolia application; not reusing its search key"
-        );
-      }
-      try {
-        const resolved = await resolveSearchOnlyKey(targetIndex, appId, envKey);
-        searchKey = resolved.key;
-        if (resolved.source === "created") {
-          searchKeyNotices.push(
-            `Created a new search-only Algolia API key for the "${targetIndex}" index in app ${appId} \u2014 safe to expose in frontend code.`
-          );
-        } else {
-          searchKeyNotices.push(
-            `Reused the existing search-only Algolia API key for the "${targetIndex}" index in app ${appId}.`
-          );
-        }
-      } catch (err) {
-        searchKeyError = err.message;
-        logger.warn(
-          { err: searchKeyError },
-          "implement: could not provision a search-only API key; the agent will scaffold a placeholder"
-        );
-      }
-    }
     process.chdir(worktree);
     let uploadFilePath;
     let uploadWarning;
@@ -3906,7 +3882,6 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     };
     const summaries = [];
     if (uploadWarning) summaries.push(uploadWarning);
-    summaries.push(...searchKeyNotices);
     let agentRuns = 0;
     let ingestRuntime;
     let ingestEntrypoint;
@@ -3925,7 +3900,8 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
           extraInstructions
         ),
         tools: toolsForUseCase(currentUseCase, input.ingestionSource),
-        outputSchema: implementationOutputSchema
+        outputSchema: implementationOutputSchema,
+        name: `implement:${currentUseCase}`
       });
       ctx.notify({
         messages: [`Installing dependencies for ${currentUseCase}\u2026`]
@@ -3950,7 +3926,8 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       return runAgent({
         instructions: buildAgentInstructions("verification", input),
         tools: toolsForUseCase("verification"),
-        outputSchema: verificationOutputSchema
+        outputSchema: verificationOutputSchema,
+        name: "implement:verification"
       });
     }
     if (useCases.includes("ingestion")) {
@@ -4116,8 +4093,7 @@ ${run.output}` : status;
       );
       if (unresolvedSearchEnvVars.length > 0) {
         summaries.push(
-          `Could not resolve a value for ${unresolvedSearchEnvVars.map((v) => v.name).join(", ")} \u2014 fill it in manually in .env.` + // Without the reason the line is a dead end.
-          (searchKeyError ? ` Reason: ${searchKeyError}` : "")
+          `Could not resolve a value for ${unresolvedSearchEnvVars.map((v) => v.name).join(", ")} \u2014 fill it in manually in .env.`
         );
       }
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.5.0-rc.49.19",
+  "version": "0.5.0-rc.50.20",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {
@@ -48,7 +48,7 @@
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.81",
     "@ai-sdk/openai-compatible": "^2.0.47",
-    "@algolia/cli": "^5.15.0",
+    "@algolia/cli": "^5.11.0",
     "@hono/node-server": "^2.0.10",
     "@mishieck/ink-titled-box": "^0.4.2",
     "@segment/analytics-node": "^3.1.0",