@jango-blockchained/hoox-cli 0.5.1 → 0.5.2

package/src/commands/dev/dev-command.test.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Unit tests for the dev command.
  *
@@ -64,39 +63,39 @@ beforeEach(() => {
   process.exitCode = undefined;
 
   // Restore prototypes to originals
-  (ConfigService.prototype as Record<string, unknown>).load = origLoad;
-  (ConfigService.prototype as Record<string, unknown>).listWorkers =
+  (ConfigService.prototype as unknown as Record<string, unknown>).load =
+    origLoad;
+  (ConfigService.prototype as unknown as Record<string, unknown>).listWorkers =
     origListWorkers;
-  (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-    origListEnabled;
-  (ConfigService.prototype as Record<string, unknown>).getWorker =
+  (
+    ConfigService.prototype as unknown as Record<string, unknown>
+  ).listEnabledWorkers = origListEnabled;
+  (ConfigService.prototype as unknown as Record<string, unknown>).getWorker =
     origGetWorker;
-  (ConfigService.prototype as Record<string, unknown>).validate = origValidate;
-  (CloudflareService.prototype as Record<string, unknown>).dev = origDev;
+  (ConfigService.prototype as unknown as Record<string, unknown>).validate =
+    origValidate;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).dev =
+    origDev;
 
   // Stub Bun.spawn to prevent actual process spawning during tests.
   // Uses individual property assignment (not globalThis.Bun = {...}) to
   // avoid "readonly property" errors in Bun 1.3.x.
-  (Bun as unknown as Record<string, unknown>).spawn = mock(() => ({
+  (Bun as unknown as unknown as Record<string, unknown>).spawn = mock(() => ({
     stdout: new Blob([]),
     stderr: new Blob([]),
     exited: Promise.resolve(0),
     stdin: { write: mock(() => {}), end: mock(() => {}) },
     kill: mock(() => {}),
   }));
-  (Bun as unknown as Record<string, unknown>).file = mock((_path: string) => ({
-    exists: mock(async () => true),
-  }));
-
   // Fresh mocks
   devMock = mock(async (_path: string, _port?: number) => ({
     ok: true as const,
-    data: { port: _port ?? 8787 },
+    value: { port: _port ?? 8787 },
   }));
 
-  loadMock = mock(async function () {
+  loadMock = mock(async function (this: ConfigService) {
     // Use a regular function so `this` refers to the ConfigService instance
-    (this as Record<string, unknown>).config = {};
+    (this as unknown as Record<string, unknown>).config = {};
     return {} as Record<string, unknown>;
   });
   listWorkersMock = mock(() => ["hoox", "trade-worker", "d1-worker"]);
@@ -114,52 +113,66 @@ beforeEach(() => {
   composeExistsMock = mock(async () => false);
 
   // Install mocks on prototypes
-  (ConfigService.prototype as Record<string, unknown>).load = loadMock;
-  (ConfigService.prototype as Record<string, unknown>).listWorkers =
+  (ConfigService.prototype as unknown as Record<string, unknown>).load =
+    loadMock;
+  (ConfigService.prototype as unknown as Record<string, unknown>).listWorkers =
     listWorkersMock;
-  (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-    listEnabledWorkersMock;
-  (ConfigService.prototype as Record<string, unknown>).getWorker =
+  (
+    ConfigService.prototype as unknown as Record<string, unknown>
+  ).listEnabledWorkers = listEnabledWorkersMock;
+  (ConfigService.prototype as unknown as Record<string, unknown>).getWorker =
     getWorkerMock;
-  (ConfigService.prototype as Record<string, unknown>).validate = validateMock;
-  (ConfigService.prototype as Record<string, unknown>).getDevRuntime =
-    getDevRuntimeMock;
-  (CloudflareService.prototype as Record<string, unknown>).dev = devMock;
+  (ConfigService.prototype as unknown as Record<string, unknown>).validate =
+    validateMock;
+  (
+    ConfigService.prototype as unknown as Record<string, unknown>
+  ).getDevRuntime = getDevRuntimeMock;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).dev =
+    devMock;
   (
-    PrerequisitesService.prototype as Record<string, unknown>
+    PrerequisitesService.prototype as unknown as Record<string, unknown>
   ).checkWranglerVersion = checkWranglerMock;
-  (DockerService.prototype as Record<string, unknown>).checkAvailability =
-    dockerCheckMock;
-  (DockerService.prototype as Record<string, unknown>).composeFileExists =
-    composeExistsMock;
+  (
+    DockerService.prototype as unknown as Record<string, unknown>
+  ).checkAvailability = dockerCheckMock;
+  (
+    DockerService.prototype as unknown as Record<string, unknown>
+  ).composeFileExists = composeExistsMock;
 });
 
 afterEach(() => {
   mock.restore();
 
   // Restore originals
-  (ConfigService.prototype as Record<string, unknown>).load = origLoad;
-  (ConfigService.prototype as Record<string, unknown>).listWorkers =
+  (ConfigService.prototype as unknown as Record<string, unknown>).load =
+    origLoad;
+  (ConfigService.prototype as unknown as Record<string, unknown>).listWorkers =
     origListWorkers;
-  (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-    origListEnabled;
-  (ConfigService.prototype as Record<string, unknown>).getWorker =
+  (
+    ConfigService.prototype as unknown as Record<string, unknown>
+  ).listEnabledWorkers = origListEnabled;
+  (ConfigService.prototype as unknown as Record<string, unknown>).getWorker =
     origGetWorker;
-  (ConfigService.prototype as Record<string, unknown>).validate = origValidate;
-  (ConfigService.prototype as Record<string, unknown>).getDevRuntime =
-    origGetDevRuntime;
-  (CloudflareService.prototype as Record<string, unknown>).dev = origDev;
+  (ConfigService.prototype as unknown as Record<string, unknown>).validate =
+    origValidate;
+  (
+    ConfigService.prototype as unknown as Record<string, unknown>
+  ).getDevRuntime = origGetDevRuntime;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).dev =
+    origDev;
   (
-    PrerequisitesService.prototype as Record<string, unknown>
+    PrerequisitesService.prototype as unknown as Record<string, unknown>
   ).checkWranglerVersion = origCheckWrangler;
-  (DockerService.prototype as Record<string, unknown>).checkAvailability =
-    origDockerCheck;
-  (DockerService.prototype as Record<string, unknown>).composeFileExists =
-    origComposeExists;
+  (
+    DockerService.prototype as unknown as Record<string, unknown>
+  ).checkAvailability = origDockerCheck;
+  (
+    DockerService.prototype as unknown as Record<string, unknown>
+  ).composeFileExists = origComposeExists;
 
   // Restore Bun globals (individual property restore)
-  (Bun as unknown as Record<string, unknown>).spawn = origBunSpawn;
-  (Bun as unknown as Record<string, unknown>).file = origBunFile;
+  (Bun as unknown as unknown as Record<string, unknown>).spawn = origBunSpawn;
+  (Bun as unknown as unknown as Record<string, unknown>).file = origBunFile;
 });
 
 // ---------------------------------------------------------------------------
@@ -187,7 +200,8 @@ async function createProgram(): Promise<Command> {
 /** Make devMock return a failure for all subsequent calls. */
 function makeDevFail(error: string): void {
   devMock = mock(async () => ({ ok: false as const, error }));
-  (CloudflareService.prototype as Record<string, unknown>).dev = devMock;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).dev =
+    devMock;
 }
 
 // ---------------------------------------------------------------------------
@@ -237,7 +251,7 @@ describe("registerDevCommand", () => {
         valid: false,
         errors: ["global.cloudflare_account_id is required"],
       }));
-      (ConfigService.prototype as Record<string, unknown>).validate =
+      (ConfigService.prototype as unknown as Record<string, unknown>).validate =
         validateMock;
 
       const program = await createProgram();
@@ -248,8 +262,9 @@ describe("registerDevCommand", () => {
 
     it("handles no enabled workers gracefully", async () => {
       listEnabledWorkersMock = mock(() => []);
-      (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-        listEnabledWorkersMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).listEnabledWorkers = listEnabledWorkersMock;
 
       const program = await createProgram();
       await program.parseAsync(["dev", "start"], { from: "user" });
@@ -259,8 +274,9 @@ describe("registerDevCommand", () => {
 
     it("starts all enabled workers on assigned ports", async () => {
       listEnabledWorkersMock = mock(() => ["hoox", "trade-worker"]);
-      (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-        listEnabledWorkersMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).listEnabledWorkers = listEnabledWorkersMock;
 
       const program = await createProgram();
       await program.parseAsync(["dev", "start"], { from: "user" });
@@ -306,8 +322,9 @@ describe("registerDevCommand", () => {
 
     it("handles unknown worker name", async () => {
       getWorkerMock = mock(() => undefined);
-      (ConfigService.prototype as Record<string, unknown>).getWorker =
-        getWorkerMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).getWorker = getWorkerMock;
 
       const program = await createProgram();
       await program.parseAsync(["dev", "worker", "nonexistent"], {
@@ -323,8 +340,9 @@ describe("registerDevCommand", () => {
         enabled: false,
         path: "workers/disabled-worker",
       }));
-      (ConfigService.prototype as Record<string, unknown>).getWorker =
-        getWorkerMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).getWorker = getWorkerMock;
 
       const program = await createProgram();
       await program.parseAsync(["dev", "worker", "disabled-worker"], {
@@ -341,8 +359,9 @@ describe("registerDevCommand", () => {
         enabled: true,
         path: "workers/hoox",
       }));
-      (ConfigService.prototype as Record<string, unknown>).getWorker =
-        getWorkerMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).getWorker = getWorkerMock;
 
       const program = await createProgram();
       await program.parseAsync(["dev", "worker", "hoox"], { from: "user" });
@@ -356,9 +375,11 @@ describe("registerDevCommand", () => {
   describe("dev dashboard", () => {
     it("handles missing dashboard directory", async () => {
       // Override Bun.file for this test to say dashboard doesn't exist
-      (Bun as unknown as Record<string, unknown>).file = mock((_p: string) => ({
-        exists: mock(async () => false),
-      }));
+      (Bun as unknown as unknown as Record<string, unknown>).file = mock(
+        (_p: string) => ({
+          exists: mock(async () => false),
+        })
+      );
 
       const program = await createProgram();
       await program.parseAsync(["dev", "dashboard"], { from: "user" });
@@ -373,7 +394,8 @@ describe("registerDevCommand", () => {
     loadMock = mock(async () => {
       throw new Error("Config file not found");
     });
-    (ConfigService.prototype as Record<string, unknown>).load = loadMock;
+    (ConfigService.prototype as unknown as Record<string, unknown>).load =
+      loadMock;
 
     const program = await createProgram();
     await program.parseAsync(["dev", "start"], { from: "user" });

package/src/commands/disclaimer/disclaimer-command.ts

@@ -0,0 +1,21 @@
+/**
+ * `hoox disclaimer` command — displays legal disclaimers and trademark information.
+ *
+ * Uses the centralized legal notices from @jango-blockchained/hoox-shared/legal
+ * so all surfaces (CLI, HTTP, Dashboard) stay consistent.
+ */
+
+import type { Command } from "commander";
+import { FULL_LEGAL_NOTICE } from "@jango-blockchained/hoox-shared/legal";
+
+/**
+ * Registers the `hoox disclaimer` command on the given Commander.js program instance.
+ */
+export function registerDisclaimerCommand(program: Command): void {
+  program
+    .command("disclaimer")
+    .description("Display legal disclaimers and trademark information")
+    .action(() => {
+      console.log(FULL_LEGAL_NOTICE);
+    });
+}

package/src/commands/disclaimer/index.ts

@@ -0,0 +1 @@
+export { registerDisclaimerCommand } from "./disclaimer-command.js";

package/src/commands/init/init-command.test.ts

@@ -8,7 +8,6 @@
  *  - process.exit        → captured exit codes
  */
 
-// @ts-nocheck — spyOn on module namespace requires type bypasses for strict signatures
 import {
   afterEach,
   beforeEach,
@@ -123,8 +122,6 @@ let customPasswordResponder: ((msg: string) => string | symbol) | null = null;
 // Mock: CloudflareService (prototype based — no mock.module, no leakage)
 // ---------------------------------------------------------------------------
 
-const origWhoami = CloudflareService.prototype.whoami;
-
 const mockWhoami = mock(
   async (): Promise<
     { ok: true; value: string } | { ok: false; error: string }
@@ -141,16 +138,19 @@ const mockWhoami = mock(
 import * as clack from "@clack/prompts";
 
 function installClackSpies(): void {
-  spyOn(clack, "intro").mockImplementation((msg: string) => {
-    captured.intro.push(msg);
-  });
-  spyOn(clack, "outro").mockImplementation((msg: string) => {
-    captured.outro.push(msg);
+  spyOn(clack, "intro").mockImplementation((msg?: string) => {
+    captured.intro.push(msg ?? "");
   });
-  spyOn(clack, "note").mockImplementation((content: string, title?: string) => {
-    captured.note.push({ title: title ?? "", content });
+  spyOn(clack, "outro").mockImplementation((msg?: string) => {
+    captured.outro.push(msg ?? "");
   });
+  spyOn(clack, "note").mockImplementation(
+    (content?: string, title?: string) => {
+      captured.note.push({ title: title ?? "", content: content ?? "" });
+    }
+  );
   spyOn(clack, "password").mockImplementation(
+    // @ts-expect-error — mock validate fn signature simplified vs clack's PasswordOptions
     async (opts: {
       message: string;
       validate?: (v: string) => string | void;
@@ -163,6 +163,7 @@ function installClackSpies(): void {
     }
   );
   spyOn(clack, "text").mockImplementation(
+    // @ts-expect-error — mock validate fn signature simplified vs clack's TextOptions
     async (opts: {
       message: string;
       placeholder?: string;
@@ -177,6 +178,7 @@ function installClackSpies(): void {
     }
   );
   spyOn(clack, "multiselect").mockImplementation(
+    // @ts-expect-error — clack's multiselect is generic, mock uses concrete types
     async (opts: {
       message: string;
       options: { value: string; label: string; hint?: string }[];
@@ -190,6 +192,7 @@ function installClackSpies(): void {
     }
   );
   spyOn(clack, "select").mockImplementation(
+    // @ts-expect-error — clack's select is generic, mock uses concrete types
     async (opts: {
       message: string;
       options: { value: string; label: string; hint?: string }[];
@@ -212,6 +215,7 @@ function installClackSpies(): void {
     }
   );
   spyOn(clack, "group").mockImplementation(
+    // @ts-expect-error — clack's group uses PromptGroup<T>, not Record<string, () => Promise<...>>
     async (
       fields: Record<string, () => Promise<string | symbol>>,
       groupOpts?: { onCancel?: () => void }
@@ -233,31 +237,33 @@ function installClackSpies(): void {
       return results;
     }
   );
-  spyOn(clack, "isCancel").mockImplementation((value: unknown) => {
-    return (
-      simulateCancel ||
-      (typeof value === "symbol" &&
-        Symbol.keyFor(value as symbol) === "clack.cancel")
-    );
+  spyOn(clack, "isCancel").mockImplementation(
+    (value: unknown): value is symbol => {
+      return (
+        simulateCancel ||
+        (typeof value === "symbol" &&
+          Symbol.keyFor(value as symbol) === "clack.cancel")
+      );
+    }
+  );
+  spyOn(clack, "cancel").mockImplementation((msg?: string) => {
+    captured.cancelMessages.push(msg ?? "");
   });
-  spyOn(clack, "cancel").mockImplementation((msg: string) => {
-    captured.cancelMessages.push(msg);
+  spyOn(clack.log, "info").mockImplementation((msg?: string) => {
+    captured.logInfo.push(msg ?? "");
+  });
+  spyOn(clack.log, "step").mockImplementation((msg?: string) => {
+    captured.logStep.push(msg ?? "");
+  });
+  spyOn(clack.log, "success").mockImplementation((msg?: string) => {
+    captured.logSuccess.push(msg ?? "");
+  });
+  spyOn(clack.log, "warn").mockImplementation((msg?: string) => {
+    captured.logWarn.push(msg ?? "");
+  });
+  spyOn(clack.log, "error").mockImplementation((msg?: string) => {
+    captured.logError.push(msg ?? "");
   });
-  spyOn(clack.log, "info").mockImplementation((msg: string) =>
-    captured.logInfo.push(msg)
-  );
-  spyOn(clack.log, "step").mockImplementation((msg: string) =>
-    captured.logStep.push(msg)
-  );
-  spyOn(clack.log, "success").mockImplementation((msg: string) =>
-    captured.logSuccess.push(msg)
-  );
-  spyOn(clack.log, "warn").mockImplementation((msg: string) =>
-    captured.logWarn.push(msg)
-  );
-  spyOn(clack.log, "error").mockImplementation((msg: string) =>
-    captured.logError.push(msg)
-  );
 }
 
 // ---------------------------------------------------------------------------
@@ -274,7 +280,7 @@ beforeEach(() => {
   customPasswordResponder = null;
   mockWhoami.mockImplementation(async () => ({
     ok: true,
-    data: "user@example.com",
+    value: "user@example.com",
   }));
 
   // Mock: CloudflareService prototype
@@ -376,7 +382,7 @@ describe("init command", () => {
         if (callCount === 1) {
           return { ok: false as const, error: "Invalid credentials" };
         }
-        return { ok: true as const, data: "user@example.com" };
+        return { ok: true as const, value: "user@example.com" };
       });
 
       // First password call returns bad token, second returns good token
@@ -460,9 +466,9 @@ describe("init command", () => {
         select: "full", // full preset includes integrations
         confirmSequence: [true, false, false],
         group: {
-          BINANCE_API_KEY: "binance-key-123",
-          BINANCE_API_SECRET: "binance-secret-123",
-          TELEGRAM_BOT_TOKEN: "tg-bot-token-123",
+          BINANCE_KEY_BINDING: "binance-key-123",
+          BINANCE_SECRET_BINDING: "binance-secret-123",
+          TG_BOT_TOKEN_BINDING: "tg-bot-token-123",
         },
       };
 
@@ -483,7 +489,7 @@ describe("init command", () => {
         select: "full",
         confirmSequence: [true, false, false],
         group: {
-          TELEGRAM_BOT_TOKEN: "tg-token-abc",
+          TG_BOT_TOKEN_BINDING: "tg-token-abc",
         },
       };
 
@@ -526,28 +532,14 @@ describe("init command", () => {
         error: "Bad token",
       }));
 
-      // Override process.exit to capture and throw (halts execution)
-      let exitCode = -1;
-      process.exit = mock((code?: number) => {
-        exitCode = code ?? -1;
-        throw new Error("EXIT");
-      }) as unknown as typeof process.exit;
-
       const options: InitOptions = {
         token: "bad-token",
         account: "abc123def456abc123def456abc123de",
       };
 
-      const promise = runInitCommand(
-        options,
-        { json: false, quiet: true },
-        true
-      );
-      await promise.catch(() => {
-        /* expected */
-      });
+      await runInitCommand(options, { json: false, quiet: true }, true);
 
-      expect(exitCode).toBe(ExitCode.ERROR);
+      expect(process.exitCode).toBe(ExitCode.ERROR);
     });
 
     it("writes wrangler.jsonc in non-interactive mode", async () => {
@@ -616,9 +608,9 @@ describe("init command", () => {
         select: "full",
         confirmSequence: [true, false, false],
         group: {
-          BINANCE_API_KEY: "bk",
-          BINANCE_API_SECRET: "bs",
-          TELEGRAM_BOT_TOKEN: "tgt",
+          BINANCE_KEY_BINDING: "bk",
+          BINANCE_SECRET_BINDING: "bs",
+          TG_BOT_TOKEN_BINDING: "tgt",
         },
       };
 
@@ -627,10 +619,10 @@ describe("init command", () => {
       const workersJsonc = captured.writes["wrangler.jsonc"];
       expect(workersJsonc).toBeDefined();
       expect(workersJsonc).toContain('"trade-worker"');
-      expect(workersJsonc).toContain('"BINANCE_API_KEY"');
-      expect(workersJsonc).toContain('"BINANCE_API_SECRET"');
+      expect(workersJsonc).toContain('"BINANCE_KEY_BINDING"');
+      expect(workersJsonc).toContain('"BINANCE_SECRET_BINDING"');
       expect(workersJsonc).toContain('"telegram-worker"');
-      expect(workersJsonc).toContain('"TELEGRAM_BOT_TOKEN"');
+      expect(workersJsonc).toContain('"TG_BOT_TOKEN_BINDING"');
     });
 
     it("includes AI provider (OpenAI) integration from full preset", async () => {
@@ -641,7 +633,7 @@ describe("init command", () => {
         select: "full",
         confirmSequence: [true, false, false],
         group: {
-          AGENT_OPENAI_KEY: "sk-openai-123",
+          AGENT_INTERNAL_KEY: "sk-openai-123",
         },
       };
 
@@ -650,7 +642,7 @@ describe("init command", () => {
       const workersJsonc = captured.writes["wrangler.jsonc"];
       expect(workersJsonc).toBeDefined();
       expect(workersJsonc).toContain('"agent-worker"');
-      expect(workersJsonc).toContain('"AGENT_OPENAI_KEY"');
+      expect(workersJsonc).toContain('"AGENT_INTERNAL_KEY"');
     });
 
     it("includes wallet integration from full preset", async () => {
@@ -681,10 +673,10 @@ describe("init command", () => {
         select: "full",
         confirmSequence: [true, false, false],
         group: {
-          BINANCE_API_KEY: "bk",
-          BINANCE_API_SECRET: "bs",
-          MEXC_API_KEY: "mk",
-          MEXC_API_SECRET: "ms",
+          BINANCE_KEY_BINDING: "bk",
+          BINANCE_SECRET_BINDING: "bs",
+          MEXC_KEY_BINDING: "mk",
+          MEXC_SECRET_BINDING: "ms",
         },
       };
 
@@ -693,8 +685,8 @@ describe("init command", () => {
       const workersJsonc = captured.writes["wrangler.jsonc"];
       expect(workersJsonc).toBeDefined();
       expect(workersJsonc).toContain('"trade-worker"');
-      expect(workersJsonc).toContain('"BINANCE_API_KEY"');
-      expect(workersJsonc).toContain('"MEXC_API_KEY"');
+      expect(workersJsonc).toContain('"BINANCE_KEY_BINDING"');
+      expect(workersJsonc).toContain('"MEXC_KEY_BINDING"');
       // Should only appear once
       const tradeWorkerCount =
         workersJsonc.match(/"trade-worker"/g)?.length ?? 0;
@@ -751,7 +743,7 @@ describe("init command", () => {
         select: "full",
         confirmSequence: [true, false, false],
         group: {
-          TELEGRAM_BOT_TOKEN: "tg-secret-value",
+          TG_BOT_TOKEN_BINDING: "tg-secret-value",
         },
       };
 
@@ -760,7 +752,7 @@ describe("init command", () => {
       const devVarsPath = "workers/telegram-worker/.dev.vars";
       const devVars = captured.writes[devVarsPath];
       expect(devVars).toBeDefined();
-      expect(devVars).toContain("TELEGRAM_BOT_TOKEN=tg-secret-value");
+      expect(devVars).toContain("TG_BOT_TOKEN_BINDING=tg-secret-value");
       expect(devVars).toContain("NEVER commit this file");
     });
 
@@ -788,7 +780,7 @@ describe("init command", () => {
         select: "full",
         confirmSequence: [true, false, false],
         group: {
-          AGENT_OPENAI_KEY: "sk-openai-real-value",
+          AGENT_INTERNAL_KEY: "sk-openai-real-value",
         },
       };
 
@@ -797,7 +789,7 @@ describe("init command", () => {
       const devVarsPath = "workers/agent-worker/.dev.vars";
       const devVars = captured.writes[devVarsPath];
       expect(devVars).toBeDefined();
-      expect(devVars).toContain("AGENT_OPENAI_KEY=sk-openai-real-value");
+      expect(devVars).toContain("AGENT_INTERNAL_KEY=sk-openai-real-value");
       expect(devVars).toContain("NEVER commit this file");
     });
 
@@ -829,26 +821,12 @@ describe("init command", () => {
 
   describe("cancellation handling", () => {
     it("exits on cancel during risk acknowledgment", async () => {
-      let exitCalled = false;
-      let exitCode = -1;
-      const exitMock = mock((code?: number) => {
-        exitCalled = true;
-        exitCode = code ?? -1;
-        throw new Error("EXIT"); // Must throw to stop execution flow
-      });
-      process.exit = exitMock as unknown as typeof process.exit;
+      // Make the first confirm return false (user declines the risk terms)
+      responses.confirmSequence = [false];
 
-      // First confirm (risk) is canceled
-      simulateCancel = true;
-
-      try {
-        await runInitCommand({}, { json: false, quiet: true }, false);
-      } catch {
-        // expected — process.exit throws
-      }
+      await runInitCommand({}, { json: false, quiet: true }, false);
 
-      expect(exitCalled).toBe(true);
-      expect(exitCode).toBe(0);
+      expect(process.exitCode).toBe(0);
     });
   });