@algolia/wizard 0.34.0 → 0.35.0-rc.125.253

package/dist/main.js

@@ -253,6 +253,7 @@ var useWizard = create((set, get) => ({
   cliOutput: [],
   targetIndex: null,
   writtenFiles: [],
+  approvedCommands: /* @__PURE__ */ new Set(),
   logs: [],
   error: null,
   inputReq: null,
@@ -348,6 +349,10 @@ var useWizard = create((set, get) => ({
   setTargetIndex: (index) => set({ targetIndex: index }),
   recordWrittenFile: (path) => set((s) => ({ writtenFiles: [...s.writtenFiles, path] })),
   clearWrittenFiles: () => set({ writtenFiles: [] }),
+  isCommandApproved: (command, cwd) => get().approvedCommands.has(`${cwd}\0${command}`),
+  approveCommand: (command, cwd) => set((s) => ({
+    approvedCommands: new Set(s.approvedCommands).add(`${cwd}\0${command}`)
+  })),
   logStart: (kind, name, input) => {
     const id = nanoid();
     set((s) => ({
@@ -396,6 +401,7 @@ var useWizard = create((set, get) => ({
       cliOutput: [],
       targetIndex: null,
       writtenFiles: [],
+      approvedCommands: /* @__PURE__ */ new Set(),
       logs: [],
       error: null,
       inputReq: null,
@@ -1122,7 +1128,7 @@ function PromptInput() {
 }
 
 // src/workflows/default.ts
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 
 // src/core/orchestrator.ts
 import "zod";
@@ -1646,8 +1652,8 @@ var selectIndexStep = async (ctx) => {
 };
 
 // src/lib/agent.ts
-import { ToolLoopAgent, hasToolCall, Output as Output2 } from "ai";
-import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
+import { ToolLoopAgent, hasToolCall, Output as Output3 } from "ai";
+import { createAnthropic as createAnthropic3 } from "@ai-sdk/anthropic";
 import "zod";
 
 // src/lib/tools/index.ts
@@ -1690,17 +1696,23 @@ async function hasSymlinkParent(ctx, target) {
 // src/lib/tools/listFiles.ts
 function listFilesTool(ctx) {
   return tool({
-    description: "List files in the current working directory",
-    inputSchema: z5.object(),
-    execute: async () => {
-      logger.info("called listFiles tool");
+    description: 'List files in a directory (default: the current working directory). Pass path to list a subdirectory directly \u2014 e.g. "packages/api" \u2014 without first changeDirectory-ing into it.',
+    inputSchema: z5.object({
+      path: z5.string().optional().describe("Directory to list, relative to cwd (default: cwd)")
+    }),
+    execute: async ({ path = "." }) => {
+      logger.info({ path }, "called listFiles tool");
       if (++ctx.counts.list > ctx.limits.list) {
         return `Refused: list limit (${ctx.limits.list}) reached. Stop listing and proceed with the information you already have.`;
       }
-      const resolved2 = resolveInRoot(ctx, ".");
+      const resolved2 = resolveInRoot(ctx, path);
       if (!resolved2.ok) return resolved2.error;
-      const entries = await readdir(resolved2.target, { withFileTypes: true });
-      return entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name).join("\n");
+      try {
+        const entries = await readdir(resolved2.target, { withFileTypes: true });
+        return entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name).join("\n");
+      } catch (err) {
+        return `Error listing ${path}: ${err.message}`;
+      }
     }
   });
 }
@@ -2072,8 +2084,7 @@ function resolveWriteKey(index, appId) {
     `Algolia Wizard write key for ${index} index`
   );
 }
-async function resolveSearchOnlyKey(index, appId, envKey) {
-  if (envKey) return { key: envKey, source: "env" };
+async function resolveSearchOnlyKey(index, appId) {
   return resolveKey(
     "search",
     index,
@@ -2112,6 +2123,12 @@ function isIgnoredByRule(root, relPath) {
 function isTracked(root, relPath) {
   return gitSucceeds(root, ["ls-files", "--error-unmatch", "--", relPath]);
 }
+async function gitIgnoreStatus(root, target) {
+  const { ignoredByRule, tracked } = await inspect(root, target);
+  if (ignoredByRule === void 0) return "unknown";
+  if (tracked) return "tracked";
+  return ignoredByRule ? "covered" : "needsRule";
+}
 async function inspect(root, target) {
   const relPath = relative2(root, target);
   if (!relPath || relPath.startsWith("..")) {
@@ -2157,31 +2174,9 @@ async function ensureGitIgnored(root, target) {
 }
 
 // src/lib/tools/writeAlgoliaCredentials.ts
-var APP_ID_VAR = "ALGOLIA_APPLICATION_ID";
-var API_KEY_VAR = "ALGOLIA_WRITE_API_KEY";
+var APP_ID_VAR = "ALGOLIA_APP_ID";
+var API_KEY_VAR = "ALGOLIA_WRITE_KEY";
 var INDEX_NAME_VAR = "ALGOLIA_INDEX_NAME";
-var PUBLIC_APP_ID_SUFFIX = "ALGOLIA_APP_ID";
-var PUBLIC_SEARCH_KEY_SUFFIX = "ALGOLIA_SEARCH_KEY";
-var PUBLIC_INDEX_NAME_SUFFIX = "ALGOLIA_INDEX_NAME";
-function publicAppIdVar(prefix) {
-  return `${prefix}${PUBLIC_APP_ID_SUFFIX}`;
-}
-function publicSearchKeyVar(prefix) {
-  return `${prefix}${PUBLIC_SEARCH_KEY_SUFFIX}`;
-}
-function publicIndexNameVar(prefix) {
-  return `${prefix}${PUBLIC_INDEX_NAME_SUFFIX}`;
-}
-function publicSearchEnvVars(prefix, index, appId, searchKey) {
-  return [
-    { name: publicAppIdVar(prefix), value: appId ?? "<your-algolia-app-id>" },
-    {
-      name: publicSearchKeyVar(prefix),
-      value: searchKey ?? "<your-algolia-search-only-api-key>"
-    },
-    { name: publicIndexNameVar(prefix), value: index }
-  ];
-}
 function appendEnv(content, entries) {
   const prefix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
   const lines = entries.map(([name, value]) => `${name}=${value}
@@ -2189,11 +2184,13 @@ function appendEnv(content, entries) {
   return content + prefix + lines;
 }
 function hasEnv(content, name) {
-  return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
+  return new RegExp(`^([ \\t]*(?:export[ \\t]+)?${name})[ \\t]*=`, "m").test(
+    content
+  );
 }
 function readEnv(content, name) {
   const found = content.match(
-    new RegExp(`^\\s*(?:export\\s+)?${name}\\s*=\\s*(.*)$`, "m")
+    new RegExp(`^[ \\t]*(?:export[ \\t]+)?${name}[ \\t]*=[ \\t]*(.*)$`, "m")
   );
   if (!found) return null;
   const raw = found[1].trim();
@@ -2204,16 +2201,16 @@ function readEnv(content, name) {
 function upsertEnv(content, name, value) {
   if (!hasEnv(content, name)) return appendEnv(content, [[name, value]]);
   return content.replace(
-    new RegExp(`^\\s*(?:export\\s+)?${name}\\s*=.*$`, "gm"),
+    new RegExp(`^[ \\t]*(?:export[ \\t]+)?${name}[ \\t]*=.*$`, "gm"),
     () => `${name}=${value}`
   );
 }
 function writeCredentialsTool(ctx) {
   return tool6({
-    description: `Write the active Algolia credentials (${APP_ID_VAR} and ${API_KEY_VAR}) and the target index name (${INDEX_NAME_VAR}) into the given env file. The credentials come from the selected Algolia application, with a write key scoped to the target index; you only pass the path to the env file. ${INDEX_NAME_VAR} is always set to this run's target index, replacing any value already there. An ${APP_ID_VAR} or ${API_KEY_VAR} the file already gives a value is left untouched; a missing or blank one is filled in when it can be paired with the selected application. The env file is added to .gitignore automatically; do not edit .gitignore yourself.`,
+    description: `Write the active Algolia credentials (${APP_ID_VAR} and ${API_KEY_VAR}) and the target index name (${INDEX_NAME_VAR}) into the given env file. The credentials come from the selected Algolia application, with a write key scoped to the target index; you only pass the path to the env file. ${INDEX_NAME_VAR} is always set to this run's target index, replacing any value already there. An ${APP_ID_VAR} or ${API_KEY_VAR} the file already gives a value is left untouched; a missing or blank one is filled in when it can be paired with the selected application. The env file is added to .gitignore automatically; do not edit .gitignore yourself. If the script or app that reads these credentials lives in a subdirectory (e.g. a package in a monorepo), an env file at the repo root is the wrong default \u2014 a script only loads env vars from its own directory (or one it's explicitly configured to read), so check every directory from the script's own up to the repo root, not just those two: its own directory, each ancestor in between (a shared workspace-level directory above the immediate package is common), and the root. Use whichever of those already holds real credentials; only fall back to the repo root when none of them do. Never invent a brand-new file in one of those directories when a real one already exists in another \u2014 that leaves the real one stale and the new one wrong. Listing just the script's own directory and the very top-level root is not enough to find a workspace-level file in between; check the intermediate ones too. If instructions describe a location that doesn't match the project you actually find (e.g. a path outside the repo, or a convention the project doesn't follow), don't stop and ask before doing anything \u2014 call this tool on the real, in-repo file the script actually reads (that's always the safe default), then note the mismatch afterward. Ending your turn with only a question and no call to this tool leaves the project unconfigured.`,
     inputSchema: z13.object({
       filePath: z13.string().describe(
-        'Path to the env file to write credentials into (e.g. ".env")'
+        'Path to the env file to write credentials into, relative to the repo root (e.g. ".env", or "packages/api/.env" when the consuming script lives in that package)'
       )
     }),
     execute: async ({ filePath }) => {
@@ -2391,7 +2388,8 @@ function searchFilesTool(ctx) {
 }
 
 // src/lib/tools/runShell.ts
-import { tool as tool8 } from "ai";
+import { tool as tool8, generateText, Output } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
 import z15 from "zod";
 import { relative as relative4 } from "node:path";
 
@@ -2500,8 +2498,10 @@ function runShell(command, opts) {
 // src/lib/tools/runShell.ts
 function storeApproval(root) {
   return async (req) => {
+    const store = useWizard.getState();
+    if (store.isCommandApproved(req.command, req.cwd)) return "approve";
     const rel = relative4(root, req.cwd);
-    const answer = await useWizard.getState().requestUserInput({
+    const answer = await store.requestUserInput({
       prompt: "Run this command?",
       promptType: "commandApproval",
       options: [],
@@ -2510,20 +2510,195 @@ function storeApproval(root) {
         cwd: rel === "" || rel.startsWith("..") ? req.cwd : rel
       }
     });
-    return answer === "approve" ? "approve" : "reject";
+    if (answer !== "approve") return "reject";
+    store.approveCommand(req.command, req.cwd);
+    return "approve";
   };
 }
 var EXPLORATORY_COMMANDS = /* @__PURE__ */ new Set(["ls", "find", "tree", "dir"]);
+function commandSegments(command) {
+  return command.split(/&&|;|\|/).map((segment) => segment.trim());
+}
 function isExploratoryCommand(command) {
-  return command.split(/&&|;|\|/).map((segment) => segment.trim().split(/\s+/)[0]).some((word) => word !== void 0 && EXPLORATORY_COMMANDS.has(word));
+  return commandSegments(command).map((segment) => segment.split(/\s+/)[0]).some((word) => word !== void 0 && EXPLORATORY_COMMANDS.has(word));
+}
+var READ_ONLY_BINARIES = /* @__PURE__ */ new Set([
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "pwd",
+  "echo",
+  "date",
+  "whoami",
+  "hostname",
+  "uname",
+  "which",
+  "file",
+  "stat",
+  "grep",
+  "egrep",
+  "fgrep",
+  "rg",
+  "diff"
+]);
+var READ_ONLY_NO_ARGS_BINARIES = /* @__PURE__ */ new Set(["env", "printenv"]);
+var GIT_READ_ONLY_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "status",
+  "log",
+  "diff",
+  "show",
+  "describe",
+  "blame",
+  "ls-files",
+  "rev-parse",
+  "cat-file",
+  "shortlog",
+  "ls-remote"
+]);
+var VERSION_CHECK_BINARIES = /* @__PURE__ */ new Set([
+  "node",
+  "tsc",
+  "npm",
+  "pnpm",
+  "yarn",
+  "python",
+  "python3",
+  "ruby",
+  "go",
+  "cargo",
+  "rustc",
+  "php",
+  "composer",
+  "java",
+  "mvn",
+  "gradle",
+  "bundle",
+  "git"
+]);
+var VERSION_FLAGS = /* @__PURE__ */ new Set(["--version", "-v", "-V"]);
+var FD_DUP_REDIRECT = /\d*>&\d+/g;
+function stripQuoted(segment) {
+  let result = "";
+  let quote = null;
+  let i = 0;
+  while (i < segment.length) {
+    const char = segment[i];
+    if (quote === "'") {
+      if (char === "'") quote = null;
+      i++;
+    } else if (char === "\\") {
+      i += 2;
+    } else if (quote) {
+      if (char === quote) quote = null;
+      i++;
+    } else if (char === '"' || char === "'") {
+      quote = char;
+      i++;
+    } else {
+      result += char;
+      i++;
+    }
+  }
+  return quote === null ? result : segment;
 }
-async function approveAndRun(ctx, command, cwd, explanation) {
-  const decision = await ctx.shell.approve({ command, cwd, explanation });
-  if (decision === "reject") {
-    ctx.shell.executions.push({ command, cwd, approved: false });
-    logger.info({ command }, "runShell: user rejected the command");
-    return "The user rejected this command. Do not retry it. Propose a different command, or report the limitation via reportStatus.";
+function hasFileRedirect(segment) {
+  return stripQuoted(segment.replace(FD_DUP_REDIRECT, "")).includes(">");
+}
+function hasShellInjectionRisk(segment) {
+  if (segment.includes("$(") || segment.includes("<(") || segment.includes("`")) {
+    return true;
+  }
+  return stripQuoted(segment.replace(FD_DUP_REDIRECT, "")).includes("&");
+}
+function fastPathSegmentSafety(segment) {
+  if (!segment) return true;
+  if (hasFileRedirect(segment)) return false;
+  if (hasShellInjectionRisk(segment)) return false;
+  const [cmd0, ...rest] = segment.split(/\s+/);
+  if (cmd0 === void 0) return true;
+  if (VERSION_CHECK_BINARIES.has(cmd0) && rest.length === 1 && VERSION_FLAGS.has(rest[0])) {
+    return true;
+  }
+  if (READ_ONLY_BINARIES.has(cmd0)) return true;
+  if (READ_ONLY_NO_ARGS_BINARIES.has(cmd0)) {
+    return rest.length === 0 ? true : void 0;
+  }
+  if (cmd0 === "git") {
+    return GIT_READ_ONLY_SUBCOMMANDS.has(rest[0] ?? "") ? true : void 0;
+  }
+  return void 0;
+}
+function fastPathSafety(command) {
+  const results = commandSegments(command).map(fastPathSegmentSafety);
+  if (results.some((r) => r === false)) return false;
+  if (results.every((r) => r === true)) return true;
+  return void 0;
+}
+var CLASSIFIER_MODEL = "claude-haiku-4-5";
+var commandSafetySchema = z15.object({
+  safe: z15.boolean(),
+  reason: z15.string().describe("One short sentence explaining the verdict.")
+});
+function defaultCreateModel() {
+  const token = getAuthToken();
+  if (!token) {
+    throw new Error("Not authenticated: no user token available");
   }
+  return createAnthropic({
+    apiKey: token,
+    baseURL: PROXY_BASE_URL,
+    fetch: proxyFetch
+  });
+}
+function approvedCommandHistory(approvedCommands) {
+  return Array.from(approvedCommands).map((entry) => {
+    const sep2 = entry.indexOf("\0");
+    return { cwd: entry.slice(0, sep2), command: entry.slice(sep2 + 1) };
+  });
+}
+async function classifyCommandSafety(createModel, command, cwd, explanation, approvedHistory) {
+  try {
+    const anthropic = createModel();
+    const { output } = await generateText({
+      model: anthropic(CLASSIFIER_MODEL),
+      temperature: 0,
+      output: Output.object({ schema: commandSafetySchema }),
+      prompt: [
+        "A coding agent wants to run this shell command in a user's project without asking for approval first. The command may be in any programming language or ecosystem.",
+        "Judge it SAFE only if it cannot modify, delete, move, rename, or install anything the project cares about, cannot push/publish/deploy/commit anything, and cannot make a network request that changes remote state.",
+        "Three broad categories are safe, and most commands you will see fall into one of them:",
+        "(1) Reporting or listing existing state, with no side effect \u2014 e.g. `git status`, `npm ls`, `npm outdated`, `pip show`, `pip freeze`, `cargo tree`, `docker ps`, `docker images`, `kubectl get pods`, `terraform state list`. This includes a read-only GET-style query to a remote registry or API that only fetches public metadata and changes nothing remote (e.g. `npm view <package>`, `pip index versions <package>`, `curl` with no -X/--request other than GET and no -d/--data) \u2014 safe because nothing changes, not because it stays local.",
+        '(2) A "preview" or "check" mode that reports what a change WOULD do, or reports a problem, without making the change. This is a general pattern, not a fixed list \u2014 ANY command that takes a dry-run/check/plan/validate/diff/list-only flag is safe when that flag is present, regardless of whether the same flag would normally appear on a "safe" kind of command: `terraform plan`, `terraform validate`, `terraform fmt -check`, `black --check`, `prettier --check`, `isort --check`, `gofmt -l` (list-only), `stylelint` with no `--fix`, and equally `git push --dry-run`, `npm publish --dry-run`, `kubectl apply --dry-run=client` \u2014 these last three are otherwise-unsafe operations (push, publish, cluster changes) that the dry-run flag turns into a report. The corresponding command WITHOUT that flag (e.g. `terraform apply`, `black .`, `gofmt -w`, `git push`) is a different, unsafe command \u2014 the flag is what makes the difference, for any tool, not just the ones named here. This cuts both ways, so do not assume a bare invocation is the safe one: `cargo fmt`, `black`, `prettier`, `isort`, `rustfmt`, and `terraform fmt` all REWRITE FILES by default and need an explicit check/diff/dry-run flag to become safe, while `gofmt`, `eslint`, `stylelint`, `rubocop`, and `ruff check` default to a safe check-only mode and need an explicit fix/write flag to become unsafe \u2014 the same-looking bare command is safe for one group and unsafe for the other, so judge each by what its own flags actually say, not by resemblance to a tool you already judged.',
+        "(3) Running the project's own tests, type checker, linter, or build/compile step (e.g. `npm run build`, `yarn build`, `vite build`, `webpack`, `tsc`, `cargo build`, `go build`, `mvn compile`), as long as it is not passed an autofix/write/update flag (e.g. --fix, -u, --write, rubocop -a) \u2014 this holds even though the point of a build step is to write compiled output to a build/dist/target directory inside the project (e.g. a target/, build/, dist/, or __pycache__ directory): writing that output does not make the command unsafe. It stops being safe the moment the command chain goes past building \u2014 a step that also deploys, publishes, uploads, or pushes the build (e.g. `next build && vercel deploy`, `npm run build && npm publish`) is unsafe for that later segment even though the build segment itself is fine; judge each chained segment on its own, same as elsewhere in this list.",
+        "Deleting or removing anything is unsafe, even something in a cache or build directory (e.g. `rm -rf __pycache__`, `cargo clean`, `git clean`), and even if the command otherwise fits one of the three categories above. Installing, uninstalling, or upgrading a dependency, changing a database schema, or writing to a path outside the project is also unsafe. A command chained with && or ; is only safe if every part of the chain is safe on its own.",
+        "One specific, narrow exception to all of the above: when the command literally invokes one of these runner programs BY NAME as the leading command \u2014 npx, bunx, pnpm dlx, yarn dlx, pipx run, uvx \u2014 it is unsafe regardless of what it then runs, even something that looks like a harmless test/lint/typecheck command (e.g. `npx tsc --noEmit`, `uvx ruff check .`), because that runner can fetch and execute a different, unreviewed version of a package from a registry each time. This exception is about that specific syntax, not a general doubt about whether a tool is installed: a plain `ruff check .`, `pytest`, or any other bare command name is NOT this exception merely because you cannot verify from the string alone that it is installed \u2014 judge those the same as any other already-installed project tool, per the categories above. If you are unsure, judge it unsafe.",
+        ...approvedHistory.length > 0 ? [
+          "The user has already explicitly approved these exact commands earlier in this session (working directory in parentheses, then the command):",
+          approvedHistory.map((h) => `- (${h.cwd}) ${h.command}`).join("\n"),
+          "If the new command performs the same action and side-effect profile as one of these \u2014 differing only in a trivial way, such as a different file path, package name, or argument value that does not change what kind of action it is \u2014 judge it SAFE on that precedent, even if it would not otherwise fit categories (1)-(3) above. Do not stretch this to a command that merely shares a binary name, or superficially resembles one on the list while doing something riskier or of a different kind (e.g. an approved `rm build/tmp.log` does not license a new `rm -rf src/`, and an approved `git push origin feature-x` does not license `git push --force`)."
+        ] : [],
+        `Command: ${command}`,
+        `Working directory: ${cwd}`,
+        `Stated purpose: ${explanation}`
+      ].join("\n")
+    });
+    if (!output.safe) {
+      logger.info(
+        { command, reason: output.reason },
+        "runShell: classifier judged command unsafe, requiring approval"
+      );
+    }
+    return output.safe;
+  } catch (err) {
+    logger.warn(
+      { err, command },
+      "runShell: command safety classifier failed, requiring approval"
+    );
+    return false;
+  }
+}
+async function runAndRecord(ctx, command, cwd) {
   useWizard.getState().pushNotice({ messages: [`Running: ${command}`] });
   const env = await ctx.shell.env().catch((err) => {
     logger.warn({ err, command }, "runShell: could not resolve command env");
@@ -2559,9 +2734,18 @@ async function approveAndRun(ctx, command, cwd, explanation) {
     output: run2.output
   };
 }
-function runShellTool(ctx) {
+async function approveAndRun(ctx, command, cwd, explanation) {
+  const decision = await ctx.shell.approve({ command, cwd, explanation });
+  if (decision === "reject") {
+    ctx.shell.executions.push({ command, cwd, approved: false });
+    logger.info({ command }, "runShell: user rejected the command");
+    return "The user rejected this command. Do not retry it. Propose a different command, or report the limitation via reportStatus.";
+  }
+  return runAndRecord(ctx, command, cwd);
+}
+function runShellTool(ctx, createModel = defaultCreateModel) {
   return tool8({
-    description: "Run a shell command in the project. Use this for anything the project needs done in its own ecosystem: installing dependencies, running a script you wrote, running the project's lint/typecheck/test commands. To inspect the project, use listFiles or searchFiles instead of ls/find \u2014 this tool refuses those. The user sees and approves every command before it runs, so write a clear `explanation`. If the user rejects a command, do not retry it \u2014 propose a different approach.",
+    description: "Run a shell command in the project. Use this for anything the project needs done in its own ecosystem: installing dependencies, running a script you wrote, running the project's lint/typecheck/test commands. Do not use this to find or read files \u2014 use listFiles, searchFiles, and readFile instead of ls/find/cat/head/tail/grep/rg. This tool refuses ls/find/tree/dir outright; a read command like cat is not refused (some read-only commands run without approval, see below), but it's still the wrong tool for reading a file \u2014 the dedicated tools exist for that and won't count against this tool's command budget. The user approves any command that could change the project before it runs, so write a clear `explanation`. A command judged read-only (inspection, or running tests/typecheck/lint without an autofix flag, in any language) runs immediately without approval. If the user rejects a command, do not retry it \u2014 propose a different approach.",
     inputSchema: z15.object({
       command: z15.string().describe(
         "The command to run, exactly as it would be typed in a shell. Pipes, && and redirects are allowed."
@@ -2580,9 +2764,29 @@ function runShellTool(ctx) {
       const resolved2 = resolveInRoot(ctx, cwd ?? ".");
       if (!resolved2.ok) return resolved2.error;
       if (isExploratoryCommand(command)) {
-        return "Refused: use listFiles or searchFiles to inspect the project instead of ls/find/tree.";
+        return "Refused: use listFiles or searchFiles to find files, and readFile to read one, instead of ls/find/tree/dir.";
       }
       logger.info({ command, cwd: resolved2.target }, "called runShell tool");
+      const fast = fastPathSafety(command);
+      let isSafe = fast;
+      if (isSafe === void 0) {
+        const store = useWizard.getState();
+        isSafe = store.isCommandApproved(command, resolved2.target);
+        if (!isSafe) {
+          isSafe = await classifyCommandSafety(
+            createModel,
+            command,
+            resolved2.target,
+            explanation,
+            approvedCommandHistory(store.approvedCommands)
+          );
+        }
+      }
+      if (isSafe) {
+        return serializePrompt(
+          () => runAndRecord(ctx, command, resolved2.target)
+        );
+      }
       return serializePrompt(
         () => approveAndRun(ctx, command, resolved2.target, explanation)
       );
@@ -2632,8 +2836,8 @@ function reviewScriptTool(ctx) {
 }
 
 // src/lib/tools/generateRecord.ts
-import { tool as tool10, generateText, Output, NoObjectGeneratedError } from "ai";
-import { createAnthropic } from "@ai-sdk/anthropic";
+import { tool as tool10, generateText as generateText2, Output as Output2, NoObjectGeneratedError } from "ai";
+import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
 import { nanoid as nanoid2 } from "nanoid";
 import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
@@ -2643,18 +2847,18 @@ var RECORD_MODEL = "claude-haiku-4-5";
 var MAX_RECORDS = 100;
 var BATCH_SIZE = 10;
 var MAX_BATCH_ATTEMPTS = 3;
-function defaultCreateModel() {
+function defaultCreateModel2() {
   const token = getAuthToken();
   if (!token) {
     throw new Error("Not authenticated: no user token available");
   }
-  return createAnthropic({
+  return createAnthropic2({
     apiKey: token,
     baseURL: PROXY_BASE_URL,
     fetch: proxyFetch
   });
 }
-function generateRecordTool(ctx, createModel = defaultCreateModel) {
+function generateRecordTool(ctx, createModel = defaultCreateModel2) {
   return tool10({
     description: "Generate realistic sample records for an entity and write them to a JSON file. Provide the entity name and its attributes; this tool asks a model to invent varied, realistic values, each with a unique objectID, and returns the file path to read them from at runtime. Do not invent the record values or objectIDs yourself, and do not inline the returned records into the script \u2014 call this tool and read the file it writes.",
     inputSchema: z17.object({
@@ -2675,9 +2879,9 @@ function generateRecordTool(ctx, createModel = defaultCreateModel) {
           let lastError;
           for (let attempt = 1; attempt <= MAX_BATCH_ATTEMPTS; attempt++) {
             try {
-              const { output } = await generateText({
+              const { output } = await generateText2({
                 model: anthropic(RECORD_MODEL),
-                output: Output.object({
+                output: Output2.object({
                   schema: z17.object({
                     records: z17.array(recordSchema).length(batchCount)
                   })
@@ -2842,7 +3046,7 @@ async function runAgentAttempt(req, attempt) {
   if (!token) {
     throw new Error("Not authenticated: no user token available");
   }
-  const anthropic = createAnthropic2({
+  const anthropic = createAnthropic3({
     apiKey: token,
     baseURL: PROXY_BASE_URL,
     fetch: proxyFetch
@@ -2879,7 +3083,7 @@ async function runAgentAttempt(req, attempt) {
         }
       };
     }),
-    output: Output2.object({ schema: req.outputSchema }),
+    output: Output3.object({ schema: req.outputSchema }),
     tools: createTools(toolContext, {
       output: req.outputSchema,
       tools: req.tools
@@ -2967,6 +3171,7 @@ var detectLanguage = () => runAgent({
     "Return the exact version",
     "Exclude things like CSS frameworks, build tools, or testing frameworks",
     `Determine publicEnvVarPrefix: check the project's own env var usage first (e.g. names already referenced in code, .env/.env.example); if none exists, fall back to the detected framework's known convention for exposing env vars to client-side code; use "" when the project has no such convention (e.g. a backend-only project).`,
+    "A brand-new project has no existing env var usage to find \u2014 one or two targeted checks (e.g. .env/.env.example, or a grep for the bundler's public-prefix convention) are enough to confirm that. Do not keep searching once those turn up nothing; fall back to the framework convention immediately.",
     'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
     "When done, call reportStatus"
   ],
@@ -3062,7 +3267,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.34.0",
+  version: "0.35.0-rc.125.253",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3467,12 +3672,13 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 };
 
 // src/actions/implement.ts
-import z29 from "zod";
+import z28 from "zod";
+import { mkdir as mkdir7 } from "node:fs/promises";
 import { join as join10, relative as relative6 } from "node:path";
 
 // src/lib/git.ts
 import { execFile as execFile2 } from "node:child_process";
-import { copyFile, mkdir as mkdir6, readFile as readFile7, stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir6, stat as stat3 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute2, join as join8, resolve as resolve3 } from "node:path";
 var MAX_BUFFER = 32 * 1024 * 1024;
 function git(args) {
@@ -3526,42 +3732,6 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
   }
   return { ok: true, relPath };
 }
-function hasEnvVar(content, name) {
-  return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
-}
-async function readEnvVar(repoRoot, name) {
-  let content;
-  try {
-    content = await readFile7(join8(repoRoot, ".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(repoRoot, vars) {
-  const target = join8(repoRoot, ".env");
-  let existing = "";
-  try {
-    existing = await readFile7(target, "utf8");
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-  const missing = vars.filter((v) => !hasEnvVar(existing, v.name));
-  if (missing.length === 0) return [];
-  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-  const lines = missing.map(({ name, value }) => `${name}=${value}
-`).join("");
-  await writeFile7(target, existing + prefix + lines, "utf8");
-  return missing.map((v) => v.name);
-}
 function normalizeFindingPaths(findings) {
   return {
     ...findings,
@@ -3642,46 +3812,36 @@ function getFrameworkSpecificDoc(frameworks) {
   return loadAlgoliaDoc("js");
 }
 
-// src/actions/resolveEnvVarPrefix.ts
-import z28 from "zod";
-var resolveEnvVarPrefixSchema = z28.object({
-  publicEnvVarPrefix: detectLanguageSchema.shape.publicEnvVarPrefix
-});
-var resolveEnvVarPrefix = (frameworkName) => runAgent({
-  instructions: [
-    `The developer corrected the project's framework to "${frameworkName}".`,
-    `Determine publicEnvVarPrefix for this framework: check the project's own env var usage first (e.g. names already referenced in code, .env/.env.example); if none exists, fall back to this framework's known convention for exposing env vars to client-side code; use "" when the framework has no such convention (e.g. a backend-only framework).`,
-    'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
-    "When done, call reportStatus"
-  ],
-  tools: ["listFiles", "changeDirectory", "readFile", "searchFiles"],
-  outputSchema: resolveEnvVarPrefixSchema,
-  modelSize: "small"
-});
-
 // src/actions/implement.ts
-var implementSchema = z29.object({
-  summary: z29.string(),
-  ingestCommand: z29.string().optional(),
-  ingestScriptRan: z29.boolean().optional(),
-  ingestRecordCount: z29.number().optional(),
-  ingestDurationMs: z29.number().optional(),
-  ingestionSource: z29.enum(["local", "fileUpload", "generated"]),
-  searchEnvVars: z29.array(
-    z29.object({
-      name: z29.string(),
-      value: z29.string()
-    })
-  ).optional()
+var implementSchema = z28.object({
+  summary: z28.string(),
+  ingestCommand: z28.string().optional(),
+  ingestScriptRan: z28.boolean().optional(),
+  ingestRecordCount: z28.number().optional(),
+  ingestDurationMs: z28.number().optional(),
+  ingestionSource: z28.enum(["local", "fileUpload", "generated"]),
+  searchConfig: z28.object({
+    filePath: z28.string().optional(),
+    vars: z28.array(
+      z28.object({
+        name: z28.string(),
+        value: z28.string()
+      })
+    )
+  }).optional()
 });
-var implementationOutputSchema = z29.object({
-  summary: z29.string(),
-  ingestCommand: z29.string().optional()
+var implementationOutputSchema = z28.object({
+  summary: z28.string(),
+  ingestCommand: z28.string().optional(),
+  // Only for the search use case: the path of whatever module the agent
+  // defined the Algolia config constants in, so the wizard can check it
+  // won't end up gitignored (it's public, meant to be committed).
+  searchConfigFile: z28.string().optional()
 });
-var verificationOutputSchema = z29.object({
-  summary: z29.string(),
-  sufficient: z29.boolean(),
-  additionalInstructions: z29.string().optional()
+var verificationOutputSchema = z28.object({
+  summary: z28.string(),
+  sufficient: z28.boolean(),
+  additionalInstructions: z28.string().optional()
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
@@ -3695,6 +3855,10 @@ function isJsProject(language) {
     (name) => JS_LANGUAGES.some((js) => name.includes(js))
   );
 }
+var SEARCH_CONFIG_APP_ID = "ALGOLIA_APP_ID";
+var SEARCH_CONFIG_SEARCH_KEY = "ALGOLIA_SEARCH_API_KEY";
+var SEARCH_CONFIG_INDEX_NAME = "ALGOLIA_INDEX_NAME";
+var SEARCH_KEY_PLACEHOLDER = "<your-algolia-search-only-api-key>";
 var UI_FRAMEWORKS = [
   { match: ["vue", "nuxt"], target: "Vue", doc: "vue" },
   { match: ["react", "next"], target: "React", doc: "react" },
@@ -3757,7 +3921,7 @@ function algoliaClientDoc(input) {
 function ingestionInstructions(input) {
   return [
     ...input.confirmed && input.confirmed.length ? [
-      `Create an ingestion script under "${input.ingestDir}/" at the repo root.`,
+      `Create an ingestion script under "${input.ingestDir}/" at the repo root. That directory already exists \u2014 writeFile creates any nested path itself, so never run a shell command just to create a directory.`,
       `Ingest only the confirmed entity (name, source paths, attributes): ${JSON.stringify(input.confirmed)}.`,
       `Ingesting writes to Algolia, so the script needs a write API key and App ID \u2014 read them from the ${API_KEY_VAR} and ${APP_ID_VAR} environment variables rather than hardcoding them. The wizard sets these when it runs the script.`,
       `Read the index name from the ${INDEX_NAME_VAR} environment variable, which the wizard sets to "${input.targetIndex}". Never hardcode an index name or derive one from the project, file, or entity name \u2014 the write key only works for that exact index. Exit with an error if ${INDEX_NAME_VAR} is unset.`,
@@ -3765,6 +3929,7 @@ function ingestionInstructions(input) {
       "After a successful ingest, the script must print exactly one line to stdout in the form `ALGOLIA_WIZARD_RECORD_COUNT=<n>`, where <n> is the total number of records pushed to Algolia. Print it last, on its own line, with no surrounding text.",
       ...algoliaClientDoc(input),
       "Install the Algolia client with the project's own package manager via runShell, declaring it in whatever manifest the project uses (e.g. package.json, requirements.txt, Gemfile, go.mod, composer.json) so the dependency is not just installed ad hoc.",
+      `If the script loads its env vars from a file (e.g. via dotenv or an equivalent for its language) rather than the process environment directly, decide that up front and call writeCredentials on that file before you finish the script \u2014 do not wait to discover the need for it by having a writeFile call refused.`,
       "When the script is finished, call reviewScript with its path and wait: running it writes records to a live index, so the developer reads it first. Do not run it before that call returns.",
       'Then run the script yourself via runShell, and report the command you ran as "ingestCommand" so the developer can re-run it. Its explanation must say that running it writes records to Algolia.',
       "The summary should be extremely concise.",
@@ -3786,17 +3951,14 @@ function searchInstructions(input) {
     `Create the search experience as its own component in a new file, following the project's existing component conventions (location, naming, styling approach). Do not write it inline into an existing file.`,
     `Import and render that new component from ${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 search input and results list against the target index.`,
     "If a search box already exists, replace its usage with an import and render of your new component; remove the old implementation.",
-    `Read the index name from the ${publicIndexNameVar(input.publicEnvVarPrefix)} env var, which the wizard sets to "${input.targetIndex}". Never hardcode an index name or derive one from the project, file, or component name.`,
-    "Read the App ID, the search-only API key, and the index name from env vars; never hardcode them. A search-only key is safe to expose client-side.",
-    // The key is provisioned only after verification passes, and the wizard
-    // reads .env to decide whether a key already exists — 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.`,
-    // The wizard writes these exact names into .env right after this step.
-    `Use exactly these env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
+    "When rendering results with an existing shared component (e.g. a card), import and reuse that component rather than inlining its markup \u2014 inlining silently drops the styles and behavior its own file provides.",
+    `Define ${SEARCH_CONFIG_APP_ID}, ${SEARCH_CONFIG_SEARCH_KEY}, and ${SEARCH_CONFIG_INDEX_NAME} as exported constants in a module that fits this project's existing conventions for shared client-side config \u2014 reuse an existing one if it already holds config like this, or add a small new one otherwise. These are PUBLIC values, safe to commit and expose client-side: never read them from an environment variable or a .env* file, and never hardcode them anywhere except in that one module (import them wherever the search client needs them).`,
+    `Set ${SEARCH_CONFIG_APP_ID} to "${input.appId}" and ${SEARCH_CONFIG_INDEX_NAME} to "${input.targetIndex}".`,
+    input.searchKey ? `Set ${SEARCH_CONFIG_SEARCH_KEY} to "${input.searchKey}".` : `A real search-only key could not be provisioned${input.searchKeyError ? ` (${input.searchKeyError})` : ""} \u2014 set ${SEARCH_CONFIG_SEARCH_KEY} to the placeholder "${SEARCH_KEY_PLACEHOLDER}" and add a prominent TODO for the developer to fill in a real one.`,
+    'Report the repo-relative path of that module as "searchConfigFile" in your final status.',
     "Install any Algolia packages you import with the project's own package manager via runShell, and declare them in the project's dependency manifest.",
     "Match the styles of the application as closely as possible.",
-    "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."
+    "The summary should be extremely concise; do not mention manual testing steps."
   ];
 }
 function verificationInstructions(input) {
@@ -3927,21 +4089,6 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     languages: ctx.getStepOutput("confirm-language")?.languages ?? scan.languages,
     frameworks: ctx.getStepOutput("confirm-framework")?.frameworks ?? scan.frameworks
   };
-  const normalizeFrameworkName = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
-  const confirmedPrimaryFramework = language.frameworks[0]?.name;
-  const frameworkWasCorrected = confirmedPrimaryFramework !== void 0 && !scan.frameworks.some(
-    (fw) => normalizeFrameworkName(fw.name) === normalizeFrameworkName(confirmedPrimaryFramework)
-  );
-  const publicEnvVarPrefixPromise = frameworkWasCorrected ? resolveEnvVarPrefix(confirmedPrimaryFramework).then(
-    (r) => r.publicEnvVarPrefix,
-    (err) => {
-      logger.warn(
-        { err, framework: confirmedPrimaryFramework },
-        "implement: could not re-resolve publicEnvVarPrefix after a framework correction; using the stale scan value"
-      );
-      return scan.publicEnvVarPrefix;
-    }
-  ) : Promise.resolve(scan.publicEnvVarPrefix);
   const selected = ctx.getStepOutput(
     "select-index"
   );
@@ -3992,6 +4139,9 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   const targetIndex = selected?.selection;
   useWizard.getState().setTargetIndex(targetIndex ?? null);
   await assertGitRepoWithHead(repoRoot);
+  if (useCases.includes("ingestion")) {
+    await mkdir7(join10(repoRoot, INGEST_DIR), { recursive: true });
+  }
   const normalized = normalizeFindingPaths(findings);
   const confirmed2 = normalized.confirmedEntities;
   const searchLocation = normalized.searchImplementationAnalysis;
@@ -4022,49 +4172,42 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
       );
     }
   }
-  const publicEnvVarPrefix = await publicEnvVarPrefixPromise;
+  const summaries = [];
+  if (uploadWarning) summaries.push(uploadWarning);
+  let searchKey;
+  let searchKeyError;
+  if (useCases.includes("search") && appId) {
+    try {
+      const resolved2 = await resolveSearchOnlyKey(targetIndex, appId);
+      searchKey = resolved2.key;
+      summaries.push(
+        resolved2.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;
+      summaries.push(
+        `Could not provision a search-only Algolia API key (${searchKeyError}) \u2014 the search agent will scaffold a placeholder with a TODO for you to fill in.`
+      );
+      logger.warn(
+        { err: searchKeyError },
+        "implement: could not provision a search-only API key; the agent will scaffold a placeholder"
+      );
+    }
+  }
   const input = {
     findings: normalized,
     confirmed: confirmed2,
     searchLocation,
     targetIndex,
     language,
-    publicEnvVarPrefix,
     appId,
-    searchEnvVars: publicSearchEnvVars(publicEnvVarPrefix, targetIndex, appId),
+    searchKey,
+    searchKeyError,
     ingestDir: INGEST_DIR,
     ingestionSource,
     uploadFilePath,
     searchUiTarget: searchUiTarget(language)
   };
-  const summaries = [];
-  if (uploadWarning) summaries.push(uploadWarning);
-  let envSearchKey;
-  let envAppIdMismatch = false;
-  if (useCases.includes("search") && appId) {
-    const envAppId = await readEnvVar(
-      repoRoot,
-      publicAppIdVar(publicEnvVarPrefix)
-    );
-    if (envAppId === appId) {
-      envSearchKey = await readEnvVar(
-        repoRoot,
-        publicSearchKeyVar(publicEnvVarPrefix)
-      );
-    } else if (envAppId) {
-      envAppIdMismatch = true;
-      const appIdVarName = publicAppIdVar(publicEnvVarPrefix);
-      const searchKeyVarName = publicSearchKeyVar(publicEnvVarPrefix);
-      summaries.push(
-        `\u26A0\uFE0F .env already sets ${appIdVarName}=${envAppId}, but the active Algolia application is ${appId}. The wizard left those values alone \u2014 update ${appIdVarName} and ${searchKeyVarName} 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 ingestCommand;
   let ingestScriptRan = false;
@@ -4174,6 +4317,7 @@ ${detail}` : ""}`
       ]
     });
   }
+  let searchConfigFile;
   if (useCases.includes("search")) {
     let extraInstructions = [];
     useWizard.getState().clearWrittenFiles();
@@ -4188,11 +4332,14 @@ ${detail}` : ""}`
           "implement: retrying search implementation after failed verification"
         );
       }
-      const { summary } = await runImplementationUseCase(
+      const searchResult = await runImplementationUseCase(
         "search",
         extraInstructions
       );
-      summaries.push(formatSummary("search", summary));
+      summaries.push(formatSummary("search", searchResult.summary));
+      if (searchResult.searchConfigFile) {
+        searchConfigFile = searchResult.searchConfigFile;
+      }
       const verification = await runVerificationUseCase();
       summaries.push(formatSummary("verification", verification.summary));
       if (verification.sufficient) {
@@ -4216,76 +4363,17 @@ ${detail}` : ""}`
       }
       extraInstructions = verificationRetryInstructions(verification);
     }
-    let searchKey;
-    let searchKeyError;
-    if (appId) {
-      try {
-        const resolved2 = await resolveSearchOnlyKey(
-          targetIndex,
-          appId,
-          envSearchKey
-        );
-        searchKey = resolved2.key;
-        summaries.push(
-          resolved2.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 = publicSearchEnvVars(
-      publicEnvVarPrefix,
-      targetIndex,
-      appId,
-      searchKey
-    );
-    const resolvedSearchEnvVars = finalSearchEnvVars.filter(
-      (v) => !v.value.startsWith("<")
-    );
-    if (resolvedSearchEnvVars.length > 0) {
-      const written = await writeSearchEnvValues(
+    if (searchConfigFile) {
+      const ignoreStatus = await gitIgnoreStatus(
         repoRoot,
-        resolvedSearchEnvVars
+        join10(repoRoot, searchConfigFile)
       );
-      if (written.length > 0) {
-        summaries.push(`Wrote ${written.join(", ")} to .env.`);
-      }
-      const ignored = await ensureGitIgnored(repoRoot, join10(repoRoot, ".env"));
-      if (ignored === "added") {
-        summaries.push("Added .env to .gitignore.");
-      } else if (ignored === "tracked") {
+      if (ignoreStatus === "covered") {
         summaries.push(
-          '\u26A0\uFE0F .env is tracked by git, so a .gitignore rule cannot un-stage it. Run "git rm --cached .env" before committing, or the credentials go into history.'
-        );
-      }
-      const stale = [];
-      for (const v of resolvedSearchEnvVars) {
-        if (written.includes(v.name)) continue;
-        const current = await readEnvVar(repoRoot, 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"
+          `\u26A0\uFE0F ${searchConfigFile} is gitignored, so this public, safe-to-share search config won't reach teammates or CI. Remove whatever .gitignore rule covers it.`
         );
       }
     }
-    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.` + (searchKeyError ? ` Reason: ${searchKeyError}` : "")
-      );
-    }
   } else {
     ctx.setUserInput("implementation", "success");
   }
@@ -4298,7 +4386,19 @@ ${detail}` : ""}`
       ...ingestRecordCount != null ? { ingestRecordCount } : {},
       ...ingestDurationMs != null ? { ingestDurationMs } : {}
     } : {},
-    ...useCases.includes("search") ? { searchEnvVars: finalSearchEnvVars } : {}
+    ...useCases.includes("search") ? {
+      searchConfig: {
+        filePath: searchConfigFile,
+        vars: [
+          { name: SEARCH_CONFIG_APP_ID, value: appId ?? "" },
+          {
+            name: SEARCH_CONFIG_SEARCH_KEY,
+            value: searchKey ?? SEARCH_KEY_PLACEHOLDER
+          },
+          { name: SEARCH_CONFIG_INDEX_NAME, value: targetIndex }
+        ]
+      }
+    } : {}
   };
 }
 
@@ -4339,8 +4439,8 @@ var defaultWorkflow = {
     defineStep({
       id: "select-index",
       title: "Set up index",
-      outputSchema: z30.object({
-        selection: z30.string()
+      outputSchema: z29.object({
+        selection: z29.string()
       }),
       run: (ctx) => selectIndexStep(ctx)
     }),
@@ -5318,7 +5418,7 @@ function App() {
 }
 
 // src/lib/envAppId.ts
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 import { join as join12 } from "node:path";
 var ENV_FILES = [".env", ".env.local"];
 var APP_ID_LINE = /^[ \t]*(?:export[ \t]+)?([A-Z0-9_]*ALGOLIA_APP(?:LICATION)?_ID)[ \t]*=[ \t]*(.*)$/gm;
@@ -5326,7 +5426,7 @@ async function findEnvApplicationId(root = process.cwd()) {
   for (const file of ENV_FILES) {
     let content;
     try {
-      content = await readFile8(join12(root, file), "utf8");
+      content = await readFile7(join12(root, file), "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         logger.warn(
@@ -5495,10 +5595,14 @@ var confirmFramework2 = {
 var search = {
   summary: "Added an InstantSearch-powered search box and results list, mounted in the shared header component.",
   ingestionSource: "generated",
-  searchEnvVars: [
-    { name: "NEXT_PUBLIC_ALGOLIA_APP_ID", value: "SEEDAPPID" },
-    { name: "NEXT_PUBLIC_ALGOLIA_SEARCH_KEY", value: "seedsearchkey" }
-  ]
+  searchConfig: {
+    filePath: "src/algolia.config.ts",
+    vars: [
+      { name: "ALGOLIA_APP_ID", value: "SEEDAPPID" },
+      { name: "ALGOLIA_SEARCH_API_KEY", value: "seedsearchkey" },
+      { name: "ALGOLIA_INDEX_NAME", value: "wizard_seed_products" }
+    ]
+  }
 };
 var review = {
   summaryPoints: [

package/docs/algolia-sdk/instantsearch-setup-js.md

@@ -4,13 +4,18 @@ Install `instantsearch.js` (v4)
 
 ## Search client: always use the lite client
 
-Import the client from `algoliasearch/lite` and alias it to `algoliasearch`
+Import the client from `algoliasearch/lite` and alias it to `algoliasearch`.
+`ALGOLIA_APP_ID`, `ALGOLIA_SEARCH_API_KEY`, and `ALGOLIA_INDEX_NAME` below are
+the constants exported from the project's shared client-side config module —
+these are public values, safe to commit; never hardcode them inline or read
+them from an env var.
 
 ```ts
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
+import { ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY } from '<the project's shared config module>'
 
 // Instantiate ONCE, outside components, with a stable reference.
-const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 ```
 
 ## Vanilla (`instantsearch.js` v4)
@@ -19,11 +24,16 @@ const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
 import instantsearch from 'instantsearch.js'
 import { searchBox, hits } from 'instantsearch.js/es/widgets'
+import {
+  ALGOLIA_APP_ID,
+  ALGOLIA_SEARCH_API_KEY,
+  ALGOLIA_INDEX_NAME,
+} from '<the project's shared config module>'
 
-const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 
 const search = instantsearch({
-  indexName: 'INDEX_NAME',
+  indexName: ALGOLIA_INDEX_NAME,
   searchClient,
   insights: true,
 })
@@ -53,7 +63,7 @@ case, install `search-insights` from npm and pass its default export as
 import aa from 'search-insights'
 
 const search = instantsearch({
-  indexName: 'INDEX_NAME',
+  indexName: ALGOLIA_INDEX_NAME,
   searchClient,
   insights: { insightsClient: aa },
 })

package/docs/algolia-sdk/instantsearch-setup-react.md

@@ -4,13 +4,18 @@ Install `react-instantsearch` (v7)
 
 ## Search client: always use the lite client
 
-Import the client from `algoliasearch/lite` and alias it to `algoliasearch`
+Import the client from `algoliasearch/lite` and alias it to `algoliasearch`.
+`ALGOLIA_APP_ID`, `ALGOLIA_SEARCH_API_KEY`, and `ALGOLIA_INDEX_NAME` below are
+the constants exported from the project's shared client-side config module —
+these are public values, safe to commit; never hardcode them inline or read
+them from an env var.
 
 ```ts
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
+import { ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY } from '<the project's shared config module>'
 
 // Instantiate ONCE, outside components, with a stable reference.
-const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 ```
 
 ## React (`react-instantsearch` v7)
@@ -18,19 +23,19 @@ const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
 ```tsx
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
 import { InstantSearch, SearchBox, Hits } from 'react-instantsearch'
+import {
+  ALGOLIA_APP_ID,
+  ALGOLIA_SEARCH_API_KEY,
+  ALGOLIA_INDEX_NAME,
+} from '<the project's shared config module>'
 
-// Read from PUBLIC env vars; never hardcode. (Vite shown; use the framework's
-// convention: NEXT_PUBLIC_* for Next.js, etc.)
-const searchClient = algoliasearch(
-  import.meta.env.VITE_ALGOLIA_APP_ID,
-  import.meta.env.VITE_ALGOLIA_SEARCH_API_KEY,
-)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 
 export function Search() {
   return (
     <InstantSearch
       searchClient={searchClient}
-      indexName="INDEX_NAME"
+      indexName={ALGOLIA_INDEX_NAME}
       insights={true}
     >
       <SearchBox />

package/docs/algolia-sdk/instantsearch-setup-vue.md

@@ -4,13 +4,18 @@ Install `vue-instantsearch` (v4)
 
 ## Search client: always use the lite client
 
-Import the client from `algoliasearch/lite` and alias it to `algoliasearch`
+Import the client from `algoliasearch/lite` and alias it to `algoliasearch`.
+`ALGOLIA_APP_ID`, `ALGOLIA_SEARCH_API_KEY`, and `ALGOLIA_INDEX_NAME` below are
+the constants exported from the project's shared client-side config module —
+these are public values, safe to commit; never hardcode them inline or read
+them from an env var.
 
 ```ts
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
+import { ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY } from '<the project's shared config module>'
 
 // Instantiate ONCE, outside components, with a stable reference.
-const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 ```
 
 ## Vue (`vue-instantsearch` v4)
@@ -19,7 +24,7 @@ const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
 <template>
   <ais-instant-search
     :search-client="searchClient"
-    index-name="INDEX_NAME"
+    :index-name="ALGOLIA_INDEX_NAME"
     :insights="true"
   >
     <ais-search-box />
@@ -29,11 +34,13 @@ const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
 
 <script setup>
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
+import {
+  ALGOLIA_APP_ID,
+  ALGOLIA_SEARCH_API_KEY,
+  ALGOLIA_INDEX_NAME,
+} from '<the project's shared config module>'
 
-const searchClient = algoliasearch(
-  import.meta.env.VITE_ALGOLIA_APP_ID,
-  import.meta.env.VITE_ALGOLIA_SEARCH_API_KEY,
-)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 </script>
 ```
 

package/docs/algolia-sdk/search-single-index.md

@@ -5,10 +5,19 @@ route, or programmatic queries). For UI, prefer `instantsearch-setup-<framework>
 
 ## Client
 
+`ALGOLIA_APP_ID`, `ALGOLIA_SEARCH_API_KEY`, and `ALGOLIA_INDEX_NAME` below are
+the constants exported from the project's shared client-side config module —
+these are public values, safe to commit; never hardcode them inline or read
+them from an env var.
+
 ```ts
 import { algoliasearch } from 'algoliasearch'
+import {
+  ALGOLIA_APP_ID,
+  ALGOLIA_SEARCH_API_KEY,
+} from '<the project's shared config module>'
 
-const client = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const client = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 ```
 
 In v5 there is no `client.initIndex(...)`. Index methods take the index name as a
@@ -18,7 +27,7 @@ parameter on the client. Every method takes a single options object.
 
 ```ts
 const { hits, nbHits } = await client.searchSingleIndex({
-  indexName: 'INDEX_NAME',
+  indexName: ALGOLIA_INDEX_NAME,
   searchParams: { query: 'shoes', hitsPerPage: 20, page: 0 },
 })
 ```
@@ -28,7 +37,7 @@ const { hits, nbHits } = await client.searchSingleIndex({
 ```ts
 const { results } = await client.search({
   requests: [
-    { indexName: 'INDEX_NAME', query: 'shoes' },
+    { indexName: ALGOLIA_INDEX_NAME, query: 'shoes' },
     { indexName: 'OTHER_INDEX', query: 'shoes' },
   ],
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.34.0",
+  "version": "0.35.0-rc.125.253",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {