docks-kit 0.17.1 → 0.17.2

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

@@ -2,162 +2,165 @@
  * Direct modes for `model` and `toolchain`. Same public argv vocabulary,
  * golden-tested messages, same exit codes.
  */
-import { p } from "./exec"
-import { readFileSync } from "node:fs"
-import { payloadText } from "../payload"
+import { p } from "./exec";
+import { readFileSync } from "node:fs";
+import { payloadText } from "../payload";
 
-import { syncClaudeModel } from "./claudeSettingsModifiers"
-import { syncCodexModel } from "./codexToml"
-import type { Ctx } from "./index"
-import { isObject, parseJson, type Json } from "./jq"
-import { printModels, validateClaudeModel, validateCodexModel } from "./models"
-import { bunBootstrap } from "./bun"
-import { installedVersion, present, report } from "./toolchain"
+import { syncClaudeModel } from "./claudeSettingsModifiers";
+import { syncCodexModel } from "./codexToml";
+import type { Ctx } from "./index";
+import { isObject, parseJson, type Json } from "./jq";
+import { printModels, validateClaudeModel, validateCodexModel } from "./models";
+import { bunBootstrap } from "./bun";
+import { installedVersion, present, report } from "./toolchain";
 
 export function modeModel(ctx: Ctx, args: ReadonlyArray<string>): number {
-  const { echo, err, warn } = ctx.services.logger
-  let tool = ""
-  let value = ""
+  const { echo, err, warn } = ctx.services.logger;
+  let tool = "";
+  let value = "";
   for (const arg of args) {
-    if (arg === "--dry-run") ctx.dryRun = true
+    if (arg === "--dry-run") ctx.dryRun = true;
     else if (arg === "--verbose") {
-      ctx.verbose = true
-    } else if (arg === "claude" || arg === "codex") tool = arg
+      ctx.verbose = true;
+    } else if (arg === "claude" || arg === "codex") tool = arg;
     else if (arg.startsWith("-")) {
-      err(`Unknown flag for model: ${arg}`)
-      return 2
-    } else value = arg
+      err(`Unknown flag for model: ${arg}`);
+      return 2;
+    } else value = arg;
   }
   if (tool === "") {
-    err("Usage: model <claude|codex> [value] [--dry-run]")
-    return 2
+    err("Usage: model <claude|codex> [value] [--dry-run]");
+    return 2;
   }
 
   if (value === "") {
     if (tool === "claude") {
-      const deployed = p(ctx.home, ".claude", "settings.json")
-      const result = readConfig(deployed)
+      const deployed = p(ctx.home, ".claude", "settings.json");
+      const result = readConfig(deployed);
       if (result.kind === "missing") {
-        warn("~/.claude/settings.json missing")
-        return 0
+        warn("~/.claude/settings.json missing");
+        return 0;
       }
       if (result.kind === "read-error") {
-        err(`Failed to read ~/.claude/settings.json: ${String(result.error)}`)
-        return 1
+        err(`Failed to read ~/.claude/settings.json: ${String(result.error)}`);
+        return 1;
       }
-      echo(`deployed: ${jsonModelText(result.data)}`)
-      echo(`SoT:      ${jsonModelText(payloadText("SoT/.claude/settings.json"))}`)
+      echo(`deployed: ${jsonModelText(result.data)}`);
+      echo(`SoT:      ${jsonModelText(payloadText("SoT/.claude/settings.json"))}`);
     } else {
-      const deployed = p(ctx.home, ".codex", "config.toml")
-      const result = readConfig(deployed)
+      const deployed = p(ctx.home, ".codex", "config.toml");
+      const result = readConfig(deployed);
       if (result.kind === "missing") {
-        warn("~/.codex/config.toml missing")
-        return 0
+        warn("~/.codex/config.toml missing");
+        return 0;
       }
       if (result.kind === "read-error") {
-        err(`Failed to read ~/.codex/config.toml: ${String(result.error)}`)
-        return 1
+        err(`Failed to read ~/.codex/config.toml: ${String(result.error)}`);
+        return 1;
       }
-      echo(`deployed: ${tomlModelText(result.data)}`)
-      echo(`SoT:      ${tomlModelText(payloadText("SoT/.codex/config.toml"))}`)
+      echo(`deployed: ${tomlModelText(result.data)}`);
+      echo(`SoT:      ${tomlModelText(payloadText("SoT/.codex/config.toml"))}`);
     }
-    printModels(ctx, tool)
-    return 0
+    printModels(ctx, tool);
+    return 0;
   }
 
   if (tool === "claude") {
     if (!validateClaudeModel(ctx, value)) {
-      printModels(ctx, "claude")
-      err(`Invalid Claude model '${value}'`)
-      return 2
+      printModels(ctx, "claude");
+      err(`Invalid Claude model '${value}'`);
+      return 2;
     }
-    syncClaudeModel(ctx, value)
+    syncClaudeModel(ctx, value);
   } else {
     if (!validateCodexModel(ctx, value)) {
-      printModels(ctx, "codex")
-      err(`Invalid Codex model '${value}'`)
-      return 2
+      printModels(ctx, "codex");
+      err(`Invalid Codex model '${value}'`);
+      return 2;
     }
-    syncCodexModel(ctx, value)
+    syncCodexModel(ctx, value);
   }
-  return 0
+  return 0;
 }
 
 type ConfigReadResult =
   | { readonly kind: "missing" }
   | { readonly kind: "read-error"; readonly error: unknown }
-  | { readonly kind: "data"; readonly data: string }
+  | { readonly kind: "data"; readonly data: string };
 
 function readConfig(file: string): ConfigReadResult {
   try {
-    return { kind: "data", data: readFileSync(file, "utf8") }
+    return { kind: "data", data: readFileSync(file, "utf8") };
   } catch (error) {
     const code =
-      typeof error === "object" && error !== null && "code" in error && typeof error.code === "string"
+      typeof error === "object" &&
+      error !== null &&
+      "code" in error &&
+      typeof error.code === "string"
         ? error.code
-        : undefined
-    return code === "ENOENT" ? { kind: "missing" } : { kind: "read-error", error }
+        : undefined;
+    return code === "ENOENT" ? { kind: "missing" } : { kind: "read-error", error };
   }
 }
 
 function jsonModelText(text: string): string {
-  const doc = parseJson(text)
-  if (doc === undefined) return ""
-  const v: Json | undefined = isObject(doc) ? doc["model"] : undefined
-  if (v === undefined || v === null || v === false) return "default (unset)"
-  return typeof v === "string" ? v : JSON.stringify(v)
+  const doc = parseJson(text);
+  if (doc === undefined) return "";
+  const v: Json | undefined = isObject(doc) ? doc["model"] : undefined;
+  if (v === undefined || v === null || v === false) return "default (unset)";
+  return typeof v === "string" ? v : JSON.stringify(v);
 }
 
 /** `awk -F'"' '/^model[[:space:]]*=/{print $2; exit}'`. */
 
 function tomlModelText(text: string): string {
   for (const line of text.split("\n")) {
-    if (/^model[ \t]*=/.test(line)) return line.split('"')[1] ?? ""
+    if (/^model[ \t]*=/.test(line)) return line.split('"')[1] ?? "";
   }
-  return ""
+  return "";
 }
 
 export async function modeToolchain(ctx: Ctx, args: ReadonlyArray<string>): Promise<number> {
-  const { echo, err, verbose } = ctx.services.logger
-  const words = args.filter((arg) => !arg.startsWith("--"))
-  const op = words[0] ?? "check"
-  const tool = words[1] ?? ""
+  const { echo, err, verbose } = ctx.services.logger;
+  const words = args.filter((arg) => !arg.startsWith("--"));
+  const op = words[0] ?? "check";
+  const tool = words[1] ?? "";
   for (const arg of args) {
-    if (arg === "--verbose") ctx.verbose = true
+    if (arg === "--verbose") ctx.verbose = true;
   }
 
   if (op === "check") {
-    await report(ctx)
-    return 0
+    await report(ctx);
+    return 0;
   }
   if (op !== "ensure") {
-    err("Usage: toolchain [check|ensure <tool>]")
-    return 2
+    err("Usage: toolchain [check|ensure <tool>]");
+    return 2;
   }
   if (tool === "") {
-    err("Usage: toolchain ensure <tool>")
-    return 2
+    err("Usage: toolchain ensure <tool>");
+    return 2;
   }
   switch (tool) {
     case "bun": {
       // `bun` is the one managed tool, and its bootstrap is silent when Bun is
       // already installed. Probe first so the no-op confirmation the `--verbose`
       // contract promises is not mistaken for a fresh install.
-      const alreadyInstalled = present(ctx, "bun")
-      if ((await bunBootstrap(ctx, ctx.services)).kind !== "ready") return 1
+      const alreadyInstalled = present(ctx, "bun");
+      if ((await bunBootstrap(ctx, ctx.services)).kind !== "ready") return 1;
       if (alreadyInstalled) {
         // A present tool whose --version cannot be read reports `unknown` in the
         // doctor table; keep the same vocabulary rather than an empty pair of
         // parentheses.
-        const probed = await installedVersion(ctx, "bun")
-        const installed = probed === "" ? "version unknown" : probed
-        if (ctx.dryRun) echo(`[dry-run] bun up to date (${installed})`)
-        else verbose(`bun up to date (${installed})`)
+        const probed = await installedVersion(ctx, "bun");
+        const installed = probed === "" ? "version unknown" : probed;
+        if (ctx.dryRun) echo(`[dry-run] bun up to date (${installed})`);
+        else verbose(`bun up to date (${installed})`);
       }
-      return 0
+      return 0;
     }
     default:
-      err("toolchain ensure supports managed tools only (bun)")
-      return 2
+      err("toolchain ensure supports managed tools only (bun)");
+      return 2;
   }
 }

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

@@ -0,0 +1,111 @@
+/**
+ * EngineNative omp file deploy: private file modes, whole-file sync, and
+ * merged-YAML sync for the agent directory. Split from ompSync.ts; the
+ * orchestration still lives there.
+ */
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { basename } from "node:path";
+
+import { payloadDisplayPath, payloadText, type PayloadPath } from "../payload";
+import type { Ctx } from "./index";
+
+export type OmpTextPayloadPath = Extract<PayloadPath, `SoT/.omp/${string}`>;
+
+// ------------------------------------------------------------ file modes ----
+
+/**
+ * `mkdirSync` and `writeFileSync` apply their `mode` only when they create the
+ * path, so an existing world-readable directory or file would keep its mode.
+ * The explicit chmod reproduces `install -d -m 0700` / `install -m 0600`.
+ */
+export function ensureDirectory(directory: string): void {
+  mkdirSync(directory, { recursive: true, mode: 0o700 });
+  chmodSync(directory, 0o700);
+}
+
+function writePrivateFile(target: string, content: string): void {
+  writeFileSync(target, content, { mode: 0o600 });
+  chmodSync(target, 0o600);
+}
+
+function backupPrivateFile(target: string): void {
+  copyFileSync(target, `${target}.bak`);
+  chmodSync(`${target}.bak`, 0o600);
+}
+
+// --------------------------------------------------------------- config ----
+
+export function syncWholeFile(
+  ctx: Ctx,
+  sourcePath: OmpTextPayloadPath,
+  target: string,
+  alreadyMessage: string,
+  syncedMessage: string,
+): void {
+  const { change, echo, verbose } = ctx.services.logger;
+  const source = payloadDisplayPath(sourcePath);
+  const content = payloadText(sourcePath);
+
+  if (ctx.dryRun) {
+    echo(`[dry-run] cp ${source} -> ${target}`);
+    return;
+  }
+
+  if (existsSync(target) && readFileSync(target, "utf8") === content) {
+    verbose(alreadyMessage);
+    return;
+  }
+  if (existsSync(target)) backupPrivateFile(target);
+  writePrivateFile(target, content);
+  change(syncedMessage);
+  ctx.nextStepTriggers.ompRestart = true;
+}
+
+export function syncMergedYaml(
+  ctx: Ctx,
+  sourcePath: OmpTextPayloadPath,
+  target: string,
+  merge: (sotText: string, deployedText: string) => string,
+): void {
+  const { change, echo, verbose } = ctx.services.logger;
+  const source = payloadDisplayPath(sourcePath);
+  const sotText = payloadText(sourcePath);
+  const name = basename(sourcePath);
+
+  if (!existsSync(target)) {
+    if (ctx.dryRun) {
+      echo(`[dry-run] cp ${source} -> ${target}`);
+      return;
+    }
+    writePrivateFile(target, sotText);
+    change(`omp ${name} installed`);
+    ctx.nextStepTriggers.ompRestart = true;
+    return;
+  }
+
+  const deployedText = readFileSync(target, "utf8");
+  const merged = merge(sotText, deployedText);
+  if (merged === deployedText) {
+    verbose(`omp ${name} already in sync`);
+    return;
+  }
+  if (ctx.dryRun) {
+    echo(`[dry-run] merge ${source} -> ${target} (backup at ${target}.bak)`);
+    return;
+  }
+
+  backupPrivateFile(target);
+  writePrivateFile(`${target}.tmp`, merged);
+  renameSync(`${target}.tmp`, target);
+  chmodSync(target, 0o600);
+  change(`omp ${name} merged (backup at ${name}.bak)`);
+  ctx.nextStepTriggers.ompRestart = true;
+}

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

@@ -0,0 +1,136 @@
+/**
+ * EngineNative omp marketplace pass: registry detection plus register, adopt,
+ * and refresh flows. Split from ompSync.ts; the orchestration still lives
+ * there. `firstOutputLine` is shared with the plugin pass in ompPlugins.ts.
+ */
+import { existsSync, readFileSync } from "node:fs";
+
+import { spawnProcess, type AsyncProcessResult } from "./exec";
+import { recordFailure } from "./failures";
+import type { Ctx } from "./index";
+import { isObject, parseJson } from "./jq";
+
+const MARKETPLACE_NAME = "docks";
+const MARKETPLACE_SOURCE = "https://github.com/DocksDocks/docks.git";
+
+// ---------------------------------------------------------- marketplace ----
+
+function registryHasDocks(registryFile: string): boolean {
+  if (!existsSync(registryFile)) return false;
+
+  let registryText: string;
+  try {
+    registryText = readFileSync(registryFile, "utf8");
+  } catch {
+    return false;
+  }
+  const registry = parseJson(registryText);
+  if (registry === undefined) return false;
+  if (isObject(registry) && Object.hasOwn(registry, MARKETPLACE_NAME)) return true;
+
+  const entries = Array.isArray(registry)
+    ? registry
+    : isObject(registry) && Array.isArray(registry["marketplaces"])
+      ? registry["marketplaces"]
+      : [];
+  return entries.some((entry) => isObject(entry) && entry["name"] === MARKETPLACE_NAME);
+}
+
+export function firstOutputLine(result: AsyncProcessResult): string {
+  const output = `${result.stdout}${result.stderr}`;
+  return output.split("\n")[0] || "unknown error";
+}
+
+/**
+ * Three states, because upstream `getMarketplacesRegistryPath` copies a legacy
+ * `configRoot` registry forward the first time it resolves an XDG data root:
+ * the active registry lists docks, only the legacy registry lists it, or
+ * neither does. In the middle state the kit never copies user data itself; it
+ * takes the refresh path, whose own resolution inside omp performs that
+ * adoption and leaves the active registry present.
+ */
+export async function syncMarketplace(
+  ctx: Ctx,
+  registryFile: string,
+  legacyRegistryFile?: string,
+): Promise<void> {
+  const { change, clearProgress, echo, progress, verbose } = ctx.services.logger;
+  const registered = registryHasDocks(registryFile);
+  const adoptable =
+    !registered && legacyRegistryFile !== undefined && registryHasDocks(legacyRegistryFile);
+
+  if (ctx.dryRun) {
+    if (adoptable) {
+      echo(
+        ctx.skipPluginRefresh === true
+          ? "[dry-run] omp plugin marketplace list"
+          : `[dry-run] omp plugin marketplace update ${MARKETPLACE_NAME}`,
+      );
+    } else if (registered) verbose("omp docks marketplace already registered");
+    else echo(`[dry-run] omp plugin marketplace add ${MARKETPLACE_SOURCE}`);
+    return;
+  }
+
+  // syncPlugins owns the single skip message for both missing CLIs, and it runs
+  // right after this pass. Without omp no marketplace command can run at all,
+  // and without git a marketplace clone cannot resolve, so both are deliberate
+  // skips: return silently instead of spawning and recording a failure.
+  if (ctx.services.deps.probe("omp").state === "missing") return;
+  if (ctx.services.deps.probe("git").state === "missing") return;
+
+  if (!registered && !adoptable) {
+    progress("Registering omp docks marketplace...");
+    const result = await spawnProcess("omp", ["plugin", "marketplace", "add", MARKETPLACE_SOURCE], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    clearProgress();
+    if (result.error === undefined && result.exitCode === 0) {
+      change("omp docks marketplace registered");
+    } else {
+      recordFailure(
+        ctx,
+        `omp docks marketplace registration failed: ${firstOutputLine(result)}; run manually: omp plugin marketplace add ${MARKETPLACE_SOURCE}`,
+      );
+    }
+    return;
+  }
+
+  if (ctx.skipPluginRefresh === true) {
+    if (!adoptable) {
+      verbose("omp docks marketplace already registered; refresh-only update skipped");
+      return;
+    }
+
+    // Adoption only needs omp to resolve the registry path. `marketplace list`
+    // does that and fetches nothing, so it stays inside the flag's contract
+    // while leaving the active registry present.
+    progress("Adopting omp docks marketplace registry...");
+    const listed = await spawnProcess("omp", ["plugin", "marketplace", "list"], {
+      stdio: ["ignore", "ignore", "pipe"],
+    });
+    clearProgress();
+    if (listed.error === undefined && listed.exitCode === 0) {
+      change("omp docks marketplace registry adopted; refresh-only update skipped");
+    } else {
+      recordFailure(
+        ctx,
+        `omp docks marketplace adoption failed: ${firstOutputLine(listed)}; run manually: omp plugin marketplace list`,
+      );
+    }
+    return;
+  }
+
+  progress("Updating omp docks marketplace...");
+  const result = await spawnProcess("omp", ["plugin", "marketplace", "update", MARKETPLACE_NAME], {
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  clearProgress();
+  if (result.error === undefined && result.exitCode === 0) {
+    verbose("omp docks marketplace refreshed");
+  } else {
+    recordFailure(
+      ctx,
+      `omp docks marketplace update failed: ${firstOutputLine(result)}; run manually: omp plugin marketplace update ${MARKETPLACE_NAME}`,
+    );
+  }
+}