docks-kit 0.17.1 → 0.17.3

package/cli/src/engine-native/ompYaml.ts

@@ -8,44 +8,44 @@
  * the kit-managed role chains. models.yml drops nothing; a user file may carry
  * provider credentials and custom models the kit never declares.
  */
-import { isMap, isScalar, parseDocument, type YAMLMap } from "yaml"
+import { isMap, isScalar, parseDocument, type YAMLMap } from "yaml";
 
 /** Decides whether a deployed-only key at `path` is dropped instead of kept. */
-type DropDeployedKey = (path: ReadonlyArray<string>, key: string) => boolean
+type DropDeployedKey = (path: ReadonlyArray<string>, key: string) => boolean;
 
-const fallbackChainsPath = ["retry", "fallbackChains"] as const
+const fallbackChainsPath = ["retry", "fallbackChains"] as const;
 
 function stringKey(key: unknown): string | undefined {
-  if (typeof key === "string") return key
-  if (isScalar(key) && typeof key.value === "string") return key.value
-  return undefined
+  if (typeof key === "string") return key;
+  if (isScalar(key) && typeof key.value === "string") return key.value;
+  return undefined;
 }
 
 function keyName(key: unknown): string {
-  return isScalar(key) ? String(key.value) : String(key)
+  return isScalar(key) ? String(key.value) : String(key);
 }
 
 const dropFallbackWildcard: DropDeployedKey = (path, key) =>
   path.length === fallbackChainsPath.length &&
   path[0] === fallbackChainsPath[0] &&
   path[1] === fallbackChainsPath[1] &&
-  key.includes("/")
+  key.includes("/");
 
-const keepEveryKey: DropDeployedKey = () => false
+const keepEveryKey: DropDeployedKey = () => false;
 
 function pruneMapping(mapping: YAMLMap, path: ReadonlyArray<string>, drop: DropDeployedKey): void {
   for (let index = mapping.items.length - 1; index >= 0; index--) {
-    const pair = mapping.items[index]
-    if (pair === undefined) continue
+    const pair = mapping.items[index];
+    if (pair === undefined) continue;
 
     if (drop(path, keyName(pair.key))) {
-      mapping.items.splice(index, 1)
-      continue
+      mapping.items.splice(index, 1);
+      continue;
     }
 
-    const key = stringKey(pair.key)
+    const key = stringKey(pair.key);
     if (key !== undefined && isMap(pair.value)) {
-      pruneMapping(pair.value, [...path, key], drop)
+      pruneMapping(pair.value, [...path, key], drop);
     }
   }
 }
@@ -54,29 +54,31 @@ function mergeMappings(
   sotMapping: YAMLMap,
   deployedMapping: YAMLMap,
   path: ReadonlyArray<string>,
-  drop: DropDeployedKey
+  drop: DropDeployedKey,
 ): void {
   for (const sotPair of sotMapping.items) {
-    const key = stringKey(sotPair.key)
-    if (key === undefined) continue
+    const key = stringKey(sotPair.key);
+    if (key === undefined) continue;
 
-    const deployedPair = deployedMapping.items.find((candidate) => stringKey(candidate.key) === key)
+    const deployedPair = deployedMapping.items.find(
+      (candidate) => stringKey(candidate.key) === key,
+    );
     if (deployedPair !== undefined && isMap(sotPair.value) && isMap(deployedPair.value)) {
-      mergeMappings(sotPair.value, deployedPair.value, [...path, key], drop)
+      mergeMappings(sotPair.value, deployedPair.value, [...path, key], drop);
     }
   }
 
   for (const deployedPair of deployedMapping.items) {
-    const key = stringKey(deployedPair.key)
+    const key = stringKey(deployedPair.key);
     const isManaged =
-      key !== undefined && sotMapping.items.some((candidate) => stringKey(candidate.key) === key)
-    if (isManaged) continue
+      key !== undefined && sotMapping.items.some((candidate) => stringKey(candidate.key) === key);
+    if (isManaged) continue;
 
-    if (drop(path, keyName(deployedPair.key))) continue
+    if (drop(path, keyName(deployedPair.key))) continue;
     if (key !== undefined && isMap(deployedPair.value)) {
-      pruneMapping(deployedPair.value, [...path, key], drop)
+      pruneMapping(deployedPair.value, [...path, key], drop);
     }
-    sotMapping.items.push(deployedPair)
+    sotMapping.items.push(deployedPair);
   }
 }
 
@@ -84,45 +86,45 @@ function mergeYamlDocuments(
   sotText: string,
   deployedText: string,
   name: string,
-  drop: DropDeployedKey
+  drop: DropDeployedKey,
 ): string {
-  const deployedDoc = parseDocument(deployedText)
-  const deployedError = deployedDoc.errors[0]
+  const deployedDoc = parseDocument(deployedText);
+  const deployedError = deployedDoc.errors[0];
   if (deployedError !== undefined) {
-    throw new Error(`Invalid deployed omp ${name} YAML: ${deployedError.message}`)
+    throw new Error(`Invalid deployed omp ${name} YAML: ${deployedError.message}`);
   }
 
-  const deployedContents = deployedDoc.contents
+  const deployedContents = deployedDoc.contents;
   if (
     deployedContents === null ||
     deployedContents === undefined ||
     (isScalar(deployedContents) && deployedContents.value === null)
   ) {
-    return sotText
+    return sotText;
   }
   if (!isMap(deployedContents)) {
-    throw new Error(`Deployed omp ${name} YAML root must be a mapping`)
+    throw new Error(`Deployed omp ${name} YAML root must be a mapping`);
   }
 
-  const sotDoc = parseDocument(sotText)
-  const sotError = sotDoc.errors[0]
+  const sotDoc = parseDocument(sotText);
+  const sotError = sotDoc.errors[0];
   if (sotError !== undefined) {
-    throw new Error(`Invalid SoT omp ${name} YAML: ${sotError.message}`)
+    throw new Error(`Invalid SoT omp ${name} YAML: ${sotError.message}`);
   }
   if (!isMap(sotDoc.contents)) {
-    throw new Error(`SoT omp ${name} YAML root must be a mapping`)
+    throw new Error(`SoT omp ${name} YAML root must be a mapping`);
   }
 
-  mergeMappings(sotDoc.contents, deployedContents, [], drop)
-  return sotDoc.toString()
+  mergeMappings(sotDoc.contents, deployedContents, [], drop);
+  return sotDoc.toString();
 }
 
 /** config.yml merge: keeps user-only keys, drops stale fallback-chain wildcards. */
 export function mergeOmpConfig(sotText: string, deployedText: string): string {
-  return mergeYamlDocuments(sotText, deployedText, "config.yml", dropFallbackWildcard)
+  return mergeYamlDocuments(sotText, deployedText, "config.yml", dropFallbackWildcard);
 }
 
 /** models.yml merge: keeps every user-only key, including credentials and custom models. */
 export function mergeOmpModels(sotText: string, deployedText: string): string {
-  return mergeYamlDocuments(sotText, deployedText, "models.yml", keepEveryKey)
+  return mergeYamlDocuments(sotText, deployedText, "models.yml", keepEveryKey);
 }

package/cli/src/engine-native/os/darwin.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 darwin: HostOs = posixHost({
   id: "darwin",
@@ -9,6 +9,6 @@ export const darwin: HostOs = posixHost({
     git: "brew install git",
     jq: "brew install jq",
     curl: "brew install curl",
-    ffplay: "brew install ffmpeg"
-  }
-})
+    ffplay: "brew install ffmpeg",
+  },
+});

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;
 }