@algolia/wizard 0.38.0-rc.131.265 → 0.38.0-rc.131.267

package/dist/main.js

@@ -1705,155 +1705,271 @@ function parseJson(text) {
   }
 }
 
-// src/lib/envAppId.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { join as join5 } 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;
-async function findEnvApplicationId(root = process.cwd()) {
-  for (const file of ENV_FILES) {
-    let content;
-    try {
-      content = await readFile3(join5(root, file), "utf8");
-    } catch (err) {
-      if (err.code !== "ENOENT") {
-        logger.warn(
-          { file, err },
-          "could not read env file for an application id"
-        );
+// src/actions/selectIndex.ts
+var CREATE_NEW_INDEX = "Create a new index\u2026";
+var selectIndexStep = async (ctx) => {
+  await requireApplication();
+  const indices = await listIndices();
+  const names = indices.map((i) => i.name);
+  const hasIndices = names.length > 0;
+  let error;
+  let chosen;
+  while (chosen === void 0) {
+    const selection = hasIndices ? await ctx.requestUserInput({
+      prompt: "Which index do you want to ingest into?",
+      promptType: "multipleChoice",
+      options: [...names, CREATE_NEW_INDEX],
+      messages: ["We found these indices:"],
+      error
+    }) : await ctx.requestUserInput({
+      prompt: "Name the index to create and ingest into:",
+      promptType: "textInput",
+      options: [],
+      messages: [
+        "This app has no existing indices \u2014 enter a name to create one."
+      ],
+      error
+    });
+    if (typeof selection !== "string") {
+      throw new Error("selectIndex received an unexpected non-text result");
+    }
+    let candidate;
+    if (!hasIndices) {
+      candidate = selection.trim();
+    } else if (selection === CREATE_NEW_INDEX) {
+      const name = await ctx.requestUserInput({
+        prompt: "Name the new index:",
+        promptType: "textInput",
+        options: []
+      });
+      if (typeof name !== "string") {
+        throw new Error("selectIndex received an unexpected non-text result");
       }
+      candidate = name.trim();
+    } else {
+      candidate = selection;
+    }
+    if (!candidate) {
+      error = "Index name cannot be empty.";
       continue;
     }
-    for (const [, name, raw] of content.matchAll(APP_ID_LINE)) {
-      const id = readValue(raw);
-      if (id) {
-        logger.info({ file, name, app: id }, "found an application id in env");
-        return { id, name, file };
-      }
+    chosen = candidate;
+  }
+  ctx.setUserInput("index", chosen);
+  return { selection: chosen };
+};
+
+// src/lib/agent.ts
+import { ToolLoopAgent, hasToolCall, Output as Output3 } from "ai";
+import { createAnthropic as createAnthropic3 } from "@ai-sdk/anthropic";
+import "zod";
+
+// src/lib/tools/index.ts
+import "zod";
+
+// src/lib/tools/listFiles.ts
+import { tool } from "ai";
+import z6 from "zod";
+import { readdir } from "node:fs/promises";
+
+// src/lib/tools/path.ts
+import { lstat } from "node:fs/promises";
+import { resolve as resolve2, relative, isAbsolute, dirname as dirname2, join as join5, sep } from "node:path";
+function resolveInRoot(ctx, path) {
+  const target = resolve2(ctx.cwd, path);
+  const rel = relative(ctx.root, target);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    return {
+      ok: false,
+      error: `Refused: ${target} is outside the repo root (${ctx.root}).`
+    };
+  }
+  return { ok: true, target };
+}
+async function hasSymlinkParent(ctx, target) {
+  let current = ctx.root;
+  const parts = relative(ctx.root, dirname2(target)).split(sep).filter(Boolean);
+  for (const part of parts) {
+    current = join5(current, part);
+    try {
+      if ((await lstat(current)).isSymbolicLink()) return true;
+    } catch (err) {
+      if (err.code === "ENOENT") return false;
+      throw err;
     }
   }
-  return null;
+  return false;
 }
-function readValue(raw) {
-  const trimmed = raw.trim();
-  const quoted = trimmed.match(/^(['"])(.*)\1/);
-  const value = quoted ? quoted[2].trim() : trimmed.replace(/\s+#.*$/, "").trim();
-  return value.length > 0 && !value.startsWith("<") ? value : null;
+
+// src/lib/tools/listFiles.ts
+function listFilesTool(ctx) {
+  return 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: z6.object({
+      path: z6.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, path);
+      if (!resolved2.ok) return resolved2.error;
+      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}`;
+      }
+    }
+  });
 }
 
-// src/lib/algoliaAppPicker.ts
-function blockReasonFor(app) {
-  return app.status !== "active" ? "Inactive" : "Missing permissions";
+// src/lib/tools/changeDirectory.ts
+import { tool as tool2 } from "ai";
+import z7 from "zod";
+import { stat } from "node:fs/promises";
+function changeDirectoryTool(ctx) {
+  return tool2({
+    description: "Change the current working directory. Subsequent file operations resolve relative to it. Returns the new working directory.",
+    inputSchema: z7.object({
+      path: z7.string().describe("Directory to change into")
+    }),
+    execute: async ({ path }) => {
+      logger.info({ path }, "called changeDirectory tool");
+      const resolved2 = resolveInRoot(ctx, path);
+      if (!resolved2.ok) return resolved2.error;
+      try {
+        const info = await stat(resolved2.target);
+        if (!info.isDirectory()) {
+          return `Error changing directory to ${path}: not a directory`;
+        }
+        ctx.cwd = resolved2.target;
+        return `Changed working directory to ${ctx.cwd}`;
+      } catch (err) {
+        return `Error changing directory to ${path}: ${err.message}`;
+      }
+    }
+  });
 }
-function secondaryFor(app) {
-  if (!canSelectApplication(app)) {
-    return { kind: "text", value: blockReasonFor(app) };
-  }
-  return app.plan ? { kind: "badge", value: app.plan } : void 0;
+
+// src/lib/tools/reportStatus.ts
+import { tool as tool3 } from "ai";
+import z8 from "zod";
+function reportStatusTool(output) {
+  return tool3({
+    description: "Report the status of your execution. Return a reason in case of failure.",
+    inputSchema: z8.object({
+      status: z8.enum(["success", "fail"]),
+      reason: z8.string().optional(),
+      output
+    }),
+    execute: async ({ status, reason, output: output2 }) => {
+      logger.info({ status, reason }, "called reportStatus tool");
+      return { status, reason, output: output2 };
+    }
+  });
 }
-function labelFor(app) {
-  return app.name.trim() ? `${app.name} \u2014 ${app.id}` : app.id;
+
+// src/lib/tools/readFile.ts
+import { tool as tool4 } from "ai";
+import z9 from "zod";
+import { readFile as readFile3 } from "node:fs/promises";
+
+// src/lib/tools/env.ts
+import { basename } from "node:path";
+function isEnvFile(filePath) {
+  const name = basename(filePath);
+  return name === ".env" || name.startsWith(".env.");
 }
-async function selectAndReport(app) {
-  const store = useWizard.getState();
-  store.setSettingUpApp(app.id);
-  try {
-    return await selectApplication(app.id);
-  } finally {
-    store.setSettingUpApp(null);
-  }
+function isSecretEnvFile(filePath) {
+  if (!isEnvFile(filePath)) return false;
+  const name = basename(filePath);
+  return !/\.(example|sample|template)$/.test(name);
 }
-async function promptForApplication(leadIn = []) {
-  const store = useWizard.getState();
-  const unordered = await listApplications();
-  if (unordered.length === 0) {
-    throw new Error(
-      "This Algolia account has no applications. Create one in the Algolia dashboard, or with `npx @algolia/cli@latest application create`, then restart the wizard."
-    );
-  }
-  const apps = [
-    ...unordered.filter(canSelectApplication),
-    ...unordered.filter((app) => !canSelectApplication(app))
-  ];
-  const messages = [...leadIn];
-  for (; ; ) {
-    const choice = await store.requestUserInput({
-      prompt: "Which Algolia application should the wizard work in?",
-      promptType: "multipleChoice",
-      options: apps.map(labelFor),
-      secondary: apps.map(secondaryFor),
-      disabled: apps.map((app) => !canSelectApplication(app)),
-      messages
-    });
-    const chosen = apps.find((app) => labelFor(app) === choice);
-    if (!chosen || !canSelectApplication(chosen)) {
-      throw new Error("Application picker received an unexpected selection");
+
+// src/lib/tools/readFile.ts
+function redactEnvValues(content) {
+  return content.split("\n").map((line) => {
+    const match = line.match(/^(\s*(?:export\s+)?[\w.-]+\s*=)(.*)$/);
+    if (!match) return line;
+    const value = match[2].trim();
+    if (value === "") return line;
+    return `${match[1]}[REDACTED]`;
+  }).join("\n");
+}
+function readFileTool(ctx) {
+  return tool4({
+    description: "Read the contents of a file at the given path",
+    inputSchema: z9.object({
+      filePath: z9.string().describe("Path to the file to read")
+    }),
+    execute: async ({ filePath }) => {
+      if (++ctx.counts.read > ctx.limits.read) {
+        return `Refused: read limit (${ctx.limits.read}) reached. Stop reading and proceed with the information you already have.`;
+      }
+      logger.info({ filePath }, "called readFile tool");
+      const resolved2 = resolveInRoot(ctx, filePath);
+      if (!resolved2.ok) return resolved2.error;
+      try {
+        const content = await readFile3(resolved2.target, "utf8");
+        return isEnvFile(resolved2.target) ? redactEnvValues(content) : content;
+      } catch (err) {
+        return `Error reading ${filePath}: ${err.message}`;
+      }
     }
-    try {
-      return await selectAndReport(chosen);
-    } catch (err) {
-      logger.warn(
-        { app: chosen.id, err: err.message },
-        "application select failed; re-prompting"
-      );
-      messages.push(
-        `Could not select \u201C${labelFor(chosen)}\u201D. It may have been removed \u2014 pick another.`
-      );
+  });
+}
+
+// src/lib/tools/writeFile.ts
+import { tool as tool5 } from "ai";
+import z10 from "zod";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+function writeFileTool(ctx) {
+  return tool5({
+    description: "Write content to a file at the given path, overwriting it. Writes to secret env files (.env, .env.local, etc.) are refused by this tool \u2014 call it anyway and the tool will tell you how to proceed.",
+    inputSchema: z10.object({
+      filePath: z10.string().describe("Path to the file to write"),
+      content: z10.string().describe("Content to write to the file")
+    }),
+    execute: async ({ filePath, content }) => {
+      logger.info({ filePath }, "called writeFile tool");
+      const resolved2 = resolveInRoot(ctx, filePath);
+      if (resolved2.ok === false) return resolved2.error;
+      if (isSecretEnvFile(resolved2.target)) {
+        return `Refused: ${filePath} holds secrets and cannot be written directly. If a writeCredentials tool is available, use it to set Algolia credentials. If not, tell the user to set the value manually \u2014 do not reproduce the secret value in your response.`;
+      }
+      try {
+        if (await hasSymlinkParent(ctx, resolved2.target)) {
+          return `Refused: ${resolved2.target} is outside the repo root (${ctx.root}).`;
+        }
+        await mkdir3(dirname3(resolved2.target), { recursive: true });
+        await writeFile3(resolved2.target, content, "utf8");
+        useWizard.getState().recordWrittenFile(resolved2.target);
+        return `Wrote to ${filePath}`;
+      } catch (err) {
+        return `Error writing ${filePath}: ${err.message}`;
+      }
     }
-  }
-}
-async function confirmEnvApplication(env, current) {
-  const useEnv = `Use ${env.id} (from ${env.file})`;
-  const choice = await useWizard.getState().requestUserInput({
-    prompt: "Select an application",
-    promptType: "multipleChoice",
-    options: [
-      useEnv,
-      current ? `Use ${labelFor(current)} (already selected)` : "Pick a different application"
-    ],
-    messages: [
-      `${env.file} already sets ${env.name}=${env.id}.`,
-      "Which Algolia application would you like to use?"
-    ]
   });
-  if (choice === useEnv) return selectEnvApplication(env);
-  return current ? selectAndReport(current) : null;
-}
-async function selectEnvApplication(env) {
-  try {
-    return await selectAndReport({ id: env.id, name: "" });
-  } catch (err) {
-    logger.warn(
-      { app: env.id, err: err.message },
-      "could not select the application named in env; falling back to the picker"
-    );
-    return promptForApplication([
-      `Could not select ${env.id} from ${env.file} \u2014 it may have been removed, or this account may not have access to it.`
-    ]);
-  }
-}
-async function ensureApplication(isResuming) {
-  const current = await currentApplication();
-  if (isResuming) {
-    return current ?? await promptForApplication();
-  }
-  const env = await findEnvApplicationId();
-  if (env && env.id !== current?.id) {
-    const chosen = await confirmEnvApplication(env, current);
-    if (chosen) return chosen;
-  }
-  return promptForApplication();
 }
 
+// src/lib/tools/writeAlgoliaCredentials.ts
+import { tool as tool6 } from "ai";
+import z13 from "zod";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname4, relative as relative3 } from "node:path";
+
 // src/lib/algoliaApiKey.ts
-import { z as z7 } from "zod";
+import { z as z12 } from "zod";
 
 // src/lib/keychain.ts
 import { deletePassword, getPassword, setPassword } from "cross-keychain";
-import { z as z6 } from "zod";
+import { z as z11 } from "zod";
 var SERVICE = "algolia-wizard";
 var account = (userId) => `api-keys:${userId}`;
-var storedKeysSchema = z6.record(z6.string(), z6.string());
+var storedKeysSchema = z11.record(z11.string(), z11.string());
 function entryId(kind, index, appId) {
   return `${kind}:${appId}:${index}`;
 }
@@ -1945,9 +2061,9 @@ var WRITE_ACLS = [
   "editSettings",
   "listIndexes"
 ];
-var createdKeySchema = z7.object({
-  key: z7.string().min(1).optional(),
-  value: z7.string().min(1).optional()
+var createdKeySchema = z12.object({
+  key: z12.string().min(1).optional(),
+  value: z12.string().min(1).optional()
 }).transform((o) => o.key ?? o.value);
 async function createKey(index, acls, description) {
   logger.info({ index, acls }, "creating an API key");
@@ -1970,355 +2086,81 @@ async function createKey(index, acls, description) {
     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 keyExists(key) {
-  try {
-    await runAlgoliaCli(["apikeys", "get", key, "-o", "json"], { redact: key });
-    return true;
-  } catch (err) {
-    return !/does not exist/i.test(err.message);
-  }
-}
-var resolved = /* @__PURE__ */ new Map();
-async function forgetResolvedKeys() {
-  resolved.clear();
-  const userId = await currentUserId();
-  if (userId) await deleteStoredKeys(userId);
-}
-function resolveKey(kind, index, appId, acls, description) {
-  const cacheKey = `${kind}:${appId}:${index}`;
-  const cached = resolved.get(cacheKey);
-  if (cached) return cached;
-  const pending = provisionKey(kind, index, appId, acls, description).catch(
-    (err) => {
-      resolved.delete(cacheKey);
-      throw err;
-    }
-  );
-  resolved.set(cacheKey, pending);
-  return pending;
-}
-async function provisionKey(kind, index, appId, acls, description) {
-  const userId = requireUserId();
-  const stored = await readStoredKey(kind, userId, index, appId);
-  if (stored) {
-    if (await keyExists(stored)) {
-      logger.info({ kind, index, appId }, "reusing the stored API key");
-      return { key: stored, source: "keychain" };
-    }
-    logger.info(
-      { kind, index, appId },
-      "the stored API key no longer exists; creating another"
-    );
-  }
-  const key = await createKey(index, acls, description);
-  await storeKey(kind, userId, index, appId, key);
-  return { key, source: "created" };
-}
-function resolveWriteKey(index, appId) {
-  return resolveKey(
-    "write",
-    index,
-    appId,
-    WRITE_ACLS,
-    `Algolia Wizard write key for ${index} index`
-  );
-}
-async function resolveSearchOnlyKey(index, appId) {
-  return resolveKey(
-    "search",
-    index,
-    appId,
-    ["search"],
-    `Algolia Wizard search-only key for ${index} index`
-  );
-}
-
-// src/actions/selectIndex.ts
-var CREATE_NEW_INDEX = "Create a new index\u2026";
-async function canIssueKeys(index, appId) {
-  try {
-    await resolveWriteKey(index, appId);
-    await resolveSearchOnlyKey(index, appId);
-    return { ok: true };
-  } catch (err) {
-    return { ok: false, error: err.message };
-  }
-}
-var selectIndexStep = async (ctx) => {
-  let appId = (await requireApplication()).id;
-  for (; ; ) {
-    const indices = await listIndices();
-    const names = indices.map((i) => i.name);
-    const hasIndices = names.length > 0;
-    let error;
-    let chosen;
-    while (chosen === void 0) {
-      const selection = hasIndices ? await ctx.requestUserInput({
-        prompt: "Which index do you want to ingest into?",
-        promptType: "multipleChoice",
-        options: [...names, CREATE_NEW_INDEX],
-        messages: ["We found these indices:"],
-        error
-      }) : await ctx.requestUserInput({
-        prompt: "Name the index to create and ingest into:",
-        promptType: "textInput",
-        options: [],
-        messages: [
-          "This app has no existing indices \u2014 enter a name to create one."
-        ],
-        error
-      });
-      if (typeof selection !== "string") {
-        throw new Error("selectIndex received an unexpected non-text result");
-      }
-      let candidate;
-      if (!hasIndices) {
-        candidate = selection.trim();
-      } else if (selection === CREATE_NEW_INDEX) {
-        const name = await ctx.requestUserInput({
-          prompt: "Name the new index:",
-          promptType: "textInput",
-          options: []
-        });
-        if (typeof name !== "string") {
-          throw new Error("selectIndex received an unexpected non-text result");
-        }
-        candidate = name.trim();
-      } else {
-        candidate = selection;
-      }
-      if (!candidate) {
-        error = "Index name cannot be empty.";
-        continue;
-      }
-      chosen = candidate;
-    }
-    const issued = await canIssueKeys(chosen, appId);
-    if (issued.ok) {
-      ctx.setUserInput("index", chosen);
-      return { selection: chosen };
-    }
-    logger.warn(
-      { appId, index: chosen, err: issued.error },
-      "selectIndex: could not mint API keys in the selected application; asking for another"
-    );
-    const reselected = await promptForApplication([
-      `Could not create an Algolia API key in application ${appId} (${issued.error}).`,
-      "Pick a different application to work in."
-    ]);
-    appId = reselected.id;
-  }
-};
-
-// src/lib/agent.ts
-import { ToolLoopAgent, hasToolCall, Output as Output3 } from "ai";
-import { createAnthropic as createAnthropic3 } from "@ai-sdk/anthropic";
-import "zod";
-
-// src/lib/tools/index.ts
-import "zod";
-
-// src/lib/tools/listFiles.ts
-import { tool } from "ai";
-import z8 from "zod";
-import { readdir } from "node:fs/promises";
-
-// src/lib/tools/path.ts
-import { lstat } from "node:fs/promises";
-import { resolve as resolve2, relative, isAbsolute, dirname as dirname2, join as join6, sep } from "node:path";
-function resolveInRoot(ctx, path) {
-  const target = resolve2(ctx.cwd, path);
-  const rel = relative(ctx.root, target);
-  if (rel.startsWith("..") || isAbsolute(rel)) {
-    return {
-      ok: false,
-      error: `Refused: ${target} is outside the repo root (${ctx.root}).`
-    };
-  }
-  return { ok: true, target };
-}
-async function hasSymlinkParent(ctx, target) {
-  let current = ctx.root;
-  const parts = relative(ctx.root, dirname2(target)).split(sep).filter(Boolean);
-  for (const part of parts) {
-    current = join6(current, part);
-    try {
-      if ((await lstat(current)).isSymbolicLink()) return true;
-    } catch (err) {
-      if (err.code === "ENOENT") return false;
-      throw err;
-    }
-  }
-  return false;
-}
-
-// src/lib/tools/listFiles.ts
-function listFilesTool(ctx) {
-  return 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: z8.object({
-      path: z8.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, path);
-      if (!resolved2.ok) return resolved2.error;
-      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}`;
-      }
-    }
-  });
-}
-
-// src/lib/tools/changeDirectory.ts
-import { tool as tool2 } from "ai";
-import z9 from "zod";
-import { stat } from "node:fs/promises";
-function changeDirectoryTool(ctx) {
-  return tool2({
-    description: "Change the current working directory. Subsequent file operations resolve relative to it. Returns the new working directory.",
-    inputSchema: z9.object({
-      path: z9.string().describe("Directory to change into")
-    }),
-    execute: async ({ path }) => {
-      logger.info({ path }, "called changeDirectory tool");
-      const resolved2 = resolveInRoot(ctx, path);
-      if (!resolved2.ok) return resolved2.error;
-      try {
-        const info = await stat(resolved2.target);
-        if (!info.isDirectory()) {
-          return `Error changing directory to ${path}: not a directory`;
-        }
-        ctx.cwd = resolved2.target;
-        return `Changed working directory to ${ctx.cwd}`;
-      } catch (err) {
-        return `Error changing directory to ${path}: ${err.message}`;
-      }
-    }
-  });
-}
-
-// src/lib/tools/reportStatus.ts
-import { tool as tool3 } from "ai";
-import z10 from "zod";
-function reportStatusTool(output) {
-  return tool3({
-    description: "Report the status of your execution. Return a reason in case of failure.",
-    inputSchema: z10.object({
-      status: z10.enum(["success", "fail"]),
-      reason: z10.string().optional(),
-      output
-    }),
-    execute: async ({ status, reason, output: output2 }) => {
-      logger.info({ status, reason }, "called reportStatus tool");
-      return { status, reason, output: output2 };
-    }
-  });
-}
-
-// src/lib/tools/readFile.ts
-import { tool as tool4 } from "ai";
-import z11 from "zod";
-import { readFile as readFile4 } from "node:fs/promises";
-
-// src/lib/tools/env.ts
-import { basename } from "node:path";
-function isEnvFile(filePath) {
-  const name = basename(filePath);
-  return name === ".env" || name.startsWith(".env.");
+  if (!created) throw new Error("apikeys create returned no key value");
+  return created;
 }
-function isSecretEnvFile(filePath) {
-  if (!isEnvFile(filePath)) return false;
-  const name = basename(filePath);
-  return !/\.(example|sample|template)$/.test(name);
+async function keyExists(key) {
+  try {
+    await runAlgoliaCli(["apikeys", "get", key, "-o", "json"], { redact: key });
+    return true;
+  } catch (err) {
+    return !/does not exist/i.test(err.message);
+  }
 }
-
-// src/lib/tools/readFile.ts
-function redactEnvValues(content) {
-  return content.split("\n").map((line) => {
-    const match = line.match(/^(\s*(?:export\s+)?[\w.-]+\s*=)(.*)$/);
-    if (!match) return line;
-    const value = match[2].trim();
-    if (value === "") return line;
-    return `${match[1]}[REDACTED]`;
-  }).join("\n");
+var resolved = /* @__PURE__ */ new Map();
+async function forgetResolvedKeys() {
+  resolved.clear();
+  const userId = await currentUserId();
+  if (userId) await deleteStoredKeys(userId);
 }
-function readFileTool(ctx) {
-  return tool4({
-    description: "Read the contents of a file at the given path",
-    inputSchema: z11.object({
-      filePath: z11.string().describe("Path to the file to read")
-    }),
-    execute: async ({ filePath }) => {
-      if (++ctx.counts.read > ctx.limits.read) {
-        return `Refused: read limit (${ctx.limits.read}) reached. Stop reading and proceed with the information you already have.`;
-      }
-      logger.info({ filePath }, "called readFile tool");
-      const resolved2 = resolveInRoot(ctx, filePath);
-      if (!resolved2.ok) return resolved2.error;
-      try {
-        const content = await readFile4(resolved2.target, "utf8");
-        return isEnvFile(resolved2.target) ? redactEnvValues(content) : content;
-      } catch (err) {
-        return `Error reading ${filePath}: ${err.message}`;
-      }
-    }
+function resolveKey(kind, index, appId, acls, description) {
+  const userId = requireUserId();
+  const cacheKey = `${userId}:${kind}:${appId}:${index}`;
+  const cached = resolved.get(cacheKey);
+  if (cached) return cached;
+  const pending = provisionKey(
+    kind,
+    userId,
+    index,
+    appId,
+    acls,
+    description
+  ).catch((err) => {
+    resolved.delete(cacheKey);
+    throw err;
   });
+  resolved.set(cacheKey, pending);
+  return pending;
 }
-
-// src/lib/tools/writeFile.ts
-import { tool as tool5 } from "ai";
-import z12 from "zod";
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3 } from "node:path";
-function writeFileTool(ctx) {
-  return tool5({
-    description: "Write content to a file at the given path, overwriting it. Writes to secret env files (.env, .env.local, etc.) are refused by this tool \u2014 call it anyway and the tool will tell you how to proceed.",
-    inputSchema: z12.object({
-      filePath: z12.string().describe("Path to the file to write"),
-      content: z12.string().describe("Content to write to the file")
-    }),
-    execute: async ({ filePath, content }) => {
-      logger.info({ filePath }, "called writeFile tool");
-      const resolved2 = resolveInRoot(ctx, filePath);
-      if (resolved2.ok === false) return resolved2.error;
-      if (isSecretEnvFile(resolved2.target)) {
-        return `Refused: ${filePath} holds secrets and cannot be written directly. If a writeCredentials tool is available, use it to set Algolia credentials. If not, tell the user to set the value manually \u2014 do not reproduce the secret value in your response.`;
-      }
-      try {
-        if (await hasSymlinkParent(ctx, resolved2.target)) {
-          return `Refused: ${resolved2.target} is outside the repo root (${ctx.root}).`;
-        }
-        await mkdir3(dirname3(resolved2.target), { recursive: true });
-        await writeFile3(resolved2.target, content, "utf8");
-        useWizard.getState().recordWrittenFile(resolved2.target);
-        return `Wrote to ${filePath}`;
-      } catch (err) {
-        return `Error writing ${filePath}: ${err.message}`;
-      }
+async function provisionKey(kind, userId, index, appId, acls, description) {
+  const stored = await readStoredKey(kind, userId, index, appId);
+  if (stored) {
+    if (await keyExists(stored)) {
+      logger.info({ kind, index, appId }, "reusing the stored API key");
+      return { key: stored, source: "keychain" };
     }
-  });
+    logger.info(
+      { kind, index, appId },
+      "the stored API key no longer exists; creating another"
+    );
+  }
+  const key = await createKey(index, acls, description);
+  await storeKey(kind, userId, index, appId, key);
+  return { key, source: "created" };
+}
+function resolveWriteKey(index, appId) {
+  return resolveKey(
+    "write",
+    index,
+    appId,
+    WRITE_ACLS,
+    `Algolia Wizard write key for ${index} index`
+  );
+}
+async function resolveSearchOnlyKey(index, appId) {
+  return resolveKey(
+    "search",
+    index,
+    appId,
+    ["search"],
+    `Algolia Wizard search-only key for ${index} index`
+  );
 }
-
-// src/lib/tools/writeAlgoliaCredentials.ts
-import { tool as tool6 } from "ai";
-import z13 from "zod";
-import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname4, relative as relative3 } from "node:path";
 
 // src/lib/gitignore.ts
 import { execFile } from "node:child_process";
-import { lstat as lstat2, readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join7, relative as relative2 } from "node:path";
+import { lstat as lstat2, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join6, relative as relative2 } from "node:path";
 var GIT_ENV_OVERRIDES = [
   "GIT_DIR",
   "GIT_WORK_TREE",
@@ -2370,7 +2212,7 @@ async function ensureGitIgnored(root, target) {
   if (ignoredByRule === void 0) return "unknown";
   if (ignoredByRule) return tracked ? "tracked" : "covered";
   const pattern = relative2(root, target);
-  const gitIgnore = join7(root, ".gitignore");
+  const gitIgnore = join6(root, ".gitignore");
   try {
     const link = await lstat2(gitIgnore).catch(() => null);
     if (link?.isSymbolicLink()) {
@@ -2380,7 +2222,7 @@ async function ensureGitIgnored(root, target) {
       );
       return "unknown";
     }
-    const existing = link ? await readFile5(gitIgnore, "utf8") : "";
+    const existing = link ? await readFile4(gitIgnore, "utf8") : "";
     const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
     await writeFile4(gitIgnore, `${existing}${prefix}${pattern}
 `, "utf8");
@@ -2449,7 +2291,7 @@ function writeCredentialsTool(ctx) {
           return `Refused: ${resolved2.target} is outside the repo root (${ctx.root}).`;
         }
         try {
-          existing = await readFile6(resolved2.target, "utf8");
+          existing = await readFile5(resolved2.target, "utf8");
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -2539,8 +2381,8 @@ async function gitIgnoreOutcome(ctx, target) {
 // src/lib/tools/searchFiles.ts
 import { tool as tool7 } from "ai";
 import z14 from "zod";
-import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { readdir as readdir2, readFile as readFile6 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 var MAX_QUERY_LENGTH = 1e3;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -2555,7 +2397,7 @@ async function walkFiles(dir) {
   const out = [];
   for (const e of await readdir2(dir, { withFileTypes: true })) {
     if (e.name.startsWith(".") || SKIP_DIRS.has(e.name)) continue;
-    const full = join8(dir, e.name);
+    const full = join7(dir, e.name);
     if (e.isDirectory()) out.push(...await walkFiles(full));
     else if (e.isFile()) out.push(full);
   }
@@ -2588,7 +2430,7 @@ function searchFilesTool(ctx) {
       for (const file of await walkFiles(resolved2.target)) {
         let content;
         try {
-          content = await readFile7(file, "utf8");
+          content = await readFile6(file, "utf8");
         } catch {
           continue;
         }
@@ -3488,7 +3330,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.38.0-rc.131.265",
+  version: "0.38.0-rc.131.267",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3896,12 +3738,12 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 // src/actions/implement.ts
 import z28 from "zod";
 import { mkdir as mkdir7 } from "node:fs/promises";
-import { join as join11, relative as relative6 } from "node:path";
+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, stat as stat3 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute2, join as join9, resolve as resolve3 } from "node:path";
+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) {
   return new Promise((resolve4, reject) => {
@@ -3938,8 +3780,8 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
   } catch {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
-  const relPath = join9(ingestDir, basename2(source));
-  const dest = join9(repoRoot, relPath);
+  const relPath = join8(ingestDir, basename2(source));
+  const dest = join8(repoRoot, relPath);
   if (resolve3(source) === resolve3(dest)) {
     return { ok: true, relPath };
   }
@@ -3978,13 +3820,13 @@ function toRootRelative(p) {
 
 // src/lib/algoliaDocs.ts
 import { readFileSync, readdirSync, existsSync } from "node:fs";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { dirname as dirname7, join as join9 } from "node:path";
 import { fileURLToPath } from "node:url";
-var DOCS_SUBPATH = join10("docs", "algolia-sdk");
+var DOCS_SUBPATH = join9("docs", "algolia-sdk");
 function findDocsDir() {
   let dir = dirname7(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const candidate = join10(dir, DOCS_SUBPATH);
+    const candidate = join9(dir, DOCS_SUBPATH);
     if (existsSync(candidate)) return candidate;
     const parent = dirname7(dir);
     if (parent === dir) return void 0;
@@ -4007,7 +3849,7 @@ function loadAlgoliaDoc(language) {
     );
     return "";
   }
-  return readFileSync(join10(docsDir, files[0]), "utf8").trim();
+  return readFileSync(join9(docsDir, files[0]), "utf8").trim();
 }
 function getNamedDoc(name, language) {
   const docsDir = findDocsDir();
@@ -4015,7 +3857,7 @@ function getNamedDoc(name, language) {
     logger.warn("docs/algolia-sdk not found");
     return "";
   }
-  const file = join10(docsDir, `${name}-${language}.md`);
+  const file = join9(docsDir, `${name}-${language}.md`);
   if (!existsSync(file)) {
     logger.warn({ name, language }, "named SDK reference not found");
     return "";
@@ -4362,7 +4204,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   useWizard.getState().setTargetIndex(targetIndex ?? null);
   await assertGitRepoWithHead(repoRoot);
   if (useCases.includes("ingestion")) {
-    await mkdir7(join11(repoRoot, INGEST_DIR), { recursive: true });
+    await mkdir7(join10(repoRoot, INGEST_DIR), { recursive: true });
   }
   const normalized = normalizeFindingPaths(findings);
   const confirmed2 = normalized.confirmedEntities;
@@ -4592,7 +4434,7 @@ ${detail}` : ""}`
     if (searchConfigFile) {
       const ignoreStatus = await gitIgnoreStatus(
         repoRoot,
-        join11(repoRoot, searchConfigFile)
+        join10(repoRoot, searchConfigFile)
       );
       if (ignoreStatus === "covered") {
         summaries.push(
@@ -4738,7 +4580,7 @@ function getWorkflow(id) {
 }
 
 // src/ui/Welcome.tsx
-import { dirname as dirname8, join as join12 } from "node:path";
+import { dirname as dirname8, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { useState as useState7 } from "react";
 import { Box as Box10, Spacer, Text as Text10, useInput as useInput3, useWindowSize as useWindowSize5 } from "ink";
@@ -4770,7 +4612,7 @@ var sidebarItems = [
 // src/ui/Welcome.tsx
 import Image, { TerminalInfoContext, defaultTerminalInfo } from "ink-picture";
 import { jsx as jsx8, jsxs as jsxs9 } from "react/jsx-runtime";
-var IMAGE_PATH = join12(dirname8(fileURLToPath2(import.meta.url)), "algolia.png");
+var IMAGE_PATH = join11(dirname8(fileURLToPath2(import.meta.url)), "algolia.png");
 var TERMINAL_INFO = {
   ...defaultTerminalInfo,
   supportsUnicode: true,
@@ -5701,7 +5543,7 @@ function App() {
                         ] }),
                         settingUpAppId && /* @__PURE__ */ jsx17(Box19, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs17(Text19, { color: COLORS.strong, bold: true, children: [
                           /* @__PURE__ */ jsx17(Spinner2, { type: "dots" }),
-                          " Setting up wizard using app",
+                          " Setting up Wizard using app",
                           " ",
                           settingUpAppId
                         ] }) }),
@@ -5737,6 +5579,151 @@ function App() {
   );
 }
 
+// src/lib/envAppId.ts
+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;
+async function findEnvApplicationId(root = process.cwd()) {
+  for (const file of ENV_FILES) {
+    let content;
+    try {
+      content = await readFile7(join12(root, file), "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        logger.warn(
+          { file, err },
+          "could not read env file for an application id"
+        );
+      }
+      continue;
+    }
+    for (const [, name, raw] of content.matchAll(APP_ID_LINE)) {
+      const id = readValue(raw);
+      if (id) {
+        logger.info({ file, name, app: id }, "found an application id in env");
+        return { id, name, file };
+      }
+    }
+  }
+  return null;
+}
+function readValue(raw) {
+  const trimmed = raw.trim();
+  const quoted = trimmed.match(/^(['"])(.*)\1/);
+  const value = quoted ? quoted[2].trim() : trimmed.replace(/\s+#.*$/, "").trim();
+  return value.length > 0 && !value.startsWith("<") ? value : null;
+}
+
+// src/lib/algoliaAppPicker.ts
+function blockReasonFor(app) {
+  return app.status !== "active" ? "Paused" : "Missing permissions";
+}
+function secondaryFor(app) {
+  if (!canSelectApplication(app)) {
+    return { kind: "text", value: blockReasonFor(app) };
+  }
+  return app.plan ? { kind: "badge", value: app.plan } : void 0;
+}
+function labelFor(app) {
+  return app.name.trim() ? `${app.name} \u2014 ${app.id}` : app.id;
+}
+async function selectAndReport(app) {
+  const store = useWizard.getState();
+  store.setSettingUpApp(app.id);
+  try {
+    return await selectApplication(app.id);
+  } finally {
+    store.setSettingUpApp(null);
+  }
+}
+async function promptForApplication(leadIn = []) {
+  const store = useWizard.getState();
+  const unordered = await listApplications();
+  if (unordered.length === 0) {
+    throw new Error(
+      "This Algolia account has no applications. Create one in the Algolia dashboard, or with `npx @algolia/cli@latest application create`, then restart the wizard."
+    );
+  }
+  if (!unordered.some(canSelectApplication)) {
+    throw new Error(
+      "None of the applications on this Algolia account are usable \u2014 each is either paused or missing key-management access. Activate one, or grant it the `keys` ACL, then restart the wizard."
+    );
+  }
+  const apps = [
+    ...unordered.filter(canSelectApplication),
+    ...unordered.filter((app) => !canSelectApplication(app))
+  ];
+  const messages = [...leadIn];
+  for (; ; ) {
+    const choice = await store.requestUserInput({
+      prompt: "Which Algolia application should the wizard work in?",
+      promptType: "multipleChoice",
+      options: apps.map(labelFor),
+      secondary: apps.map(secondaryFor),
+      disabled: apps.map((app) => !canSelectApplication(app)),
+      messages
+    });
+    const chosen = apps.find((app) => labelFor(app) === choice);
+    if (!chosen || !canSelectApplication(chosen)) {
+      throw new Error("Application picker received an unexpected selection");
+    }
+    try {
+      return await selectAndReport(chosen);
+    } catch (err) {
+      logger.warn(
+        { app: chosen.id, err: err.message },
+        "application select failed; re-prompting"
+      );
+      messages.push(
+        `Could not select \u201C${labelFor(chosen)}\u201D. It may have been removed \u2014 pick another.`
+      );
+    }
+  }
+}
+async function confirmEnvApplication(env, current) {
+  const useEnv = `Use ${env.id} (from ${env.file})`;
+  const choice = await useWizard.getState().requestUserInput({
+    prompt: "Select an application",
+    promptType: "multipleChoice",
+    options: [
+      useEnv,
+      current ? `Use ${labelFor(current)} (already selected)` : "Pick a different application"
+    ],
+    messages: [
+      `${env.file} already sets ${env.name}=${env.id}.`,
+      "Which Algolia application would you like to use?"
+    ]
+  });
+  if (choice === useEnv) return selectEnvApplication(env);
+  return current ? selectAndReport(current) : null;
+}
+async function selectEnvApplication(env) {
+  try {
+    return await selectAndReport({ id: env.id, name: "" });
+  } catch (err) {
+    logger.warn(
+      { app: env.id, err: err.message },
+      "could not select the application named in env; falling back to the picker"
+    );
+    return promptForApplication([
+      `Could not select ${env.id} from ${env.file} \u2014 it may have been removed, or this account may not have access to it.`
+    ]);
+  }
+}
+async function ensureApplication(isResuming) {
+  const current = await currentApplication();
+  if (isResuming) {
+    return current ?? await promptForApplication();
+  }
+  const env = await findEnvApplicationId();
+  if (env && env.id !== current?.id) {
+    const chosen = await confirmEnvApplication(env, current);
+    if (chosen) return chosen;
+  }
+  return promptForApplication();
+}
+
 // src/lib/seed.ts
 var projectScan2 = {
   languages: [{ name: "TypeScript", version: "5.7.2" }],

package/package.json

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