gsd-pi 2.50.0-dev.d210a87 → 2.50.0

package/dist/resources/extensions/shared/rtk-session-stats.js

@@ -1,189 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { gsdRoot } from "../gsd/paths.js";
-import { formatTokenCount } from "./format-utils.js";
-import { buildRtkEnv, isRtkEnabled, resolveRtkBinaryPath } from "./rtk.js";
-const SESSION_BASELINES_FILE = "rtk-session-baselines.json";
-const CURRENT_SUMMARY_TTL_MS = 15_000;
-const CURRENT_SUMMARY_TIMEOUT_MS = 5_000;
-const MAX_BASELINE_SESSIONS = 200;
-let cachedSummary = null;
-function getRuntimeDir(basePath) {
-    return join(gsdRoot(basePath), "runtime");
-}
-function getBaselinesPath(basePath) {
-    return join(getRuntimeDir(basePath), SESSION_BASELINES_FILE);
-}
-function defaultStore() {
-    return { version: 1, sessions: {} };
-}
-function loadBaselineStore(basePath) {
-    const path = getBaselinesPath(basePath);
-    if (!existsSync(path))
-        return defaultStore();
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf-8"));
-        if (parsed.version !== 1 || typeof parsed.sessions !== "object" || parsed.sessions === null) {
-            return defaultStore();
-        }
-        return {
-            version: 1,
-            sessions: parsed.sessions,
-        };
-    }
-    catch {
-        return defaultStore();
-    }
-}
-function saveBaselineStore(basePath, store) {
-    const runtimeDir = getRuntimeDir(basePath);
-    mkdirSync(runtimeDir, { recursive: true });
-    const entries = Object.entries(store.sessions)
-        .sort((left, right) => right[1].updatedAt.localeCompare(left[1].updatedAt))
-        .slice(0, MAX_BASELINE_SESSIONS);
-    const normalized = {
-        version: 1,
-        sessions: Object.fromEntries(entries),
-    };
-    writeFileSync(getBaselinesPath(basePath), JSON.stringify(normalized, null, 2), "utf-8");
-}
-function normalizeSummary(raw) {
-    if (!raw || typeof raw !== "object")
-        return null;
-    const summary = raw;
-    return {
-        totalCommands: Number(summary.total_commands ?? 0),
-        totalInput: Number(summary.total_input ?? 0),
-        totalOutput: Number(summary.total_output ?? 0),
-        totalSaved: Number(summary.total_saved ?? 0),
-        avgSavingsPct: Number(summary.avg_savings_pct ?? 0),
-        totalTimeMs: Number(summary.total_time_ms ?? 0),
-        avgTimeMs: Number(summary.avg_time_ms ?? 0),
-    };
-}
-export function readCurrentRtkGainSummary(env = process.env) {
-    if (!isRtkEnabled(env))
-        return null;
-    const binaryPath = resolveRtkBinaryPath({ env });
-    if (!binaryPath)
-        return null;
-    if (cachedSummary &&
-        cachedSummary.binaryPath === binaryPath &&
-        Date.now() - cachedSummary.at < CURRENT_SUMMARY_TTL_MS) {
-        return cachedSummary.summary;
-    }
-    const result = spawnSync(binaryPath, ["gain", "--all", "--format", "json"], {
-        encoding: "utf-8",
-        env: buildRtkEnv(env),
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: CURRENT_SUMMARY_TIMEOUT_MS,
-        // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows
-        shell: /\.(cmd|bat)$/i.test(binaryPath),
-    });
-    if (result.error || result.status !== 0) {
-        cachedSummary = { at: Date.now(), binaryPath, summary: null };
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(result.stdout ?? "{}");
-        const summary = normalizeSummary(parsed.summary ?? null);
-        cachedSummary = { at: Date.now(), binaryPath, summary };
-        return summary;
-    }
-    catch {
-        cachedSummary = { at: Date.now(), binaryPath, summary: null };
-        return null;
-    }
-}
-function computeSavingsDelta(current, baseline) {
-    const commands = Math.max(0, current.totalCommands - baseline.totalCommands);
-    const inputTokens = Math.max(0, current.totalInput - baseline.totalInput);
-    const outputTokens = Math.max(0, current.totalOutput - baseline.totalOutput);
-    const savedTokens = Math.max(0, current.totalSaved - baseline.totalSaved);
-    const totalTimeMs = Math.max(0, current.totalTimeMs - baseline.totalTimeMs);
-    const avgTimeMs = commands > 0 ? Math.round(totalTimeMs / commands) : 0;
-    const savingsPct = inputTokens > 0 ? (savedTokens / inputTokens) * 100 : 0;
-    return {
-        commands,
-        inputTokens,
-        outputTokens,
-        savedTokens,
-        savingsPct,
-        totalTimeMs,
-        avgTimeMs,
-        updatedAt: new Date().toISOString(),
-    };
-}
-export function ensureRtkSessionBaseline(basePath, sessionId, env = process.env) {
-    if (!sessionId)
-        return null;
-    const current = readCurrentRtkGainSummary(env);
-    if (!current)
-        return null;
-    const store = loadBaselineStore(basePath);
-    const existing = store.sessions[sessionId];
-    if (existing)
-        return existing.summary;
-    const now = new Date().toISOString();
-    store.sessions[sessionId] = {
-        summary: current,
-        createdAt: now,
-        updatedAt: now,
-    };
-    saveBaselineStore(basePath, store);
-    return current;
-}
-export function getRtkSessionSavings(basePath, sessionId, env = process.env) {
-    if (!sessionId)
-        return null;
-    const current = readCurrentRtkGainSummary(env);
-    if (!current)
-        return null;
-    const store = loadBaselineStore(basePath);
-    const existing = store.sessions[sessionId];
-    if (!existing) {
-        const now = new Date().toISOString();
-        store.sessions[sessionId] = {
-            summary: current,
-            createdAt: now,
-            updatedAt: now,
-        };
-        saveBaselineStore(basePath, store);
-        return computeSavingsDelta(current, current);
-    }
-    if (current.totalCommands < existing.summary.totalCommands ||
-        current.totalInput < existing.summary.totalInput ||
-        current.totalSaved < existing.summary.totalSaved) {
-        const now = new Date().toISOString();
-        store.sessions[sessionId] = {
-            summary: current,
-            createdAt: existing.createdAt,
-            updatedAt: now,
-        };
-        saveBaselineStore(basePath, store);
-        return computeSavingsDelta(current, current);
-    }
-    existing.updatedAt = new Date().toISOString();
-    saveBaselineStore(basePath, store);
-    return computeSavingsDelta(current, existing.summary);
-}
-export function clearRtkSessionBaseline(basePath, sessionId) {
-    if (!sessionId)
-        return;
-    const store = loadBaselineStore(basePath);
-    if (!(sessionId in store.sessions))
-        return;
-    delete store.sessions[sessionId];
-    saveBaselineStore(basePath, store);
-}
-export function formatRtkSavingsLabel(savings) {
-    if (!savings)
-        return null;
-    if (savings.commands <= 0)
-        return "rtk: waiting for shell usage";
-    if (savings.inputTokens <= 0 && savings.outputTokens <= 0) {
-        return `rtk: active (${savings.commands} cmd${savings.commands === 1 ? "" : "s"})`;
-    }
-    return `rtk: ${formatTokenCount(savings.savedTokens)} saved (${Math.round(savings.savingsPct)}%)`;
-}

package/dist/resources/extensions/shared/rtk.js

@@ -1,100 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { delimiter, join } from "node:path";
-const GSD_RTK_PATH_ENV = "GSD_RTK_PATH";
-const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED";
-const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED";
-const RTK_REWRITE_TIMEOUT_MS = 5_000;
-function isTruthy(value) {
-    if (!value)
-        return false;
-    const normalized = value.trim().toLowerCase();
-    return normalized === "1" || normalized === "true" || normalized === "yes";
-}
-export function isRtkEnabled(env = process.env) {
-    return !isTruthy(env[GSD_RTK_DISABLED_ENV]);
-}
-export function buildRtkEnv(env = process.env) {
-    return {
-        ...env,
-        [RTK_TELEMETRY_DISABLED_ENV]: "1",
-    };
-}
-function getManagedRtkDir(env = process.env) {
-    return join(env.GSD_HOME || join(homedir(), ".gsd"), "agent", "bin");
-}
-function getRtkBinaryName(platform = process.platform) {
-    return platform === "win32" ? "rtk.exe" : "rtk";
-}
-function getPathValue(env) {
-    const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path");
-    return pathKey ? env[pathKey] : env.PATH;
-}
-function resolvePathCandidates(pathValue) {
-    if (!pathValue)
-        return [];
-    return pathValue
-        .split(delimiter)
-        .map((part) => part.trim())
-        .filter(Boolean);
-}
-function resolveSystemRtkPath(pathValue, platform = process.platform) {
-    const candidates = platform === "win32"
-        ? ["rtk.exe", "rtk.cmd", "rtk.bat", "rtk"]
-        : ["rtk"];
-    for (const dir of resolvePathCandidates(pathValue)) {
-        for (const candidate of candidates) {
-            const fullPath = join(dir, candidate);
-            if (existsSync(fullPath)) {
-                return fullPath;
-            }
-        }
-    }
-    return null;
-}
-export function resolveRtkBinaryPath(options = {}) {
-    const env = options.env ?? process.env;
-    const platform = options.platform ?? process.platform;
-    const explicitPath = options.binaryPath ?? env[GSD_RTK_PATH_ENV];
-    if (explicitPath && existsSync(explicitPath)) {
-        return explicitPath;
-    }
-    const managedDir = getManagedRtkDir(env);
-    const managedPath = join(managedDir, getRtkBinaryName(platform));
-    if (existsSync(managedPath)) {
-        return managedPath;
-    }
-    // On Windows, also check for rtk.cmd in the managed dir (used by test fake RTK
-    // and any wrapper-style installs where a .cmd launcher accompanies the binary).
-    if (platform === "win32") {
-        const managedCmd = join(managedDir, "rtk.cmd");
-        if (existsSync(managedCmd)) {
-            return managedCmd;
-        }
-    }
-    return resolveSystemRtkPath(options.pathValue ?? getPathValue(env), platform);
-}
-export function rewriteCommandWithRtk(command, env = process.env) {
-    if (!command.trim())
-        return command;
-    if (!isRtkEnabled(env))
-        return command;
-    const binaryPath = resolveRtkBinaryPath({ env });
-    if (!binaryPath)
-        return command;
-    const result = spawnSync(binaryPath, ["rewrite", command], {
-        encoding: "utf-8",
-        env: buildRtkEnv(env),
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: RTK_REWRITE_TIMEOUT_MS,
-        // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows
-        shell: /\.(cmd|bat)$/i.test(binaryPath),
-    });
-    if (result.error)
-        return command;
-    if (result.status !== 0 && result.status !== 3)
-        return command;
-    const rewritten = (result.stdout ?? "").trimEnd();
-    return rewritten || command;
-}

package/dist/rtk.d.ts

@@ -1,52 +0,0 @@
-import { spawnSync } from "node:child_process";
-export declare const RTK_VERSION = "0.33.1";
-export declare const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED";
-export declare const GSD_SKIP_RTK_INSTALL_ENV = "GSD_SKIP_RTK_INSTALL";
-export declare const GSD_RTK_PATH_ENV = "GSD_RTK_PATH";
-export declare const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED";
-export interface EnsureRtkOptions {
-    targetDir?: string;
-    allowDownload?: boolean;
-    env?: NodeJS.ProcessEnv;
-    pathValue?: string;
-    releaseVersion?: string;
-    log?: (message: string) => void;
-}
-export interface EnsureRtkResult {
-    enabled: boolean;
-    supported: boolean;
-    available: boolean;
-    source: "disabled" | "unsupported" | "managed" | "system" | "downloaded" | "missing";
-    binaryPath?: string;
-    reason?: string;
-}
-export declare function isRtkEnabled(env?: NodeJS.ProcessEnv): boolean;
-export declare function getManagedRtkDir(env?: NodeJS.ProcessEnv): string;
-export declare function getRtkBinaryName(platform?: NodeJS.Platform): string;
-export declare function getManagedRtkPath(platform?: NodeJS.Platform, targetDir?: string): string;
-export declare function prependPathEntry(env: NodeJS.ProcessEnv, entry: string): NodeJS.ProcessEnv;
-export declare function applyRtkProcessEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-export declare function buildRtkEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-export declare function resolveRtkAssetName(platform: NodeJS.Platform, arch: string, version?: string): string | null;
-export interface ResolveRtkBinaryPathOptions {
-    binaryPath?: string;
-    env?: NodeJS.ProcessEnv;
-    pathValue?: string;
-    platform?: NodeJS.Platform;
-    targetDir?: string;
-}
-export declare function resolveRtkBinaryPath(options?: ResolveRtkBinaryPathOptions): string | null;
-export interface RewriteCommandOptions {
-    binaryPath?: string;
-    env?: NodeJS.ProcessEnv;
-    timeoutMs?: number;
-    spawnSyncImpl?: typeof spawnSync;
-}
-export declare function rewriteCommandWithRtk(command: string, options?: RewriteCommandOptions): string;
-export interface ValidateRtkBinaryOptions {
-    spawnSyncImpl?: typeof spawnSync;
-    env?: NodeJS.ProcessEnv;
-}
-export declare function validateRtkBinary(binaryPath: string, options?: ValidateRtkBinaryOptions): boolean;
-export declare function ensureRtkAvailable(options?: EnsureRtkOptions): Promise<EnsureRtkResult>;
-export declare function bootstrapRtk(options?: EnsureRtkOptions): Promise<EnsureRtkResult>;

package/dist/rtk.js

@@ -1,332 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { spawnSync } from "node:child_process";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, chmodSync, readdirSync } from "node:fs";
-import { createWriteStream } from "node:fs";
-import { arch as osArch, homedir as osHomedir } from "node:os";
-import { delimiter, join } from "node:path";
-import { Readable } from "node:stream";
-import { finished } from "node:stream/promises";
-import extractZip from "extract-zip";
-export const RTK_VERSION = "0.33.1";
-export const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED";
-export const GSD_SKIP_RTK_INSTALL_ENV = "GSD_SKIP_RTK_INSTALL";
-export const GSD_RTK_PATH_ENV = "GSD_RTK_PATH";
-export const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED";
-const RTK_REPO = "rtk-ai/rtk";
-const RTK_REWRITE_TIMEOUT_MS = 5_000;
-function isTruthy(value) {
-    if (!value)
-        return false;
-    const normalized = value.trim().toLowerCase();
-    return normalized === "1" || normalized === "true" || normalized === "yes";
-}
-export function isRtkEnabled(env = process.env) {
-    return !isTruthy(env[GSD_RTK_DISABLED_ENV]);
-}
-function resolveAppRoot(env = process.env) {
-    return env.GSD_HOME || join(osHomedir(), ".gsd");
-}
-export function getManagedRtkDir(env = process.env) {
-    return join(resolveAppRoot(env), "agent", "bin");
-}
-export function getRtkBinaryName(platform = process.platform) {
-    return platform === "win32" ? "rtk.exe" : "rtk";
-}
-export function getManagedRtkPath(platform = process.platform, targetDir = getManagedRtkDir()) {
-    return join(targetDir, getRtkBinaryName(platform));
-}
-export function prependPathEntry(env, entry) {
-    const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") ?? (process.platform === "win32" ? "Path" : "PATH");
-    const currentPath = env[pathKey] ?? "";
-    const parts = currentPath.split(delimiter).filter(Boolean);
-    if (!parts.includes(entry)) {
-        env[pathKey] = [entry, currentPath].filter(Boolean).join(delimiter);
-    }
-    return env;
-}
-export function applyRtkProcessEnv(env = process.env) {
-    prependPathEntry(env, getManagedRtkDir(env));
-    env[RTK_TELEMETRY_DISABLED_ENV] = "1";
-    return env;
-}
-function getPathValue(env) {
-    const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path");
-    return pathKey ? env[pathKey] : env.PATH;
-}
-export function buildRtkEnv(env = process.env) {
-    return applyRtkProcessEnv({ ...env });
-}
-export function resolveRtkAssetName(platform, arch, version = RTK_VERSION) {
-    void version;
-    if (platform === "darwin" && arch === "arm64")
-        return "rtk-aarch64-apple-darwin.tar.gz";
-    if (platform === "darwin" && arch === "x64")
-        return "rtk-x86_64-apple-darwin.tar.gz";
-    if (platform === "linux" && arch === "arm64")
-        return "rtk-aarch64-unknown-linux-gnu.tar.gz";
-    if (platform === "linux" && arch === "x64")
-        return "rtk-x86_64-unknown-linux-musl.tar.gz";
-    if (platform === "win32" && arch === "x64")
-        return "rtk-x86_64-pc-windows-msvc.zip";
-    return null;
-}
-function getReleaseBaseUrl(version) {
-    return `https://github.com/${RTK_REPO}/releases/download/v${version}`;
-}
-function getChecksumsUrl(version) {
-    return `${getReleaseBaseUrl(version)}/checksums.txt`;
-}
-function buildAssetUrl(version, assetName) {
-    return `${getReleaseBaseUrl(version)}/${assetName}`;
-}
-function parseChecksums(content) {
-    const checksums = new Map();
-    for (const rawLine of content.split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (!line)
-            continue;
-        const match = line.match(/^([a-f0-9]{64})\s+(.+)$/i);
-        if (!match)
-            continue;
-        checksums.set(match[2], match[1].toLowerCase());
-    }
-    return checksums;
-}
-function sha256File(path) {
-    const hash = createHash("sha256");
-    hash.update(readFileSync(path));
-    return hash.digest("hex");
-}
-async function downloadToFile(url, destination) {
-    const response = await fetch(url, {
-        headers: { "User-Agent": "gsd-pi-rtk" },
-    });
-    if (!response.ok) {
-        throw new Error(`download failed (${response.status}) for ${url}`);
-    }
-    if (!response.body) {
-        throw new Error(`download returned no body for ${url}`);
-    }
-    const output = createWriteStream(destination);
-    await finished(Readable.fromWeb(response.body).pipe(output));
-}
-function findBinaryRecursively(rootDir, binaryName) {
-    const stack = [rootDir];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        if (!current)
-            continue;
-        const entries = readdirSync(current, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = join(current, entry.name);
-            if (entry.isFile() && entry.name === binaryName) {
-                return fullPath;
-            }
-            if (entry.isDirectory()) {
-                stack.push(fullPath);
-            }
-        }
-    }
-    return null;
-}
-function extractArchive(assetName, archivePath, extractDir) {
-    if (!assetName.endsWith(".tar.gz")) {
-        throw new Error(`unsupported RTK archive format: ${assetName}`);
-    }
-    mkdirSync(extractDir, { recursive: true });
-    const result = spawnSync("tar", ["xzf", archivePath, "-C", extractDir], {
-        encoding: "utf-8",
-        timeout: 30_000,
-    });
-    if (result.error || result.status !== 0) {
-        throw new Error(result.error?.message ?? result.stderr?.trim() ?? `tar extraction failed for ${assetName}`);
-    }
-}
-async function extractArchiveAsync(assetName, archivePath, extractDir) {
-    if (assetName.endsWith(".zip")) {
-        mkdirSync(extractDir, { recursive: true });
-        await extractZip(archivePath, { dir: extractDir });
-        return;
-    }
-    extractArchive(assetName, archivePath, extractDir);
-}
-function resolvePathCandidates(pathValue) {
-    if (!pathValue)
-        return [];
-    return pathValue
-        .split(delimiter)
-        .map((part) => part.trim())
-        .filter(Boolean);
-}
-function resolveSystemRtkPath(pathValue, platform = process.platform) {
-    const candidates = platform === "win32"
-        ? ["rtk.exe", "rtk.cmd", "rtk.bat", "rtk"]
-        : ["rtk"];
-    for (const dir of resolvePathCandidates(pathValue)) {
-        for (const candidate of candidates) {
-            const fullPath = join(dir, candidate);
-            if (existsSync(fullPath)) {
-                return fullPath;
-            }
-        }
-    }
-    return null;
-}
-export function resolveRtkBinaryPath(options = {}) {
-    const env = options.env ?? process.env;
-    const platform = options.platform ?? process.platform;
-    const explicitPath = options.binaryPath ?? env[GSD_RTK_PATH_ENV];
-    if (explicitPath && existsSync(explicitPath)) {
-        return explicitPath;
-    }
-    const managedPath = getManagedRtkPath(platform, options.targetDir ?? getManagedRtkDir(env));
-    if (existsSync(managedPath)) {
-        return managedPath;
-    }
-    // On Windows, also check for rtk.cmd in the managed dir (used by test fake RTK
-    // and any wrapper-style installs where a .cmd launcher accompanies the binary).
-    if (platform === "win32") {
-        const managedDir = options.targetDir ?? getManagedRtkDir(env);
-        const managedCmd = join(managedDir, "rtk.cmd");
-        if (existsSync(managedCmd)) {
-            return managedCmd;
-        }
-    }
-    return resolveSystemRtkPath(options.pathValue ?? getPathValue(env), platform);
-}
-export function rewriteCommandWithRtk(command, options = {}) {
-    if (!command.trim())
-        return command;
-    if (!isRtkEnabled(options.env ?? process.env))
-        return command;
-    const env = options.env ?? process.env;
-    const binaryPath = resolveRtkBinaryPath({
-        env,
-        binaryPath: options.binaryPath,
-    });
-    if (!binaryPath)
-        return command;
-    const run = options.spawnSyncImpl ?? spawnSync;
-    const result = run(binaryPath, ["rewrite", command], {
-        encoding: "utf-8",
-        env: buildRtkEnv(options.env ?? process.env),
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: options.timeoutMs ?? RTK_REWRITE_TIMEOUT_MS,
-        // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows
-        shell: /\.(cmd|bat)$/i.test(binaryPath),
-    });
-    if (result.error)
-        return command;
-    if (result.status !== 0 && result.status !== 3)
-        return command;
-    const rewritten = (result.stdout ?? "").trimEnd();
-    return rewritten || command;
-}
-export function validateRtkBinary(binaryPath, options = {}) {
-    const run = options.spawnSyncImpl ?? spawnSync;
-    const result = run(binaryPath, ["rewrite", "git status"], {
-        encoding: "utf-8",
-        env: buildRtkEnv(options.env ?? process.env),
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: RTK_REWRITE_TIMEOUT_MS,
-    });
-    if (result.error)
-        return false;
-    if (result.status !== 0)
-        return false;
-    return (result.stdout ?? "").trim() === "rtk git status";
-}
-export async function ensureRtkAvailable(options = {}) {
-    const env = options.env ?? process.env;
-    if (!isRtkEnabled(env)) {
-        return { enabled: false, supported: true, available: false, source: "disabled", reason: `${GSD_RTK_DISABLED_ENV} is set` };
-    }
-    if (isTruthy(env[GSD_SKIP_RTK_INSTALL_ENV])) {
-        const configuredPath = env[GSD_RTK_PATH_ENV];
-        if (configuredPath && existsSync(configuredPath)) {
-            return { enabled: true, supported: true, available: true, source: "managed", binaryPath: configuredPath };
-        }
-        return { enabled: true, supported: true, available: false, source: "missing", reason: `${GSD_SKIP_RTK_INSTALL_ENV} is set` };
-    }
-    const targetDir = options.targetDir ?? getManagedRtkDir(env);
-    const managedPath = getManagedRtkPath(process.platform, targetDir);
-    if (existsSync(managedPath) && validateRtkBinary(managedPath, { env })) {
-        return { enabled: true, supported: true, available: true, source: "managed", binaryPath: managedPath };
-    }
-    const systemPath = resolveSystemRtkPath(options.pathValue ?? getPathValue(env));
-    if (systemPath && validateRtkBinary(systemPath, { env })) {
-        return { enabled: true, supported: true, available: true, source: "system", binaryPath: systemPath };
-    }
-    const version = options.releaseVersion ?? RTK_VERSION;
-    const assetName = resolveRtkAssetName(process.platform, osArch(), version);
-    if (!assetName) {
-        return {
-            enabled: true,
-            supported: false,
-            available: false,
-            source: "unsupported",
-            reason: `RTK release asset unavailable for ${process.platform}/${osArch()}`,
-        };
-    }
-    if (options.allowDownload === false) {
-        return { enabled: true, supported: true, available: false, source: "missing", reason: "download disabled" };
-    }
-    mkdirSync(targetDir, { recursive: true });
-    const tempRoot = join(targetDir, `.rtk-install-${randomUUID().slice(0, 8)}`);
-    const archivePath = join(tempRoot, assetName);
-    const extractDir = join(tempRoot, "extract");
-    mkdirSync(tempRoot, { recursive: true });
-    try {
-        const checksumsUrl = getChecksumsUrl(version);
-        const checksumsResponse = await fetch(checksumsUrl, { headers: { "User-Agent": "gsd-pi-rtk" } });
-        if (!checksumsResponse.ok) {
-            throw new Error(`failed to fetch RTK checksums (${checksumsResponse.status})`);
-        }
-        const checksums = parseChecksums(await checksumsResponse.text());
-        const expectedSha = checksums.get(assetName);
-        if (!expectedSha) {
-            throw new Error(`missing checksum for ${assetName}`);
-        }
-        await downloadToFile(buildAssetUrl(version, assetName), archivePath);
-        const actualSha = sha256File(archivePath);
-        if (actualSha !== expectedSha) {
-            throw new Error(`checksum mismatch for ${assetName}`);
-        }
-        await extractArchiveAsync(assetName, archivePath, extractDir);
-        const extractedBinary = findBinaryRecursively(extractDir, getRtkBinaryName(process.platform));
-        if (!extractedBinary) {
-            throw new Error(`RTK binary not found in ${assetName}`);
-        }
-        copyFileSync(extractedBinary, managedPath);
-        if (process.platform !== "win32") {
-            chmodSync(managedPath, 0o755);
-        }
-        if (!validateRtkBinary(managedPath, { env })) {
-            rmSync(managedPath, { force: true });
-            throw new Error("downloaded RTK binary failed validation");
-        }
-        options.log?.(`installed RTK ${version} to ${managedPath}`);
-        return { enabled: true, supported: true, available: true, source: "downloaded", binaryPath: managedPath };
-    }
-    catch (error) {
-        options.log?.(`RTK install skipped: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            enabled: true,
-            supported: true,
-            available: false,
-            source: "missing",
-            reason: error instanceof Error ? error.message : String(error),
-        };
-    }
-    finally {
-        rmSync(tempRoot, { recursive: true, force: true });
-    }
-}
-export async function bootstrapRtk(options = {}) {
-    const result = await ensureRtkAvailable(options);
-    applyRtkProcessEnv(process.env);
-    if (result.binaryPath) {
-        process.env[GSD_RTK_PATH_ENV] = result.binaryPath;
-    }
-    return result;
-}