docks-kit 0.17.0 → 0.17.2

package/cli/src/engine-native/os/index.ts

@@ -1,24 +1,24 @@
-import { darwin } from "./darwin"
-import { linux } from "./linux"
-import type { HostOs, PlatformName } from "./types"
-import { windows } from "./windows"
+import { darwin } from "./darwin";
+import { linux } from "./linux";
+import type { HostOs, PlatformName } from "./types";
+import { windows } from "./windows";
 
-export * from "./types"
+export * from "./types";
 
 export function rawPlatform(): NodeJS.Platform {
-  return process.platform
+  return process.platform;
 }
 
 export function platformName(pf: NodeJS.Platform = rawPlatform()): PlatformName {
   switch (pf) {
     case "linux":
-      return "linux"
+      return "linux";
     case "darwin":
-      return "darwin"
+      return "darwin";
     case "win32":
-      return "windows"
+      return "windows";
     default:
-      return "unknown"
+      return "unknown";
   }
 }
 
@@ -27,16 +27,16 @@ const unknown: HostOs = {
   ...linux,
   id: "unknown",
   toolchainOs: "",
-  supportsBubblewrap: false
-}
+  supportsBubblewrap: false,
+};
 
 const HOSTS: Readonly<Record<PlatformName, HostOs>> = {
   linux,
   darwin,
   windows,
-  unknown
-}
+  unknown,
+};
 
 export function hostOs(id: PlatformName = platformName()): HostOs {
-  return HOSTS[id]
+  return HOSTS[id];
 }

package/cli/src/engine-native/os/linux.ts

@@ -1,5 +1,5 @@
-import { posixHost } from "./posix"
-import type { HostOs } from "./types"
+import { posixHost } from "./posix";
+import type { HostOs } from "./types";
 
 export const linux: HostOs = posixHost({
   id: "linux",
@@ -9,6 +9,6 @@ export const linux: HostOs = posixHost({
     git: "sudo apt install -y git (or your distro's package manager)",
     jq: "sudo apt install -y jq",
     curl: "sudo apt install -y curl",
-    ffplay: "sudo apt install -y ffmpeg"
-  }
-})
+    ffplay: "sudo apt install -y ffmpeg",
+  },
+});

package/cli/src/engine-native/os/posix.ts

@@ -1,24 +1,26 @@
 // No import from "../exec": exec.ts imports "./os", which evaluates linux and darwin
 // through this module. A slash join keeps the same host-stable path p() would produce.
-import type { HintedTool, HostOs } from "./types"
+import type { HintedTool, HostOs } from "./types";
 
 function posixLiteral(value: string): string {
-  return `'${value.replaceAll("'", `'"'"'`)}'`
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
 
 /** Package-manager hints for the tools a POSIX host installs through its own package manager. */
-export type PackageManagerHints = Readonly<Record<Exclude<HintedTool, "claude" | "codex">, string>>
+export type PackageManagerHints = Readonly<Record<Exclude<HintedTool, "claude" | "codex">, string>>;
 
 const UPSTREAM_INSTALLER_HINTS: Readonly<Record<"claude" | "codex", string>> = {
-  claude: "curl -fsSL https://claude.ai/install.sh -o /tmp/claude-install.sh && bash /tmp/claude-install.sh",
-  codex: 'tmp=$(mktemp) && curl -fsSL https://chatgpt.com/codex/install.sh -o "$tmp" && CODEX_NON_INTERACTIVE=1 sh "$tmp"'
-}
+  claude:
+    "curl -fsSL https://claude.ai/install.sh -o /tmp/claude-install.sh && bash /tmp/claude-install.sh",
+  codex:
+    'tmp=$(mktemp) && curl -fsSL https://chatgpt.com/codex/install.sh -o "$tmp" && CODEX_NON_INTERACTIVE=1 sh "$tmp"',
+};
 
 interface PosixHostInputs {
-  readonly id: HostOs["id"]
-  readonly toolchainOs: HostOs["toolchainOs"]
-  readonly supportsBubblewrap: boolean
-  readonly packageManagerHints: PackageManagerHints
+  readonly id: HostOs["id"];
+  readonly toolchainOs: HostOs["toolchainOs"];
+  readonly supportsBubblewrap: boolean;
+  readonly packageManagerHints: PackageManagerHints;
 }
 
 /** Members shared by every POSIX host; linux and darwin differ only in the inputs. */
@@ -32,36 +34,38 @@ export function posixHost(inputs: PosixHostInputs): HostOs {
     invoke: (executablePath, args) => ({ command: executablePath, args }),
     bunExecutableName: "bun",
     bunInstaller: (pin, directory) => {
-      const scriptPath = `${directory}/install.sh`
+      const scriptPath = `${directory}/install.sh`;
       return {
         scriptPath,
         download: {
           command: "curl",
-          args: ["-fsSL", "https://bun.sh/install", "-o", scriptPath]
+          args: ["-fsSL", "https://bun.sh/install", "-o", scriptPath],
         },
         run: {
           command: "bash",
-          args: [scriptPath, `bun-v${pin}`]
-        }
-      }
+          args: [scriptPath, `bun-v${pin}`],
+        },
+      };
     },
     environmentSetting: (name, value) => ({
       kind: "profile",
       candidates: [".zshrc", ".bashrc", ".bash_profile", ".profile", ".zshenv"],
       target: (shell) => {
-        const shellPath = shell ?? "bash"
-        const shellName = shellPath.slice(shellPath.lastIndexOf("/") + 1)
-        return shellName === "zsh" ? ".zshrc" : shellName === "bash" ? ".bashrc" : ".profile"
+        const shellPath = shell ?? "bash";
+        const shellName = shellPath.slice(shellPath.lastIndexOf("/") + 1);
+        return shellName === "zsh" ? ".zshrc" : shellName === "bash" ? ".bashrc" : ".profile";
       },
-      line: `export ${name}=${value}`
+      line: `export ${name}=${value}`,
     }),
     statusLineCommand: (bun, script) => {
-      const bunLiteral = posixLiteral(bun)
-      const scriptLiteral = posixLiteral(script)
-      return `test -x ${bunLiteral} && test -f ${scriptLiteral} && exec ${bunLiteral} ${scriptLiteral} || true`
+      const bunLiteral = posixLiteral(bun);
+      const scriptLiteral = posixLiteral(script);
+      return `test -x ${bunLiteral} && test -f ${scriptLiteral} && exec ${bunLiteral} ${scriptLiteral} || true`;
     },
     failureHookCommand: (command) => command,
     installHint: (tool) =>
-      tool === "claude" || tool === "codex" ? UPSTREAM_INSTALLER_HINTS[tool] : inputs.packageManagerHints[tool]
-  }
+      tool === "claude" || tool === "codex"
+        ? UPSTREAM_INSTALLER_HINTS[tool]
+        : inputs.packageManagerHints[tool],
+  };
 }

package/cli/src/engine-native/os/targets.ts

@@ -8,7 +8,7 @@
  * supported, and `requireSupportedHost` in cli/src/engine.ts admits exactly the
  * platform/arch pairs this table names.
  */
-import { platformName, type PlatformName } from "./index"
+import { platformName, type PlatformName } from "./index";
 
 export type TargetId =
   | "linux-x64"
@@ -16,26 +16,26 @@ export type TargetId =
   | "darwin-x64"
   | "darwin-arm64"
   | "windows-x64"
-  | "windows-arm64"
+  | "windows-arm64";
 
-export type TargetArch = "x64" | "arm64"
+export type TargetArch = "x64" | "arm64";
 
 export interface HostTarget {
-  readonly id: TargetId
-  readonly platform: PlatformName
-  readonly arch: TargetArch
+  readonly id: TargetId;
+  readonly platform: PlatformName;
+  readonly arch: TargetArch;
   /** `bun build --compile --target=` value. */
-  readonly bunTarget: string
+  readonly bunTarget: string;
   /** Compiled binary file name, including the Windows `.exe` suffix. */
-  readonly artifact: string
+  readonly artifact: string;
   /** `uname -s`-`uname -m` keys the Bash launcher matches; empty on Windows. */
-  readonly unameKeys: ReadonlyArray<string>
+  readonly unameKeys: ReadonlyArray<string>;
   /**
    * `$env:PROCESSOR_ARCHITECTURE` values the PowerShell launcher matches; empty
    * off Windows. Windows PowerShell 5.1 runs emulated on ARM64 and reports
    * `AMD64` there, so a launcher must read `PROCESSOR_ARCHITEW6432` first.
    */
-  readonly processorArchitectures: ReadonlyArray<string>
+  readonly processorArchitectures: ReadonlyArray<string>;
 }
 
 const target = (
@@ -43,7 +43,7 @@ const target = (
   platform: PlatformName,
   arch: TargetArch,
   unameKeys: ReadonlyArray<string>,
-  processorArchitectures: ReadonlyArray<string>
+  processorArchitectures: ReadonlyArray<string>,
 ): HostTarget => ({
   id,
   platform,
@@ -51,8 +51,8 @@ const target = (
   bunTarget: `bun-${id}`,
   artifact: platform === "windows" ? `docks-kit-${id}.exe` : `docks-kit-${id}`,
   unameKeys,
-  processorArchitectures
-})
+  processorArchitectures,
+});
 
 export const HOST_TARGETS: ReadonlyArray<HostTarget> = [
   target("linux-x64", "linux", "x64", ["Linux-x86_64"], []),
@@ -60,14 +60,14 @@ export const HOST_TARGETS: ReadonlyArray<HostTarget> = [
   target("darwin-x64", "darwin", "x64", ["Darwin-x86_64"], []),
   target("darwin-arm64", "darwin", "arm64", ["Darwin-arm64"], []),
   target("windows-x64", "windows", "x64", [], ["AMD64"]),
-  target("windows-arm64", "windows", "arm64", [], ["ARM64"])
-]
+  target("windows-arm64", "windows", "arm64", [], ["ARM64"]),
+];
 
 function targetFor(platform: PlatformName, arch: string): HostTarget | undefined {
-  return HOST_TARGETS.find((t) => t.platform === platform && t.arch === arch)
+  return HOST_TARGETS.find((t) => t.platform === platform && t.arch === arch);
 }
 
 /** Resolve the artifact for a raw Node platform/arch pair. */
 export function targetForHost(platform: NodeJS.Platform, arch: string): HostTarget | undefined {
-  return targetFor(platformName(platform), arch)
+  return targetFor(platformName(platform), arch);
 }

package/cli/src/engine-native/os/types.ts

@@ -4,72 +4,72 @@
  * only the order of that fallback chain.
  */
 
-export type PlatformName = "linux" | "darwin" | "windows" | "unknown"
+export type PlatformName = "linux" | "darwin" | "windows" | "unknown";
 /** Directory-link mechanisms, tried in order before the copy fallback. */
-export type DirectoryLinkKind = "symlink" | "junction"
+export type DirectoryLinkKind = "symlink" | "junction";
 /** Tools whose install command differs per host OS. */
-export type HintedTool = "git" | "jq" | "curl" | "ffplay" | "claude" | "codex"
+export type HintedTool = "git" | "jq" | "curl" | "ffplay" | "claude" | "codex";
 
 /** A command plus argv, already shaped for how this host must invoke it. */
 export interface Invocation {
-  readonly command: string
-  readonly args: ReadonlyArray<string>
+  readonly command: string;
+  readonly args: ReadonlyArray<string>;
   /** Preserve a fully quoted Windows command line instead of applying libuv quoting. */
-  readonly windowsVerbatimArguments?: boolean
+  readonly windowsVerbatimArguments?: boolean;
 }
 
 /** How this host persists a user-level environment variable. */
 export type EnvironmentSetting =
   | {
-      readonly kind: "profile"
+      readonly kind: "profile";
       /** Home-relative files scanned for an existing setting. */
-      readonly candidates: ReadonlyArray<string>
+      readonly candidates: ReadonlyArray<string>;
       /** Home-relative file that receives the write for this shell. */
-      readonly target: (shell: string | undefined) => string
+      readonly target: (shell: string | undefined) => string;
       /** Line appended to the target file. */
-      readonly line: string
+      readonly line: string;
     }
   | {
-      readonly kind: "command"
+      readonly kind: "command";
       /** Exits zero when the variable is already persisted. */
-      readonly probe: Invocation
+      readonly probe: Invocation;
       /** Persists the variable. */
-      readonly apply: Invocation
+      readonly apply: Invocation;
       /** Where the value lands, named for the log line. */
-      readonly location: string
+      readonly location: string;
       /** Manual recovery when `apply` fails. */
-      readonly manualHint: string
-    }
+      readonly manualHint: string;
+    };
 
 /** The two steps that fetch and run a pinned Bun installer. */
 export interface BunInstaller {
-  readonly scriptPath: string
-  readonly download: Invocation
-  readonly run: Invocation
+  readonly scriptPath: string;
+  readonly download: Invocation;
+  readonly run: Invocation;
 }
 
 export interface HostOs {
-  readonly id: PlatformName
+  readonly id: PlatformName;
   /** `SoT/toolchain.json` `os` field this host matches; "" matches every row. */
-  readonly toolchainOs: string
+  readonly toolchainOs: string;
   /** Bubblewrap is the Linux-only Codex sandbox runtime. */
-  readonly supportsBubblewrap: boolean
+  readonly supportsBubblewrap: boolean;
   /** Directory-link mechanisms tried in order before `skillsSync.ts linkOrCopy` copies. */
-  readonly directoryLinkKinds: ReadonlyArray<DirectoryLinkKind>
+  readonly directoryLinkKinds: ReadonlyArray<DirectoryLinkKind>;
   /** One-line install command for a tool whose package differs per OS. */
-  readonly installHint: (tool: HintedTool) => string
+  readonly installHint: (tool: HintedTool) => string;
   /** Filename suffixes tried in order when resolving a bare tool name on PATH. */
-  readonly executableSuffixes: ReadonlyArray<string>
+  readonly executableSuffixes: ReadonlyArray<string>;
   /** Shape the argv that actually runs a resolved executable on this host. */
-  readonly invoke: (executablePath: string, args: ReadonlyArray<string>) => Invocation
+  readonly invoke: (executablePath: string, args: ReadonlyArray<string>) => Invocation;
   /** Bun executable filename inside `<bunRoot>/bin`. */
-  readonly bunExecutableName: string
+  readonly bunExecutableName: string;
   /** Download-then-run installer for a pinned Bun version placed in `directory`. */
-  readonly bunInstaller: (pin: string, directory: string) => BunInstaller
+  readonly bunInstaller: (pin: string, directory: string) => BunInstaller;
   /** How this host persists a user-level environment variable. */
-  readonly environmentSetting: (name: string, value: string) => EnvironmentSetting
+  readonly environmentSetting: (name: string, value: string) => EnvironmentSetting;
   /** Claude `statusLine.command` for a resolved bun executable and script. */
-  readonly statusLineCommand: (bun: string, script: string) => string
+  readonly statusLineCommand: (bun: string, script: string) => string;
   /** Reshape the SoT `PostToolUseFailure` command for this host's shell. */
-  readonly failureHookCommand: (command: string) => string
+  readonly failureHookCommand: (command: string) => string;
 }

package/cli/src/engine-native/os/windows.ts

@@ -1,14 +1,14 @@
-import { win32 } from "node:path"
-import { p } from "../exec"
-import type { HostOs } from "./types"
+import { win32 } from "node:path";
+import { p } from "../exec";
+import type { HostOs } from "./types";
 
 function powershellLiteral(value: string): string {
-  return `'${value.replaceAll("'", "''")}'`
+  return `'${value.replaceAll("'", "''")}'`;
 }
 
 function encodedPowerShellCommand(script: string): string {
-  const encoded = Buffer.from(script, "utf16le").toString("base64")
-  return `powershell.exe -NoProfile -NonInteractive -EncodedCommand ${encoded}`
+  const encoded = Buffer.from(script, "utf16le").toString("base64");
+  return `powershell.exe -NoProfile -NonInteractive -EncodedCommand ${encoded}`;
 }
 
 /**
@@ -21,22 +21,22 @@ function encodedPowerShellCommand(script: string): string {
  * https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/
  * https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/cmd
  */
-const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g
+const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
 
 function escapeCommand(arg: string): string {
-  return arg.replace(metaCharsRegExp, "^$1")
+  return arg.replace(metaCharsRegExp, "^$1");
 }
 
 function escapeArgument(arg: string, doubleEscapeMetaChars: boolean): string {
-  arg = `${arg}`
-  arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"")
-  arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1")
-  arg = `"${arg}"`
-  arg = arg.replace(metaCharsRegExp, "^$1")
+  arg = `${arg}`;
+  arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+  arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+  arg = `"${arg}"`;
+  arg = arg.replace(metaCharsRegExp, "^$1");
   if (doubleEscapeMetaChars) {
-    arg = arg.replace(metaCharsRegExp, "^$1")
+    arg = arg.replace(metaCharsRegExp, "^$1");
   }
-  return arg
+  return arg;
 }
 
 function assertCommandLineValue(value: string, kind: "executable path" | "argument"): void {
@@ -46,16 +46,16 @@ function assertCommandLineValue(value: string, kind: "executable path" | "argume
       ? "carriage return (CR)"
       : value.includes("\n")
         ? "line feed (LF)"
-        : undefined
-  if (unsupported === undefined) return
+        : undefined;
+  if (unsupported === undefined) return;
 
   const executablePercentHint =
     kind === "executable path" && unsupported === "percent sign (%)"
       ? " The tool must be reached through its .exe or moved out of a directory whose name contains a percent sign."
-      : ""
+      : "";
   throw new Error(
-    `${kind} ${JSON.stringify(value)} contains a ${unsupported}, which cannot be escaped on a cmd command line; the caller must pass the value another way.${executablePercentHint}`
-  )
+    `${kind} ${JSON.stringify(value)} contains a ${unsupported}, which cannot be escaped on a cmd command line; the caller must pass the value another way.${executablePercentHint}`,
+  );
 }
 
 /**
@@ -65,28 +65,28 @@ function assertCommandLineValue(value: string, kind: "executable path" | "argume
  * when it is an absolute path; otherwise it is rebuilt under SystemRoot.
  */
 function commandInterpreter(environment: NodeJS.ProcessEnv = process.env): string {
-  const comSpec = environment["ComSpec"] ?? ""
-  if (win32.isAbsolute(comSpec)) return comSpec
-  const systemRoot = environment["SystemRoot"] ?? ""
-  const root = win32.isAbsolute(systemRoot) ? systemRoot : "C:\\Windows"
-  return win32.join(root, "System32", "cmd.exe")
+  const comSpec = environment["ComSpec"] ?? "";
+  if (win32.isAbsolute(comSpec)) return comSpec;
+  const systemRoot = environment["SystemRoot"] ?? "";
+  const root = win32.isAbsolute(systemRoot) ? systemRoot : "C:\\Windows";
+  return win32.join(root, "System32", "cmd.exe");
 }
 
 function commandShimInvocation(executablePath: string, args: ReadonlyArray<string>) {
-  assertCommandLineValue(executablePath, "executable path")
-  for (const arg of args) assertCommandLineValue(arg, "argument")
+  assertCommandLineValue(executablePath, "executable path");
+  for (const arg of args) assertCommandLineValue(arg, "argument");
 
-  const normalizedPath = win32.normalize(executablePath)
-  const doubleEscapeMetaChars = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i.test(normalizedPath)
+  const normalizedPath = win32.normalize(executablePath);
+  const doubleEscapeMetaChars = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i.test(normalizedPath);
   const commandLine = [
     escapeCommand(normalizedPath),
-    ...args.map((arg) => escapeArgument(arg, doubleEscapeMetaChars))
-  ].join(" ")
+    ...args.map((arg) => escapeArgument(arg, doubleEscapeMetaChars)),
+  ].join(" ");
   return {
     command: commandInterpreter(),
     args: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
-    windowsVerbatimArguments: true
-  } as const
+    windowsVerbatimArguments: true,
+  } as const;
 }
 
 // Authored now, but unreachable until the supported-host admission gate opens.
@@ -102,12 +102,12 @@ export const windows: HostOs = {
       : { command: executablePath, args },
   bunExecutableName: "bun.exe",
   bunInstaller: (pin, directory) => {
-    const scriptPath = p(directory, "install.ps1")
+    const scriptPath = p(directory, "install.ps1");
     return {
       scriptPath,
       download: {
         command: "curl",
-        args: ["-fsSL", "https://bun.sh/install.ps1", "-o", scriptPath]
+        args: ["-fsSL", "https://bun.sh/install.ps1", "-o", scriptPath],
       },
       run: {
         command: "powershell.exe",
@@ -119,58 +119,58 @@ export const windows: HostOs = {
           "-File",
           scriptPath,
           "-Version",
-          pin
-        ]
-      }
-    }
+          pin,
+        ],
+      },
+    };
   },
   environmentSetting: (name, value) => ({
     kind: "command",
     probe: {
       command: "reg",
-      args: ["query", "HKCU\\Environment", "/v", name]
+      args: ["query", "HKCU\\Environment", "/v", name],
     },
     apply: {
       command: "setx",
-      args: [name, value]
+      args: [name, value],
     },
     location: "user environment",
-    manualHint: "set it manually in System Properties > Environment Variables"
+    manualHint: "set it manually in System Properties > Environment Variables",
   }),
   statusLineCommand: (bun, script) => {
-    const bunLiteral = powershellLiteral(bun)
-    const scriptLiteral = powershellLiteral(script)
+    const bunLiteral = powershellLiteral(bun);
+    const scriptLiteral = powershellLiteral(script);
     // Module auto-loading reports "Preparing modules for first use" as a
     // progress record, which a redirected host serializes to stderr as CLIXML.
     // Claude runs this command every turn, and the records recur across runs, so
     // silencing progress inside the stored command keeps its streams clean.
     return encodedPowerShellCommand(
-      `$ProgressPreference = 'SilentlyContinue'; if ((Test-Path -LiteralPath ${bunLiteral} -PathType Leaf) -and (Test-Path -LiteralPath ${scriptLiteral} -PathType Leaf)) { & ${bunLiteral} ${scriptLiteral} }`
-    )
+      `$ProgressPreference = 'SilentlyContinue'; if ((Test-Path -LiteralPath ${bunLiteral} -PathType Leaf) -and (Test-Path -LiteralPath ${scriptLiteral} -PathType Leaf)) { & ${bunLiteral} ${scriptLiteral} }`,
+    );
   },
   failureHookCommand: (command) => {
-    const prefix = "echo '"
-    if (!command.startsWith(prefix) || !command.endsWith("'")) return command
-    const quotedPayload = command.slice(prefix.length, -1)
-    const posixApostrophe = `'"'"'`
-    if (quotedPayload.replaceAll(posixApostrophe, "").includes("'")) return command
-    const payload = quotedPayload.replaceAll(posixApostrophe, "'")
-    return encodedPowerShellCommand(`Write-Output ${powershellLiteral(payload)}`)
+    const prefix = "echo '";
+    if (!command.startsWith(prefix) || !command.endsWith("'")) return command;
+    const quotedPayload = command.slice(prefix.length, -1);
+    const posixApostrophe = `'"'"'`;
+    if (quotedPayload.replaceAll(posixApostrophe, "").includes("'")) return command;
+    const payload = quotedPayload.replaceAll(posixApostrophe, "'");
+    return encodedPowerShellCommand(`Write-Output ${powershellLiteral(payload)}`);
   },
   installHint: (tool) => {
     switch (tool) {
       case "git":
-        return "winget install --id Git.Git -e"
+        return "winget install --id Git.Git -e";
       case "jq":
-        return "winget install --id jqlang.jq -e"
+        return "winget install --id jqlang.jq -e";
       case "curl":
-        return "winget install --id cURL.cURL -e"
+        return "winget install --id cURL.cURL -e";
       case "ffplay":
-        return "winget install --id Gyan.FFmpeg -e"
+        return "winget install --id Gyan.FFmpeg -e";
       case "claude":
-        return "$tmp = Join-Path $env:TEMP 'claude-install.ps1'; curl.exe -fsSL https://claude.ai/install.ps1 -o $tmp; if ($LASTEXITCODE -eq 0) { powershell.exe -NoProfile -ExecutionPolicy Bypass -File $tmp }"
+        return "$tmp = Join-Path $env:TEMP 'claude-install.ps1'; curl.exe -fsSL https://claude.ai/install.ps1 -o $tmp; if ($LASTEXITCODE -eq 0) { powershell.exe -NoProfile -ExecutionPolicy Bypass -File $tmp }";
       case "codex":
-        return "$tmp = Join-Path $env:TEMP 'codex-install.ps1'; curl.exe -fsSL https://chatgpt.com/codex/install.ps1 -o $tmp; if ($LASTEXITCODE -eq 0) { $env:CODEX_NON_INTERACTIVE = '1'; powershell.exe -NoProfile -ExecutionPolicy Bypass -File $tmp }"
+        return "$tmp = Join-Path $env:TEMP 'codex-install.ps1'; curl.exe -fsSL https://chatgpt.com/codex/install.ps1 -o $tmp; if ($LASTEXITCODE -eq 0) { $env:CODEX_NON_INTERACTIVE = '1'; powershell.exe -NoProfile -ExecutionPolicy Bypass -File $tmp }";
     }
-  }
-}
+  },
+};