@algolia/wizard 0.9.0-rc.93.95 → 0.9.0-rc.96.109

package/dist/main.js

@@ -17,10 +17,8 @@ function npxArgs(args) {
   return ["--yes", "@algolia/cli@latest", ...args];
 }
 var shell = process.platform === "win32";
-function childEnv(withoutAdminKey) {
-  if (!withoutAdminKey) return void 0;
-  const { ALGOLIA_API_KEY: _adminKey, ...rest } = process.env;
-  return rest;
+function mask(text, secret) {
+  return secret ? text.replaceAll(secret, "***") : text;
 }
 function lineSplitter(emit) {
   let buffer = "";
@@ -45,14 +43,12 @@ var stderrSink = (stream, line) => {
   if (stream === "stdout") return;
   wizardSink(stream, line);
 };
-function runAlgoliaCli(args, { onOutput, withoutAdminKey } = {}) {
+function runAlgoliaCli(args, { onOutput, redact } = {}) {
   const store = useWizard.getState();
-  const logId = store.logStart("tool", `algolia ${args.join(" ")}`);
+  const command = mask(args.join(" "), redact);
+  const logId = store.logStart("tool", `algolia ${command}`);
   return new Promise((resolve4, reject) => {
-    const child = spawn("npx", npxArgs(args), {
-      shell,
-      env: childEnv(withoutAdminKey)
-    });
+    const child = spawn("npx", npxArgs(args), { shell });
     let stdout = "";
     let stderr = "";
     const splitters = {
@@ -79,13 +75,13 @@ function runAlgoliaCli(args, { onOutput, withoutAdminKey } = {}) {
         const failed = stderr.trim();
         let detail = "";
         if (failed) {
-          detail = `: ${failed}`;
+          detail = `: ${mask(failed, redact)}`;
         } else if (stdout.trim()) {
           detail = " (no stderr; stdout withheld \u2014 it may contain credentials)";
         }
         reject(
           new Error(
-            `Algolia CLI \`${args.join(" ")}\` failed (exit ${code})${detail}`
+            `Algolia CLI \`${command}\` failed (exit ${code})${detail}`
           )
         );
       }
@@ -2161,7 +2157,7 @@ async function ensureApplication() {
 }
 
 // src/workflows/default.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // src/actions/listIndices.ts
 import { z as z5 } from "zod";
@@ -2421,22 +2417,48 @@ function writeFileTool(ctx) {
 
 // src/lib/tools/writeAlgoliaCredentials.ts
 import { tool as tool6 } from "ai";
-import z12 from "zod";
+import z13 from "zod";
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
 
 // src/lib/algoliaApiKey.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/lib/keychain.ts
-import { getPassword, setPassword } from "cross-keychain";
+import { deletePassword, getPassword, setPassword } from "cross-keychain";
+import { z as z11 } from "zod";
 var SERVICE = "algolia-wizard";
-function account(kind, index, appId) {
+var ACCOUNT = "api-keys";
+var storedKeysSchema = z11.record(z11.string(), z11.string());
+function entryId(kind, index, appId) {
   return `${kind}:${appId}:${index}`;
 }
+async function loadKeys() {
+  const raw = await getPassword(SERVICE, ACCOUNT);
+  if (!raw) return {};
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    payload = null;
+  }
+  const keys = storedKeysSchema.safeParse(payload);
+  if (!keys.success) {
+    logger.warn("the stored API keys are unreadable; treating them as empty");
+    return {};
+  }
+  return keys.data;
+}
+var queue = Promise.resolve();
+function serialized(op) {
+  const next = queue.then(op);
+  queue = next.catch(() => {
+  });
+  return next;
+}
 async function readStoredKey(kind, index, appId) {
   try {
-    return await getPassword(SERVICE, account(kind, index, appId));
+    return (await loadKeys())[entryId(kind, index, appId)] ?? null;
   } catch (err) {
     logger.warn(
       { err: err.message, kind, index, appId },
@@ -2445,19 +2467,40 @@ async function readStoredKey(kind, index, appId) {
     return null;
   }
 }
-async function storeKey(kind, index, appId, value) {
-  const name = account(kind, index, appId);
-  try {
-    await setPassword(SERVICE, name, value);
-    if (await getPassword(SERVICE, name) !== value) {
-      throw new Error("the keychain did not store the value");
+function storeKey(kind, index, appId, value) {
+  return serialized(async () => {
+    const id = entryId(kind, index, appId);
+    try {
+      const keys = await loadKeys();
+      await setPassword(
+        SERVICE,
+        ACCOUNT,
+        JSON.stringify({ ...keys, [id]: value })
+      );
+      if ((await loadKeys())[id] !== value) {
+        throw new Error("the keychain did not store the value");
+      }
+    } catch (err) {
+      logger.warn(
+        { err: err.message, kind, index, appId },
+        "could not store the API key in the keychain; the next run will create another"
+      );
     }
-  } catch (err) {
-    logger.warn(
-      { err: err.message, kind, index, appId },
-      "could not store the API key in the keychain; the next run will create another"
-    );
-  }
+  });
+}
+function deleteStoredKeys() {
+  return serialized(async () => {
+    try {
+      await deletePassword(SERVICE, ACCOUNT);
+    } catch (err) {
+      const message = err.message;
+      if (/not found/i.test(message)) return;
+      logger.warn(
+        { err: message },
+        "could not delete the API keys from the keychain"
+      );
+    }
+  });
 }
 
 // src/lib/algoliaApiKey.ts
@@ -2468,27 +2511,24 @@ var WRITE_ACLS = [
   "editSettings",
   "listIndexes"
 ];
-var createdKeySchema = z11.object({
-  key: z11.string().min(1).optional(),
-  value: z11.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");
-  const stdout = await runAlgoliaCli(
-    [
-      "apikeys",
-      "create",
-      "--acl",
-      acls.join(","),
-      "--indices",
-      index,
-      "--description",
-      description,
-      "-o",
-      "json"
-    ],
-    { withoutAdminKey: true }
-  );
+  const stdout = await runAlgoliaCli([
+    "apikeys",
+    "create",
+    "--acl",
+    acls.join(","),
+    "--indices",
+    index,
+    "--description",
+    description,
+    "-o",
+    "json"
+  ]);
   let payload;
   try {
     payload = JSON.parse(stdout);
@@ -2499,9 +2539,18 @@ async function createKey(index, acls, description) {
   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();
-function forgetResolvedKeys() {
+async function forgetResolvedKeys() {
   resolved.clear();
+  await deleteStoredKeys();
 }
 function resolveKey(kind, index, appId, acls, description) {
   const cacheKey = `${kind}:${appId}:${index}`;
@@ -2519,8 +2568,14 @@ function resolveKey(kind, index, appId, acls, description) {
 async function provisionKey(kind, index, appId, acls, description) {
   const stored = await readStoredKey(kind, index, appId);
   if (stored) {
-    logger.info({ kind, index, appId }, "reusing the stored API key");
-    return { key: stored, source: "keychain" };
+    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, index, appId, key);
@@ -2569,8 +2624,8 @@ function upsertEnv(content, 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 (e.g. ".env"). Any name the file already defines is left untouched.`,
-    inputSchema: z12.object({
-      filePath: z12.string().describe(
+    inputSchema: z13.object({
+      filePath: z13.string().describe(
         'Path to the env file to write credentials into (e.g. ".env")'
       )
     }),
@@ -2630,7 +2685,7 @@ function writeCredentialsTool(ctx) {
 
 // src/lib/tools/searchFiles.ts
 import { tool as tool7 } from "ai";
-import z13 from "zod";
+import z14 from "zod";
 import { readdir as readdir2, readFile as readFile5 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 var MAX_QUERY_LENGTH = 1e3;
@@ -2656,9 +2711,9 @@ async function walkFiles(dir) {
 function searchFilesTool(ctx) {
   return tool7({
     description: "Search file contents for a JavaScript regular expression (RegExp syntax, not grep/PCRE). Returns matching lines as file:line:text.",
-    inputSchema: z13.object({
-      query: z13.string().describe("JavaScript RegExp pattern to search for"),
-      path: z13.string().optional().describe("Directory to search in (default: cwd)")
+    inputSchema: z14.object({
+      query: z14.string().describe("JavaScript RegExp pattern to search for"),
+      path: z14.string().optional().describe("Directory to search in (default: cwd)")
     }),
     execute: async ({ query, path = "." }) => {
       logger.info({ query, path }, "called searchFiles tool");
@@ -2702,7 +2757,7 @@ function searchFilesTool(ctx) {
 
 // src/lib/tools/runShell.ts
 import { tool as tool8 } from "ai";
-import z14 from "zod";
+import z15 from "zod";
 import { relative as relative2 } from "node:path";
 
 // src/lib/tools/utils/runShell.ts
@@ -2815,15 +2870,15 @@ function storeApproval(root) {
 }
 function runShellTool(ctx) {
   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. 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.",
-    inputSchema: z14.object({
-      command: z14.string().describe(
+    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. 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. Never `cd`, `pushd` or `popd` inside the command \u2014 pass `cwd` instead. Never leave the project root: no `..` in any path, no absolute paths outside the root, and no `-C`/`--prefix` flag pointing outside it. Everything you need is inside the root.",
+    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."
       ),
-      cwd: z14.string().optional().describe(
+      cwd: z15.string().optional().describe(
         "Directory to run in, relative to the project root. Defaults to the project root."
       ),
-      explanation: z14.string().describe(
+      explanation: z15.string().describe(
         "One short line telling the user what this command does and why, including any side effect (e.g. writes records to Algolia). This is what they approve against."
       )
     }),
@@ -2892,7 +2947,7 @@ import { createAnthropic } from "@ai-sdk/anthropic";
 import { nanoid as nanoid2 } from "nanoid";
 import { mkdir as mkdir5, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname6 } from "node:path";
-import z15 from "zod";
+import z16 from "zod";
 var DATA_DIR = ".algolia-wizard/data";
 var RECORD_MODEL = "claude-haiku-4-5";
 var MAX_RECORDS = 100;
@@ -2904,17 +2959,17 @@ var anthropic = createAnthropic({
 function generateRecordTool(ctx) {
   return tool9({
     description: "Generate realistic sample records for an entity and write them to a JSON file in the worktree. 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: z15.object({
-      entityName: z15.string().describe("Name of the entity to generate records for."),
-      attributes: z15.array(z15.string()).describe("Attribute names each record must contain."),
-      count: z15.number().int().min(1).max(MAX_RECORDS).default(10).describe(`How many records to generate (max ${MAX_RECORDS}).`),
-      hint: z15.string().optional().describe("Optional context to steer realistic values.")
+    inputSchema: z16.object({
+      entityName: z16.string().describe("Name of the entity to generate records for."),
+      attributes: z16.array(z16.string()).describe("Attribute names each record must contain."),
+      count: z16.number().int().min(1).max(MAX_RECORDS).default(10).describe(`How many records to generate (max ${MAX_RECORDS}).`),
+      hint: z16.string().optional().describe("Optional context to steer realistic values.")
     }),
     execute: async ({ entityName, attributes, count, hint }) => {
       logger.info({ entityName, count }, "called generateRecord tool");
       try {
-        const value = z15.union([z15.string(), z15.number(), z15.boolean(), z15.null()]);
-        const recordSchema = z15.object(
+        const value = z16.union([z16.string(), z16.number(), z16.boolean(), z16.null()]);
+        const recordSchema = z16.object(
           Object.fromEntries(attributes.map((attr) => [attr, value]))
         );
         const generateBatch = async (batchCount) => {
@@ -2924,8 +2979,8 @@ function generateRecordTool(ctx) {
               const { output } = await generateText({
                 model: anthropic(RECORD_MODEL),
                 output: Output.object({
-                  schema: z15.object({
-                    records: z15.array(recordSchema).length(batchCount)
+                  schema: z16.object({
+                    records: z16.array(recordSchema).length(batchCount)
                   })
                 }),
                 prompt: [
@@ -2983,12 +3038,12 @@ function generateRecordTool(ctx) {
 
 // src/lib/tools/notifyUser.ts
 import { tool as tool10 } from "ai";
-import z16 from "zod";
+import z17 from "zod";
 function notifyUserTool() {
   return tool10({
     description: `Give the user a brief, high-level update on what you are currently doing or about to do next. This is for the big picture (e.g. "Reading through your data models", "Writing the search UI") \u2014 not granular detail like individual tool calls, which are already logged separately. Call it when you start a new phase of work or your focus shifts, just not on every step, enough to keep the user engaged. Don't say things like "starting", just describe what you are doing. Don't mention tool calls themselves, just general direction of the work.`,
-    inputSchema: z16.object({
-      message: z16.string().describe(
+    inputSchema: z17.object({
+      message: z17.string().describe(
         "Short, plain-language description of what you are doing now."
       )
     }),
@@ -3153,10 +3208,10 @@ async function runAgent(req) {
 }
 
 // src/actions/detectLanguage.ts
-import z19 from "zod";
-var detectLanguageSchema = z19.object({
-  languages: z19.array(z19.object({ name: z19.string(), version: z19.string() })),
-  frameworks: z19.array(z19.object({ name: z19.string(), version: z19.string() }))
+import z20 from "zod";
+var detectLanguageSchema = z20.object({
+  languages: z20.array(z20.object({ name: z20.string(), version: z20.string() })),
+  frameworks: z20.array(z20.object({ name: z20.string(), version: z20.string() }))
 });
 var detectLanguage = () => runAgent({
   instructions: [
@@ -3174,31 +3229,31 @@ var detectLanguage = () => runAgent({
 });
 
 // src/actions/analyzeCodebase.ts
-import z20 from "zod";
+import z21 from "zod";
 var READONLY_TOOLS = [
   "listFiles",
   "changeDirectory",
   "readFile",
   "searchFiles"
 ];
-var ingestionAnalysisSchema = z20.object({
-  ingestionAnalysis: z20.array(
-    z20.object({
-      name: z20.string(),
-      paths: z20.array(z20.string()),
+var ingestionAnalysisSchema = z21.object({
+  ingestionAnalysis: z21.array(
+    z21.object({
+      name: z21.string(),
+      paths: z21.array(z21.string()),
       // indexable fields the agent found for this entity
-      attributes: z20.array(z20.string())
+      attributes: z21.array(z21.string())
     })
   )
 });
-var searchImplementationAnalysisSchema = z20.object({
-  searchImplementationAnalysis: z20.string()
+var searchImplementationAnalysisSchema = z21.object({
+  searchImplementationAnalysis: z21.string()
 });
-var verificationSchema = z20.object({
-  verification: z20.array(z20.string())
+var verificationSchema = z21.object({
+  verification: z21.array(z21.string())
 });
 var confirmedEntitiesFieldSchema = ingestionAnalysisSchema.shape.ingestionAnalysis.optional();
-var analyzeCodebaseSchema = z20.object({
+var analyzeCodebaseSchema = z21.object({
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   searchImplementationAnalysis: searchImplementationAnalysisSchema.shape.searchImplementationAnalysis.optional(),
   verification: verificationSchema.shape.verification.optional(),
@@ -3260,7 +3315,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.9.0-rc.93.95",
+  version: "0.9.0-rc.96.109",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3379,8 +3434,8 @@ async function askList(ctx, prompt, { required = false } = {}) {
 }
 
 // src/actions/confirmLanguage.ts
-import z22 from "zod";
-var confirmLanguageSchema = z22.object({
+import z23 from "zod";
+var confirmLanguageSchema = z23.object({
   languages: detectLanguageSchema.shape.languages
 });
 async function confirmLanguage(ctx) {
@@ -3401,8 +3456,8 @@ async function confirmLanguage(ctx) {
 }
 
 // src/actions/confirmFramework.ts
-import z23 from "zod";
-var confirmFrameworkSchema = z23.object({
+import z24 from "zod";
+var confirmFrameworkSchema = z24.object({
   frameworks: detectLanguageSchema.shape.frameworks
 });
 var CURATED_FRAMEWORKS = [
@@ -3535,8 +3590,8 @@ async function promptUser(ctx, params) {
 }
 
 // src/actions/confirmEntities.ts
-import z24 from "zod";
-var confirmEntitiesSchema = z24.object({
+import z25 from "zod";
+var confirmEntitiesSchema = z25.object({
   // Final detection — the focused re-run may supersede project-scan's.
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   confirmedEntities: confirmedEntitiesFieldSchema
@@ -3606,15 +3661,15 @@ async function confirmEntities(ctx) {
 }
 
 // src/actions/review.ts
-import { z as z25 } from "zod";
-var reviewSchema = z25.object({
+import { z as z26 } from "zod";
+var reviewSchema = z26.object({
   // Broad, high-level takeaways grouped by theme (e.g. ingestion, search UI),
   // not one entry per workflow step — a step's raw output can be a long,
   // multi-paragraph blob (see implement.ts's summaries.join), and mirroring
   // that 1:1 is what made the old per-step summary an unreadable wall of text.
-  summaryPoints: z25.array(z25.string()),
-  reviewPrompt: z25.string(),
-  nextSteps: z25.array(z25.string())
+  summaryPoints: z26.array(z26.string()),
+  reviewPrompt: z26.string(),
+  nextSteps: z26.array(z26.string())
 });
 function formatCompletedSteps(steps) {
   if (!steps.length) return "(no prior steps completed)";
@@ -3665,7 +3720,7 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 };
 
 // src/actions/implement.ts
-import z26 from "zod";
+import z27 from "zod";
 
 // src/lib/worktree.ts
 import { execFile } from "node:child_process";
@@ -3915,30 +3970,30 @@ function shellQuote(value) {
 }
 
 // src/actions/implement.ts
-var implementSchema = z26.object({
-  filesChanged: z26.array(z26.string()),
-  summary: z26.string(),
-  worktreePath: z26.string().optional(),
-  ingestCommand: z26.string().optional(),
-  ingestScriptRan: z26.boolean().optional(),
-  ingestRecordCount: z26.number().optional(),
-  ingestDurationMs: z26.number().optional(),
-  ingestionSource: z26.enum(["local", "fileUpload", "generated"]),
-  searchEnvVars: z26.array(
-    z26.object({
-      name: z26.string(),
-      value: z26.string()
+var implementSchema = z27.object({
+  filesChanged: z27.array(z27.string()),
+  summary: z27.string(),
+  worktreePath: z27.string().optional(),
+  ingestCommand: z27.string().optional(),
+  ingestScriptRan: z27.boolean().optional(),
+  ingestRecordCount: z27.number().optional(),
+  ingestDurationMs: z27.number().optional(),
+  ingestionSource: z27.enum(["local", "fileUpload", "generated"]),
+  searchEnvVars: z27.array(
+    z27.object({
+      name: z27.string(),
+      value: z27.string()
     })
   ).optional()
 });
-var implementationOutputSchema = z26.object({
-  summary: z26.string(),
-  ingestCommand: z26.string().optional()
+var implementationOutputSchema = z27.object({
+  summary: z27.string(),
+  ingestCommand: z27.string().optional()
 });
-var verificationOutputSchema = z26.object({
-  summary: z26.string(),
-  sufficient: z26.boolean(),
-  additionalInstructions: z26.string().optional()
+var verificationOutputSchema = z27.object({
+  summary: z27.string(),
+  sufficient: z27.boolean(),
+  additionalInstructions: z27.string().optional()
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
@@ -4585,8 +4640,8 @@ var defaultWorkflow = {
     defineStep({
       id: "select-index",
       title: "Set up index",
-      outputSchema: z27.object({
-        selection: z27.string()
+      outputSchema: z28.object({
+        selection: z28.string()
       }),
       run: (ctx) => selectIndexStep(ctx)
     }),
@@ -4828,7 +4883,10 @@ Options:
   --no-telemetry   Send no telemetry or analytics for this run.
   --reset-on-run   Wipe this project's wizard state (run state, AI consent,
                    worktrees) before starting, so the run behaves like a
-                   first-ever run. Algolia credentials are not touched.
+                   first-ever run. Also drops every API key the wizard has
+                   stored in your keychain, for this project and any other, so
+                   later runs create new ones. Your Algolia login is not
+                   touched.
   -h, --help       Print this message.`;
 function parseCliArgs(argv) {
   const positionals = [];
@@ -4869,7 +4927,7 @@ import { join as join10 } from "node:path";
 var KEEP = ["wizard.log"];
 async function resetProjectState() {
   const dir = stateDir();
-  forgetResolvedKeys();
+  await forgetResolvedKeys();
   let entries;
   try {
     entries = await readdir4(dir);

package/package.json

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