@algolia/wizard 0.71.0 → 0.73.0

package/dist/main.js

@@ -177,7 +177,7 @@ function stateDir(cwd = pinnedRoot ?? process.cwd()) {
 // src/lib/logger.ts
 var STDERR_FD = 2;
 function resolveDest() {
-  const target = process.env.VITEST ? devNull : process.env.WIZARD_LOG ?? join2(stateDir(), "wizard.log");
+  const target = process.env.VITEST ? devNull : process.env.WIZARD_LOG || join2(stateDir(), "wizard.log");
   try {
     mkdirSync(dirname(target), { recursive: true });
     closeSync(openSync(target, "a"));
@@ -263,7 +263,9 @@ var useWizard = create((set, get) => ({
   inputReq: null,
   _resolve: null,
   settingUpAppId: null,
+  loadingMessage: null,
   setSettingUpApp: (appId) => set({ settingUpAppId: appId }),
+  setLoadingMessage: (message) => set({ loadingMessage: message }),
   // `endAuth` lands on 'preflight', not 'idle': sign-in happens after the
   // welcome screen, so going back would gate the run a second time.
   beginAuth: () => set({ phase: "authenticating", cliOutput: [] }),
@@ -359,6 +361,11 @@ var useWizard = create((set, get) => ({
   setTargetIndex: (index) => set({ targetIndex: index }),
   recordWrittenFile: (path) => set((s) => ({ writtenFiles: [...s.writtenFiles, path] })),
   clearWrittenFiles: () => set({ writtenFiles: [] }),
+  resetRunState: () => set({
+    targetIndex: null,
+    writtenFiles: [],
+    approvedCommands: /* @__PURE__ */ new Set()
+  }),
   isCommandApproved: (command, cwd) => get().approvedCommands.has(commandApprovalKey(command, cwd)),
   approveCommand: (command, cwd) => set((s) => ({
     approvedCommands: new Set(s.approvedCommands).add(
@@ -389,7 +396,8 @@ var useWizard = create((set, get) => ({
     set({
       phase: "awaitingInput",
       inputReq: req,
-      _resolve: resolve5
+      _resolve: resolve5,
+      loadingMessage: null
     });
   }),
   submitInput: async (value) => {
@@ -402,8 +410,8 @@ var useWizard = create((set, get) => ({
     );
     get().logEnd(id, "success");
   },
-  setDone: () => set({ phase: "done" }),
-  setError: (message) => set({ phase: "error", error: message }),
+  setDone: () => set({ phase: "done", loadingMessage: null }),
+  setError: (message) => set({ phase: "error", error: message, loadingMessage: null }),
   reset: () => {
     get()._clearNoticeQueue();
     get()._resolve?.(false);
@@ -424,7 +432,8 @@ var useWizard = create((set, get) => ({
       error: null,
       inputReq: null,
       _resolve: null,
-      settingUpAppId: null
+      settingUpAppId: null,
+      loadingMessage: null
     });
   }
 }));
@@ -1770,6 +1779,37 @@ function trackWorkflowStart(ctx) {
   );
   sendMetric("wizard.workflow.invocation", 1, 1, metricTags(ctx.workflowId));
 }
+function trackWorkflowAbandoned(ctx) {
+  const attributes = {
+    event: "wizard.workflow.abandoned",
+    workflow_id: ctx.workflowId,
+    app_id: ctx.appId,
+    reason: ctx.reason
+  };
+  emitTelemetryLog(
+    "info",
+    "wizard workflow abandoned",
+    attributes,
+    logTags(ctx.workflowId, void 0, ctx.appId)
+  );
+}
+function trackActionAbandoned(ctx) {
+  const attributes = {
+    event: "wizard.action.abandoned",
+    workflow_id: ctx.workflowId,
+    action_id: ctx.actionId,
+    action_title: ctx.actionTitle,
+    duration_ms: ctx.durationMs,
+    app_id: ctx.appId,
+    reason: ctx.reason
+  };
+  emitTelemetryLog(
+    "info",
+    "wizard action abandoned",
+    attributes,
+    logTags(ctx.workflowId, ctx.actionId, ctx.appId)
+  );
+}
 function trackActionStart(ctx) {
   const attributes = {
     event: "wizard.action.start",
@@ -1966,10 +2006,261 @@ function identify(traits) {
   postAnalytics("/identify", { userId, traits }, "identify");
 }
 
+// src/lib/algoliaApp.ts
+import { z as z3 } from "zod";
+var applicationSchema = z3.object({
+  id: z3.string().min(1),
+  name: z3.string().default(""),
+  plan: z3.string().optional()
+});
+var listSchema = z3.array(
+  z3.object({
+    id: z3.string().min(1),
+    name: z3.string().default(""),
+    plan_label: z3.string().optional(),
+    status: z3.string().optional(),
+    acl: z3.array(z3.string()).optional()
+  }).transform(({ id, name, plan_label, status, acl }) => ({
+    id,
+    name,
+    plan: plan_label,
+    status,
+    acl
+  }))
+);
+function canSelectApplication(app) {
+  return app.status === "active" && (app.acl ?? []).includes("keys");
+}
+async function currentApplication() {
+  let raw;
+  try {
+    raw = await runAlgoliaCli(["application", "current", "-o", "json"]);
+  } catch {
+    return null;
+  }
+  const parsed = applicationSchema.safeParse(parseJson(raw));
+  return parsed.success ? parsed.data : null;
+}
+async function requireApplication(expectedAppId) {
+  const app = await currentApplication();
+  if (!app) {
+    throw new Error(
+      "No Algolia application is selected. Run `npx @algolia/cli@latest application select` and restart the wizard."
+    );
+  }
+  if (expectedAppId && app.id !== expectedAppId) {
+    throw new Error(
+      `The wizard is running in application ${expectedAppId}, but the Algolia CLI is pointed at ${app.id}. Select ${expectedAppId} with the Algolia CLI and restart the wizard: npx @algolia/cli@latest application select --app-id "${expectedAppId}"`
+    );
+  }
+  return app;
+}
+async function listApplications() {
+  const raw = await runAlgoliaCli(["application", "list", "-o", "json"]);
+  const parsed = listSchema.safeParse(parseJson(raw));
+  if (!parsed.success) {
+    throw new Error("Could not read the list of Algolia applications.");
+  }
+  return parsed.data;
+}
+async function selectApplication(id) {
+  const raw = await runAlgoliaCli(
+    ["application", "select", "--non-interactive", "--app-id", id],
+    { onOutput: stderrSink }
+  );
+  const parsed = applicationSchema.safeParse(parseJson(raw));
+  if (!parsed.success) {
+    throw new Error(
+      `Selected application ${id}, but the Algolia CLI returned an unreadable result.`
+    );
+  }
+  return parsed.data;
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+
+// 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"
+        );
+      }
+      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, marks) {
+  if (!canSelectApplication(app)) {
+    return { kind: "text", value: blockReasonFor(app) };
+  }
+  if (marks?.currentId && app.id === marks.currentId) {
+    return { kind: "badge", value: "[CURRENT]" };
+  }
+  if (marks?.detectedId && app.id === marks.detectedId) {
+    return { kind: "badge", value: "[DETECTED]" };
+  }
+  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(id) {
+  const store = useWizard.getState();
+  store.setSettingUpApp(id);
+  try {
+    return await selectApplication(id);
+  } finally {
+    store.setSettingUpApp(null);
+  }
+}
+async function loadSelectableApps() {
+  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."
+    );
+  }
+  return [
+    ...unordered.filter(canSelectApplication),
+    ...unordered.filter((app) => !canSelectApplication(app))
+  ];
+}
+async function pickApplication(opts) {
+  const store = useWizard.getState();
+  const apps = await loadSelectableApps();
+  const envHighlight = opts.highlight;
+  const envApp = envHighlight ? apps.find((app) => app.id === envHighlight.id) : void 0;
+  const highlightIndex = envApp && canSelectApplication(envApp) ? apps.indexOf(envApp) : -1;
+  const marks = {
+    detectedId: envHighlight?.id,
+    currentId: opts.currentId
+  };
+  const messages = [];
+  if (envHighlight && highlightIndex < 0) {
+    messages.push(
+      envApp ? `Could not use ${envHighlight.id} from ${envHighlight.file} \u2014 it\u2019s ${blockReasonFor(envApp).toLowerCase()}. Pick another below.` : `Could not use ${envHighlight.id} from ${envHighlight.file} \u2014 it may have been removed, or this account may not have access to it.`
+    );
+  }
+  const extras = opts.extraOptions ?? [];
+  const options = [...extras, ...apps.map(labelFor)];
+  const secondary = [
+    ...extras.map(() => void 0),
+    ...apps.map((app) => secondaryFor(app, marks))
+  ];
+  const disabled = [
+    ...extras.map(() => false),
+    ...apps.map(
+      (app) => !canSelectApplication(app) || app.id === opts.currentId
+    )
+  ];
+  const defaultSelectedIndex = extras.length > 0 ? 0 : highlightIndex >= 0 ? highlightIndex : void 0;
+  for (; ; ) {
+    const choice = await store.requestUserInput({
+      prompt: "Which Algolia application should the wizard work in?",
+      promptType: "multipleChoice",
+      options,
+      secondary,
+      disabled,
+      ...defaultSelectedIndex !== void 0 ? { defaultSelectedIndex } : {},
+      messages,
+      ...opts.helpText ? { helpText: opts.helpText } : {}
+    });
+    if (typeof choice === "string" && extras.includes(choice)) {
+      return { type: "option", value: choice };
+    }
+    const chosen = apps.find((app) => labelFor(app) === choice);
+    if (!chosen || !canSelectApplication(chosen)) {
+      throw new Error("Application picker received an unexpected selection");
+    }
+    try {
+      return { type: "application", app: await selectAndReport(chosen.id) };
+    } 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 promptForApplication(highlight) {
+  const result = await pickApplication({ highlight });
+  if (result.type !== "application") {
+    throw new Error("Application picker received an unexpected selection");
+  }
+  return result.app;
+}
+async function promptToChangeApplication(currentId) {
+  const store = useWizard.getState();
+  store.setLoadingMessage("Loading applications\u2026");
+  try {
+    const env = await findEnvApplicationId();
+    const highlight = env ? { id: env.id, file: env.file } : void 0;
+    const result = await pickApplication({
+      currentId,
+      highlight,
+      extraOptions: ["Keep current application"],
+      helpText: "Choosing another application restarts this wizard run. Progress so far is discarded."
+    });
+    if (result.type === "option") return null;
+    return result.app;
+  } finally {
+    store.setLoadingMessage(null);
+  }
+}
+async function ensureApplication(resumeAppId) {
+  if (resumeAppId) return selectAndReport(resumeAppId);
+  const env = await findEnvApplicationId();
+  if (!env) return promptForApplication();
+  return promptForApplication({ id: env.id, file: env.file });
+}
+
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.71.0",
+  version: "0.73.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2053,6 +2344,14 @@ var ReturnToStepSignal = class extends Error {
   targetIndex;
   stepId;
 };
+var RestartWorkflowSignal = class extends Error {
+  constructor(appId) {
+    super(`restartWorkflow: ${appId}`);
+    this.appId = appId;
+    this.name = "RestartWorkflowSignal";
+  }
+  appId;
+};
 function ensureExecutedStepCount(state) {
   if (state.executedStepCount == null) {
     state.executedStepCount = state.steps.filter(
@@ -2189,6 +2488,12 @@ async function makeContext(state) {
       }
       throw new ReturnToStepSignal(targetIndex, stepId);
     },
+    changeApplication: async () => {
+      const currentAppId = runAppId(state);
+      const next = await promptToChangeApplication(currentAppId);
+      if (next?.id) throw new RestartWorkflowSignal(next.id);
+    },
+    appId: runAppId(state),
     config: await loadConfig()
   };
 }
@@ -2201,13 +2506,16 @@ async function rewindTo(state, targetIndex, fromIndex) {
   }
   state.currentStepIndex = targetIndex;
   state.updatedAt = nowIso();
-  useWizard.getState().syncSteps([...state.steps], targetIndex);
+  const store = useWizard.getState();
+  store.setActiveStep(targetIndex);
+  store.syncSteps([...state.steps], targetIndex);
   await saveWorkflowState(state);
 }
-async function runStep(state, index, step, appId) {
+async function runStep(state, index, step) {
   const store = useWizard.getState();
   const record = state.steps[index];
   const startedAt = Date.now();
+  const appId = runAppId(state);
   trackActionStart({
     workflowId: state.workflowId,
     appId,
@@ -2235,6 +2543,16 @@ async function runStep(state, index, step, appId) {
       await rewindTo(state, err.targetIndex, index);
       return err.targetIndex;
     }
+    if (err instanceof RestartWorkflowSignal) {
+      trackActionAbandoned({
+        workflowId: state.workflowId,
+        appId,
+        actionId: step.id,
+        actionTitle: step.title,
+        durationMs: Date.now() - startedAt,
+        reason: "application_changed"
+      });
+    }
     throw err;
   }
   record.status = "done";
@@ -2253,57 +2571,106 @@ async function runStep(state, index, step, appId) {
 }
 var RESUME_OPTION = "Resume";
 var START_NEW_OPTION = "Start a new one";
+async function startFresh(workflow, appId) {
+  await clearWorkflowState(workflow.id);
+  return initWorkflowState(workflow, nowIso(), appId);
+}
 async function resolveWorkflowState(workflow, appId, options) {
   const resumed = options?.resumableState !== void 0 ? options.resumableState : await loadResumableState(workflow);
   if (!resumed) {
     return initWorkflowState(workflow, nowIso(), appId);
   }
+  const savedAppId = runAppId(resumed);
   if (options?.skipResumePrompt) {
+    if (appId && savedAppId === void 0) {
+      resumed.algoliaState.appId = appId;
+    }
     return resumed;
   }
+  if (appId && savedAppId !== appId) {
+    logger.warn(
+      { workflowId: workflow.id, savedAppId, appId },
+      "resolveWorkflowState: persisted run is not pinned to the selected application; starting from scratch"
+    );
+    return startFresh(workflow, appId);
+  }
   const answer = await useWizard.getState().requestUserInput({
     prompt: "You have a previous session. Do you want to resume, or start a new one?",
     promptType: "multipleChoice",
     options: [RESUME_OPTION, START_NEW_OPTION]
   });
   if (answer === START_NEW_OPTION) {
-    await clearWorkflowState(workflow.id);
-    return initWorkflowState(workflow, nowIso(), appId);
+    return startFresh(workflow, appId);
   }
   return resumed;
 }
-async function runWorkflow(workflow, appId, options) {
+async function beginRun(workflow, state) {
+  ensureExecutedStepCount(state);
+  ensureAgentRunId(state);
+  setAnalyticsContext({ appId: runAppId(state), agentRunId: state.agentRunId });
+  useWizard.getState().startWorkflow(
+    {
+      id: workflow.id,
+      title: workflow.title,
+      description: workflow.description
+    },
+    [...state.steps]
+  );
+  await ensureConsent();
+  trackWorkflowStart({ workflowId: workflow.id, appId: runAppId(state) });
+}
+async function handleRestartWorkflow(workflow, previous, newAppId) {
+  trackWorkflowAbandoned({
+    workflowId: workflow.id,
+    appId: runAppId(previous),
+    reason: "application_changed"
+  });
+  await clearWorkflowState(workflow.id);
+  const next = initWorkflowState(workflow, nowIso(), newAppId);
+  useWizard.getState().resetRunState();
+  useWizard.getState().setLoadingMessage("Restarting wizard\u2026");
+  try {
+    await beginRun(workflow, next);
+  } finally {
+    useWizard.getState().setLoadingMessage(null);
+  }
+  return next;
+}
+async function runWorkflow(workflow, startWorkflowAppId, options) {
   const store = useWizard.getState();
   try {
-    const state = await resolveWorkflowState(workflow, appId, options);
-    ensureExecutedStepCount(state);
-    ensureAgentRunId(state);
-    setAnalyticsContext({ appId, agentRunId: state.agentRunId });
-    store.startWorkflow(
-      {
-        id: workflow.id,
-        title: workflow.title,
-        description: workflow.description
-      },
-      [...state.steps]
+    let state = await resolveWorkflowState(
+      workflow,
+      startWorkflowAppId,
+      options
     );
-    await ensureConsent();
-    trackWorkflowStart({ workflowId: workflow.id, appId });
+    await beginRun(workflow, state);
     track("AI Wizard Started", {
       version: package_default.version,
       wizard_version: package_default.version,
       os: process.platform
     });
-    let i = state.currentStepIndex;
-    while (i < workflow.steps.length) {
-      const rewoundTo = await runStep(state, i, workflow.steps[i], appId);
-      i = rewoundTo ?? i + 1;
+    for (; ; ) {
+      try {
+        let i = state.currentStepIndex;
+        while (i < workflow.steps.length) {
+          const rewoundTo = await runStep(state, i, workflow.steps[i]);
+          i = rewoundTo ?? i + 1;
+        }
+        break;
+      } catch (err) {
+        if (err instanceof RestartWorkflowSignal) {
+          state = await handleRestartWorkflow(workflow, state, err.appId);
+          continue;
+        }
+        throw err;
+      }
     }
     const totalDurationMs = Date.now() - Date.parse(state.startedAt);
     const stepCount = state.executedStepCount ?? state.steps.filter((s) => s.status === "done" && isStepVisible(s)).length;
     trackWizardComplete({
       workflowId: workflow.id,
-      appId,
+      appId: runAppId(state),
       total_duration: Math.round(totalDurationMs / 1e3),
       total_steps: stepCount
     });
@@ -2317,19 +2684,20 @@ async function runWorkflow(workflow, appId, options) {
     store.setDone();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    const state = await loadWorkflowState(workflow.id);
+    const failed = await loadWorkflowState(workflow.id);
+    const failedAppId = failed ? runAppId(failed) : startWorkflowAppId;
     let step = "unknown";
     let failedActionId;
     let failedActionTitle;
-    if (state) {
-      const record = state.steps[state.currentStepIndex];
+    if (failed) {
+      const record = failed.steps[failed.currentStepIndex];
       if (record) {
         step = record.title;
         if (record.status === "running") {
           record.status = "error";
           record.error = message;
-          await saveWorkflowState(state);
-          store.syncSteps([...state.steps], state.currentStepIndex);
+          await saveWorkflowState(failed);
+          store.syncSteps([...failed.steps], failed.currentStepIndex);
         }
         failedActionId = record.id;
         failedActionTitle = record.title;
@@ -2338,7 +2706,7 @@ async function runWorkflow(workflow, appId, options) {
     if (failedActionId && failedActionTitle) {
       trackActionError({
         workflowId: workflow.id,
-        appId,
+        appId: failedAppId,
         actionId: failedActionId,
         actionTitle: failedActionTitle,
         error: message,
@@ -2347,7 +2715,7 @@ async function runWorkflow(workflow, appId, options) {
     }
     trackWorkflowError({
       workflowId: workflow.id,
-      appId,
+      appId: failedAppId,
       error: message,
       actionId: failedActionId,
       cause: err
@@ -2367,12 +2735,12 @@ async function runWorkflow(workflow, appId, options) {
 }
 
 // src/actions/listIndices.ts
-import { z as z4 } from "zod";
-var indicesListSchema = z4.object({
-  items: z4.array(
-    z4.object({
-      name: z4.string(),
-      entries: z4.number().default(0)
+import { z as z5 } from "zod";
+var indicesListSchema = z5.object({
+  items: z5.array(
+    z5.object({
+      name: z5.string(),
+      entries: z5.number().default(0)
     })
   )
 });
@@ -2382,83 +2750,10 @@ async function listIndices() {
   return items.map((i) => ({ name: i.name, entries: i.entries })).sort((a, b) => a.name.localeCompare(b.name));
 }
 
-// src/lib/algoliaApp.ts
-import { z as z5 } from "zod";
-var applicationSchema = z5.object({
-  id: z5.string().min(1),
-  name: z5.string().default(""),
-  plan: z5.string().optional()
-});
-var listSchema = z5.array(
-  z5.object({
-    id: z5.string().min(1),
-    name: z5.string().default(""),
-    plan_label: z5.string().optional(),
-    status: z5.string().optional(),
-    acl: z5.array(z5.string()).optional()
-  }).transform(({ id, name, plan_label, status, acl }) => ({
-    id,
-    name,
-    plan: plan_label,
-    status,
-    acl
-  }))
-);
-function canSelectApplication(app) {
-  return app.status === "active" && (app.acl ?? []).includes("keys");
-}
-async function currentApplication() {
-  let raw;
-  try {
-    raw = await runAlgoliaCli(["application", "current", "-o", "json"]);
-  } catch {
-    return null;
-  }
-  const parsed = applicationSchema.safeParse(parseJson(raw));
-  return parsed.success ? parsed.data : null;
-}
-async function requireApplication() {
-  const app = await currentApplication();
-  if (!app) {
-    throw new Error(
-      "No Algolia application is selected. Run `npx @algolia/cli@latest application select` and restart the wizard."
-    );
-  }
-  return app;
-}
-async function listApplications() {
-  const raw = await runAlgoliaCli(["application", "list", "-o", "json"]);
-  const parsed = listSchema.safeParse(parseJson(raw));
-  if (!parsed.success) {
-    throw new Error("Could not read the list of Algolia applications.");
-  }
-  return parsed.data;
-}
-async function selectApplication(id) {
-  const raw = await runAlgoliaCli(
-    ["application", "select", "--non-interactive", "--app-id", id],
-    { onOutput: stderrSink }
-  );
-  const parsed = applicationSchema.safeParse(parseJson(raw));
-  if (!parsed.success) {
-    throw new Error(
-      `Selected application ${id}, but the Algolia CLI returned an unreadable result.`
-    );
-  }
-  return parsed.data;
-}
-function parseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-}
-
 // src/actions/selectIndex.ts
 var CREATE_NEW_INDEX = "Create a new index\u2026";
 var selectIndexStep = async (ctx) => {
-  await requireApplication();
+  await requireApplication(ctx.appId);
   const indices = await listIndices();
   const names = indices.map((i) => i.name);
   const hasIndices = names.length > 0;
@@ -2532,7 +2827,7 @@ import { readdir } from "node:fs/promises";
 // src/lib/tools/path.ts
 import { constants } from "node:fs";
 import { lstat, mkdir as mkdir3, open } from "node:fs/promises";
-import { resolve as resolve2, relative, isAbsolute, dirname as dirname2, join as join5, sep } from "node:path";
+import { resolve as resolve2, relative, isAbsolute, dirname as dirname2, join as join6, sep } from "node:path";
 var DEFAULT_FILE_MODE = 438;
 function errorCode(err) {
   if (typeof err === "object" && err !== null && "code" in err && typeof err.code === "string") {
@@ -2555,7 +2850,7 @@ 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);
+    current = join6(current, part);
     try {
       if ((await lstat(current)).isSymbolicLink()) return true;
     } catch (err) {
@@ -2673,7 +2968,7 @@ function reportStatusTool(output) {
 // src/lib/tools/readFile.ts
 import { tool as tool4 } from "ai";
 import z9 from "zod";
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 
 // src/lib/tools/env.ts
 import { basename } from "node:path";
@@ -2761,7 +3056,7 @@ function readFileTool(ctx) {
       const resolved2 = resolveInRoot(ctx, filePath);
       if (resolved2.ok === false) return resolved2.error;
       try {
-        const content = await readFile3(resolved2.target, "utf8");
+        const content = await readFile4(resolved2.target, "utf8");
         const safeContent = isEnvFile(resolved2.target) ? redactEnvValues(content) : content;
         return readLines ? readLineRange(safeContent, [readLines[0], readLines[1]]) : sampleFile(safeContent);
       } catch (err) {
@@ -2803,7 +3098,7 @@ function writeFileTool(ctx) {
 // src/lib/tools/writeAlgoliaCredentials.ts
 import { tool as tool6 } from "ai";
 import z13 from "zod";
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { relative as relative3 } from "node:path";
 
 // src/lib/algoliaApiKey.ts
@@ -3007,8 +3302,8 @@ async function resolveSearchOnlyKey(index, appId) {
 
 // src/lib/gitignore.ts
 import { execFile } from "node:child_process";
-import { lstat as lstat2, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join6, relative as relative2 } from "node:path";
+import { lstat as lstat2, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join7, relative as relative2 } from "node:path";
 var GIT_ENV_OVERRIDES = [
   "GIT_DIR",
   "GIT_WORK_TREE",
@@ -3060,7 +3355,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 = join6(root, ".gitignore");
+  const gitIgnore = join7(root, ".gitignore");
   try {
     const link = await lstat2(gitIgnore).catch(() => null);
     if (link?.isSymbolicLink()) {
@@ -3070,7 +3365,7 @@ async function ensureGitIgnored(root, target) {
       );
       return "unknown";
     }
-    const existing = link ? await readFile4(gitIgnore, "utf8") : "";
+    const existing = link ? await readFile5(gitIgnore, "utf8") : "";
     const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
     await writeFile3(gitIgnore, `${existing}${prefix}${pattern}
 `, "utf8");
@@ -3138,7 +3433,7 @@ function writeCredentialsTool(ctx) {
         const targetError = await validateSafeWriteTarget(ctx, resolved2.target);
         if (targetError) return targetError;
         try {
-          existing = await readFile5(resolved2.target, "utf8");
+          existing = await readFile6(resolved2.target, "utf8");
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -3155,7 +3450,7 @@ function writeCredentialsTool(ctx) {
       const fileIndex = readEnv(existing, INDEX_NAME_VAR);
       if (fileAppId === null || fileKey === null) {
         try {
-          const selected = (await requireApplication()).id;
+          const selected = (await requireApplication(ctx.appId)).id;
           if (fileAppId === null) credentials.push([APP_ID_VAR, selected]);
           if (fileKey === null) {
             if (fileAppId !== null && fileAppId !== selected) {
@@ -3174,7 +3469,7 @@ function writeCredentialsTool(ctx) {
             );
           }
         } catch (err) {
-          return `Error: could not resolve Algolia credentials (${err.message}). Ask the user to authenticate with the Algolia CLI first.`;
+          return `Error: could not resolve Algolia credentials (${err.message})`;
         }
       }
       let wrote;
@@ -3228,8 +3523,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 readFile6 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
+import { join as join8 } from "node:path";
 var MAX_QUERY_LENGTH = 1e3;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -3244,7 +3539,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 = join7(dir, e.name);
+    const full = join8(dir, e.name);
     if (e.isDirectory()) out.push(...await walkFiles(full));
     else if (e.isFile()) out.push(full);
   }
@@ -3277,7 +3572,7 @@ function searchFilesTool(ctx) {
       for (const file of await walkFiles(resolved2.target)) {
         let content;
         try {
-          content = await readFile6(file, "utf8");
+          content = await readFile7(file, "utf8");
         } catch {
           continue;
         }
@@ -3307,7 +3602,7 @@ import { relative as relative5 } from "node:path";
 import { tool as tool8 } from "ai";
 import z15 from "zod";
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile7, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile8, stat as stat2 } from "node:fs/promises";
 import { relative as relative4 } from "node:path";
 
 // src/lib/tools/utils/prompt.ts
@@ -3322,7 +3617,7 @@ function serializePrompt(work) {
 // src/lib/tools/reviewScript.ts
 var reviewedCommandApprovals = /* @__PURE__ */ new WeakMap();
 async function fileDigest(filePath) {
-  const content = await readFile7(filePath);
+  const content = await readFile8(filePath);
   return createHash2("sha256").update(content).digest("hex");
 }
 function grantReviewedCommandApproval(ctx, approval) {
@@ -4913,13 +5208,13 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 
 // src/actions/implement.ts
 import z28 from "zod";
-import { access, mkdir as mkdir5, readFile as readFile8 } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join10, relative as relative6, resolve as resolve4, sep as sep2 } from "node:path";
+import { access, mkdir as mkdir5, readFile as readFile9 } from "node:fs/promises";
+import { dirname as dirname5, isAbsolute as isAbsolute3, join as join11, relative as relative6, resolve as resolve4, sep as sep2 } from "node:path";
 
 // src/lib/git.ts
 import { execFile as execFile2 } from "node:child_process";
 import { copyFile, mkdir as mkdir4, stat as stat3 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join8, resolve as resolve3 } from "node:path";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join9, resolve as resolve3 } from "node:path";
 var MAX_BUFFER = 32 * 1024 * 1024;
 function git(args) {
   return new Promise((resolve5, reject) => {
@@ -4956,8 +5251,8 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
   } catch {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
-  const relPath = join8(ingestDir, basename2(source));
-  const dest = join8(repoRoot, relPath);
+  const relPath = join9(ingestDir, basename2(source));
+  const dest = join9(repoRoot, relPath);
   if (resolve3(source) === resolve3(dest)) {
     return { ok: true, relPath };
   }
@@ -4996,13 +5291,13 @@ function toRootRelative(p) {
 
 // src/lib/algoliaDocs.ts
 import { readFileSync, readdirSync, existsSync } from "node:fs";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname4, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
-var DOCS_SUBPATH = join9("docs", "algolia-sdk");
+var DOCS_SUBPATH = join10("docs", "algolia-sdk");
 function findDocsDir() {
   let dir = dirname4(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const candidate = join9(dir, DOCS_SUBPATH);
+    const candidate = join10(dir, DOCS_SUBPATH);
     if (existsSync(candidate)) return candidate;
     const parent = dirname4(dir);
     if (parent === dir) return void 0;
@@ -5025,7 +5320,7 @@ function loadAlgoliaDoc(language) {
     );
     return "";
   }
-  return readFileSync(join9(docsDir, files[0]), "utf8").trim();
+  return readFileSync(join10(docsDir, files[0]), "utf8").trim();
 }
 function getNamedDoc(name, language) {
   const docsDir = findDocsDir();
@@ -5033,7 +5328,7 @@ function getNamedDoc(name, language) {
     logger.warn("docs/algolia-sdk not found");
     return "";
   }
-  const file = join9(docsDir, `${name}-${language}.md`);
+  const file = join10(docsDir, `${name}-${language}.md`);
   if (!existsSync(file)) {
     logger.warn({ name, language }, "named SDK reference not found");
     return "";
@@ -5363,7 +5658,7 @@ function jsTypeName(value) {
 }
 async function firstRecordIn(filePath) {
   try {
-    const parsed = JSON.parse(await readFile8(filePath, "utf8"));
+    const parsed = JSON.parse(await readFile9(filePath, "utf8"));
     const first = Array.isArray(parsed) ? parsed[0] : parsed;
     if (first && typeof first === "object" && !Array.isArray(first)) {
       return first;
@@ -5377,10 +5672,10 @@ async function ingestedRecordSample(repoRoot, entityName, uploadFilePath) {
   const candidates = [];
   if (entityName) {
     const slug = entityName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-    candidates.push(join10(repoRoot, INGEST_DIR, "data", `${slug}.json`));
+    candidates.push(join11(repoRoot, INGEST_DIR, "data", `${slug}.json`));
   }
   if (uploadFilePath?.toLowerCase().endsWith(".json")) {
-    candidates.push(join10(repoRoot, uploadFilePath));
+    candidates.push(join11(repoRoot, uploadFilePath));
   }
   for (const candidate of candidates) {
     const sample = await firstRecordIn(candidate);
@@ -5410,12 +5705,15 @@ function ingestFailure(attempt, executions) {
   }
   return { reason: `it failed (exit ${attempt.exitCode ?? "unknown"})`, detail };
 }
-function makeToolContext(root, env = async () => ({})) {
-  return createToolContext(
-    DEFAULT_TOOL_LIMITS,
-    root,
-    createShellContext({ env, approve: storeApproval(root) })
-  );
+function makeToolContext(root, appId, env = async () => ({})) {
+  return {
+    ...createToolContext(
+      DEFAULT_TOOL_LIMITS,
+      root,
+      createShellContext({ env, approve: storeApproval(root) })
+    ),
+    appId
+  };
 }
 function validationRetryInstructions(validation) {
   return [
@@ -5439,7 +5737,7 @@ async function frontendHasPackageJson(repoRoot, searchLocation) {
     if (!outsideRoot) directory = candidate;
   }
   for (; ; ) {
-    if (await pathExists(join10(directory, "package.json"))) return true;
+    if (await pathExists(join11(directory, "package.json"))) return true;
     if (directory === repoRoot) return false;
     directory = dirname5(directory);
   }
@@ -5448,7 +5746,7 @@ async function resolveBuildCheckPlan(ctx, repoRoot, input) {
   if (!input.findings.verification?.length) {
     return { run: false, installDependencies: false };
   }
-  const installDependencies = input.frontendHasPackageJson && isJsProject(input.language) && !await pathExists(join10(repoRoot, "node_modules"));
+  const installDependencies = input.frontendHasPackageJson && isJsProject(input.language) && !await pathExists(join11(repoRoot, "node_modules"));
   const accepted = Boolean(
     await ctx.requestUserInput({
       prompt: installDependencies ? MISSING_DEPENDENCIES_PROMPT : BUILD_CHECK_PROMPT,
@@ -5526,7 +5824,7 @@ async function resolveIngestionSource(ctx, repoRoot) {
       messages: []
     });
     const uploadSourcePath = typeof answer === "string" ? answer : "";
-    await mkdir5(join10(repoRoot, INGEST_DIR), { recursive: true });
+    await mkdir5(join11(repoRoot, INGEST_DIR), { recursive: true });
     const copied = await copyUploadIntoProject(
       repoRoot,
       INGEST_DIR,
@@ -5536,10 +5834,7 @@ async function resolveIngestionSource(ctx, repoRoot) {
       return { ingestionSource: "fileUpload", uploadFilePath: copied.relPath };
     }
     error = `Could not use the uploaded file (${copied.reason}).`;
-    logger.warn(
-      { reason: copied.reason },
-      "implement: file upload unavailable"
-    );
+    logger.warn({ reason: copied.reason }, "implement: file upload unavailable");
   }
 }
 async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
@@ -5562,6 +5857,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   let ingestionSource = "generated";
   let uploadFilePath = void 0;
   if (useCases.includes("ingestion")) {
+    ;
     ({ ingestionSource, uploadFilePath } = await resolveIngestionSource(
       ctx,
       repoRoot
@@ -5570,7 +5866,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   const targetIndex = selected?.selection;
   useWizard.getState().setTargetIndex(targetIndex ?? null);
   if (useCases.includes("ingestion")) {
-    await mkdir5(join10(repoRoot, INGEST_DIR), { recursive: true });
+    await mkdir5(join11(repoRoot, INGEST_DIR), { recursive: true });
   }
   const findings = normalizeFindingPaths({
     ingestionAnalysis: entities?.ingestionAnalysis ?? scan.ingestionAnalysis,
@@ -5583,10 +5879,10 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   let appId;
   let ingestAppId;
   if (useCases.includes("search")) {
-    appId = (await requireApplication()).id;
+    appId = (await requireApplication(ctx.appId)).id;
   }
   if (useCases.includes("ingestion")) {
-    ingestAppId = appId ?? (await requireApplication()).id;
+    ingestAppId = appId ?? (await requireApplication(ctx.appId)).id;
   }
   let ingestWriteKey;
   if (useCases.includes("ingestion") && ingestAppId) {
@@ -5638,11 +5934,11 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   let ingestDurationMs;
   let ingestOutcomeMessage;
   const ingestKeyAppId = ingestAppId;
-  const ingestionTools = ingestKeyAppId && ingestWriteKey ? makeToolContext(repoRoot, async () => ({
+  const ingestionTools = ingestKeyAppId && ingestWriteKey ? makeToolContext(repoRoot, ctx.appId, async () => ({
     [APP_ID_VAR]: ingestKeyAppId,
     [API_KEY_VAR]: ingestWriteKey,
     [INDEX_NAME_VAR]: targetIndex
-  })) : makeToolContext(repoRoot);
+  })) : makeToolContext(repoRoot, ctx.appId);
   async function runImplementationUseCase(currentUseCase, extraInstructions = [], isRetry = false) {
     if (agentRuns > 0) ctx.recordStepExecution();
     agentRuns += 1;
@@ -5667,14 +5963,10 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     );
     return runAgent({
       operation: "search-validation",
-      instructions: buildAgentInstructions(
-        "validation",
-        input,
-        [
-          writtenFiles.length ? `Files written during search implementation: ${JSON.stringify(writtenFiles)}. Inspect these first, then trace the actual import and render site.` : "The search agent reported no written files. Inspect the current diff and set sufficient=false if no complete mounted search implementation exists.",
-          ...extraInstructions
-        ]
-      ),
+      instructions: buildAgentInstructions("validation", input, [
+        writtenFiles.length ? `Files written during search implementation: ${JSON.stringify(writtenFiles)}. Inspect these first, then trace the actual import and render site.` : "The search agent reported no written files. Inspect the current diff and set sufficient=false if no complete mounted search implementation exists.",
+        ...extraInstructions
+      ]),
       tools: toolsForUseCase("validation"),
       outputSchema: validationOutputSchema,
       modelProfile: "validation" /* validation */,
@@ -5884,7 +6176,7 @@ ${detail}` : ""}`
     if (searchConfigFile) {
       const ignoreStatus = await gitIgnoreStatus(
         repoRoot,
-        join10(repoRoot, searchConfigFile)
+        join11(repoRoot, searchConfigFile)
       );
       if (ignoreStatus === "covered") {
         summaries.push(
@@ -6028,13 +6320,21 @@ import { z as z32 } from "zod";
 import "zod";
 var DASHBOARD_API_BASE_URL = `${PROXY_BASE_URL}/dashboard`;
 var DashboardApiError = class extends Error {
-  constructor(status, message) {
-    super(message);
+  constructor(status, body) {
+    super("Couldn't complete the request.");
     this.status = status;
+    this.body = body;
     this.name = "DashboardApiError";
   }
   status;
+  body;
+  errorBody() {
+    return isRecord(this.body) ? this.body : void 0;
+  }
 };
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
 async function dashboardRequest(path, schema, init) {
   const token = getAuthToken();
   if (!token) {
@@ -6049,17 +6349,24 @@ async function dashboardRequest(path, schema, init) {
     }
   });
   if (!res.ok) {
-    throw new DashboardApiError(
-      res.status,
-      `Dashboard API responded ${res.status} for ${path}`
-    );
+    throw await dashboardError(res);
   }
   const body = await res.json();
   return { status: res.status, data: schema.parse(body) };
 }
+async function dashboardError(res) {
+  try {
+    return new DashboardApiError(res.status, await res.json());
+  } catch {
+    return new DashboardApiError(res.status, void 0);
+  }
+}
 
 // src/lib/dashboardApi/schemas.ts
 import { z as z31 } from "zod";
+var messageResponseSchema = z31.object({
+  message: z31.string()
+});
 var playbookSchema = z31.object({
   slug: z31.string(),
   category: z31.string().optional(),
@@ -6067,6 +6374,57 @@ var playbookSchema = z31.object({
   description: z31.string().optional()
 });
 var playbooksListSchema = z31.array(playbookSchema);
+var playbookExecutionStepSchema = z31.enum([
+  "assessment",
+  "optimization",
+  "implement"
+]);
+var playbookExecutionStepStatusSchema = z31.enum([
+  "not_started",
+  "in_progress",
+  "done",
+  "error"
+]);
+var schemaComparisonEntrySchema = z31.object({
+  canonical_attr: z31.string(),
+  canonical_type: z31.array(z31.string()),
+  canonical_roles: z31.array(z31.string()),
+  canonical_required: z31.boolean(),
+  index_attr: z31.string().nullable(),
+  index_type: z31.array(z31.string()).nullable(),
+  index_required: z31.boolean().nullable(),
+  status: z31.string(),
+  mapping_confidence: z31.number()
+});
+var settingsRecommendationSchema = z31.record(
+  z31.string(),
+  z31.object({
+    current: z31.any(),
+    recommended: z31.any()
+  })
+);
+var assessmentResultSchema = z31.object({
+  ready: z31.boolean(),
+  schema_comparison: z31.array(schemaComparisonEntrySchema),
+  settings_recommendation: settingsRecommendationSchema
+});
+var playbookExecutionSchema = z31.object({
+  uuid: z31.string(),
+  playbook_slug: z31.string(),
+  application_id: z31.string(),
+  source_index_name: z31.string(),
+  current_step: playbookExecutionStepSchema,
+  step_status: playbookExecutionStepStatusSchema,
+  status_reason: z31.string().nullable(),
+  completed: z31.boolean(),
+  assessment_result: assessmentResultSchema.nullable(),
+  settings_snapshot: z31.json().nullable(),
+  created_at: z31.iso.datetime()
+});
+var playbookExecutionCreateResponseSchema = playbookExecutionSchema.extend({
+  resumed: z31.boolean(),
+  sample_data: z31.boolean()
+});
 
 // src/lib/dashboardApi/api.ts
 async function getPlaybooks() {
@@ -6115,20 +6473,28 @@ import { z as z33 } from "zod";
 var confirmPlaybookSchema = z33.void();
 var CONTINUE_OPTION = "Looks good, continue";
 var GO_BACK_OPTION = "Go back";
+var SELECT_APP_OPTION = "Select app";
 async function confirmPlaybookStep(ctx) {
   const { slug } = ctx.getStepOutput("select-playbook");
-  const selection = await ctx.requestUserInput({
-    prompt: "Ready to continue?",
-    promptType: "multipleChoice",
-    options: [CONTINUE_OPTION, GO_BACK_OPTION],
-    messages: [`Playbook: ${slug}`],
-    helpText: "Going back re-opens the playbook catalogue."
-  });
-  if (typeof selection !== "string") {
-    throw new Error("confirm-playbook received an unexpected result");
-  }
-  if (selection === GO_BACK_OPTION) {
-    return ctx.returnToStep("select-playbook");
+  for (; ; ) {
+    const selection = await ctx.requestUserInput({
+      prompt: "Ready to continue?",
+      promptType: "multipleChoice",
+      options: [CONTINUE_OPTION, GO_BACK_OPTION, SELECT_APP_OPTION],
+      messages: [`Playbook: ${slug}`, `Application: ${ctx.appId}`],
+      helpText: "Going back re-opens the playbook catalogue. Select app opens the application catalogue \u2014 keep the current app to stay here, or pick another to restart the wizard."
+    });
+    if (typeof selection !== "string") {
+      throw new Error("confirm-playbook received an unexpected result");
+    }
+    if (selection === SELECT_APP_OPTION) {
+      await ctx.changeApplication();
+      continue;
+    }
+    if (selection === GO_BACK_OPTION) {
+      return ctx.returnToStep("select-playbook");
+    }
+    return;
   }
 }
 
@@ -6219,7 +6585,7 @@ function getWorkflow(id) {
 }
 
 // src/ui/Welcome.tsx
-import { dirname as dirname6, join as join11 } from "node:path";
+import { dirname as dirname6, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { useState as useState10 } from "react";
 import { Box as Box11, Spacer, Text as Text12, useInput as useInput6, useWindowSize as useWindowSize5 } from "ink";
@@ -6251,7 +6617,7 @@ var sidebarItems = [
 // src/ui/Welcome.tsx
 import Image, { TerminalInfoContext, defaultTerminalInfo } from "ink-picture";
 import { jsx as jsx10, jsxs as jsxs11 } from "react/jsx-runtime";
-var IMAGE_PATH = join11(dirname6(fileURLToPath2(import.meta.url)), "algolia.png");
+var IMAGE_PATH = join12(dirname6(fileURLToPath2(import.meta.url)), "algolia.png");
 var TERMINAL_INFO = {
   ...defaultTerminalInfo,
   supportsUnicode: true,
@@ -7084,6 +7450,7 @@ function App() {
     user,
     workflow,
     settingUpAppId,
+    loadingMessage,
     review: review2
   } = useWizard();
   const { exit } = useApp();
@@ -7190,6 +7557,11 @@ function App() {
                           " ",
                           settingUpAppId
                         ] }) }),
+                        phase === "running" && !settingUpAppId && loadingMessage && /* @__PURE__ */ jsx19(Box20, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs19(Text21, { color: COLORS.strong, bold: true, children: [
+                          /* @__PURE__ */ jsx19(Spinner3, { type: "dots" }),
+                          " ",
+                          loadingMessage
+                        ] }) }),
                         /* @__PURE__ */ jsx19(CliOutput, {}),
                         showTips && currentStep && /* @__PURE__ */ jsx19(
                           Tips,
@@ -7223,126 +7595,6 @@ function App() {
   );
 }
 
-// src/lib/envAppId.ts
-import { readFile as readFile9 } 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 readFile9(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, highlightId) {
-  if (!canSelectApplication(app)) {
-    return { kind: "text", value: blockReasonFor(app) };
-  }
-  if (app.id === highlightId) {
-    return { kind: "badge", value: "[DETECTED]" };
-  }
-  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(id) {
-  const store = useWizard.getState();
-  store.setSettingUpApp(id);
-  try {
-    return await selectApplication(id);
-  } finally {
-    store.setSettingUpApp(null);
-  }
-}
-async function promptForApplication(highlight) {
-  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 envApp = highlight ? unordered.find((app) => app.id === highlight.id) : void 0;
-  const highlightIndex = envApp && canSelectApplication(envApp) ? apps.indexOf(envApp) : -1;
-  const messages = [];
-  if (highlight && highlightIndex < 0) {
-    messages.push(
-      envApp ? `Could not use ${highlight.id} from ${highlight.file} \u2014 it\u2019s ${blockReasonFor(envApp).toLowerCase()}. Pick another below.` : `Could not use ${highlight.id} from ${highlight.file} \u2014 it may have been removed, or this account may not have access to it.`
-    );
-  }
-  for (; ; ) {
-    const choice = await store.requestUserInput({
-      prompt: "Which Algolia application should the wizard work in?",
-      promptType: "multipleChoice",
-      options: apps.map(labelFor),
-      secondary: apps.map((app) => secondaryFor(app, highlight?.id)),
-      disabled: apps.map((app) => !canSelectApplication(app)),
-      ...highlightIndex >= 0 ? { defaultSelectedIndex: highlightIndex } : {},
-      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.id);
-    } 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 ensureApplication(resumeAppId) {
-  if (resumeAppId) return selectAndReport(resumeAppId);
-  const env = await findEnvApplicationId();
-  if (!env) return promptForApplication();
-  return promptForApplication({ id: env.id, file: env.file });
-}
-
 // src/lib/seed.ts
 var projectScan2 = {
   languages: [{ name: "TypeScript", version: "5.7.2" }],
@@ -7589,7 +7841,7 @@ function delay(ms) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.71.0",
+  version: "0.73.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.71.0",
+  "version": "0.73.0",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {