@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/coding-agent/utils/tools-manager.js

@@ -0,0 +1,308 @@
+import { spawnSync } from "child_process";
+import { chmodSync, createWriteStream, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from "fs";
+import { arch, platform } from "os";
+import { join } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { APP_NAME, andorraGetBinDir } from "../config.js";
+import { andorraFetchWithRetry } from "./management-http.js";
+const TOOLS_DIR = andorraGetBinDir();
+const NETWORK_TIMEOUT_MS = 10_000;
+const DOWNLOAD_TIMEOUT_MS = 120_000;
+function andorraIsOfflineModeEnabled() {
+    const value = process.env.ANDORRA_ENGINE_OFFLINE;
+    if (!value)
+        return false;
+    return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
+const TOOLS = {
+    fd: {
+        name: "fd",
+        repo: "sharkdp/fd",
+        binaryName: "fd",
+        systemBinaryNames: ["fd", "fdfind"],
+        tagPrefix: "v",
+        getAssetName: (version, plat, architecture) => {
+            if (plat === "darwin") {
+                const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+                return `fd-v${version}-${archStr}-apple-darwin.tar.gz`;
+            }
+            else if (plat === "linux") {
+                const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+                return `fd-v${version}-${archStr}-unknown-linux-musl.tar.gz`;
+            }
+            else if (plat === "win32") {
+                const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+                return `fd-v${version}-${archStr}-pc-windows-msvc.zip`;
+            }
+            return null;
+        },
+    },
+    rg: {
+        name: "ripgrep",
+        repo: "BurntSushi/ripgrep",
+        binaryName: "rg",
+        tagPrefix: "",
+        getAssetName: (version, plat, architecture) => {
+            if (plat === "darwin") {
+                const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+                return `ripgrep-${version}-${archStr}-apple-darwin.tar.gz`;
+            }
+            else if (plat === "linux") {
+                const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+                return `ripgrep-${version}-${archStr}-unknown-linux-musl.tar.gz`;
+            }
+            else if (plat === "win32") {
+                const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+                return `ripgrep-${version}-${archStr}-pc-windows-msvc.zip`;
+            }
+            return null;
+        },
+    },
+};
+// Check if a command exists in PATH by trying to run it
+function andorraCommandExists(cmd) {
+    try {
+        const result = spawnSync(cmd, ["--version"], { stdio: "pipe", windowsHide: true, timeout: 2000 });
+        // Check for ENOENT error (command not found)
+        return result.error === undefined || result.error === null;
+    }
+    catch {
+        return false;
+    }
+}
+// Get the path to a tool (system-wide or in our tools dir)
+export function andorraGetToolPath(tool) {
+    const config = TOOLS[tool];
+    if (!config)
+        return null;
+    // Check our tools directory first
+    const localPath = join(TOOLS_DIR, config.binaryName + (platform() === "win32" ? ".exe" : ""));
+    if (existsSync(localPath)) {
+        return localPath;
+    }
+    // Check system PATH - if found, just return the command name (it's in PATH)
+    const systemBinaryNames = config.systemBinaryNames ?? [config.binaryName];
+    for (const systemBinaryName of systemBinaryNames) {
+        if (andorraCommandExists(systemBinaryName)) {
+            return systemBinaryName;
+        }
+    }
+    return null;
+}
+// Resolve the latest release version from the release page redirect.
+// The api.github.com releases endpoint counts against the anonymous API
+// quota (60 requests/hour per IP), which is permanently exhausted behind
+// shared egress IPs such as corporate proxies and CI runners. The web
+// endpoint answers with a redirect to the tagged release at no quota cost
+// and lives on the same origin as the binary download itself.
+export async function andorraGetLatestVersion(repo) {
+    const response = await andorraFetchWithRetry(`https://github.com/${repo}/releases/latest`, {
+        headers: { "User-Agent": `${APP_NAME}-coding-agent` },
+        redirect: "manual",
+    }, { timeoutMs: NETWORK_TIMEOUT_MS });
+    // Only the status and headers matter here. Discard the body so the
+    // connection can be reused.
+    try {
+        await response.body?.cancel();
+    }
+    catch {
+        // Discarding the body is best-effort.
+    }
+    const location = response.status >= 300 && response.status < 400 ? response.headers.get("location") : null;
+    if (!location) {
+        throw new Error(`Failed to resolve latest ${repo} release: HTTP ${response.status} without redirect`);
+    }
+    const tag = new URL(location, "https://github.com").pathname.split("/").pop();
+    if (!tag || !location.includes("/releases/tag/")) {
+        throw new Error(`Failed to resolve latest ${repo} release: unexpected redirect to ${location}`);
+    }
+    return decodeURIComponent(tag).replace(/^v/, "");
+}
+// Download a file from URL
+async function andorraDownloadFile(url, dest) {
+    const response = await andorraFetchWithRetry(url, undefined, { timeoutMs: DOWNLOAD_TIMEOUT_MS });
+    if (!response.ok) {
+        throw new Error(`Download failed with HTTP ${response.status}: ${url}`);
+    }
+    if (!response.body) {
+        throw new Error("No response body");
+    }
+    const fileStream = createWriteStream(dest);
+    await pipeline(Readable.fromWeb(response.body), fileStream);
+}
+function andorraFindBinaryRecursively(rootDir, binaryFileName) {
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        if (!currentDir)
+            continue;
+        const entries = readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry.name);
+            if (entry.isFile() && entry.name === binaryFileName) {
+                return fullPath;
+            }
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+            }
+        }
+    }
+    return null;
+}
+function andorraFormatSpawnFailure(result) {
+    if (result.error?.message) {
+        return result.error.message;
+    }
+    const stderr = result.stderr?.toString().trim();
+    if (stderr) {
+        return stderr;
+    }
+    const stdout = result.stdout?.toString().trim();
+    if (stdout) {
+        return stdout;
+    }
+    return `exit status ${result.status ?? "unknown"}`;
+}
+function andorraRunExtractionCommand(command, args) {
+    const result = spawnSync(command, args, { stdio: "pipe" });
+    if (!result.error && result.status === 0) {
+        return null;
+    }
+    return `${command}: ${andorraFormatSpawnFailure(result)}`;
+}
+function andorraExtractTarGzArchive(archivePath, extractDir, assetName) {
+    const failure = andorraRunExtractionCommand("tar", ["xzf", archivePath, "-C", extractDir]);
+    if (failure) {
+        throw new Error(`Failed to extract ${assetName}: ${failure}`);
+    }
+}
+function andorraGetWindowsTarCommand() {
+    const systemRoot = process.env.SystemRoot ?? process.env.WINDIR;
+    if (systemRoot) {
+        const systemTar = join(systemRoot, "System32", "tar.exe");
+        if (existsSync(systemTar)) {
+            return systemTar;
+        }
+    }
+    return "tar.exe";
+}
+function andorraExtractZipArchive(archivePath, extractDir, assetName) {
+    const failures = [];
+    if (platform() === "win32") {
+        // Windows ships bsdtar as tar.exe, which supports zip files. Prefer the
+        // System32 binary over Git Bash's GNU tar, which does not handle zip archives.
+        const tarFailure = andorraRunExtractionCommand(andorraGetWindowsTarCommand(), ["xf", archivePath, "-C", extractDir]);
+        if (!tarFailure)
+            return;
+        failures.push(tarFailure);
+        const script = "& { param($archive, $destination) $ErrorActionPreference = 'Stop'; Expand-Archive -LiteralPath $archive -DestinationPath $destination -Force }";
+        const powershellFailure = andorraRunExtractionCommand("powershell.exe", [
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            script,
+            archivePath,
+            extractDir,
+        ]);
+        if (!powershellFailure)
+            return;
+        failures.push(powershellFailure);
+    }
+    else {
+        const unzipFailure = andorraRunExtractionCommand("unzip", ["-q", archivePath, "-d", extractDir]);
+        if (!unzipFailure)
+            return;
+        failures.push(unzipFailure);
+        const tarFailure = andorraRunExtractionCommand("tar", ["xf", archivePath, "-C", extractDir]);
+        if (!tarFailure)
+            return;
+        failures.push(tarFailure);
+    }
+    throw new Error(`Failed to extract ${assetName}: ${failures.join("; ")}`);
+}
+// Download and install a tool
+async function andorraDownloadTool(tool) {
+    const config = TOOLS[tool];
+    if (!config)
+        throw new Error(`Unknown tool: ${tool}`);
+    const plat = platform();
+    const architecture = arch();
+    // fd is pinned on darwin/x64, so skip the version lookup there.
+    const version = tool === "fd" && plat === "darwin" && architecture === "x64" ? "10.3.0" : await andorraGetLatestVersion(config.repo);
+    // Get asset name for this platform
+    const assetName = config.getAssetName(version, plat, architecture);
+    if (!assetName) {
+        throw new Error(`Unsupported platform: ${plat}/${architecture}`);
+    }
+    // Create tools directory
+    mkdirSync(TOOLS_DIR, { recursive: true });
+    const downloadUrl = `https://github.com/${config.repo}/releases/download/${config.tagPrefix}${version}/${assetName}`;
+    const archivePath = join(TOOLS_DIR, assetName);
+    const binaryExt = plat === "win32" ? ".exe" : "";
+    const binaryPath = join(TOOLS_DIR, config.binaryName + binaryExt);
+    // Download
+    await andorraDownloadFile(downloadUrl, archivePath);
+    // Extract into a unique temp directory. fd and rg downloads can run concurrently
+    // during startup, so sharing a fixed directory causes races.
+    const extractDir = join(TOOLS_DIR, `extract_tmp_${config.binaryName}_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`);
+    mkdirSync(extractDir, { recursive: true });
+    try {
+        if (assetName.endsWith(".tar.gz")) {
+            andorraExtractTarGzArchive(archivePath, extractDir, assetName);
+        }
+        else if (assetName.endsWith(".zip")) {
+            andorraExtractZipArchive(archivePath, extractDir, assetName);
+        }
+        else {
+            throw new Error(`Unsupported archive format: ${assetName}`);
+        }
+        // Find the binary in extracted files. Some archives contain files directly
+        // at root, others nest under a versioned subdirectory.
+        const binaryFileName = config.binaryName + binaryExt;
+        const extractedDir = join(extractDir, assetName.replace(/\.(tar\.gz|zip)$/, ""));
+        const extractedBinaryCandidates = [join(extractedDir, binaryFileName), join(extractDir, binaryFileName)];
+        let extractedBinary = extractedBinaryCandidates.find((candidate) => existsSync(candidate));
+        if (!extractedBinary) {
+            extractedBinary = andorraFindBinaryRecursively(extractDir, binaryFileName) ?? undefined;
+        }
+        if (extractedBinary) {
+            renameSync(extractedBinary, binaryPath);
+        }
+        else {
+            throw new Error(`Binary not found in archive: expected ${binaryFileName} under ${extractDir}`);
+        }
+        // Make executable (Unix only)
+        if (plat !== "win32") {
+            chmodSync(binaryPath, 0o755);
+        }
+    }
+    finally {
+        // Cleanup
+        rmSync(archivePath, { force: true });
+        rmSync(extractDir, { recursive: true, force: true });
+    }
+    return binaryPath;
+}
+// Termux package names for tools
+const TERMUX_PACKAGES = {
+    fd: "fd",
+    rg: "ripgrep",
+};
+/**
+ * Ensure a tool is available, downloading if necessary.
+ * Reports progress through `onStatus`; status messages are otherwise silent.
+ * Returns the tool path, or undefined if unavailable.
+ */
+export async function andorraEnsureTool(tool, onStatus) {
+    const existingPath = andorraGetToolPath(tool);
+    if (existingPath) {
+        return existingPath;
+    }
+    // Andorra never installs executable dependencies as a side effect of a read tool.
+    onStatus?.({ type: "warning", message: `${tool} is not installed; install it explicitly to enable this tool.` });
+    return undefined;
+}

package/dist/vendor/engine/runtime/coding-agent/utils/version-check.d.ts

@@ -0,0 +1,18 @@
+export interface LatestAndorraRelease {
+    version: string;
+    packageName?: string;
+    note?: string;
+}
+/** Include useful errno details hidden behind Node's generic "fetch failed" error. */
+export declare function andorraFormatVersionCheckError(error: unknown): string;
+export declare function andorraComparePackageVersions(leftVersion: string, rightVersion: string): number | undefined;
+export declare function andorraIsNewerPackageVersion(candidateVersion: string, currentVersion: string): boolean;
+export declare function andorraGetLatestAndorraRelease(currentVersion: string, options?: {
+    timeoutMs?: number;
+    retry?: boolean;
+}): Promise<LatestAndorraRelease | undefined>;
+export declare function andorraGetLatestAndorraVersion(currentVersion: string, options?: {
+    timeoutMs?: number;
+    retry?: boolean;
+}): Promise<string | undefined>;
+export declare function andorraCheckForNewAndorraVersion(currentVersion: string): Promise<LatestAndorraRelease | undefined>;

package/dist/vendor/engine/runtime/coding-agent/utils/version-check.js

@@ -0,0 +1,78 @@
+import { compare, valid } from "semver";
+import { andorraFetchWithRetry } from "./management-http.js";
+import { andorraGetAndorraUserAgent } from "./pi-user-agent.js";
+const LATEST_VERSION_URL = "https://pi.dev/api/latest-version";
+const DEFAULT_VERSION_CHECK_TIMEOUT_MS = 10000;
+/** Include useful errno details hidden behind Node's generic "fetch failed" error. */
+export function andorraFormatVersionCheckError(error) {
+    const rootMessage = error instanceof Error && error.message ? error.message : String(error);
+    const cause = error instanceof Error ? error.cause : undefined;
+    const causes = cause instanceof AggregateError ? cause.errors : cause === undefined ? [] : [cause];
+    const codes = causes
+        .map((value) => typeof value === "object" && value !== null && "code" in value && typeof value.code === "string"
+        ? value.code
+        : undefined)
+        .filter((code) => code !== undefined);
+    if (codes.length > 0)
+        return `${rootMessage} (${[...new Set(codes)].join(", ")})`;
+    const causeMessage = causes.find((value) => value instanceof Error && Boolean(value.message))?.message;
+    return causeMessage ? `${rootMessage} (cause: ${causeMessage})` : rootMessage;
+}
+export function andorraComparePackageVersions(leftVersion, rightVersion) {
+    const left = valid(leftVersion.trim());
+    const right = valid(rightVersion.trim());
+    if (!left || !right) {
+        return undefined;
+    }
+    return compare(left, right);
+}
+export function andorraIsNewerPackageVersion(candidateVersion, currentVersion) {
+    const comparison = andorraComparePackageVersions(candidateVersion, currentVersion);
+    if (comparison !== undefined) {
+        return comparison > 0;
+    }
+    return candidateVersion.trim() !== currentVersion.trim();
+}
+export async function andorraGetLatestAndorraRelease(currentVersion, options = {}) {
+    if (process.env.ANDORRA_ENGINE_OFFLINE)
+        return undefined;
+    const response = await andorraFetchWithRetry(LATEST_VERSION_URL, {
+        headers: {
+            "User-Agent": andorraGetAndorraUserAgent(currentVersion),
+            accept: "application/json",
+        },
+    }, {
+        maxRetries: options.retry ? 2 : 0,
+        timeoutMs: options.timeoutMs ?? DEFAULT_VERSION_CHECK_TIMEOUT_MS,
+    });
+    if (!response.ok)
+        return undefined;
+    const data = (await response.json());
+    if (typeof data.version !== "string" || !data.version.trim()) {
+        return undefined;
+    }
+    const packageName = typeof data.packageName === "string" && data.packageName.trim() ? data.packageName.trim() : undefined;
+    const note = typeof data.note === "string" && data.note.trim() ? data.note.trim() : undefined;
+    return {
+        version: data.version.trim(),
+        packageName,
+        ...(note ? { note } : {}),
+    };
+}
+export async function andorraGetLatestAndorraVersion(currentVersion, options = {}) {
+    return (await andorraGetLatestAndorraRelease(currentVersion, options))?.version;
+}
+export async function andorraCheckForNewAndorraVersion(currentVersion) {
+    if (process.env.ANDORRA_ENGINE_SKIP_VERSION_CHECK)
+        return undefined;
+    try {
+        const latestRelease = await andorraGetLatestAndorraRelease(currentVersion);
+        if (latestRelease && andorraIsNewerPackageVersion(latestRelease.version, currentVersion)) {
+            return latestRelease;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/utils/windows-self-update.d.ts

@@ -0,0 +1,2 @@
+export declare function andorraCleanupWindowsSelfUpdateQuarantine(packageDir: string): void;
+export declare function andorraQuarantineWindowsNativeDependencies(packageDir: string): void;

package/dist/vendor/engine/runtime/coding-agent/utils/windows-self-update.js

@@ -0,0 +1,76 @@
+import { randomUUID } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync } from "node:fs";
+import { basename, dirname, join, relative, resolve, toNamespacedPath } from "node:path";
+import { andorraGetCwdRelativePath } from "./paths.js";
+const QUARANTINE_DIR_NAME = ".pi-native-quarantine";
+function andorraNormalizePath(path) {
+    return toNamespacedPath(resolve(path));
+}
+function andorraGetQuarantineRoot(packageDir) {
+    let current = resolve(packageDir);
+    while (true) {
+        if (basename(current).toLowerCase() === "node_modules") {
+            return join(current, QUARANTINE_DIR_NAME);
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+function andorraGetLoadedSharedObjectsInPackageDir(packageDir) {
+    const sharedObjects = process.report.getReport().sharedObjects;
+    if (!Array.isArray(sharedObjects)) {
+        return [];
+    }
+    const root = andorraNormalizePath(packageDir).toLowerCase();
+    const seen = new Set();
+    const loadedFiles = [];
+    for (const value of sharedObjects) {
+        if (typeof value !== "string") {
+            continue;
+        }
+        const filePath = andorraNormalizePath(value);
+        const comparisonPath = filePath.toLowerCase();
+        if (andorraGetCwdRelativePath(comparisonPath, root) === undefined || seen.has(comparisonPath)) {
+            continue;
+        }
+        seen.add(comparisonPath);
+        loadedFiles.push(filePath);
+    }
+    return loadedFiles;
+}
+export function andorraCleanupWindowsSelfUpdateQuarantine(packageDir) {
+    const quarantineRoot = andorraGetQuarantineRoot(packageDir);
+    if (!quarantineRoot) {
+        return;
+    }
+    try {
+        rmSync(quarantineRoot, { recursive: true, force: true });
+    }
+    catch {
+        // A previous pi process may still be exiting and holding a native addon.
+    }
+}
+export function andorraQuarantineWindowsNativeDependencies(packageDir) {
+    const resolvedPackageDir = andorraNormalizePath(packageDir);
+    const quarantineRoot = andorraGetQuarantineRoot(resolvedPackageDir);
+    if (!quarantineRoot) {
+        return;
+    }
+    const loadedFiles = andorraGetLoadedSharedObjectsInPackageDir(resolvedPackageDir);
+    if (loadedFiles.length === 0) {
+        return;
+    }
+    const quarantineRunDir = join(quarantineRoot, `${Date.now()}-${process.pid}-${randomUUID()}`);
+    for (const loadedFile of loadedFiles) {
+        if (!existsSync(loadedFile)) {
+            continue;
+        }
+        const quarantinePath = join(quarantineRunDir, relative(resolvedPackageDir, loadedFile));
+        mkdirSync(dirname(quarantinePath), { recursive: true });
+        renameSync(loadedFile, quarantinePath);
+        copyFileSync(quarantinePath, loadedFile);
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/utils/wsl.d.ts

@@ -0,0 +1,2 @@
+/** Windows Subsystem for Linux, where Windows executables are reachable through interop. */
+export declare function andorraIsWSL(env?: NodeJS.ProcessEnv): boolean;

package/dist/vendor/engine/runtime/coding-agent/utils/wsl.js

@@ -0,0 +1,14 @@
+import { readFileSync } from "node:fs";
+/** Windows Subsystem for Linux, where Windows executables are reachable through interop. */
+export function andorraIsWSL(env = process.env) {
+    if (env.WSL_DISTRO_NAME || env.WSLENV) {
+        return true;
+    }
+    try {
+        const release = readFileSync("/proc/version", "utf-8");
+        return /microsoft|wsl/i.test(release);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/utils/zip.d.ts

@@ -0,0 +1,6 @@
+interface ZipEntry {
+    name: string;
+    data: string | Uint8Array;
+}
+export declare function andorraWriteZipArchive(filePath: string, entries: readonly ZipEntry[]): Promise<void>;
+export {};

package/dist/vendor/engine/runtime/coding-agent/utils/zip.js

@@ -0,0 +1,59 @@
+import { writeFile } from "node:fs/promises";
+import { crc32, deflateRawSync } from "node:zlib";
+function andorraDosDateTime(date) {
+    return {
+        time: (date.getHours() << 11) | (date.getMinutes() << 5) | (date.getSeconds() >> 1),
+        day: ((Math.max(1980, date.getFullYear()) - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
+    };
+}
+/** Create the small, classic ZIP archives used by bug reports. */
+function andorraCreateZipArchive(entries) {
+    const files = [];
+    const directory = [];
+    const { time, day } = andorraDosDateTime(new Date());
+    let offset = 0;
+    for (const entry of entries) {
+        const name = Buffer.from(entry.name);
+        const data = typeof entry.data === "string" ? Buffer.from(entry.data) : Buffer.from(entry.data);
+        const compressed = deflateRawSync(data);
+        const checksum = crc32(data);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0x0800, 6);
+        local.writeUInt16LE(8, 8);
+        local.writeUInt16LE(time, 10);
+        local.writeUInt16LE(day, 12);
+        local.writeUInt32LE(checksum, 14);
+        local.writeUInt32LE(compressed.length, 18);
+        local.writeUInt32LE(data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(20, 4);
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0x0800, 8);
+        central.writeUInt16LE(8, 10);
+        central.writeUInt16LE(time, 12);
+        central.writeUInt16LE(day, 14);
+        central.writeUInt32LE(checksum, 16);
+        central.writeUInt32LE(compressed.length, 20);
+        central.writeUInt32LE(data.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt32LE(offset, 42);
+        files.push(local, name, compressed);
+        directory.push(central, name);
+        offset += local.length + name.length + compressed.length;
+    }
+    const centralDirectory = Buffer.concat(directory);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(entries.length, 8);
+    end.writeUInt16LE(entries.length, 10);
+    end.writeUInt32LE(centralDirectory.length, 12);
+    end.writeUInt32LE(offset, 16);
+    return Buffer.concat([...files, centralDirectory, end]);
+}
+export function andorraWriteZipArchive(filePath, entries) {
+    return writeFile(filePath, andorraCreateZipArchive(entries));
+}

package/dist/vendor/engine/runtime/package.json

@@ -0,0 +1,9 @@
+{
+  "type": "module",
+  "name": "@andorra-labs/agent-engine",
+  "version": "0.86.1",
+  "andorraConfig": {
+    "name": "andorra",
+    "configDir": ".andorracode"
+  }
+}