dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/providers/lib/acquire.d.ts

@@ -8,7 +8,8 @@
  * local changes aborts, because a rebase would eat the user's work.
  * @module dsh-plugin-local-infer/providers/acquire
  */
-import type { LifecycleHost } from '../../core/lib/index.js';
+import type { DeployOptions, EnginePlatformConfig, LaunchProgress, LifecycleHost } from '../../core/lib/index.js';
+import type { EngineOsProfile } from './engines/engineOs.ts';
 /**
  * EngineSource is the per-engine acquisition data: the upstream git repo the
  * clone step uses when no fork is provided, the branch the fetch/rebase step
@@ -20,6 +21,7 @@ export interface EngineSource {
     repo: string;
     branch: string;
     buildSteps: readonly string[];
+    windowsBuildSteps?: readonly string[];
 }
 /**
  * The remote name a user-provided fork is added under, so the checkout's own
@@ -31,10 +33,36 @@ export declare const FORK_REMOTE = "dsh-fork";
  * through cmake (Infernix through its own preset); llama.cpp builds through
  * the same cmake shape as NInfer; Hyper-Qwen is the compose-driven vLLM
  * engine, so it carries no local build steps (the compose up pulls the
- * image); Strata is the placeholder engine, and its repo and pull step land
- * with the engine, the same way its docker image constant did.
+ * image); Strata builds through its own setup.sh (the README's
+ * Build-from-source route), which the source-build mode runs in the checkout;
+ * Basalt builds through its own CMake route (the Ninja/MSVC variant on
+ * Windows). The build steps are read from the per-engine OS profiles, so a
+ * build command has one home (the OS-specific files under engines/).
  */
 export declare const ENGINE_SOURCES: Record<string, EngineSource>;
+/**
+ * engineOsProfile reads the registered build profile for an engine id on an OS,
+ * or undefined when none is registered. A host OS with no dedicated profile
+ * (a Windows host for an engine that carries no Windows route) reads the
+ * shared Linux profile.
+ */
+export declare function engineOsProfile(engineId: string, os?: 'linux' | 'windows' | 'macos'): EngineOsProfile | undefined;
+/**
+ * engineBuildDir reads the directory, relative to the checkout, where an
+ * engine's build leaves its binary on an OS, so the binary symlink step reads
+ * the right tree. A Windows host reads the engine's Windows build tree (the
+ * vcpkg route for NInfer writes into build-windows\apps\Release); every other
+ * host reads the shared Linux build directory. An engine that installs its
+ * binary to the path (Strata) carries no build directory, so it reads as
+ * `build`, the shared default.
+ */
+export declare function engineBuildDir(engineId: string, os?: 'linux' | 'windows' | 'macos'): string;
+/**
+ * engineBinary reads the engine binary name on an OS (the .exe on Windows), so
+ * the adapters and the symlink step share one source. An engine with no local
+ * binary (the compose engines) reads as undefined.
+ */
+export declare function engineBinary(engineId: string, os?: 'linux' | 'windows' | 'macos'): string | undefined;
 /**
  * AcquireLog receives one line (or chunk) of Get output as it lands, so the
  * route can stream it to the card's Logs section.
@@ -50,42 +78,63 @@ export interface EngineStepResult {
     aborted?: boolean;
     detail?: string;
 }
+/**
+ * SyncStepResult is the sync step's EngineStepResult plus the path it took:
+ * `cloned` true means a fresh clone ran (no prior checkout), so a failure on
+ * that path leaves no current version to launch; an absent `cloned` means the
+ * checkout was present and the rebase, fetch, or dirty path ran, so a failure
+ * there leaves a launchable current version. The Get step reads the flag to
+ * decide a sync failure's fatality instead of re-probing the checkout.
+ */
+export interface SyncStepResult extends EngineStepResult {
+    cloned?: boolean;
+}
 /**
  * engineSource reads the registered acquisition data for an engine id, or
  * undefined when none is registered.
  */
 export declare function engineSource(engineId: string): EngineSource | undefined;
 /**
- * engineBuildSteps reads the build steps an engine runs in its checkout, so
- * the adapter's deploy step and the Get build step share one list.
+ * engineBuildSteps reads the build steps an engine runs in its checkout for an
+ * OS, so the adapter's deploy step and the Get build step share one list. The
+ * steps come from the engine's OS profile: a Windows host reads the engine's
+ * Windows profile (the vcpkg route for NInfer), and a host OS with no
+ * dedicated profile reads the shared Linux profile.
  */
-export declare function engineBuildSteps(engineId: string): readonly string[];
+export declare function engineBuildSteps(engineId: string, os?: 'linux' | 'windows' | 'macos'): readonly string[];
 /**
  * syncEngineRepo brings the engine checkout to the listed source. A missing
  * checkout is a fresh clone of the fork (or the engine's upstream repo when
  * no fork is provided). An existing checkout with local changes aborts, so
  * the user's work is never rebased away; a clean checkout fetches the listed
  * fork (added as the named fork remote when provided, origin when not) and
- * rebases onto its branch. Every command echoes into log as it runs.
+ * rebases onto its branch. Every command echoes into log as it runs. The
+ * result's `cloned` flag names the path taken: set on a fresh clone (the
+ * checkout was absent), absent on the present-checkout path, so a caller
+ * prices a failure's fatality from the flag instead of re-probing the
+ * checkout.
  */
 export declare function syncEngineRepo(host: LifecycleHost, request: {
     engineId: string;
     directory: string;
     fork?: string;
-}, log: AcquireLog): Promise<EngineStepResult>;
+}, log: AcquireLog): Promise<SyncStepResult>;
 /**
  * SyncRebuildRequest names the checkout the conditional rebuild prices: the
- * engine, its directory, the optional fork remote, the engine binary the
- * symlink step links when a rebuild leaves it out of the path, and the
- * Play/Run trust gate that decides whether that symlink runs (on) or is
- * written to the logs (off).
+ * engine, its directory, the optional fork remote, and the Play/Run trust gate
+ * that decides whether the binary symlink (added when a rebuild leaves the
+ * binary out of the path) runs (on) or is written to the logs (off). The
+ * symlink step reads the bare binary name from the engine profile, so the
+ * request carries no binary of its own.
  */
 export interface SyncRebuildRequest {
     engineId: string;
     directory: string;
     fork?: string;
-    binary?: string;
     allowRunDeps?: boolean;
+    buildCommands?: string;
+    onBuildStart?: () => void;
+    os?: 'linux' | 'windows' | 'macos';
 }
 /**
  * SyncRebuildResult reports the conditional rebuild: whether it passed,
@@ -115,11 +164,42 @@ export interface SyncRebuildResult {
  * added (run when the trust gate is on, written to the logs when it is off).
  */
 export declare function syncAndRebuildEngine(host: LifecycleHost, request: SyncRebuildRequest, log: AcquireLog): Promise<SyncRebuildResult>;
+/**
+ * EngineDeploySync reports the deploy step's git sync (the shared
+ * syncAndRebuildEngine): whether it passed, a detail for a failure, and the
+ * captured build output the deploy step threads to the card's Logs section
+ * (a "Building..." separator leads a rebuild's output, the same line the
+ * card writes when the build step event lands).
+ */
+export interface EngineDeploySync {
+    ok: boolean;
+    detail?: string;
+    buildLogs: string;
+}
+/**
+ * syncEngineForDeploy runs the deploy step's git sync (the shared
+ * syncAndRebuildEngine) with the option shape every adapter's deploy step
+ * assembles: the platform entry's fork and build-command override, the
+ * Play/Run trust gate, the plan's host OS (the Windows vcpkg route when the
+ * user carries no build-command override), and the progress sink the card's
+ * button reads (the git sync reports "Downloading...", the build step
+ * reports "Building..." the moment it starts). The captured build output is
+ * returned as buildLogs, so a caller threads it to the card's Logs section
+ * without re-running the steps.
+ */
+export declare function syncEngineForDeploy(host: LifecycleHost, request: {
+    engineId: string;
+    directory: string;
+    platform?: EnginePlatformConfig;
+    options?: DeployOptions;
+    os?: 'linux' | 'windows' | 'macos';
+    onProgress?: LaunchProgress;
+}): Promise<EngineDeploySync>;
 /**
  * buildEngineRepo runs the engine's build steps in the checkout, streaming
  * each step's output through log. An engine with no build steps (the compose
  * engines) passes through with a note; a failing step stops the build with
  * the step's detail.
  */
-export declare function buildEngineRepo(host: LifecycleHost, engineId: string, directory: string, log: AcquireLog): Promise<EngineStepResult>;
-//# sourceMappingURL=acquire.d.ts.map
+export declare function buildEngineRepo(host: LifecycleHost, engineId: string, directory: string, log: AcquireLog, buildCommands?: string, os?: 'linux' | 'windows' | 'macos'): Promise<EngineStepResult>;
+//# sourceMappingURL=acquire.d.ts.map

package/packages/providers/lib/acquire.js

@@ -8,50 +8,134 @@
  * local changes aborts, because a rebase would eat the user's work.
  * @module dsh-plugin-local-infer/providers/acquire
  */
+import { commandLogLine } from '../../core/lib/index.js';
+import { NINFER_LINUX } from "./engines/ninfer/ninferLinux.js";
+import { NINFER_MACOS } from "./engines/ninfer/ninferMacOS.js";
+import { NINFER_WINDOWS } from "./engines/ninfer/ninferWindows.js";
+import { INFERNIX_LINUX } from "./engines/infernix/infernixLinux.js";
+import { INFERNIX_MACOS } from "./engines/infernix/infernixMacOS.js";
+import { INFERNIX_WINDOWS } from "./engines/infernix/infernixWindows.js";
+import { LLAMACPP_LINUX } from "./engines/llamacpp/llamacppLinux.js";
+import { LLAMACPP_MACOS } from "./engines/llamacpp/llamacppMacOS.js";
+import { LLAMACPP_WINDOWS } from "./engines/llamacpp/llamacppWindows.js";
+import { HYPERQWEN_LINUX } from "./engines/hyperqwen/hyperqwenLinux.js";
+import { HYPERQWEN_MACOS } from "./engines/hyperqwen/hyperqwenMacOS.js";
+import { HYPERQWEN_WINDOWS } from "./engines/hyperqwen/hyperqwenWindows.js";
+import { STRATA_LINUX } from "./engines/strata/strataLinux.js";
+import { STRATA_MACOS } from "./engines/strata/strataMacOS.js";
+import { STRATA_WINDOWS } from "./engines/strata/strataWindows.js";
+import { BASALT_LINUX } from "./engines/basalt/basaltLinux.js";
+import { BASALT_MACOS } from "./engines/basalt/basaltMacOS.js";
+import { BASALT_WINDOWS } from "./engines/basalt/basaltWindows.js";
 /**
  * The remote name a user-provided fork is added under, so the checkout's own
  * origin (the upstream it was cloned from) survives the fork override.
  */
 export const FORK_REMOTE = 'dsh-fork';
+/**
+ * The per-engine, per-OS build profiles, keyed by engine id then OS. The
+ * distro-specific Linux profiles (Arch, Debian, Fedora) reuse the shared Linux
+ * profile, so they are not separate keys here. A host OS with no dedicated
+ * profile (a Windows host for an engine that carries no Windows route) reads
+ * the shared Linux profile.
+ */
+const ENGINE_OS_PROFILES = {
+    ninfer: { linux: NINFER_LINUX, macos: NINFER_MACOS, windows: NINFER_WINDOWS },
+    hyperqwen: { linux: HYPERQWEN_LINUX, macos: HYPERQWEN_MACOS, windows: HYPERQWEN_WINDOWS },
+    llamacpp: { linux: LLAMACPP_LINUX, macos: LLAMACPP_MACOS, windows: LLAMACPP_WINDOWS },
+    infernix: { linux: INFERNIX_LINUX, macos: INFERNIX_MACOS, windows: INFERNIX_WINDOWS },
+    strata: { linux: STRATA_LINUX, macos: STRATA_MACOS, windows: STRATA_WINDOWS },
+    basalt: { linux: BASALT_LINUX, macos: BASALT_MACOS, windows: BASALT_WINDOWS },
+};
 /**
  * The per-engine git sources, keyed by engine id. NInfer and Infernix build
  * through cmake (Infernix through its own preset); llama.cpp builds through
  * the same cmake shape as NInfer; Hyper-Qwen is the compose-driven vLLM
  * engine, so it carries no local build steps (the compose up pulls the
- * image); Strata is the placeholder engine, and its repo and pull step land
- * with the engine, the same way its docker image constant did.
+ * image); Strata builds through its own setup.sh (the README's
+ * Build-from-source route), which the source-build mode runs in the checkout;
+ * Basalt builds through its own CMake route (the Ninja/MSVC variant on
+ * Windows). The build steps are read from the per-engine OS profiles, so a
+ * build command has one home (the OS-specific files under engines/).
  */
 export const ENGINE_SOURCES = {
     ninfer: {
         repo: 'https://github.com/Neroued/ninfer',
         branch: 'master',
-        buildSteps: [
-            'cmake -S {dir} -B {dir}/build -G Ninja -DCMAKE_BUILD_TYPE=Release && cmake --build {dir}/build -j',
-        ],
+        buildSteps: NINFER_LINUX.buildSteps,
+        // The Windows route is the ninfer-all fork's vcpkg build: the manifest
+        // pulls the dev libraries, then the engine's own build-native.bat
+        // configures and builds. The step cds into the checkout first (the {dir}
+        // placeholder), because vcpkg install and the relative script path both
+        // resolve against the checkout root.
+        windowsBuildSteps: NINFER_WINDOWS.buildSteps,
     },
     hyperqwen: {
         repo: 'https://github.com/vllm-project/vllm',
         branch: 'main',
-        buildSteps: [],
+        buildSteps: HYPERQWEN_LINUX.buildSteps,
     },
     llamacpp: {
         repo: 'https://github.com/ggml-org/llama.cpp',
         branch: 'master',
-        buildSteps: [
-            'cmake -S {dir} -B {dir}/build -G Ninja -DCMAKE_BUILD_TYPE=Release && cmake --build {dir}/build -j',
-        ],
+        buildSteps: LLAMACPP_LINUX.buildSteps,
     },
     infernix: {
         repo: 'https://github.com/Wallawalla47/Infernix',
         branch: 'main',
-        buildSteps: ['cd {dir} && cmake --preset release && cmake --build build -j'],
+        buildSteps: INFERNIX_LINUX.buildSteps,
     },
     strata: {
-        repo: 'https://github.com/strata/strata',
+        // The README's Build-from-source route: git clone the repo, then run the
+        // engine's own setup.sh. `--yes` takes the recommended answer to every
+        // question (no prompts) and `--no-start` builds and installs the engine
+        // without starting the server, which the adapter's launch step then does.
+        repo: 'https://github.com/Niko1221/Strata',
         branch: 'main',
-        buildSteps: ['docker pull ghcr.io/strata/strata'],
+        buildSteps: STRATA_LINUX.buildSteps,
+    },
+    basalt: {
+        // The engine's own CMake route: configure a Release build into the
+        // `build` directory, then compile it. The Windows variant adds the Ninja
+        // generator and runs in the MSVC developer shell (vcvars64.bat).
+        repo: 'https://github.com/jesdga95/basalt',
+        branch: 'main',
+        buildSteps: BASALT_LINUX.buildSteps,
+        windowsBuildSteps: BASALT_WINDOWS.buildSteps,
     },
 };
+/**
+ * engineOsProfile reads the registered build profile for an engine id on an OS,
+ * or undefined when none is registered. A host OS with no dedicated profile
+ * (a Windows host for an engine that carries no Windows route) reads the
+ * shared Linux profile.
+ */
+export function engineOsProfile(engineId, os = 'linux') {
+    const profiles = ENGINE_OS_PROFILES[engineId];
+    if (profiles === undefined)
+        return undefined;
+    return profiles[os] ?? profiles.linux;
+}
+/**
+ * engineBuildDir reads the directory, relative to the checkout, where an
+ * engine's build leaves its binary on an OS, so the binary symlink step reads
+ * the right tree. A Windows host reads the engine's Windows build tree (the
+ * vcpkg route for NInfer writes into build-windows\apps\Release); every other
+ * host reads the shared Linux build directory. An engine that installs its
+ * binary to the path (Strata) carries no build directory, so it reads as
+ * `build`, the shared default.
+ */
+export function engineBuildDir(engineId, os = 'linux') {
+    return engineOsProfile(engineId, os)?.buildDir ?? 'build';
+}
+/**
+ * engineBinary reads the engine binary name on an OS (the .exe on Windows), so
+ * the adapters and the symlink step share one source. An engine with no local
+ * binary (the compose engines) reads as undefined.
+ */
+export function engineBinary(engineId, os = 'linux') {
+    return engineOsProfile(engineId, os)?.binary;
+}
 /**
  * engineSource reads the registered acquisition data for an engine id, or
  * undefined when none is registered.
@@ -60,17 +144,23 @@ export function engineSource(engineId) {
     return ENGINE_SOURCES[engineId];
 }
 /**
- * engineBuildSteps reads the build steps an engine runs in its checkout, so
- * the adapter's deploy step and the Get build step share one list.
+ * engineBuildSteps reads the build steps an engine runs in its checkout for an
+ * OS, so the adapter's deploy step and the Get build step share one list. The
+ * steps come from the engine's OS profile: a Windows host reads the engine's
+ * Windows profile (the vcpkg route for NInfer), and a host OS with no
+ * dedicated profile reads the shared Linux profile.
  */
-export function engineBuildSteps(engineId) {
-    return ENGINE_SOURCES[engineId]?.buildSteps ?? [];
+export function engineBuildSteps(engineId, os = 'linux') {
+    return engineOsProfile(engineId, os)?.buildSteps ?? [];
 }
 /**
  * runLogged runs one shell command through the host's streaming surface when
  * it has one (echoing the command and streaming its output through log), and
  * through plain run otherwise. The streamed copy is also collected, so a
- * caller can price the command's stdout (the dirty-check, for one).
+ * caller can price the command's stdout (the dirty-check, for one). A
+ * `shell` option (the engine OS profile's shell) runs the command in that
+ * shell instead of the host's default. A `needsSudo` option declares the
+ * command runs sudo, so the host applies the sudo-prompt rule to it.
  */
 async function runLogged(host, command, log, options) {
     let output = '';
@@ -79,13 +169,20 @@ async function runLogged(host, command, log, options) {
         log(chunk);
     };
     if (options?.echo !== false) {
-        log(`$ ${command}\n`);
+        log(commandLogLine(command));
     }
+    // exactOptionalPropertyTypes: carry only the options the caller set, so an
+    // absent shell or sudo declaration never passes `{ shell: undefined }`
+    // through.
+    const runOptions = {
+        ...(options?.shell === undefined ? {} : { shell: options.shell }),
+        ...(options?.needsSudo === undefined ? {} : { needsSudo: options.needsSudo }),
+    };
     if (host.runStream !== undefined) {
-        const outcome = await host.runStream(command, collect);
+        const outcome = await host.runStream(command, collect, runOptions);
         return { ...outcome, output };
     }
-    const outcome = await host.run(command);
+    const outcome = await host.run(command, runOptions);
     return { ...outcome, output };
 }
 /**
@@ -94,7 +191,11 @@ async function runLogged(host, command, log, options) {
  * no fork is provided). An existing checkout with local changes aborts, so
  * the user's work is never rebased away; a clean checkout fetches the listed
  * fork (added as the named fork remote when provided, origin when not) and
- * rebases onto its branch. Every command echoes into log as it runs.
+ * rebases onto its branch. Every command echoes into log as it runs. The
+ * result's `cloned` flag names the path taken: set on a fresh clone (the
+ * checkout was absent), absent on the present-checkout path, so a caller
+ * prices a failure's fatality from the flag instead of re-probing the
+ * checkout.
  */
 export async function syncEngineRepo(host, request, log) {
     const source = engineSource(request.engineId);
@@ -106,7 +207,12 @@ export async function syncEngineRepo(host, request, log) {
     }
     const directory = request.directory;
     const fork = request.fork !== undefined && request.fork.trim() !== '' ? request.fork : undefined;
-    const present = await host.run(`[ -d ${directory}/.git ]`);
+    // The presence probe is a git query, not a POSIX [ -d ] test: the shell the
+    // host runs is cmd on Windows, where [ is not a command and the test reads
+    // as a missing checkout every time. rev-parse exits 0 only inside a work
+    // tree, so a real checkout reads as present and an absent or non-git
+    // directory reads as missing, on every platform.
+    const present = await host.run(`git -C ${directory} rev-parse --is-inside-work-tree`);
     if (present.ok) {
         const status = await runLogged(host, `git -C ${directory} status --short`, log);
         if (!status.ok) {
@@ -145,9 +251,9 @@ export async function syncEngineRepo(host, request, log) {
     }
     const clone = await runLogged(host, `git clone ${fork ?? source.repo} ${directory}`, log);
     if (!clone.ok) {
-        return { ok: false, detail: `git clone failed: ${clone.detail ?? 'unknown'}` };
+        return { ok: false, cloned: true, detail: `git clone failed: ${clone.detail ?? 'unknown'}` };
     }
-    return { ok: true };
+    return { ok: true, cloned: true };
 }
 /**
  * syncAndRebuildEngine brings the engine checkout to the listed source and
@@ -181,7 +287,12 @@ export async function syncAndRebuildEngine(host, request, log) {
         chunks.push(chunk);
         log(chunk);
     };
-    const present = await host.run(`[ -d ${directory}/.git ]`);
+    // The presence probe is a git query, not a POSIX [ -d ] test: the shell the
+    // host runs is cmd on Windows, where [ is not a command and the test reads
+    // as a missing checkout every time. rev-parse exits 0 only inside a work
+    // tree, so a real checkout reads as present and an absent or non-git
+    // directory reads as missing, on every platform.
+    const present = await host.run(`git -C ${directory} rev-parse --is-inside-work-tree`);
     let rebuilt = false;
     if (!present.ok) {
         // A missing checkout is a fresh clone of the fork (or the upstream repo),
@@ -201,10 +312,13 @@ export async function syncAndRebuildEngine(host, request, log) {
     else {
         if (fork !== undefined) {
             // Add the fork under its own remote name; a re-launch updates the URL in
-            // place so an edited fork field takes effect on the next run.
-            const add = await runLogged(host, `git -C ${directory} remote add ${FORK_REMOTE} ${fork}`, emit, { echo: false });
+            // place so an edited fork field takes effect on the next run. Both
+            // remote commands mutate the checkout's git config, so their `$ command`
+            // lines lead their output (the TASK-007 exec-audit rule): a re-launch
+            // reads the expected add failure and the set-url that follows.
+            const add = await runLogged(host, `git -C ${directory} remote add ${FORK_REMOTE} ${fork}`, emit);
             if (!add.ok) {
-                await runLogged(host, `git -C ${directory} remote set-url ${FORK_REMOTE} ${fork}`, emit, { echo: false });
+                await runLogged(host, `git -C ${directory} remote set-url ${FORK_REMOTE} ${fork}`, emit);
             }
         }
         const status = await runLogged(host, `git -C ${directory} status --short`, emit, { echo: false });
@@ -221,7 +335,10 @@ export async function syncAndRebuildEngine(host, request, log) {
             return { ok: true, rebuilt: false, logs: chunks.join('') };
         }
         // The fetch is best-effort: an offline host prices the checkout it has.
-        await runLogged(host, `git -C ${directory} fetch ${remote} || true`, emit, { echo: false });
+        // It mutates the checkout's objects and refs, so the `$ command` line
+        // leads its output (the TASK-007 exec-audit rule); the `|| true` keeps a
+        // failed fetch silent so the behind-check prices what is already present.
+        await runLogged(host, `git -C ${directory} fetch ${remote} || true`, emit);
         // Price whether the current branch is behind the remote branch. A fetch
         // that failed (offline) or a missing remote branch reads as not-behind, so
         // the checkout builds as-is.
@@ -264,10 +381,26 @@ export async function syncAndRebuildEngine(host, request, log) {
         }
     }
     if (rebuilt) {
-        // Run the engine's build steps, capturing the command and its output.
-        for (const step of source.buildSteps) {
+        // The user's local build command (the card's Build commands field)
+        // overrides the engine's default build steps: it runs in the checkout, so
+        // it is wrapped with a cd into the directory. Absent falls back to the
+        // engine's acquisition build steps.
+        const buildCommands = request.buildCommands !== undefined && request.buildCommands.trim() !== ''
+            ? request.buildCommands
+            : undefined;
+        const steps = buildCommands !== undefined
+            ? [`cd ${directory} && ${buildCommands}`]
+            : engineBuildSteps(request.engineId, request.os ?? 'linux');
+        // The engine OS profile's shell (the Windows vcpkg route's pwsh.exe)
+        // runs the build steps; absent keeps the host's default shell.
+        const shell = engineOsProfile(request.engineId, request.os ?? 'linux')?.shell;
+        const stepOptions = shell !== undefined ? { shell } : undefined;
+        // Report the build phase before the first step runs, so the card's button
+        // reads "Building..." while the build is in flight, not after it completes.
+        request.onBuildStart?.();
+        for (const step of steps) {
             const command = step.replaceAll('{dir}', directory);
-            const outcome = await runLogged(host, command, emit);
+            const outcome = await runLogged(host, command, emit, stepOptions);
             if (!outcome.ok) {
                 return {
                     ok: false,
@@ -279,13 +412,24 @@ export async function syncAndRebuildEngine(host, request, log) {
         }
         // A rebuild that did not install the binary (no make install) leaves it
         // out of the path. Check, and add a symlink when the trust gate allows.
-        const binary = request.binary;
+        // The symlink name is the profile's bare binary (the .exe on Windows), not
+        // the launch path: a Windows launch path carries its build tree
+        // (build-windows\apps\Release\ninfer-serve.exe), so linking it under
+        // buildDir would double the tree.
+        const binary = engineBinary(request.engineId, request.os ?? 'linux');
         if (binary !== undefined) {
             const which = await host.run(`command -v ${binary}`);
             if (!which.ok) {
-                const link = `sudo ln -sf ${directory}/build/${binary} /usr/local/bin/${binary}`;
+                // The build directory is OS-specific: a Windows host reads the
+                // engine's Windows build tree (the vcpkg route for NInfer writes into
+                // build-windows\apps\Release), every other host the shared Linux build
+                // directory.
+                const buildDir = engineBuildDir(request.engineId, request.os ?? 'linux');
+                const link = `sudo ln -sf ${directory}/${buildDir}/${binary} /usr/local/bin/${binary}`;
                 if (request.allowRunDeps === true) {
-                    const result = await runLogged(host, link, emit);
+                    // The hand-written sudo line declares its need at this call site;
+                    // the host never parses the command text to find out.
+                    const result = await runLogged(host, link, emit, { needsSudo: true });
                     if (!result.ok) {
                         emit(`!! ${link} failed: ${result.detail ?? 'unknown'}\n`);
                     }
@@ -298,28 +442,83 @@ export async function syncAndRebuildEngine(host, request, log) {
     }
     return { ok: true, rebuilt, logs: chunks.join('') };
 }
+/**
+ * syncEngineForDeploy runs the deploy step's git sync (the shared
+ * syncAndRebuildEngine) with the option shape every adapter's deploy step
+ * assembles: the platform entry's fork and build-command override, the
+ * Play/Run trust gate, the plan's host OS (the Windows vcpkg route when the
+ * user carries no build-command override), and the progress sink the card's
+ * button reads (the git sync reports "Downloading...", the build step
+ * reports "Building..." the moment it starts). The captured build output is
+ * returned as buildLogs, so a caller threads it to the card's Logs section
+ * without re-running the steps.
+ */
+export async function syncEngineForDeploy(host, request) {
+    // The git sync is the checkout download: the card's button reads
+    // "Downloading..." for it, not "Building...".
+    request.onProgress?.('download');
+    const sync = await syncAndRebuildEngine(host, {
+        engineId: request.engineId,
+        directory: request.directory,
+        ...(request.platform?.engineFork !== undefined
+            ? { fork: request.platform.engineFork }
+            : {}),
+        ...(request.options?.allowRunDeps !== undefined
+            ? { allowRunDeps: request.options.allowRunDeps }
+            : {}),
+        ...(request.platform?.buildCommands !== undefined
+            ? { buildCommands: request.platform.buildCommands }
+            : {}),
+        ...(request.os !== undefined ? { os: request.os } : {}),
+        // Report the build phase the moment the build steps start, so the
+        // card's button reads "Building..." while the build is in flight.
+        onBuildStart: () => request.onProgress?.('build'),
+    }, () => { });
+    // The build output reads as a fresh Logs section: a "Building..."
+    // separator leads the rebuild decision and output, the same line the card
+    // writes when the build step event lands.
+    let buildLogs = sync.logs;
+    if (sync.rebuilt && buildLogs !== '') {
+        buildLogs = `--- Building...\n${buildLogs}`;
+    }
+    return {
+        ok: sync.ok,
+        ...(sync.detail !== undefined ? { detail: sync.detail } : {}),
+        buildLogs,
+    };
+}
 /**
  * buildEngineRepo runs the engine's build steps in the checkout, streaming
  * each step's output through log. An engine with no build steps (the compose
  * engines) passes through with a note; a failing step stops the build with
  * the step's detail.
  */
-export async function buildEngineRepo(host, engineId, directory, log) {
+export async function buildEngineRepo(host, engineId, directory, log, buildCommands, os = 'linux') {
     const source = engineSource(engineId);
     if (source === undefined) {
         return { ok: false, detail: `no engine source is registered for "${engineId}"` };
     }
-    if (source.buildSteps.length === 0) {
+    // The user's local build command (the card's Build commands field) overrides
+    // the engine's default build steps: it runs in the checkout, so it is wrapped
+    // with a cd into the directory. Absent falls back to the engine's steps for
+    // the host OS (the Windows vcpkg route on a Windows host).
+    const commands = buildCommands !== undefined && buildCommands.trim() !== '' ? buildCommands : undefined;
+    const steps = commands !== undefined ? [`cd ${directory} && ${commands}`] : engineBuildSteps(engineId, os);
+    if (steps.length === 0) {
         log(`no local build steps for ${engineId}\n`);
         return { ok: true };
     }
-    for (const step of source.buildSteps) {
+    // The engine OS profile's shell (the Windows vcpkg route's pwsh.exe)
+    // runs the build steps; absent keeps the host's default shell.
+    const shell = engineOsProfile(engineId, os)?.shell;
+    const stepOptions = shell !== undefined ? { shell } : undefined;
+    for (const step of steps) {
         const command = step.replaceAll('{dir}', directory);
-        const outcome = await runLogged(host, command, log);
+        const outcome = await runLogged(host, command, log, stepOptions);
         if (!outcome.ok) {
             return { ok: false, detail: `build failed: ${outcome.detail ?? 'unknown'}` };
         }
     }
     return { ok: true };
 }
-//# sourceMappingURL=acquire.js.map
+//# sourceMappingURL=acquire.js.map