voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/status/index.d.ts

@@ -1,12 +1,6 @@
 import { z } from "zod";
 export declare const RUN_STATUS_VALUES: readonly ["queued", "running", "succeeded", "failed", "errored", "aborted", "pruned"];
 export type RunStatus = (typeof RUN_STATUS_VALUES)[number];
-export declare const AGENT_STATUS_VALUES: readonly ["queued", "running", "succeeded", "failed", "errored", "skipped", "aborted"];
-export type AgentStatus = (typeof AGENT_STATUS_VALUES)[number];
-export declare const EVAL_STATUS_VALUES: readonly ["succeeded", "failed", "errored", "skipped"];
-export type EvalStatus = (typeof EVAL_STATUS_VALUES)[number];
-export declare const APPLY_STATUS_VALUES: readonly ["succeeded", "failed"];
-export type ApplyStatus = (typeof APPLY_STATUS_VALUES)[number];
 export declare const runStatusSchema: z.ZodEnum<{
     queued: "queued";
     running: "running";
@@ -16,6 +10,30 @@ export declare const runStatusSchema: z.ZodEnum<{
     aborted: "aborted";
     pruned: "pruned";
 }>;
+/**
+ * Derive the terminal run status from agent outcomes.
+ * Returns "succeeded" when at least one agent succeeds; otherwise "failed".
+ */
+export declare function deriveRunStatusFromAgents(agentStatuses: readonly AgentStatus[]): RunStatus;
+/**
+ * Map a terminal run status to a deterministic process exit code.
+ * Throws when invoked with a non-terminal status to avoid contradictory pairs.
+ */
+export declare function mapRunStatusToExitCode(status: RunStatus): number;
+/**
+ * Run statuses that indicate the run has finished execution.
+ */
+export declare const TERMINAL_RUN_STATUSES: readonly RunStatus[];
+/**
+ * Run statuses that indicate the run is queued or executing.
+ */
+export declare const IN_PROGRESS_RUN_STATUSES: readonly RunStatus[];
+/**
+ * Run statuses that allow forced termination (e.g., abort or fail).
+ */
+export declare const TERMINABLE_RUN_STATUSES: readonly RunStatus[];
+export declare const AGENT_STATUS_VALUES: readonly ["queued", "running", "succeeded", "failed", "errored", "skipped", "aborted"];
+export type AgentStatus = (typeof AGENT_STATUS_VALUES)[number];
 export declare const agentStatusSchema: z.ZodEnum<{
     queued: "queued";
     running: "running";
@@ -25,13 +43,95 @@ export declare const agentStatusSchema: z.ZodEnum<{
     aborted: "aborted";
     skipped: "skipped";
 }>;
-export declare const evalStatusSchema: z.ZodEnum<{
+/**
+ * Agent statuses that indicate the agent has finished execution.
+ */
+export declare const TERMINAL_AGENT_STATUSES: readonly AgentStatus[];
+/**
+ * Agent statuses that indicate the agent is still running or waiting.
+ */
+export declare const IN_PROGRESS_AGENT_STATUSES: readonly AgentStatus[];
+export declare const CHECK_STATUS_VALUES: readonly ["succeeded", "failed", "errored", "skipped"];
+export type CheckStatus = (typeof CHECK_STATUS_VALUES)[number];
+export declare const checkStatusSchema: z.ZodEnum<{
     succeeded: "succeeded";
     failed: "failed";
     errored: "errored";
     skipped: "skipped";
 }>;
-export declare const applyStatusEnum: z.ZodEnum<{
+export declare const APPLY_STATUS_VALUES: readonly ["succeeded", "failed"];
+export type ApplyStatus = (typeof APPLY_STATUS_VALUES)[number];
+export declare const applyStatusSchema: z.ZodEnum<{
+    succeeded: "succeeded";
+    failed: "failed";
+}>;
+export declare const VERIFICATION_STATUS_VALUES: readonly ["queued", "running", "succeeded", "failed", "aborted"];
+export type VerificationStatus = (typeof VERIFICATION_STATUS_VALUES)[number];
+export declare const verificationStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+    aborted: "aborted";
+}>;
+export declare const TERMINAL_VERIFICATION_STATUSES: readonly VerificationStatus[];
+export declare const IN_PROGRESS_VERIFICATION_STATUSES: readonly VerificationStatus[];
+export declare const REDUCTION_STATUS_VALUES: readonly ["queued", "running", "succeeded", "failed", "aborted"];
+export type ReductionStatus = (typeof REDUCTION_STATUS_VALUES)[number];
+export declare const reductionStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+    aborted: "aborted";
+}>;
+/**
+ * Reduction statuses that indicate the reduction session has finished.
+ */
+export declare const TERMINAL_REDUCTION_STATUSES: readonly ReductionStatus[];
+export declare const IN_PROGRESS_REDUCTION_STATUSES: readonly ReductionStatus[];
+export declare const MESSAGE_STATUS_VALUES: readonly ["queued", "running", "succeeded", "failed", "aborted"];
+export type MessageStatus = (typeof MESSAGE_STATUS_VALUES)[number];
+export declare const messageStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+    aborted: "aborted";
+}>;
+export declare const TERMINAL_MESSAGE_STATUSES: readonly MessageStatus[];
+export declare const IN_PROGRESS_MESSAGE_STATUSES: readonly MessageStatus[];
+export declare const MESSAGE_RECIPIENT_STATUS_VALUES: readonly ["queued", "running", "succeeded", "failed", "aborted"];
+export type MessageRecipientStatus = (typeof MESSAGE_RECIPIENT_STATUS_VALUES)[number];
+export declare const messageRecipientStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+    aborted: "aborted";
+}>;
+export declare const TERMINAL_MESSAGE_RECIPIENT_STATUSES: readonly MessageRecipientStatus[];
+export declare const SPEC_RECORD_STATUS_VALUES: readonly ["running", "succeeded", "aborted", "failed"];
+export type SpecRecordStatus = (typeof SPEC_RECORD_STATUS_VALUES)[number];
+export declare const specRecordStatusSchema: z.ZodEnum<{
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+    aborted: "aborted";
+}>;
+/**
+ * Spec record statuses that indicate the spec session has finished.
+ */
+export declare const TERMINAL_SPEC_STATUSES: readonly SpecRecordStatus[];
+export declare const SPEC_AGENT_STATUS_VALUES: readonly ["queued", "running", "succeeded", "failed"];
+export type SpecAgentStatus = (typeof SPEC_AGENT_STATUS_VALUES)[number];
+export declare const specAgentStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    running: "running";
     succeeded: "succeeded";
     failed: "failed";
 }>;
+/**
+ * Spec agent statuses that indicate the agent has finished execution.
+ */
+export declare const TERMINAL_SPEC_AGENT_STATUSES: readonly SpecAgentStatus[];

package/dist/status/index.js

@@ -8,6 +8,56 @@ export const RUN_STATUS_VALUES = [
     "aborted",
     "pruned",
 ];
+export const runStatusSchema = z.enum(RUN_STATUS_VALUES);
+/**
+ * Derive the terminal run status from agent outcomes.
+ * Returns "succeeded" when at least one agent succeeds; otherwise "failed".
+ */
+export function deriveRunStatusFromAgents(agentStatuses) {
+    const hasAgentSuccess = agentStatuses.some((status) => status === "succeeded");
+    return hasAgentSuccess ? "succeeded" : "failed";
+}
+/**
+ * Map a terminal run status to a deterministic process exit code.
+ * Throws when invoked with a non-terminal status to avoid contradictory pairs.
+ */
+export function mapRunStatusToExitCode(status) {
+    switch (status) {
+        case "succeeded":
+            return 0;
+        case "failed":
+            return 1;
+        case "errored":
+            return 2;
+        case "aborted":
+            return 3;
+        default:
+            throw new Error(`Cannot map non-terminal run status \`${status}\` to an exit code.`);
+    }
+}
+/**
+ * Run statuses that indicate the run has finished execution.
+ */
+export const TERMINAL_RUN_STATUSES = [
+    "succeeded",
+    "failed",
+    "errored",
+    "aborted",
+];
+/**
+ * Run statuses that indicate the run is queued or executing.
+ */
+export const IN_PROGRESS_RUN_STATUSES = [
+    "queued",
+    "running",
+];
+/**
+ * Run statuses that allow forced termination (e.g., abort or fail).
+ */
+export const TERMINABLE_RUN_STATUSES = [
+    "failed",
+    "aborted",
+];
 export const AGENT_STATUS_VALUES = [
     "queued",
     "running",
@@ -17,14 +67,123 @@ export const AGENT_STATUS_VALUES = [
     "skipped",
     "aborted",
 ];
-export const EVAL_STATUS_VALUES = [
+export const agentStatusSchema = z.enum(AGENT_STATUS_VALUES);
+/**
+ * Agent statuses that indicate the agent has finished execution.
+ */
+export const TERMINAL_AGENT_STATUSES = [
+    "succeeded",
+    "failed",
+    "errored",
+    "skipped",
+    "aborted",
+];
+/**
+ * Agent statuses that indicate the agent is still running or waiting.
+ */
+export const IN_PROGRESS_AGENT_STATUSES = [
+    "queued",
+    "running",
+];
+export const CHECK_STATUS_VALUES = [
     "succeeded",
     "failed",
     "errored",
     "skipped",
 ];
+export const checkStatusSchema = z.enum(CHECK_STATUS_VALUES);
 export const APPLY_STATUS_VALUES = ["succeeded", "failed"];
-export const runStatusSchema = z.enum(RUN_STATUS_VALUES);
-export const agentStatusSchema = z.enum(AGENT_STATUS_VALUES);
-export const evalStatusSchema = z.enum(EVAL_STATUS_VALUES);
-export const applyStatusEnum = z.enum(APPLY_STATUS_VALUES);
+export const applyStatusSchema = z.enum(APPLY_STATUS_VALUES);
+export const VERIFICATION_STATUS_VALUES = [
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "aborted",
+];
+export const verificationStatusSchema = z.enum(VERIFICATION_STATUS_VALUES);
+export const TERMINAL_VERIFICATION_STATUSES = [
+    "succeeded",
+    "failed",
+    "aborted",
+];
+export const IN_PROGRESS_VERIFICATION_STATUSES = ["queued", "running"];
+export const REDUCTION_STATUS_VALUES = [
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "aborted",
+];
+export const reductionStatusSchema = z.enum(REDUCTION_STATUS_VALUES);
+/**
+ * Reduction statuses that indicate the reduction session has finished.
+ */
+export const TERMINAL_REDUCTION_STATUSES = [
+    "succeeded",
+    "failed",
+    "aborted",
+];
+export const IN_PROGRESS_REDUCTION_STATUSES = [
+    "queued",
+    "running",
+];
+export const MESSAGE_STATUS_VALUES = [
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "aborted",
+];
+export const messageStatusSchema = z.enum(MESSAGE_STATUS_VALUES);
+export const TERMINAL_MESSAGE_STATUSES = [
+    "succeeded",
+    "failed",
+    "aborted",
+];
+export const IN_PROGRESS_MESSAGE_STATUSES = [
+    "queued",
+    "running",
+];
+export const MESSAGE_RECIPIENT_STATUS_VALUES = [
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "aborted",
+];
+export const messageRecipientStatusSchema = z.enum(MESSAGE_RECIPIENT_STATUS_VALUES);
+export const TERMINAL_MESSAGE_RECIPIENT_STATUSES = [
+    "succeeded",
+    "failed",
+    "aborted",
+];
+export const SPEC_RECORD_STATUS_VALUES = [
+    "running",
+    "succeeded",
+    "aborted",
+    "failed",
+];
+export const specRecordStatusSchema = z.enum(SPEC_RECORD_STATUS_VALUES);
+/**
+ * Spec record statuses that indicate the spec session has finished.
+ */
+export const TERMINAL_SPEC_STATUSES = [
+    "succeeded",
+    "aborted",
+    "failed",
+];
+export const SPEC_AGENT_STATUS_VALUES = [
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+];
+export const specAgentStatusSchema = z.enum(SPEC_AGENT_STATUS_VALUES);
+/**
+ * Spec agent statuses that indicate the agent has finished execution.
+ */
+export const TERMINAL_SPEC_AGENT_STATUSES = [
+    "succeeded",
+    "failed",
+];

package/dist/update-check/checker.d.ts

@@ -0,0 +1,24 @@
+export interface StartOptions {
+    isTty: boolean;
+    env: NodeJS.ProcessEnv;
+    cachePath: string;
+    now?: () => Date;
+    fetchImpl?: typeof fetch;
+}
+export interface UpdateHandle {
+    peekNotice(): string | undefined;
+    finish(): void;
+}
+interface CacheState {
+    lastCheckedAt: string;
+    latestVersion: string;
+}
+export declare function readCache(cachePath: string): CacheState | undefined;
+export declare function writeCache(cachePath: string, state: CacheState): void;
+/**
+ * Start the update check. Returns undefined when trigger rules fail
+ * (non-TTY or CI). Otherwise returns a handle that can peek at cached
+ * notices and perform background bookkeeping via finish().
+ */
+export declare function startUpdateCheck(localVersion: string, opts: StartOptions): UpdateHandle | undefined;
+export {};

package/dist/update-check/checker.js

@@ -0,0 +1,130 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { isNewerVersion } from "./semver.js";
+const REGISTRY_URL = "https://registry.npmjs.org/voratiq/latest";
+const FETCH_TIMEOUT_MS = 1500;
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+export function readCache(cachePath) {
+    try {
+        const raw = readFileSync(cachePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.lastCheckedAt === "string" &&
+            typeof parsed.latestVersion === "string") {
+            return {
+                lastCheckedAt: parsed.lastCheckedAt,
+                latestVersion: parsed.latestVersion,
+            };
+        }
+    }
+    catch {
+        // Missing file, parse error, etc. - all non-actionable.
+    }
+    return undefined;
+}
+export function writeCache(cachePath, state) {
+    try {
+        mkdirSync(dirname(cachePath), { recursive: true });
+        writeFileSync(cachePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // Write failure is non-actionable.
+    }
+}
+function isCiEnvironment(env) {
+    const raw = env.CI;
+    if (raw === undefined) {
+        return false;
+    }
+    const normalized = raw.trim().toLowerCase();
+    return normalized !== "" && normalized !== "0" && normalized !== "false";
+}
+function isCacheFresh(cache, now) {
+    try {
+        const checkedAt = new Date(cache.lastCheckedAt);
+        return now.getTime() - checkedAt.getTime() < CHECK_INTERVAL_MS;
+    }
+    catch {
+        return false;
+    }
+}
+function buildNotice(localVersion, latestVersion) {
+    return `Update available: Voratiq ${localVersion} -> ${latestVersion}`;
+}
+async function fetchLatestVersion(fetchImpl) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        if (typeof timer === "object" && "unref" in timer) {
+            timer.unref();
+        }
+        const response = await fetchImpl(REGISTRY_URL, {
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!response.ok) {
+            return undefined;
+        }
+        const body = (await response.json());
+        if (typeof body.version === "string" && body.version.length > 0) {
+            return body.version;
+        }
+    }
+    catch {
+        // Network error, timeout, invalid JSON - all silent.
+    }
+    return undefined;
+}
+/**
+ * Start the update check. Returns undefined when trigger rules fail
+ * (non-TTY or CI). Otherwise returns a handle that can peek at cached
+ * notices and perform background bookkeeping via finish().
+ */
+export function startUpdateCheck(localVersion, opts) {
+    // Trigger rules: skip in non-TTY or CI environments
+    if (!opts.isTty) {
+        return undefined;
+    }
+    if (isCiEnvironment(opts.env)) {
+        return undefined;
+    }
+    const now = opts.now ?? (() => new Date());
+    const fetchFn = opts.fetchImpl ?? fetch;
+    const { cachePath } = opts;
+    // Read cache synchronously at startup
+    const cache = readCache(cachePath);
+    // Start background refresh if cache is stale or missing
+    if (!cache || !isCacheFresh(cache, now())) {
+        fetchLatestVersion(fetchFn)
+            .then((version) => {
+            if (version) {
+                writeCache(cachePath, {
+                    lastCheckedAt: now().toISOString(),
+                    latestVersion: version,
+                });
+            }
+        })
+            .catch(() => {
+            // Network error, timeout - silent.
+        });
+    }
+    let consumed = false;
+    return {
+        peekNotice() {
+            if (consumed) {
+                return undefined;
+            }
+            if (!cache) {
+                return undefined;
+            }
+            if (!isNewerVersion(localVersion, cache.latestVersion)) {
+                return undefined;
+            }
+            consumed = true;
+            return buildNotice(localVersion, cache.latestVersion);
+        },
+        finish() {
+            // Bookkeeping only - no output. The background fetch promise
+            // resolves on its own; this is a hook for future cleanup.
+        },
+    };
+}

package/dist/update-check/prompt.d.ts

@@ -0,0 +1,25 @@
+import type { CommandOutputWriter } from "../cli/output.js";
+export interface UpdatePromptHandler {
+    (options: {
+        message: string;
+        prefaceLines?: string[];
+    }): Promise<string>;
+}
+export interface UpdatePromptWriter {
+    (text: string): void;
+}
+export interface UpdatePromptDeps {
+    prompt: UpdatePromptHandler;
+    write: UpdatePromptWriter;
+    writeCommandOutput?: CommandOutputWriter;
+    execCommand?: (command: string, args: readonly string[]) => void;
+}
+export interface UpdatePromptResult {
+    shouldExit: boolean;
+    exitCode?: number;
+}
+/**
+ * Show the interactive update prompt and handle user choice.
+ * Returns an object indicating whether the process should exit and with what code.
+ */
+export declare function showUpdatePrompt(notice: string, deps: UpdatePromptDeps): Promise<UpdatePromptResult>;

package/dist/update-check/prompt.js

@@ -0,0 +1,62 @@
+import { spawnSync } from "node:child_process";
+import { renderUpdateProgressLines, renderUpdatePromptPreface, } from "../render/transcripts/update-check.js";
+import { colorize } from "../utils/colors.js";
+const UPDATE_COMMAND = "npm";
+const UPDATE_ARGS = ["install", "-g", "voratiq@latest"];
+/**
+ * Show the interactive update prompt and handle user choice.
+ * Returns an object indicating whether the process should exit and with what code.
+ */
+export async function showUpdatePrompt(notice, deps) {
+    const { prompt, write, writeCommandOutput, execCommand = defaultExecCommand, } = deps;
+    let firstPrompt = true;
+    for (;;) {
+        const response = await prompt({
+            message: "[1]",
+            prefaceLines: firstPrompt
+                ? renderUpdatePromptPreface(notice, firstPrompt)
+                : undefined,
+        });
+        const trimmed = response.trim();
+        const normalized = trimmed.length === 0 ? "1" : trimmed;
+        if (normalized === "1") {
+            write(`${renderUpdateProgressLines().join("\n")}\n`);
+            try {
+                execCommand(UPDATE_COMMAND, UPDATE_ARGS);
+            }
+            catch {
+                writeStatusLine("Update failed.", "red", write, writeCommandOutput);
+                return { shouldExit: true, exitCode: 1 };
+            }
+            writeStatusLine("Updated. Rerun your command.", "green", write, writeCommandOutput);
+            return { shouldExit: true, exitCode: 0 };
+        }
+        if (normalized === "2") {
+            return { shouldExit: false };
+        }
+        write("Choose 1 or 2.\n");
+        firstPrompt = false;
+    }
+}
+function writeStatusLine(message, color, fallbackWrite, writeCommandOutput) {
+    const rendered = colorize(message, color);
+    if (writeCommandOutput) {
+        writeCommandOutput({ body: rendered });
+        return;
+    }
+    fallbackWrite("\n");
+    fallbackWrite(rendered);
+    fallbackWrite("\n");
+}
+function defaultExecCommand(command, args) {
+    const result = spawnSync(command, args, { stdio: "inherit" });
+    if (result.error) {
+        throw result.error;
+    }
+    if (typeof result.status === "number" && result.status !== 0) {
+        throw new Error(`Update command exited with status ${result.status}`);
+    }
+    if (result.signal) {
+        throw new Error(`Update command terminated with signal ${result.signal}`);
+    }
+}

package/dist/update-check/semver.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Lightweight semver comparison for update-check.
+ * Ignores prerelease/build metadata per MVP spec.
+ */
+interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+}
+export declare function parseSemver(version: string): ParsedVersion | undefined;
+/**
+ * Returns true when `candidate` is strictly newer than `current`.
+ * Prerelease/build metadata is stripped before comparison.
+ * Returns false for invalid version strings.
+ */
+export declare function isNewerVersion(current: string, candidate: string): boolean;
+export {};

package/dist/update-check/semver.js

@@ -0,0 +1,36 @@
+/**
+ * Lightweight semver comparison for update-check.
+ * Ignores prerelease/build metadata per MVP spec.
+ */
+export function parseSemver(version) {
+    // Strip leading 'v' if present, then strip prerelease/build metadata
+    const cleaned = version.startsWith("v") ? version.slice(1) : version;
+    const coreMatch = /^(\d+)\.(\d+)\.(\d+)/.exec(cleaned);
+    if (!coreMatch) {
+        return undefined;
+    }
+    return {
+        major: Number(coreMatch[1]),
+        minor: Number(coreMatch[2]),
+        patch: Number(coreMatch[3]),
+    };
+}
+/**
+ * Returns true when `candidate` is strictly newer than `current`.
+ * Prerelease/build metadata is stripped before comparison.
+ * Returns false for invalid version strings.
+ */
+export function isNewerVersion(current, candidate) {
+    const a = parseSemver(current);
+    const b = parseSemver(candidate);
+    if (!a || !b) {
+        return false;
+    }
+    if (b.major !== a.major) {
+        return b.major > a.major;
+    }
+    if (b.minor !== a.minor) {
+        return b.minor > a.minor;
+    }
+    return b.patch > a.patch;
+}

package/dist/update-check/state-path.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolve the path to the update-check cache file.
+ *
+ * macOS/Linux:
+ *   $XDG_STATE_HOME/voratiq/update-state.json   (when XDG_STATE_HOME is set)
+ *   ~/.local/state/voratiq/update-state.json     (fallback)
+ */
+export declare function resolveUpdateStatePath(env?: NodeJS.ProcessEnv): string;

package/dist/update-check/state-path.js

@@ -0,0 +1,18 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CACHE_FILENAME = "update-state.json";
+const APP_DIR = "voratiq";
+/**
+ * Resolve the path to the update-check cache file.
+ *
+ * macOS/Linux:
+ *   $XDG_STATE_HOME/voratiq/update-state.json   (when XDG_STATE_HOME is set)
+ *   ~/.local/state/voratiq/update-state.json     (fallback)
+ */
+export function resolveUpdateStatePath(env = process.env) {
+    const xdgState = env.XDG_STATE_HOME;
+    const base = xdgState && xdgState.length > 0
+        ? xdgState
+        : join(homedir(), ".local", "state");
+    return join(base, APP_DIR, CACHE_FILENAME);
+}

package/dist/utils/binaries.js

@@ -1,12 +1,18 @@
-import { spawnSync } from "node:child_process";
+import { accessSync, constants as fsConstants } from "node:fs";
+import { delimiter, join } from "node:path";
 export function detectBinary(command) {
-    const result = spawnSync("bash", ["-lc", `command -v ${command}`], {
-        encoding: "utf8",
-    });
-    if (result.status === 0) {
-        const path = result.stdout.trim();
-        if (path.length > 0) {
-            return path;
+    const pathEntries = (process.env.PATH ?? "")
+        .split(delimiter)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    for (const entry of pathEntries) {
+        const candidate = join(entry, command);
+        try {
+            accessSync(candidate, fsConstants.X_OK);
+            return candidate;
+        }
+        catch {
+            continue;
         }
     }
     return undefined;