@algolia/wizard 0.7.0 → 0.8.0-rc.49.42

package/dist/main.js

@@ -1568,7 +1568,8 @@ var configFile = () => join5(stateDir(), "config.json");
 var DEFAULT_CONFIG = {
   version: 1,
   aiConsent: false,
-  workflowsRun: []
+  workflowsRun: [],
+  searchApiKeys: {}
 };
 async function loadConfig() {
   try {
@@ -1587,6 +1588,38 @@ 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/core/orchestrator.ts
 function defineStep(step) {
@@ -2701,7 +2734,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.7.0",
+  version: "0.8.0-rc.49.42",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2749,7 +2782,7 @@ var package_default = {
   dependencies: {
     "@ai-sdk/anthropic": "^3.0.81",
     "@ai-sdk/openai-compatible": "^2.0.47",
-    "@algolia/cli": "^5.11.0",
+    "@algolia/cli": "^5.15.0",
     "@hono/node-server": "^2.0.10",
     "@mishieck/ink-titled-box": "^0.4.2",
     "@segment/analytics-node": "^3.1.0",
@@ -3307,6 +3340,23 @@ 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 = "";
@@ -3381,50 +3431,72 @@ 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()
-});
-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) {
+}).transform((o) => o.key ?? o.value);
+async function createSearchOnlyKey(index) {
+  logger.info({ index }, "creating a search-only API key");
   const stdout = await runAlgoliaCli([
     "apikeys",
     "create",
+    "--acl",
+    "search",
     "--indices",
     index,
-    "--acl",
-    "search,browse",
     "--description",
-    `wizard search-only key for ${index}`,
+    `Algolia Wizard search-only key for ${index}`,
     "-o",
     "json"
   ]);
-  const { key, value } = createdKeySchema.parse(JSON.parse(stdout));
-  const created = key ?? value;
+  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);
   if (!created) throw new Error("apikeys create returned no key value");
   return created;
 }
-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;
+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"
+    );
   }
-  logger.info({ index }, "no reusable search-only key found; creating one");
-  return createSearchKey(index);
 }
 
 // src/lib/algoliaDocs.ts
@@ -3579,15 +3651,22 @@ 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: `${prefix}ALGOLIA_APP_ID`,
+      name: appIdVar(language),
       value: appId ?? "<your-algolia-app-id>"
     },
     {
-      name: `${prefix}ALGOLIA_SEARCH_API_KEY`,
+      name: searchKeyVar(language),
       value: searchKey ?? "<your-algolia-search-only-api-key>"
     }
   ];
@@ -3649,15 +3728,13 @@ 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.`,
-    "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.
+    // The key is provisioned only after verification passes, so the agent never
+    // sees one. It must also leave .env alone: the wizard reads that file to
+    // decide whether a key already exists, and an agent-invented value there
+    // would be reused as if it were real.
+    `Add Algolia App ID "${input.appId}"; leave the search-only key as a placeholder. Do not create or edit .env \u2014 the wizard writes the resolved key there itself.`,
     `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.",
     '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."
   ];
@@ -3807,17 +3884,8 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
   const confirmed2 = normalized.confirmedEntities;
   const searchLocation = normalized.searchImplementationAnalysis;
   let appId;
-  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 {
@@ -3849,8 +3917,9 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       targetIndex,
       language,
       appId,
-      searchKey,
-      searchEnvVars: searchEnvVars(language, appId, searchKey),
+      // Names only: the search-only key is provisioned after verification, so
+      // every value here is still a placeholder when the agent reads them.
+      searchEnvVars: searchEnvVars(language, appId),
       ingestDir: INGEST_DIR,
       ingestionSource,
       uploadFilePath,
@@ -3860,6 +3929,24 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     };
     const summaries = [];
     if (uploadWarning) summaries.push(uploadWarning);
+    let envSearchKey;
+    let envAppIdMismatch = false;
+    if (useCases.includes("search") && appId) {
+      const envAppId = await readEnvVar(worktree, appIdVar(language));
+      if (envAppId === appId) {
+        envSearchKey = await readEnvVar(worktree, searchKeyVar(language));
+      } else if (envAppId) {
+        envAppIdMismatch = true;
+        summaries.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"
+        );
+      }
+    }
+    let finalSearchEnvVars = input.searchEnvVars;
     let agentRuns = 0;
     let ingestRuntime;
     let ingestEntrypoint;
@@ -4052,7 +4139,29 @@ ${run2.output}` : status;
         }
         extraInstructions = verificationRetryInstructions(verification);
       }
-      const resolvedSearchEnvVars = input.searchEnvVars.filter(
+      let searchKey;
+      let searchKeyError;
+      if (appId) {
+        try {
+          const resolved = await resolveSearchOnlyKey(
+            targetIndex,
+            appId,
+            envSearchKey
+          );
+          searchKey = resolved.key;
+          summaries.push(
+            resolved.source === "created" ? `Created a new search-only Algolia API key for the "${targetIndex}" index in app ${appId} \u2014 safe to expose in frontend code.` : `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 .env value stays a placeholder"
+          );
+        }
+      }
+      finalSearchEnvVars = searchEnvVars(language, appId, searchKey);
+      const resolvedSearchEnvVars = finalSearchEnvVars.filter(
         (v) => !v.value.startsWith("<")
       );
       if (resolvedSearchEnvVars.length > 0) {
@@ -4063,13 +4172,29 @@ ${run2.output}` : status;
         if (written.length > 0) {
           summaries.push(`Wrote ${written.join(", ")} to .env.`);
         }
+        const stale = [];
+        for (const v of resolvedSearchEnvVars) {
+          if (written.includes(v.name)) continue;
+          const current = await readEnvVar(worktree, v.name);
+          if (current && current !== v.value) stale.push(v);
+        }
+        if (stale.length > 0 && !envAppIdMismatch) {
+          summaries.push(
+            `\u26A0\uFE0F .env already assigns a different value to ${stale.map((v) => `${v.name} (should be ${v.value})`).join(", ")} \u2014 the wizard left it alone. Fix it by hand, or searches will fail.`
+          );
+          logger.warn(
+            { vars: stale.map((v) => v.name) },
+            "implement: .env holds different values for the resolved search credentials; not overwriting them"
+          );
+        }
       }
-      const unresolvedSearchEnvVars = input.searchEnvVars.filter(
+      const unresolvedSearchEnvVars = finalSearchEnvVars.filter(
         (v) => v.value.startsWith("<")
       );
       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.`
+          `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}` : "")
         );
       }
     } else {
@@ -4101,7 +4226,7 @@ ${run2.output}` : status;
         ...ingestRecordCount != null ? { ingestRecordCount } : {},
         ...ingestDurationMs != null ? { ingestDurationMs } : {}
       } : {},
-      ...useCases.includes("search") ? { searchEnvVars: input.searchEnvVars } : {}
+      ...useCases.includes("search") ? { searchEnvVars: finalSearchEnvVars } : {}
     };
   } finally {
     process.chdir(repoRoot);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.7.0",
+  "version": "0.8.0-rc.49.42",
   "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.11.0",
+    "@algolia/cli": "^5.15.0",
     "@hono/node-server": "^2.0.10",
     "@mishieck/ink-titled-box": "^0.4.2",
     "@segment/analytics-node": "^3.1.0",