docks-kit 0.14.2 → 0.14.4

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

@@ -9,7 +9,6 @@
  */
 import { homedir } from "node:os"
 import { isAbsolute } from "node:path"
-import { existsSync, readdirSync } from "node:fs"
 
 import { capture, commandExists, p, which } from "./exec"
 import { isObject, parseJson } from "./jq"
@@ -24,12 +23,9 @@ export type ToolId =
   | "npx"
   | "claude"
   | "codex"
-  | "rtk"
   | "bun"
   | "bwrap"
-  | "agent-browser"
   | "effect-solutions"
-  | "chrome-for-testing"
   | "ffplay"
   | "intelephense"
   | "typescript-language-server"
@@ -53,7 +49,7 @@ export interface DependencyLocation {
 
 export interface ProbeExecutor {
   readonly commandExists: (name: string) => boolean
-  readonly capture: (cmd: string, args: ReadonlyArray<string>) => string
+  readonly capture: (cmd: string, args: ReadonlyArray<string>) => Promise<string>
   readonly which: (name: string) => string
 }
 
@@ -64,17 +60,17 @@ export interface DependencySpec {
   /** Platform-correct one-line install command (param injectable for tests). */
   readonly installHint: (platform?: NodeJS.Platform) => string
   readonly resolve?: (exec: ProbeExecutor, platform: NodeJS.Platform) => ProbeResult
-  readonly version?: (exec: ProbeExecutor) => string
-  readonly locate?: (exec: ProbeExecutor, platform: NodeJS.Platform) => DependencyLocation
-  readonly latest?: (exec: ProbeExecutor) => string
+  readonly version?: (exec: ProbeExecutor) => Promise<string>
+  readonly locate?: (exec: ProbeExecutor, platform: NodeJS.Platform) => Promise<DependencyLocation>
+  readonly latest?: (exec: ProbeExecutor) => Promise<string>
 }
 
 interface SpecOptions {
   readonly versionArgs?: ReadonlyArray<string>
   readonly resolve?: (exec: ProbeExecutor, platform: NodeJS.Platform) => ProbeResult
-  readonly version?: (exec: ProbeExecutor) => string
-  readonly locate?: (exec: ProbeExecutor, platform: NodeJS.Platform) => DependencyLocation
-  readonly latest?: (exec: ProbeExecutor) => string
+  readonly version?: (exec: ProbeExecutor) => Promise<string>
+  readonly locate?: (exec: ProbeExecutor, platform: NodeJS.Platform) => Promise<DependencyLocation>
+  readonly latest?: (exec: ProbeExecutor) => Promise<string>
 }
 
 const spec = (
@@ -103,8 +99,8 @@ const versionProbe = (
   id: string,
   versionArgs: ReadonlyArray<string> = ["--version"],
   parse: (out: string) => string = (out) => out
-): ((exec: ProbeExecutor) => string) =>
-  (exec) => parse(exec.capture(id, versionArgs))
+): ((exec: ProbeExecutor) => Promise<string>) =>
+  async (exec) => parse(await exec.capture(id, versionArgs))
 
 const home = (): string => {
   const envHome = process.env["HOME"]
@@ -148,54 +144,49 @@ const resolveEffectSolutions = (exec: ProbeExecutor): ProbeResult => {
 const versionBunCommand = (exec: ProbeExecutor): string =>
   exec.commandExists("bun") ? "bun" : p(home(), ".bun", "bin", "bun")
 
-const versionEffectSolutions = (exec: ProbeExecutor): string => {
+const versionEffectSolutions = async (exec: ProbeExecutor): Promise<string> => {
   const bun = versionBunCommand(exec)
   if (bun !== "bun" && exec.which(bun) === "") return ""
-  const match = /effect-solutions@([0-9][0-9.]*)/.exec(exec.capture(bun, ["pm", "-g", "ls"]))
+  const match = /effect-solutions@([0-9][0-9.]*)/.exec(await exec.capture(bun, ["pm", "-g", "ls"]))
   return match?.[1] ?? ""
 }
 
-const locateEffectSolutions = (exec: ProbeExecutor): DependencyLocation => {
+const locateEffectSolutions = async (exec: ProbeExecutor): Promise<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 globalBin = await exec.capture(bun.command, ["pm", "-g", "bin"])
   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 === "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))
-      if (path !== "") return { state: "present", path }
+const npmGlobalCache = new WeakMap<ProbeExecutor, Promise<{ [k: string]: string }>>()
+
+const npmGlobalVersions = (exec: ProbeExecutor): Promise<{ [k: string]: string }> => {
+  const hit = npmGlobalCache.get(exec)
+  if (hit !== undefined) return hit
+  const pending = (async (): Promise<{ [k: string]: string }> => {
+    const out: { [k: string]: string } = {}
+    if (exec.commandExists("npm")) {
+      const doc = parseJson(await exec.capture("npm", ["ls", "-g", "--depth=0", "--json"]))
+      const deps = doc !== undefined && isObject(doc) && isObject(doc["dependencies"]) ? doc["dependencies"] : {}
+      for (const [name, value] of Object.entries(deps)) {
+        if (isObject(value) && typeof value["version"] === "string") out[name] = value["version"]
+      }
     }
-  }
-  for (const command of ["chrome-for-testing", "google-chrome-for-testing", "google-chrome", "chromium", "chromium-browser", "brave-browser", "brave"]) {
-    const path = exec.which(command)
-    if (path !== "") return { state: "present", path }
-  }
-  return { state: "missing" }
+    return out
+  })()
+  npmGlobalCache.set(exec, pending)
+  return pending
 }
 
-const latestRtk = (exec: ProbeExecutor): string => {
-  if (!exec.commandExists("curl")) return ""
-  const doc = parseJson(
-    exec.capture("curl", ["-fsSL", "--max-time", "5", "https://api.github.com/repos/rtk-ai/rtk/releases/latest"])
-  )
-  const tag = doc !== undefined && isObject(doc) && typeof doc["tag_name"] === "string" ? doc["tag_name"] : ""
-  return tag.replace(/^v/, "")
-}
+const versionNpmGlobal = (pkg: string) => async (exec: ProbeExecutor): Promise<string> =>
+  (await npmGlobalVersions(exec))[pkg] ?? ""
 
-const latestNpm = (id: "agent-browser" | "effect-solutions") => (exec: ProbeExecutor): string =>
-  exec.commandExists("npm") ? exec.capture("npm", ["view", id, "version"]) : ""
+const latestNpm = (id: "effect-solutions") => async (exec: ProbeExecutor): Promise<string> =>
+  exec.commandExists("npm") ? await exec.capture("npm", ["view", id, "version"]) : ""
 
 export const defaultProbeExecutor: ProbeExecutor = { commandExists, capture, which }
 
@@ -236,10 +227,6 @@ export const DEPENDENCIES: Record<ToolId, DependencySpec> = {
     () => '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 Linux/macOS-only)", {
-    version: versionProbe("rtk"),
-    latest: latestRtk
-  }),
   bun: spec(
     "bun",
     "optional",
@@ -247,13 +234,11 @@ export const DEPENDENCIES: Record<ToolId, DependencySpec> = {
     {
       resolve: resolveBun,
       version: (exec) => exec.capture(versionBunCommand(exec), ["--version"]),
-      locate: (exec) => ({ path: findBun(exec)?.path ?? "", binDir: "" })
+      locate: async (exec) => ({ path: findBun(exec)?.path ?? "", binDir: "" })
     }
   ),
-  bwrap: spec("bwrap", "optional", () => "sudo apt install -y bubblewrap (or dnf/pacman/zypper equivalent)"),
-  "agent-browser": spec("agent-browser", "optional", () => "npm install -g agent-browser", {
-    version: versionProbe("agent-browser"),
-    latest: latestNpm("agent-browser")
+  bwrap: spec("bwrap", "optional", () => "sudo apt install -y bubblewrap (or dnf/pacman/zypper equivalent)", {
+    version: versionProbe("bwrap")
   }),
   "effect-solutions": spec("effect-solutions", "optional", () => "bun add -g effect-solutions", {
     resolve: resolveEffectSolutions,
@@ -261,27 +246,22 @@ export const DEPENDENCIES: Record<ToolId, DependencySpec> = {
     locate: locateEffectSolutions,
     latest: latestNpm("effect-solutions")
   }),
-  "chrome-for-testing": spec(
-    "chrome-for-testing",
-    "optional",
-    (pf = rawPlatform()) => (pf === "linux" ? "agent-browser install --with-deps" : "agent-browser install"),
-    { resolve: resolveChrome }
-  ),
   ffplay: spec(
     "ffplay",
     "optional",
     (pf = rawPlatform()) =>
       pf === "darwin" ? "brew install ffmpeg" : "sudo apt install -y ffmpeg",
-    { versionArgs: ["-version"], resolve: pathProbe("ffplay") }
+    { versionArgs: ["-version"], version: versionProbe("ffplay", ["-version"]), resolve: pathProbe("ffplay") }
   ),
   intelephense: spec("intelephense", "optional", () => "npm install -g intelephense", {
-    resolve: pathProbe("intelephense")
+    resolve: pathProbe("intelephense"),
+    version: versionNpmGlobal("intelephense")
   }),
   "typescript-language-server": spec(
     "typescript-language-server",
     "optional",
     () => "npm install -g typescript-language-server typescript",
-    { resolve: pathProbe("typescript-language-server") }
+    { resolve: pathProbe("typescript-language-server"), version: versionProbe("typescript-language-server") }
   ),
   tsc: spec("tsc", "optional", () => "npm install -g typescript", {
     resolve: pathProbe("tsc"),
@@ -301,21 +281,25 @@ export function resolveDependency(
   return (specification.resolve ?? pathProbe(specification.id))(exec, platform)
 }
 
-export function resolveVersion(specification: DependencySpec, exec: ProbeExecutor): string {
+export async function resolveVersion(specification: DependencySpec, exec: ProbeExecutor): Promise<string> {
   if (resolveDependency(specification, exec).state !== "present") return ""
-  return (specification.version ?? versionProbe(specification.id, specification.versionArgs))(exec)
+  return await (specification.version ?? versionProbe(specification.id, specification.versionArgs))(exec)
 }
 
-export function resolveLocation(
+export async function resolveLocation(
   specification: DependencySpec,
   exec: ProbeExecutor,
   platform: NodeJS.Platform = rawPlatform()
-): DependencyLocation {
-  if (specification.locate !== undefined) return specification.locate(exec, platform)
+): Promise<DependencyLocation> {
+  if (specification.locate !== undefined) return await specification.locate(exec, platform)
   const result = resolveDependency(specification, exec, platform)
   return { path: result.state === "present" ? (result.path ?? exec.which(specification.id)) : "", binDir: "" }
 }
 
-export function resolvePath(specification: DependencySpec, exec: ProbeExecutor, platform?: NodeJS.Platform): string {
-  return resolveLocation(specification, exec, platform).path
+export async function resolvePath(
+  specification: DependencySpec,
+  exec: ProbeExecutor,
+  platform?: NodeJS.Platform
+): Promise<string> {
+  return (await resolveLocation(specification, exec, platform)).path
 }

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

@@ -3,7 +3,7 @@
  * the intended binary with deterministic argv, and capture() mirrors command
  * substitution: stdout with trailing newlines stripped, empty on failure.
  */
-import { spawnSync } from "node:child_process"
+import { spawn, type ChildProcess, type SpawnOptions } from "node:child_process"
 import { accessSync, chmodSync, constants, existsSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import { delimiter, isAbsolute, join } from "node:path"
 
@@ -12,10 +12,66 @@ export function p(...parts: Array<string>): string {
   return parts.join("/")
 }
 
-export function capture(cmd: string, args: ReadonlyArray<string>): string {
-  const res = spawnSync(cmd, args as Array<string>, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })
-  if (res.error !== undefined || res.status !== 0) return ""
-  return (res.stdout ?? "").replace(/[\r\n]+$/, "")
+export interface AsyncProcessResult {
+  readonly exitCode: number | null
+  readonly stdout: string
+  readonly stderr: string
+  readonly error?: Error
+}
+
+export interface AsyncProcessOptions {
+  readonly stdio?: SpawnOptions["stdio"]
+}
+
+export function spawnProcess(
+  cmd: string,
+  args: ReadonlyArray<string>,
+  options: AsyncProcessOptions = {}
+): Promise<AsyncProcessResult> {
+  const { promise, resolve } = Promise.withResolvers<AsyncProcessResult>()
+  let child: ChildProcess
+  try {
+    child = spawn(cmd, [...args], { stdio: options.stdio ?? ["ignore", "pipe", "ignore"] })
+  } catch (cause) {
+    const error = cause instanceof Error ? cause : new Error(String(cause))
+    resolve({ exitCode: null, stdout: "", stderr: "", error })
+    return promise
+  }
+  let stdout = ""
+  let stderr = ""
+  let error: Error | undefined
+
+  if (child.stdout !== null) {
+    child.stdout.setEncoding("utf8")
+    child.stdout.on("data", (chunk: string) => {
+      stdout += chunk
+    })
+    child.stdout.on("error", (cause) => {
+      error ??= cause
+    })
+  }
+  if (child.stderr !== null) {
+    child.stderr.setEncoding("utf8")
+    child.stderr.on("data", (chunk: string) => {
+      stderr += chunk
+    })
+    child.stderr.on("error", (cause) => {
+      error ??= cause
+    })
+  }
+  child.once("error", (cause) => {
+    error ??= cause
+  })
+  child.once("close", (exitCode) => {
+    resolve({ exitCode, stdout, stderr, ...(error !== undefined ? { error } : {}) })
+  })
+  return promise
+}
+
+export async function capture(cmd: string, args: ReadonlyArray<string>): Promise<string> {
+  const res = await spawnProcess(cmd, args, { stdio: ["ignore", "pipe", "ignore"] })
+  if (res.error !== undefined || res.exitCode !== 0) return ""
+  return res.stdout.replace(/[\r\n]+$/, "")
 }
 
 /** `command -v` — resolve an executable name on PATH. */

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

@@ -9,11 +9,13 @@ import { p } from "./exec"
 import { homedir } from "node:os"
 
 import { kitHome } from "../kitHome"
+import { payloadText } from "../payload"
 import { makeEngineServices, type EngineServices, type Logger } from "./services"
+import type { TerminalLease } from "./logger"
 import type { BunRuntimeState } from "./bun"
-import { claudeNextSteps, claudeSummary, claudeSync } from "./claudeSync"
+import { claudeNextSteps, claudeSummary, claudeSync, type ClaudeRuntimeState } from "./claudeSync"
 import { codexNextSteps, codexSummary, codexSync } from "./codexSync"
-import { skillsNextSteps, skillsSummary, skillsSync } from "./skillsSync"
+import { normalizeManifest, skillsNextSteps, skillsSummary, skillsSync, type SkillsState } from "./skillsSync"
 import { modeModel, modeToolchain } from "./modes"
 import { ExitError, parseArgs, validateModifierFlags } from "./parseArgs"
 
@@ -24,13 +26,61 @@ export type ModifierFlag =
   | "--codex-model"
   | "--codex-effort"
 
+export type SyncConcurrency = 1 | 2 | 3
+export type SyncTask<T> = () => Promise<T>
+
+/**
+ * Run input-ordered tasks with bounded overlap. Once one task rejects, queued
+ * tasks stay queued while already-started tasks drain; the earliest rejection
+ * in input order is then propagated.
+ */
+export async function runBounded<T>(
+  tasks: ReadonlyArray<SyncTask<T>>,
+  concurrency: SyncConcurrency
+): Promise<Array<T>> {
+  const results = new Array<T>(tasks.length)
+  const failures = new Map<number, unknown>()
+  let nextIndex = 0
+  let stopped = false
+
+  const workers = Array.from({ length: Math.min(concurrency, tasks.length) }, async () => {
+    for (;;) {
+      if (stopped || nextIndex >= tasks.length) return
+      const index = nextIndex
+      nextIndex += 1
+      try {
+        results[index] = await tasks[index]!()
+      } catch (error) {
+        failures.set(index, error)
+        stopped = true
+      }
+    }
+  })
+  await Promise.all(workers)
+
+  for (let index = 0; index < tasks.length; index += 1) {
+    if (failures.has(index)) throw failures.get(index)
+  }
+  return results
+}
+
+export function syncConcurrencyForManifest(
+  configured: SyncConcurrency,
+  manifest: string,
+  claudeSelected: boolean,
+  skillsSelected: boolean
+): SyncConcurrency {
+  if (!claudeSelected || !skillsSelected || normalizeManifest(manifest).length === 0) return configured
+  return 1
+}
+
 export interface Ctx {
   readonly repoDir: string
   readonly home: string
   readonly agentsDir: string
   dryRun: boolean
   verbose: boolean
-  skipRtk: boolean
+  skipBubblewrap: boolean
   skipPluginRefresh?: boolean
   reconcile: boolean
   prune: boolean
@@ -47,7 +97,9 @@ export interface Ctx {
   modifierFlags?: Set<ModifierFlag>
   /** Injected capability seam (logger/deps/platform) — see services.ts. */
   readonly services: EngineServices
-  bunRuntime?: BunRuntimeState
+  syncConcurrency: SyncConcurrency
+  terminalLease?: TerminalLease
+  bunRuntime?: Promise<BunRuntimeState>
   targetFilterSet: boolean
   syncClaude: boolean
   syncCodex: boolean
@@ -71,7 +123,7 @@ function makeCtx(services: EngineServices): Ctx {
     agentsDir: env["AGENTS_DIR"] !== undefined && env["AGENTS_DIR"] !== "" ? env["AGENTS_DIR"] : p(home, ".agents"),
     dryRun: env["DRY_RUN"] === "1",
     verbose: env["DOCKS_KIT_VERBOSE"] === "1",
-    skipRtk: env["SKIP_RTK"] === "1",
+    skipBubblewrap: env["SKIP_BUBBLEWRAP"] === "1",
     skipPluginRefresh: false,
     reconcile: env["RECONCILE"] === "1",
     prune: env["PRUNE"] === "1",
@@ -85,6 +137,7 @@ function makeCtx(services: EngineServices): Ctx {
     codexModel: env["CODEX_MODEL"] ?? "",
     codexEffort: "",
     modifierFlags: new Set(),
+    syncConcurrency: 3,
     services,
     targetFilterSet: false,
     syncClaude: false,
@@ -94,18 +147,95 @@ function makeCtx(services: EngineServices): Ctx {
   }
 }
 
-function engineSync(ctx: Ctx, args: ReadonlyArray<string>): number {
-  const { echo } = ctx.services.logger
+async function engineSync(ctx: Ctx, args: ReadonlyArray<string>): Promise<number> {
+  const { acquireTerminal, echo, err } = ctx.services.logger
   parseArgs(ctx, args)
   validateModifierFlags(ctx)
 
-  const claudeRan = ctx.syncClaude
-  const claudeRuntime = claudeRan ? claudeSync(ctx) : undefined
+  const configuredConcurrency = process.env["DOCKS_KIT_SYNC_CONCURRENCY"]
+  if (configuredConcurrency === undefined || configuredConcurrency === "") {
+    ctx.syncConcurrency = 3
+  } else if (
+    configuredConcurrency === "1" ||
+    configuredConcurrency === "2" ||
+    configuredConcurrency === "3"
+  ) {
+    ctx.syncConcurrency = Number(configuredConcurrency) as SyncConcurrency
+  } else {
+    err("DOCKS_KIT_SYNC_CONCURRENCY must be 1, 2, or 3")
+    throw new ExitError(2)
+  }
 
-  const codexRan = ctx.syncCodex
-  if (codexRan) codexSync(ctx)
+  type PipelineResult =
+    | { readonly kind: "claude"; readonly runtime: ClaudeRuntimeState }
+    | { readonly kind: "codex" }
+    | { readonly kind: "skills"; readonly state: SkillsState }
+  interface SelectedPipeline {
+    readonly name: string
+    readonly run: SyncTask<PipelineResult>
+  }
+
+  const selected: Array<SelectedPipeline> = []
+  if (ctx.syncClaude) {
+    selected.push({
+      name: "Claude",
+      run: async () => ({ kind: "claude", runtime: await claudeSync(ctx) })
+    })
+  }
+  if (ctx.syncCodex) {
+    selected.push({
+      name: "Codex",
+      run: async () => {
+        await codexSync(ctx)
+        return { kind: "codex" }
+      }
+    })
+  }
+  if (ctx.syncAgents) {
+    selected.push({
+      name: "skills",
+      run: async () => ({ kind: "skills", state: await skillsSync(ctx) })
+    })
+  }
+
+  // A populated skills manifest deploys with `-a claude-code codex`, and symlink healing also writes into Claude's tree.
+  ctx.syncConcurrency = syncConcurrencyForManifest(
+    ctx.syncConcurrency,
+    payloadText("SoT/.agents/skills.txt"),
+    ctx.syncClaude,
+    ctx.syncAgents
+  )
 
-  const skillsState = ctx.syncAgents ? skillsSync(ctx) : undefined
+  const remaining = new Set(selected.map(({ name }) => name))
+  const lease = acquireTerminal(`Syncing ${[...remaining].join(", ")}...`)
+  ctx.terminalLease = lease
+  let results: Array<PipelineResult>
+  try {
+    const tasks = selected.map(
+      ({ name, run }): SyncTask<PipelineResult> =>
+        async () => {
+          try {
+            return await run()
+          } finally {
+            remaining.delete(name)
+            if (remaining.size > 0) lease.update(`Syncing ${[...remaining].join(", ")}...`)
+          }
+        }
+    )
+    results = await runBounded(tasks, ctx.syncConcurrency)
+  } finally {
+    lease.release()
+    ctx.terminalLease = undefined
+  }
+
+  const claudeRan = ctx.syncClaude
+  const codexRan = ctx.syncCodex
+  let claudeRuntime: ClaudeRuntimeState | undefined
+  let skillsState: SkillsState | undefined
+  for (const result of results) {
+    if (result.kind === "claude") claudeRuntime = result.runtime
+    else if (result.kind === "skills") skillsState = result.state
+  }
 
   echo("")
   echo("--- Sync complete ---")
@@ -127,18 +257,21 @@ function engineSync(ctx: Ctx, args: ReadonlyArray<string>): number {
 }
 
 
-export function runEngineNative(argv: ReadonlyArray<string>, services?: EngineServices): number {
+export async function runEngineNative(argv: ReadonlyArray<string>, services?: EngineServices): Promise<number> {
   let ctx!: Ctx
   const baseServices = services ?? makeEngineServices()
   const baseLogger = baseServices.logger
   const logger: Logger = {
     change: (msg) => baseLogger.change(msg),
+    progress: (msg) => baseLogger.progress(msg),
+    clearProgress: () => baseLogger.clearProgress(),
     verbose: (msg) => {
       if (ctx.verbose) baseLogger.verbose(msg)
     },
     warn: (msg) => baseLogger.warn(msg),
     err: (msg) => baseLogger.err(msg),
-    echo: (line) => baseLogger.echo(line)
+    echo: (line) => baseLogger.echo(line),
+    acquireTerminal: (message) => baseLogger.acquireTerminal(message)
   }
   const runServices: EngineServices = {
     logger,
@@ -151,11 +284,11 @@ export function runEngineNative(argv: ReadonlyArray<string>, services?: EngineSe
       case "model":
         return modeModel(ctx, argv.slice(1))
       case "toolchain":
-        return modeToolchain(ctx, argv.slice(1))
+        return await modeToolchain(ctx, argv.slice(1))
       case "sync":
-        return engineSync(ctx, argv.slice(1))
+        return await engineSync(ctx, argv.slice(1))
       default:
-        return engineSync(ctx, argv)
+        return await engineSync(ctx, argv)
     }
   } catch (e) {
     if (e instanceof ExitError) return e.code