docks-kit 0.9.0 → 0.10.1

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

@@ -112,34 +112,29 @@ const home = (): string => {
   return envHome !== undefined && envHome !== "" ? envHome : homedir()
 }
 
-const absoluteWindowsExe = (path: string): boolean =>
-  /\.exe$/i.test(path) && (/^[A-Za-z]:[\\/]/.test(path) || /^\\\\/.test(path))
 
 // The resolved path gets persisted into global direct-exec hooks, so a
 // relative `which` hit (relative PATH entry, relative BUN_INSTALL) would
 // break outside the sync working directory.
-const absoluteExecutable = (path: string, platform: NodeJS.Platform): boolean =>
-  platform === "win32" ? absoluteWindowsExe(path) : isAbsolute(path)
 
-const findBun = (exec: ProbeExecutor, platform: NodeJS.Platform = rawPlatform()): { command: string; path: string } | undefined => {
+const findBun = (exec: ProbeExecutor): { command: string; path: string } | undefined => {
   const onPath = exec.which("bun")
-  if (onPath !== "" && absoluteExecutable(onPath, platform)) {
-    return { command: platform === "win32" ? onPath : "bun", path: onPath }
+  if (onPath !== "" && isAbsolute(onPath)) {
+    return { command: "bun", path: onPath }
   }
   const root =
     process.env["BUN_INSTALL"] !== undefined && process.env["BUN_INSTALL"] !== ""
       ? process.env["BUN_INSTALL"]!
       : p(home(), ".bun")
-  const name = platform === "win32" ? "bun.exe" : "bun"
-  for (const candidate of [p(root, "bin", name), p(home(), ".bun", "bin", name)]) {
+  for (const candidate of [p(root, "bin", "bun"), p(home(), ".bun", "bin", "bun")]) {
     const found = exec.which(candidate)
-    if (found !== "" && absoluteExecutable(found, platform)) return { command: found, path: found }
+    if (found !== "" && isAbsolute(found)) return { command: found, path: found }
   }
   return undefined
 }
 
-const resolveBun = (exec: ProbeExecutor, platform: NodeJS.Platform): ProbeResult => {
-  const bun = findBun(exec, platform)
+const resolveBun = (exec: ProbeExecutor): ProbeResult => {
+  const bun = findBun(exec)
   return bun === undefined
     ? { state: "missing" }
     : { state: "present", path: bun.path }
@@ -161,28 +156,23 @@ const versionEffectSolutions = (exec: ProbeExecutor): string => {
   return match?.[1] ?? ""
 }
 
-const locateEffectSolutions = (exec: ProbeExecutor, platform: NodeJS.Platform): DependencyLocation => {
-  const strictBun = findBun(exec, platform)
+const locateEffectSolutions = (exec: ProbeExecutor): DependencyLocation => {
+  const strictBun = findBun(exec)
   const pathBun = exec.which("bun")
   const bun = strictBun ?? (pathBun !== "" ? { command: "bun", path: pathBun } : undefined)
   if (bun === undefined) return { path: "", binDir: "" }
   const globalBin = exec.capture(bun.command, ["pm", "-g", "bin"])
-  const names =
-    platform === "win32"
-      ? ["effect-solutions.exe", "effect-solutions.cmd", "effect-solutions.bunx"]
-      : ["effect-solutions"]
-  const path = names.map((name) => p(globalBin, name)).find((candidate) => globalBin !== "" && exec.which(candidate) !== "")
-  return { path: path ?? "", binDir: globalBin }
+  const path = globalBin !== "" ? p(globalBin, "effect-solutions") : ""
+  const resolved = path !== "" && exec.which(path) !== "" ? path : ""
+  return { path: resolved, binDir: globalBin }
 }
 
 const resolveChrome = (exec: ProbeExecutor, platform: NodeJS.Platform): ProbeResult => {
   const root = p(home(), ".agent-browser", "browsers")
   const relative =
-    platform === "win32"
-      ? "chrome.exe"
-      : platform === "darwin"
-        ? "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing"
-        : "chrome"
+    platform === "darwin"
+      ? "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing"
+      : "chrome"
   if (existsSync(root)) {
     for (const directory of readdirSync(root).filter((name) => name.startsWith("chrome-")).sort().reverse()) {
       const path = exec.which(p(root, directory, relative))
@@ -215,23 +205,19 @@ export const DEPENDENCIES: Record<ToolId, DependencySpec> = {
     "git",
     "optional",
     (pf = rawPlatform()) =>
-      pf === "win32"
-        ? "winget install Git.Git (then open a new terminal)"
-        : pf === "darwin"
-          ? "brew install git"
-          : "sudo apt install -y git (or your distro's package manager)",
+      pf === "darwin"
+        ? "brew install git"
+        : "sudo apt install -y git (or your distro's package manager)",
     { version: versionProbe("git") }
   ),
   jq: spec("jq", "optional", (pf = rawPlatform()) =>
-    pf === "win32"
-      ? "winget install jqlang.jq (then open a new terminal)"
-      : pf === "darwin"
-        ? "brew install jq"
-        : "sudo apt install -y jq",
+    pf === "darwin"
+      ? "brew install jq"
+      : "sudo apt install -y jq",
     { version: versionProbe("jq") }
   ),
   curl: spec("curl", "optional", (pf = rawPlatform()) =>
-    pf === "win32" ? "winget install cURL.cURL" : pf === "darwin" ? "brew install curl" : "sudo apt install -y curl",
+    pf === "darwin" ? "brew install curl" : "sudo apt install -y curl",
     { version: versionProbe("curl") }
   ),
   node: spec("node", "optional", () => "install Node.js via https://nodejs.org (or your package manager)", {
@@ -242,22 +228,16 @@ export const DEPENDENCIES: Record<ToolId, DependencySpec> = {
   claude: spec(
     "claude",
     "optional",
-    (pf = rawPlatform()) =>
-      pf === "win32"
-        ? "winget install Anthropic.ClaudeCode"
-        : "curl -fsSL https://claude.ai/install.sh -o /tmp/claude-install.sh && bash /tmp/claude-install.sh",
+    () => "curl -fsSL https://claude.ai/install.sh -o /tmp/claude-install.sh && bash /tmp/claude-install.sh",
     { version: versionProbe("claude") }
   ),
   codex: spec(
     "codex",
     "optional",
-    (pf = rawPlatform()) =>
-      pf === "win32"
-        ? `powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"`
-        : 'tmp=$(mktemp) && curl -fsSL https://chatgpt.com/codex/install.sh -o "$tmp" && CODEX_NON_INTERACTIVE=1 sh "$tmp"',
+    () => 'tmp=$(mktemp) && curl -fsSL https://chatgpt.com/codex/install.sh -o "$tmp" && CODEX_NON_INTERACTIVE=1 sh "$tmp"',
     { version: versionProbe("codex") }
   ),
-  rtk: spec("rtk", "optional", () => "see https://github.com/rtk-ai/rtk (kit auto-install is Unix-only)", {
+  rtk: spec("rtk", "optional", () => "see https://github.com/rtk-ai/rtk (kit auto-install is Linux/macOS-only)", {
     version: versionProbe("rtk"),
     latest: latestRtk
   }),
@@ -269,12 +249,11 @@ export const DEPENDENCIES: Record<ToolId, DependencySpec> = {
   bun: spec(
     "bun",
     "optional",
-    (pf = rawPlatform()) =>
-      pf === "win32" ? `powershell -c "irm bun.sh/install.ps1 | iex"` : "curl -fsSL https://bun.sh/install | bash",
+    () => "curl -fsSL https://bun.sh/install | bash",
     {
       resolve: resolveBun,
       version: (exec) => exec.capture(versionBunCommand(exec), ["--version"]),
-      locate: (exec, platform) => ({ path: findBun(exec, platform)?.path ?? "", binDir: "" })
+      locate: (exec) => ({ path: findBun(exec)?.path ?? "", binDir: "" })
     }
   ),
   bwrap: spec("bwrap", "optional", () => "sudo apt install -y bubblewrap (or dnf/pacman/zypper equivalent)"),
@@ -298,7 +277,7 @@ export const DEPENDENCIES: Record<ToolId, DependencySpec> = {
     "ffplay",
     "optional",
     (pf = rawPlatform()) =>
-      pf === "win32" ? "winget install Gyan.FFmpeg" : pf === "darwin" ? "brew install ffmpeg" : "sudo apt install -y ffmpeg",
+      pf === "darwin" ? "brew install ffmpeg" : "sudo apt install -y ffmpeg",
     { versionArgs: ["-version"], resolve: pathProbe("ffplay") }
   ),
   intelephense: spec("intelephense", "optional", () => "npm install -g intelephense", {

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

@@ -7,11 +7,7 @@ import { spawnSync } from "node:child_process"
 import { accessSync, chmodSync, constants, existsSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import { delimiter, isAbsolute, join } from "node:path"
 
-/**
- * Engine paths are built with "/" because they appear verbatim in output
- * (dry-run lines, warns), where node:path.join would print "\" on Windows
- * and break the golden contract. fs accepts "/" on every platform.
- */
+/** Keep engine paths slash-separated so rendered output is host-stable. */
 export function p(...parts: Array<string>): string {
   return parts.join("/")
 }
@@ -22,18 +18,15 @@ export function capture(cmd: string, args: ReadonlyArray<string>): string {
   return (res.stdout ?? "").replace(/[\r\n]+$/, "")
 }
 
-/** `command -v` — resolve a name on PATH (PATHEXT-aware on Windows). */
+/** `command -v` — resolve an executable name on PATH. */
 export function which(name: string): string {
-  if (isAbsolute(name) || name.includes("/") || name.includes("\\")) {
+  if (isAbsolute(name) || name.includes("/")) {
     return isExecutable(name) ? name : ""
   }
-  const exts = process.platform === "win32" ? (process.env["PATHEXT"] ?? ".EXE;.CMD;.BAT;.COM").split(";").concat("") : [""]
   for (const dir of (process.env["PATH"] ?? "").split(delimiter)) {
     if (dir === "") continue
-    for (const ext of exts) {
-      const cand = join(dir, name + ext.toLowerCase())
-      if (isExecutable(cand)) return cand
-    }
+    const candidate = join(dir, name)
+    if (isExecutable(candidate)) return candidate
   }
   return ""
 }
@@ -45,7 +38,7 @@ export function commandExists(name: string): boolean {
 export function isExecutable(p: string): boolean {
   try {
     if (!statSync(p).isFile()) return false
-    if (process.platform !== "win32") accessSync(p, constants.X_OK)
+    accessSync(p, constants.X_OK)
     return true
   } catch {
     return false

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

@@ -1,29 +1,24 @@
 /**
- * Platform capability seam (Output Policy in DESIGN.md) — the only engine
- * module that reads process.platform besides exec.ts's PATH/executability
- * primitives. Per-tool package identifiers stay in deps.ts; symlink handling
- * stays try-then-fallback at the call site (capability-driven, not predicted).
+ * Platform capability seam (Output Policy in DESIGN.md). Per-tool package
+ * identifiers stay in deps.ts; symlink handling stays try-then-fallback at
+ * the call site (capability-driven, not predicted).
  */
 
-export type PlatformName = "linux" | "darwin" | "windows" | "unknown"
+export type PlatformName = "linux" | "darwin" | "unknown"
 
 export function rawPlatform(): NodeJS.Platform {
   return process.platform
 }
 
 export function platformName(pf: NodeJS.Platform = rawPlatform()): PlatformName {
-  return pf === "linux" ? "linux" : pf === "darwin" ? "darwin" : pf === "win32" ? "windows" : "unknown"
-}
-
-export function isWindows(): boolean {
-  return rawPlatform() === "win32"
+  return pf === "linux" ? "linux" : pf === "darwin" ? "darwin" : "unknown"
 }
 
 export function isLinux(): boolean {
   return rawPlatform() === "linux"
 }
 
-/** Shell-rc exports (bashrc/zshrc) apply only off Windows. */
+/** Shell-rc exports apply only on supported hosts. */
 export function shellRcApplicable(): boolean {
-  return !isWindows()
+  return platformName() !== "unknown"
 }

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

@@ -36,7 +36,6 @@ export interface DependencyManager {
 export interface Platform {
   readonly raw: () => NodeJS.Platform
   readonly name: () => PlatformName
-  readonly isWindows: () => boolean
   readonly isLinux: () => boolean
   readonly shellRcApplicable: () => boolean
 }
@@ -51,13 +50,12 @@ export interface EngineServiceOptions {
   readonly sinks?: LoggerSinks
 }
 
-/** Platform view over an injectable platform id (tests pass e.g. "win32"). */
+/** Platform view over an injectable platform id. */
 export const makePlatform = (pf: NodeJS.Platform = rawPlatform()): Platform => ({
   raw: () => pf,
   name: () => platformName(pf),
-  isWindows: () => pf === "win32",
   isLinux: () => pf === "linux",
-  shellRcApplicable: () => pf !== "win32"
+  shellRcApplicable: () => pf === "linux" || pf === "darwin"
 })
 
 /** DependencyManager whose hints default to the INJECTED platform, not the host. */

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

@@ -9,7 +9,7 @@ import {
   rmSync,
   statSync
 } from "node:fs"
-import { basename, dirname, join } from "node:path"
+import { dirname, join } from "node:path"
 
 import { isObject, parseJson, type Json } from "./jq"
 import type { Ctx } from "./index"

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

@@ -5,12 +5,12 @@
  * and the snapshot write.
  */
 import { spawnSync } from "node:child_process"
-import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, realpathSync, rmdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs"
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmSync, statSync, symlinkSync } from "node:fs"
 import { p, writeFileIfChanged } from "./exec"
 import { bunBootstrap } from "./bun"
 import type { Ctx } from "./index"
 import { compareCodepoints } from "./jq"
-import type { EngineServices, Platform } from "./services"
+import type { EngineServices } from "./services"
 import { ensure, field } from "./toolchain"
 import { payloadText } from "../payload"
 
@@ -139,9 +139,6 @@ function healClaudeSymlink(ctx: Ctx, skillsDir: string, base: string): boolean {
   if (linkStat?.isSymbolicLink() === true) {
     const current = safeReadlink(claudeLink)
     if (current === relTarget) return false
-    // win32: `npx skills add` creates absolute symlinks/junctions — any link
-    // that RESOLVES to the canonical dir is healthy, not stale.
-    if (ctx.services.platform.isWindows() && realpathEquals(claudeLink, canonical)) return false
     if (ctx.dryRun) {
       echo(`[dry-run] would replace stale Claude symlink: ~/.claude/skills/${base} -> ${current}  (correct: ${relTarget})`)
       return true
@@ -178,36 +175,22 @@ function safeReadlink(path: string): string {
   }
 }
 
-function realpathEquals(a: string, b: string): boolean {
-  try {
-    return realpathSync(a) === realpathSync(b)
-  } catch {
-    return false
-  }
-}
 
-/**
- * Remove a symlink/junction without crashing: Bun's rmSync throws EFAULT on
- * win32 directory symlinks. unlink handles file symlinks, rmdir handles
- * dir symlinks/junctions, rmSync is the POSIX catch-all.
- */
+/** Remove a symlink without touching a real directory. */
 function removeLink(path: string): boolean {
-  for (const rm of [() => unlinkSync(path), () => rmdirSync(path), () => rmSync(path, { force: true })]) {
-    try {
-      rm()
-      return true
-    } catch {
-      // try the next removal shape
-    }
+  try {
+    rmSync(path, { force: true })
+    return true
+  } catch {
+    return lstat(path) === undefined
   }
-  return lstat(path) === undefined
 }
 
-/** skills::_link_or_copy — real symlink preferred, copy fallback (Windows). */
-export function linkOrCopy(target: string, link: string, platform: Platform): boolean {
+/** skills::_link_or_copy — real symlink preferred, copy fallback. */
+export function linkOrCopy(target: string, link: string): boolean {
   removeLink(link)
   try {
-    symlinkSync(target, link, platform.isWindows() ? "dir" : undefined)
+    symlinkSync(target, link)
   } catch {
     // fall through to the copy fallback below
   }
@@ -223,11 +206,11 @@ export function linkOrCopy(target: string, link: string, platform: Platform): bo
 }
 
 function linkOrCopyWithWarnings(target: string, link: string, services: EngineServices): boolean {
-  const linked = linkOrCopy(target, link, services.platform)
+  const linked = linkOrCopy(target, link)
   if (!linked) {
     services.logger.warn(`could not create ${link} (symlink and copy both failed)`)
   } else if (lstat(link)?.isSymbolicLink() !== true) {
-    services.logger.warn(`symlinks unsupported here — ${link} is a copy (refreshed on sync; enable Windows Developer Mode for real links)`)
+    services.logger.warn(`symlinks unsupported here — ${link} is a copy refreshed on sync`)
   }
   return linked
 }
@@ -298,14 +281,6 @@ export function effectSolutionsInstall(
 
     const location = services.deps.location("effect-solutions")
     const gbin = location.binDir
-    // win32: bun writes an .exe shim (not the bare Unix name), and the
-    // ~/.local/bin link step below is Unix-only plumbing (non-interactive
-    // agent PATH) — bun's global bin is already the Windows PATH entry.
-    if (services.platform.isWindows()) {
-      if (location.path !== "") change(`effect-solutions CLI ready (${gbin})`)
-      else warn(`effect-solutions installed but no shim found under '${gbin !== "" ? gbin : "<unknown>"}' — check bun pm -g bin`)
-      return 0
-    }
     if (location.path !== "") {
       mkdirSync(p(ctx.home, ".local", "bin"), { recursive: true })
       linkOrCopyWithWarnings(bun, p(ctx.home, ".local", "bin", "bun"), services)

package/cli/src/engine.ts

@@ -5,28 +5,32 @@ import { makeEngineServices } from "./engine-native/services"
 import { kitHome } from "./kitHome"
 import { DependencyManagerService, LoggerService, PlatformService } from "./services"
 
-// Same factory as the Effect rim's live layers — this path runs outside the
-// runtime (child-spawn capture), so it takes the services directly.
-const services = makeEngineServices()
-
 /**
  * The single seam between the typed CLI and EngineNative. Engine execution
  * stays in-process after @effect/cli has parsed pickers and flag spellings.
  */
 const bashRemovedMessage = "bash engine removed — recover at tag bash-engine-final"
 const bashEngineRequested = (): boolean => process.env["DOCKS_KIT_ENGINE"] === "bash"
+const requireSupportedHost = () => {
+  const platform = process.platform
+  const arch = process.arch
+  return (platform === "linux" || platform === "darwin") && (arch === "x64" || arch === "arm64")
+    ? Effect.void
+    : bail(
+      `unsupported host ${platform}/${arch}; docks-kit supports only Linux and macOS on x64 or arm64`,
+      2
+    )
+}
 
-// bun build --compile runs the embedded entry from a virtual path
-// ("/$bunfs/root/…" on POSIX, "B:\~BUN\root\…" on Windows). There
-// process.execPath IS the CLI, so a re-spawn must not pass main.ts.
-// The Windows check is anchored to the drive-rooted "~BUN" segment so a
-// real checkout under a ~BUN-named directory can't false-positive.
+// bun build --compile runs the embedded entry from a virtual POSIX path
+// ("/$bunfs/root/…"). There process.execPath IS the CLI, so a re-spawn must
+// not pass main.ts.
 export const compiled =
-  process.argv[1] !== undefined &&
-  (process.argv[1].startsWith("/$bunfs/") || /^[A-Za-z]:[\\/]~BUN[\\/]/i.test(process.argv[1]))
+  process.argv[1] !== undefined && process.argv[1].startsWith("/$bunfs/")
 
 export const engine = (args: ReadonlyArray<string>) =>
   Effect.gen(function* () {
+    yield* requireSupportedHost()
     if (bashEngineRequested()) {
       yield* bail(bashRemovedMessage, 2)
     }
@@ -41,9 +45,12 @@ export const engine = (args: ReadonlyArray<string>) =>
 
 /** Run the engine capturing stdout (engine logs/warns go to stderr and pass through). */
 export const engineCapture = (args: ReadonlyArray<string>) =>
-  bashEngineRequested()
-    ? bail(bashRemovedMessage, 2)
-    : Effect.sync(() => {
+  Effect.gen(function* () {
+    yield* requireSupportedHost()
+    if (bashEngineRequested()) {
+      return yield* bail(bashRemovedMessage, 2)
+    }
+    return yield* Effect.sync(() => {
       // Child process (raw channel): runEngineNative writes straight to
       // process.stdout, so in-process capture isn't possible.
       const res = spawnSync(process.execPath, compiled ? [...args] : [`${kitHome()}/cli/src/main.ts`, ...args], {
@@ -52,10 +59,11 @@ export const engineCapture = (args: ReadonlyArray<string>) =>
         stdio: ["ignore", "pipe", "inherit"]
       })
       if (res.error !== undefined || res.status !== 0) {
-        services.logger.warn(`engine capture failed (${args.join(" ")} exited ${res.status ?? "spawn-error"})`)
+        makeEngineServices().logger.warn(`engine capture failed (${args.join(" ")} exited ${res.status ?? "spawn-error"})`)
       }
       return res.stdout ?? ""
     })
+  })
 
 /** Print a message to stderr and exit — for CLI-side validation failures. */
 export const bail = (message: string, code = 2) =>