@whisperr/wizard 0.7.0 → 0.7.2

package/dist/index.js

@@ -1969,10 +1969,10 @@ var RunsClient = class {
     return payload;
   }
   createOrResumeRun(input) {
-    return this.request("POST", "/wizard/runs", { ...input });
+    return this.request("POST", "/wizard/runs", { ...input }).then(normalizeRunBootstrap);
   }
   getRun(runId) {
-    return this.request("GET", `/wizard/runs/${runId}`);
+    return this.request("GET", `/wizard/runs/${runId}`).then(normalizeRunBootstrap);
   }
   patchRun(runId, patch) {
     return this.request("PATCH", `/wizard/runs/${runId}`, { ...patch });
@@ -1983,7 +1983,7 @@ var RunsClient = class {
       idempotencyKey: itemIdempotencyKey(kind, code, idempotencyExtra),
       kind,
       payload
-    });
+    }).then(normalizeItemWriteResult);
   }
   completeRun(runId, completion) {
     return this.request(
@@ -1993,6 +1993,64 @@ var RunsClient = class {
     );
   }
 };
+function normalizeItemWriteResult(payload) {
+  const value = record(payload);
+  const item = record(value?.item);
+  const id = stringValue(value?.id) || stringValue(item?.id);
+  if (!value || value.kind !== "event" || typeof value.created !== "boolean" || !id) {
+    throw new RunsApiError("runs API returned an invalid item write response");
+  }
+  return {
+    kind: "event",
+    created: value.created,
+    id,
+    ...typeof value.code === "string" ? { code: value.code } : {},
+    ...item && typeof item.id === "string" ? { item: { id: item.id, ...typeof item.code === "string" ? { code: item.code } : {} } } : {}
+  };
+}
+function normalizeRunBootstrap(payload) {
+  const value = record(payload);
+  if (!value) {
+    throw new RunsApiError("runs API returned an invalid run bootstrap response");
+  }
+  const snapshotSource = record(value.snapshot) ?? value;
+  const events = Array.isArray(snapshotSource.events) ? snapshotSource.events : void 0;
+  const run3 = record(value.run);
+  const project = record(value.project);
+  const ingestion = record(value.ingestion);
+  if (!run3 || typeof run3.id !== "string" || !project || typeof project.id !== "string" || !events || events.some((event) => !isSnapshotEvent(event)) || !ingestion || typeof ingestion.apiKey !== "string" || typeof ingestion.baseUrl !== "string") {
+    throw new RunsApiError("runs API returned an invalid run bootstrap response");
+  }
+  return {
+    project: {
+      id: project.id,
+      repoFingerprint: stringValue(project.repoFingerprint),
+      displayName: stringValue(project.displayName),
+      target: stringValue(project.target),
+      kind: stringValue(project.kind)
+    },
+    run: { id: run3.id, status: stringValue(run3.status), phase: stringValue(run3.phase) },
+    resumed: value.resumed === true,
+    universeMode: stringValue(value.universeMode),
+    ...record(value.onboardingContext) ? { onboardingContext: record(value.onboardingContext) } : {},
+    app: record(value.app) ?? {},
+    snapshot: {
+      setupStatus: stringValue(snapshotSource.setupStatus),
+      events
+    },
+    ingestion: { apiKey: ingestion.apiKey, baseUrl: ingestion.baseUrl }
+  };
+}
+function record(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : "";
+}
+function isSnapshotEvent(value) {
+  const event = record(value);
+  return !!event && typeof event.id === "string" && typeof event.code === "string" && typeof event.name === "string" && typeof event.reasoning === "string" && typeof event.projectId === "string" && !!record(event.payloadSchema);
+}
 
 // src/engine/selection.ts
 import { z } from "zod";
@@ -2172,6 +2230,7 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
   const seen = /* @__PURE__ */ new Set();
   const rejected = new Set(rejectedCodes);
   let summary = "";
+  let finished = false;
   const proposeTool = {
     name: "propose_event",
     description: "Propose one important, concretely-anchored product event. Returns ok:true when accepted.",
@@ -2233,6 +2292,7 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
     },
     handler: async (input) => {
       summary = String(input.summary ?? "");
+      finished = true;
       return { ok: true };
     }
   };
@@ -2256,6 +2316,7 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
   );
   return {
     outcome: outcome.kind,
+    finished,
     proposed,
     summary,
     surveyReport,
@@ -2271,8 +2332,7 @@ async function registerApprovedEvents(runs, runId, approved, sink) {
       reasoning: event.reasoning,
       ...Object.keys(event.payloadSchema).length > 0 ? { payloadSchema: event.payloadSchema } : {}
     });
-    const item = result.item;
-    registered.push({ ...event, eventId: item?.id ?? result.id ?? "" });
+    registered.push({ ...event, eventId: result.id || result.item?.id || "" });
     sink.emit({ phase: "persisting", file: event.anchorFile, action: `registered ${event.code}` });
   }
   return registered;
@@ -2290,7 +2350,7 @@ function placementsFor(registered) {
 // src/engine/state.ts
 import { createHash as createHash3 } from "crypto";
 import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
-import { homedir } from "os";
+import { homedir, tmpdir } from "os";
 import { join as join4 } from "path";
 
 // src/engine/types.ts
@@ -2310,10 +2370,16 @@ var ENGINE_PHASES = [
 // src/engine/state.ts
 function stateDirectory() {
   const override = process.env.WHISPERR_WIZARD_STATE_DIR?.trim();
-  if (override) {
-    return override;
+  const preferred = override || join4(homedir(), ".whisperr", "wizard-runs");
+  if (canCreateStateDirectory(preferred)) {
+    return preferred;
   }
-  return join4(homedir(), ".whisperr", "wizard-runs");
+  const user = typeof process.getuid === "function" ? process.getuid() : "user";
+  const fallback = join4(tmpdir(), `whisperr-${user}`, "wizard-runs");
+  if (canCreateStateDirectory(fallback)) {
+    return fallback;
+  }
+  throw new Error("Whisperr Wizard could not create a directory for run state");
 }
 function stateKey(apiBaseUrl, appId, repoFingerprint2) {
   return createHash3("sha256").update(`${apiBaseUrl}
@@ -2324,13 +2390,21 @@ function statePath(apiBaseUrl, appId, repoFingerprint2) {
   return join4(stateDirectory(), `${stateKey(apiBaseUrl, appId, repoFingerprint2)}.json`);
 }
 function saveRunState(state) {
-  const path = statePath(state.apiBaseUrl, state.appId, state.repoFingerprint);
-  mkdirSync(stateDirectory(), { recursive: true, mode: 448 });
+  const directory = stateDirectory();
+  const path = join4(directory, `${stateKey(state.apiBaseUrl, state.appId, state.repoFingerprint)}.json`);
   const payload = JSON.stringify({ ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2);
   const temporary = `${path}.tmp`;
   writeFileSync(temporary, payload, { mode: 384 });
   renameSync(temporary, path);
 }
+function canCreateStateDirectory(directory) {
+  try {
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function loadRunState(apiBaseUrl, appId, repoFingerprint2) {
   const path = statePath(apiBaseUrl, appId, repoFingerprint2);
   let raw;
@@ -2364,7 +2438,7 @@ function isEngineRunState(value) {
 // src/engine/worktree.ts
 import { spawn as spawn2 } from "child_process";
 import { mkdtemp, writeFile as writeFile2 } from "fs/promises";
-import { tmpdir } from "os";
+import { tmpdir as tmpdir2 } from "os";
 import { join as join5 } from "path";
 var WorktreeError = class extends Error {
   constructor(code, message) {
@@ -2409,7 +2483,7 @@ async function createWorktree(repoPath, force = false) {
     );
   }
   const baseRef = (await must(repoPath, ["rev-parse", "HEAD"])).trim();
-  const path = await mkdtemp(join5(tmpdir(), "whisperr-worktree-"));
+  const path = await mkdtemp(join5(tmpdir2(), "whisperr-worktree-"));
   await must(repoPath, ["worktree", "add", "--detach", "--force", path, "HEAD"]);
   return { path, baseRef, repoPath };
 }
@@ -2485,84 +2559,88 @@ async function runEngine(input) {
     } catch {
     }
   };
-  let state = loadRunState(input.config.apiBaseUrl, input.session.appId, input.repoFingerprint) ?? freshState(input, runId);
-  if (state.runId !== runId) {
-    state = freshState(input, runId);
+  let state;
+  try {
+    state = loadRunState(input.config.apiBaseUrl, input.session.appId, input.repoFingerprint) ?? freshState(input, runId);
+    if (state.runId !== runId) {
+      state = freshState(input, runId);
+    }
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    await failRun(`state initialization failed: ${reason}`);
+    return { kind: "aborted", reason: `state initialization failed: ${reason}` };
   }
   const persist = () => saveRunState(state);
   let registered;
   if (!state.designComplete) {
-    await patchPhase("surveying");
-    const survey = await runSurvey(
-      input.provider,
-      input.models,
-      input.repoPath,
-      bootstrap,
-      input.sink,
-      state.providerSessions.survey
-    );
-    if (survey.outcome.kind !== "completed") {
-      await failRun(`survey ${survey.outcome.kind}`);
-      return { kind: "aborted", reason: `survey ${survey.outcome.kind}` };
-    }
-    state.providerSessions.survey = survey.outcome.sessionId;
-    persist();
-    await patchPhase("designing");
-    const selection = await runSelection(
-      input.provider,
-      input.models,
-      input.repoPath,
-      bootstrap,
-      survey.report,
-      state.tombstonedCodes,
-      input.sink
-    );
-    if (selection.outcome !== "completed" && selection.proposed.length === 0) {
-      await failRun(`selection ${selection.outcome}`);
-      return { kind: "aborted", reason: `selection ${selection.outcome}` };
-    }
-    const approved = await input.callbacks.reviewEvents(selection.proposed);
-    if (approved === null) {
-      await failRun("selection rejected by user");
-      return { kind: "aborted", reason: "selection rejected by user" };
-    }
-    const approvedCodes = new Set(approved.map((event) => event.code));
-    for (const event of selection.proposed) {
-      if (!approvedCodes.has(event.code) && !state.tombstonedCodes.includes(event.code)) {
-        state.tombstonedCodes.push(event.code);
-      }
-    }
-    persist();
-    await patchPhase("persisting", `registering ${approved.length} events`);
     try {
+      await patchPhase("surveying");
+      const survey = await runSurvey(
+        input.provider,
+        input.models,
+        input.repoPath,
+        bootstrap,
+        input.sink,
+        state.providerSessions.survey
+      );
+      if (survey.outcome.kind !== "completed") {
+        await failRun(`survey ${survey.outcome.kind}`);
+        return { kind: "aborted", reason: `survey ${survey.outcome.kind}` };
+      }
+      state.providerSessions.survey = survey.outcome.sessionId;
+      persist();
+      await patchPhase("designing");
+      const selection = await runSelection(
+        input.provider,
+        input.models,
+        input.repoPath,
+        bootstrap,
+        survey.report,
+        state.tombstonedCodes,
+        input.sink
+      );
+      if (!selection.finished) {
+        const reason = selection.outcome === "completed" ? "selection did not call finish_selection" : `selection ${selection.outcome}`;
+        await failRun(reason);
+        return { kind: "aborted", reason };
+      }
+      if (selection.proposed.length === 0) {
+        await failRun("selection finished with no accepted events");
+        return { kind: "aborted", reason: "selection finished with no accepted events" };
+      }
+      const approved = await input.callbacks.reviewEvents(selection.proposed);
+      if (approved === null) {
+        await failRun("selection rejected by user");
+        return { kind: "aborted", reason: "selection rejected by user" };
+      }
+      if (approved.length === 0) {
+        await failRun("no events accepted for instrumentation");
+        return { kind: "aborted", reason: "no events accepted for instrumentation" };
+      }
+      const approvedCodes = new Set(approved.map((event) => event.code));
+      for (const event of selection.proposed) {
+        if (!approvedCodes.has(event.code) && !state.tombstonedCodes.includes(event.code)) {
+          state.tombstonedCodes.push(event.code);
+        }
+      }
+      persist();
+      await patchPhase("persisting", `registering ${approved.length} events`);
       registered = await registerApprovedEvents(runs, runId, approved, input.sink);
+      state.designComplete = true;
+      state.clusters = deriveClusters(placementsFor(registered));
+      persist();
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
-      await failRun(`event registration failed: ${reason}`);
-      persist();
-      return { kind: "aborted", reason: `event registration failed: ${reason}` };
+      await failRun(`design failed: ${reason}`);
+      return { kind: "aborted", reason: `design failed: ${reason}` };
     }
-    state.designComplete = true;
-    state.clusters = deriveClusters(placementsFor(registered));
-    persist();
   } else {
     registered = rebuildRegistered(state, bootstrap);
     input.sink.emit({ phase: "designing", action: `resumed with ${registered.length} registered events` });
   }
   if (registered.length === 0) {
-    await patchPhase("reporting", "no events registered for this project");
-    await completeRun(runs, runId, [], /* @__PURE__ */ new Map(), [], true, "unavailable", void 0);
-    return {
-      kind: "completed",
-      runId,
-      registered,
-      eventStatuses: /* @__PURE__ */ new Map(),
-      reportEvents: [],
-      changedFiles: [],
-      identifyWired: false,
-      applied: false,
-      summary: "No important events found for this project; nothing was instrumented."
-    };
+    await failRun("no events registered for this project");
+    return { kind: "aborted", reason: "no events registered for this project" };
   }
   await patchPhase("binding");
   let worktree;
@@ -2713,16 +2791,13 @@ function buildEvidence(registered, statuses, changedFiles2) {
   });
 }
 async function completeRun(runs, runId, evidence, _statuses, changedFiles2, identifyWired, verificationStatus, verificationCommand2) {
-  try {
-    await runs.completeRun(runId, {
-      changedFiles: changedFiles2,
-      identifyWired,
-      verificationStatus,
-      ...verificationCommand2 ? { verificationCommand: verificationCommand2 } : {},
-      events: evidence
-    });
-  } catch {
-  }
+  await runs.completeRun(runId, {
+    changedFiles: changedFiles2,
+    identifyWired,
+    verificationStatus,
+    ...verificationCommand2 ? { verificationCommand: verificationCommand2 } : {},
+    events: evidence
+  });
 }
 function buildReportEvents(registered, statuses) {
   return registered.map((event) => {
@@ -3113,6 +3188,12 @@ var WRITE_OUTSIDE_REPO_DENIAL = "blocked: writes must stay inside the target rep
 var SENSITIVE_WRITE_DENIAL = "blocked: refusing to write CI/git configuration";
 var BASH_ALLOWLIST_DENIAL = "blocked: command is outside the Bash allowlist - use package install/add commands, mkdir, or git status/diff/log only";
 var CHAINED_COMMAND_DENIAL = "blocked: chained or substituted shell command - run one command at a time";
+function engineMcpToolName(toolName) {
+  return `mcp__engine__${toolName}`;
+}
+function trustedEngineMcpTools(tools) {
+  return new Set(tools.map((tool2) => engineMcpToolName(tool2.name)));
+}
 var ENV_EXAMPLES = /* @__PURE__ */ new Set([".env.example", ".env.sample", ".env.template"]);
 var SECRET_DIRECTORIES = /* @__PURE__ */ new Set([".aws", ".ssh", ".gnupg"]);
 var SECRET_EXACT_FILES = /* @__PURE__ */ new Set([".netrc", ".npmrc", ".pypirc"]);
@@ -3137,6 +3218,9 @@ var JS_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]
 var PYTHON_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["pip", "pip3", "poetry", "uv"]);
 var RUBY_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["gem", "bundle"]);
 function evaluateToolUse(toolName, input, context) {
+  if (context.trustedTools?.has(toolName)) {
+    return { behavior: "allow" };
+  }
   switch (toolName) {
     case "Read":
       return evaluateReadLike(readPathInputs(input), readPathInputs(input), context);
@@ -4168,7 +4252,7 @@ async function runPass(opts) {
   }
   return { summary, costUsd, ok, maxedOut };
 }
-function buildToolPolicyHooks(repoPath) {
+function buildToolPolicyHooks(repoPath, trustedTools) {
   return {
     PreToolUse: [
       {
@@ -4176,7 +4260,8 @@ function buildToolPolicyHooks(repoPath) {
           async (input) => {
             if (input.hook_event_name !== "PreToolUse") return { continue: true };
             const decision = evaluateToolUse(input.tool_name, toolInputRecord(input.tool_input), {
-              repoPath
+              repoPath,
+              trustedTools
             });
             if (decision.behavior === "allow") {
               return { continue: true };
@@ -4194,9 +4279,9 @@ function buildToolPolicyHooks(repoPath) {
     ]
   };
 }
-function createToolPermissionCallback(repoPath) {
+function createToolPermissionCallback(repoPath, trustedTools) {
   return async (toolName, input, options) => {
-    const decision = evaluateToolUse(toolName, input, { repoPath });
+    const decision = evaluateToolUse(toolName, input, { repoPath, trustedTools });
     return decision.behavior === "allow" ? { behavior: "allow", toolUseID: options.toolUseID } : {
       behavior: "deny",
       message: decision.message,
@@ -4275,9 +4360,10 @@ function createClaudeProvider(config, session) {
           return { content: [{ type: "text", text: JSON.stringify(result) }] };
         })
       );
+      const trustedTools = trustedEngineMcpTools(invocation.tools);
       const allowedTools = [
         ...invocation.allowRepoWrite ? EDIT_TOOLS : READ_ONLY_TOOLS2,
-        ...invocation.tools.map((engineTool) => `mcp__engine__${engineTool.name}`)
+        ...trustedTools
       ];
       let sessionId = invocation.resumeSessionId;
       let costUsd = 0;
@@ -4295,8 +4381,8 @@ function createClaudeProvider(config, session) {
             ...roleConfig.effort ? { effort: roleConfig.effort } : {},
             tools: [...allowedTools],
             ...hostTools.length > 0 ? { mcpServers: { engine: createSdkMcpServer({ name: "engine", tools: hostTools }) } } : {},
-            hooks: buildToolPolicyHooks(invocation.cwd),
-            canUseTool: createToolPermissionCallback(invocation.cwd),
+            hooks: buildToolPolicyHooks(invocation.cwd, trustedTools),
+            canUseTool: createToolPermissionCallback(invocation.cwd, trustedTools),
             maxTurns: roleConfig.maxTurns,
             ...invocation.resumeSessionId ? { resume: invocation.resumeSessionId } : {},
             settingSources: []
@@ -4798,8 +4884,8 @@ async function fetchSuggestions(config, session, statuses) {
 }
 function isSuggestionRecord(value) {
   if (typeof value !== "object" || value === null) return false;
-  const record = value;
-  return typeof record.id === "string" && (record.kind === "event" || record.kind === "intervention") && typeof record.code === "string" && (record.status === "proposed" || record.status === "approved" || record.status === "rejected" || record.status === "integrated") && typeof record.payload === "object" && record.payload !== null;
+  const record2 = value;
+  return typeof record2.id === "string" && (record2.kind === "event" || record2.kind === "intervention") && typeof record2.code === "string" && (record2.status === "proposed" || record2.status === "approved" || record2.status === "rejected" || record2.status === "integrated") && typeof record2.payload === "object" && record2.payload !== null;
 }
 async function markSuggestionIntegrated(config, session, id, target9, repoFingerprint2) {
   if (config.offline) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whisperr/wizard",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Whisperr Wizard \u2014 one command to integrate the Whisperr SDK into your app. Authenticates with your onboarded account and uses an AI coding agent to wire up identify() and your business events automatically.",
   "repository": {
     "type": "git",