@replayio/app-building 1.25.0 → 1.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@replayio/app-building",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "Library for managing agentic app-building containers",
   "type": "module",
   "exports": {
@@ -13,6 +13,10 @@
     "dist"
   ],
   "scripts": {
-    "prepublishOnly": "tsc -p tsconfig.json"
+    "build": "tsup",
+    "prepublishOnly": "tsup"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
   }
 }

package/dist/container-registry.d.ts

@@ -1,25 +0,0 @@
-import type { AgentState } from "./container";
-export interface RegistryEntry extends AgentState {
-    startedAt: string;
-    stoppedAt?: string;
-}
-export interface ContainerRegistry {
-    log(state: AgentState): void;
-    markStopped(containerName?: string): void;
-    clearStopped(containerName: string): void;
-    getRecent(limit?: number): RegistryEntry[];
-    find(containerName: string): RegistryEntry | null;
-    findAlive(): Promise<RegistryEntry[]>;
-}
-export declare class FileContainerRegistry implements ContainerRegistry {
-    private filePath;
-    constructor(filePath: string);
-    private readRegistry;
-    private updateEntry;
-    log(state: AgentState): void;
-    markStopped(containerName?: string): void;
-    clearStopped(containerName: string): void;
-    getRecent(limit?: number): RegistryEntry[];
-    find(containerName: string): RegistryEntry | null;
-    findAlive(): Promise<RegistryEntry[]>;
-}

package/dist/container-registry.js

@@ -1,78 +0,0 @@
-import { readFileSync, writeFileSync, appendFileSync, existsSync } from "fs";
-import { probeAlive } from "./container-utils";
-export class FileContainerRegistry {
-    filePath;
-    constructor(filePath) {
-        this.filePath = filePath;
-    }
-    readRegistry() {
-        if (!existsSync(this.filePath))
-            return { lines: [], entries: [] };
-        const lines = readFileSync(this.filePath, "utf-8").split("\n").filter((l) => l.trim());
-        const entries = lines.map((line) => {
-            try {
-                return JSON.parse(line);
-            }
-            catch {
-                return null;
-            }
-        });
-        return { lines, entries };
-    }
-    updateEntry(match, update) {
-        const { lines, entries } = this.readRegistry();
-        for (let i = entries.length - 1; i >= 0; i--) {
-            const entry = entries[i];
-            if (entry && match(entry)) {
-                update(entry);
-                lines[i] = JSON.stringify(entry);
-                writeFileSync(this.filePath, lines.join("\n") + "\n");
-                return;
-            }
-        }
-    }
-    log(state) {
-        const entry = {
-            ...state,
-            startedAt: new Date().toISOString(),
-        };
-        appendFileSync(this.filePath, JSON.stringify(entry) + "\n");
-    }
-    markStopped(containerName) {
-        this.updateEntry((e) => !e.stoppedAt && (!containerName || e.containerName === containerName), (e) => { e.stoppedAt = new Date().toISOString(); });
-    }
-    clearStopped(containerName) {
-        this.updateEntry((e) => e.containerName === containerName && !!e.stoppedAt, (e) => { delete e.stoppedAt; });
-    }
-    getRecent(limit = 20) {
-        const { entries } = this.readRegistry();
-        return entries.filter((e) => e !== null).slice(-limit);
-    }
-    find(containerName) {
-        const entries = this.getRecent(100);
-        for (let i = entries.length - 1; i >= 0; i--) {
-            if (entries[i].containerName === containerName) {
-                return entries[i];
-            }
-        }
-        return null;
-    }
-    async findAlive() {
-        const entries = this.getRecent();
-        const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
-        const candidates = entries.filter((e) => new Date(e.startedAt).getTime() > oneDayAgo);
-        const aliveResults = await Promise.all(candidates.map(async (entry) => ({
-            entry,
-            alive: await probeAlive(entry),
-        })));
-        for (const r of aliveResults) {
-            if (r.alive && r.entry.stoppedAt) {
-                this.clearStopped(r.entry.containerName);
-            }
-            else if (!r.alive && !r.entry.stoppedAt) {
-                this.markStopped(r.entry.containerName);
-            }
-        }
-        return aliveResults.filter((r) => r.alive).map((r) => r.entry);
-    }
-}

package/dist/container-utils.d.ts

@@ -1,5 +0,0 @@
-import type { AgentState } from "./container";
-import type { RegistryEntry } from "./container-registry";
-import type { HttpOptions } from "./http-client";
-export declare function httpOptsFor(state: AgentState): HttpOptions;
-export declare function probeAlive(entry: RegistryEntry): Promise<boolean>;

package/dist/container-utils.js

@@ -1,30 +0,0 @@
-export function httpOptsFor(state) {
-    if (state.type === "remote" && state.flyMachineId) {
-        return { headers: { "fly-force-instance-id": state.flyMachineId } };
-    }
-    return {};
-}
-export async function probeAlive(entry) {
-    try {
-        const headers = {};
-        if (entry.type === "remote" && entry.flyMachineId) {
-            headers["fly-force-instance-id"] = entry.flyMachineId;
-        }
-        const res = await fetch(`${entry.baseUrl}/status`, {
-            headers,
-            signal: AbortSignal.timeout(5000),
-        });
-        if (!res.ok)
-            return false;
-        // Verify the response is actually from the expected container,
-        // not a different machine on the same Fly app.
-        const body = await res.json();
-        if (body.containerName && body.containerName !== entry.containerName) {
-            return false;
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/container.d.ts

@@ -1,58 +0,0 @@
-import type { ContainerRegistry, RegistryEntry } from "./container-registry";
-import type { InfisicalConfig } from "./secrets";
-export interface AgentState {
-    type: "local" | "remote";
-    containerName: string;
-    port: number;
-    baseUrl: string;
-    flyApp?: string;
-    flyMachineId?: string;
-    flyVolumeId?: string;
-}
-export interface ContainerConfig {
-    projectRoot?: string;
-    /** Infisical credentials — required for all containers. */
-    infisical: InfisicalConfig;
-    registry: ContainerRegistry;
-    flyToken?: string;
-    flyApp?: string;
-    imageRef?: string;
-    webhookUrl?: string;
-    webhookSecret?: string;
-    /** GET endpoint to fetch the next task when the local queue is empty. Uses webhookSecret for auth. */
-    taskWebhookUrl?: string;
-    /** POST endpoint to receive tasks added by the add-task script. When set, add-task POSTs tasks here instead of writing to the local task file. Uses webhookSecret for auth. */
-    addTaskWebhookUrl?: string;
-    /** Start the container in detached mode. It will exit after processing all messages and tasks. */
-    detached?: boolean;
-    /** Initial prompt to queue at container startup (before the HTTP server accepts external requests). */
-    initialPrompt?: string;
-    /** Override the host port for local containers (default: auto-selected). */
-    localPort?: number;
-    /** Absorb task files from other containers at startup. Default: false. */
-    absorbTasks?: boolean;
-    /** Container name prefix. Default: "app-building". */
-    namePrefix?: string;
-    /** Agent command override (e.g. "codex", "gemini"). Default: "claude". */
-    agentCommand?: string;
-}
-export interface RepoOptions {
-    repoUrl: string;
-    cloneBranch: string;
-    pushBranch: string;
-}
-export declare function loadDotEnv(projectRoot: string): Record<string, string>;
-export declare function buildImage(config: ContainerConfig): void;
-/**
- * Start a container (local Docker or remote Fly.io based on config).
- * If flyToken and flyApp are set, starts remotely; otherwise locally.
- */
-export declare function startContainer(config: ContainerConfig, repo: RepoOptions): Promise<AgentState>;
-/**
- * Stop a container by its state or registry entry.
- */
-export declare function stopContainer(config: ContainerConfig, state: AgentState | RegistryEntry): Promise<void>;
-/**
- * Spawn an interactive test container (local only).
- */
-export declare function spawnTestContainer(config: ContainerConfig): Promise<void>;

package/dist/container.js

@@ -1,361 +0,0 @@
-import { execFileSync, spawn } from "child_process";
-import { readFileSync, existsSync } from "fs";
-import { resolve } from "path";
-import { createMachine, waitForMachine, destroyMachine, listMachines } from "./fly";
-import { getImageRef } from "./image-ref";
-const IMAGE_NAME = "app-building";
-function debugLog(...args) {
-    if (process.env.DEBUG)
-        console.log("[container]", ...args);
-}
-export function loadDotEnv(projectRoot) {
-    const envPath = resolve(projectRoot, ".env");
-    if (!existsSync(envPath)) {
-        return {};
-    }
-    const content = readFileSync(envPath, "utf-8");
-    const vars = {};
-    for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#"))
-            continue;
-        const eqIndex = trimmed.indexOf("=");
-        if (eqIndex === -1)
-            continue;
-        const key = trimmed.slice(0, eqIndex).trim();
-        let value = trimmed.slice(eqIndex + 1).trim();
-        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        vars[key] = value;
-    }
-    return vars;
-}
-export function buildImage(config) {
-    if (!config.projectRoot)
-        throw new Error("projectRoot is required for local Docker operations");
-    console.log("Building Docker image...");
-    execFileSync("docker", ["build", "--platform", "linux/amd64", "--network", "host", "-t", IMAGE_NAME, config.projectRoot], {
-        stdio: "inherit",
-        timeout: 600000,
-    });
-    console.log("Docker image built successfully.");
-}
-function ensureImageExists(projectRoot) {
-    try {
-        execFileSync("docker", ["image", "inspect", IMAGE_NAME], {
-            stdio: "ignore",
-        });
-    }
-    catch {
-        console.log("Building Docker image...");
-        execFileSync("docker", ["build", "--platform", "linux/amd64", "--network", "host", "-t", IMAGE_NAME, projectRoot], {
-            stdio: "inherit",
-            timeout: 600000,
-        });
-        console.log("Docker image built successfully.");
-    }
-}
-function findFreePort() {
-    let port = 3100;
-    try {
-        const out = execFileSync("ss", ["-tlnH"], {
-            encoding: "utf-8",
-            timeout: 5000,
-        });
-        const usedPorts = new Set();
-        for (const match of out.matchAll(/:(\d+)\s/g)) {
-            usedPorts.add(parseInt(match[1], 10));
-        }
-        while (usedPorts.has(port))
-            port++;
-    }
-    catch {
-        // ss not available, just use default
-    }
-    return port;
-}
-function buildContainerEnv(repo, infisical, extra = {}) {
-    const env = {
-        REPO_URL: repo.repoUrl,
-        CLONE_BRANCH: repo.cloneBranch,
-        PUSH_BRANCH: repo.pushBranch,
-        GIT_AUTHOR_NAME: "App Builder",
-        GIT_AUTHOR_EMAIL: "app-builder@localhost",
-        GIT_COMMITTER_NAME: "App Builder",
-        GIT_COMMITTER_EMAIL: "app-builder@localhost",
-        PLAYWRIGHT_BROWSERS_PATH: "/opt/playwright",
-        INFISICAL_TOKEN: infisical.token,
-        INFISICAL_PROJECT_ID: infisical.projectId,
-        INFISICAL_ENVIRONMENT: infisical.environment,
-        ...extra,
-    };
-    if (process.env.DEBUG) {
-        env.DEBUG = process.env.DEBUG;
-    }
-    return env;
-}
-function buildExtraEnv(config, containerName) {
-    const extra = {
-        PORT: "3000",
-        CONTAINER_NAME: containerName,
-    };
-    if (config.webhookUrl)
-        extra.WEBHOOK_URL = config.webhookUrl;
-    if (config.taskWebhookUrl)
-        extra.TASK_WEBHOOK_URL = config.taskWebhookUrl;
-    if (config.addTaskWebhookUrl)
-        extra.ADD_TASK_WEBHOOK_URL = config.addTaskWebhookUrl;
-    if (config.webhookSecret)
-        extra.WEBHOOK_SECRET = config.webhookSecret;
-    if (config.detached)
-        extra.DETACHED = "1";
-    if (config.initialPrompt)
-        extra.INITIAL_PROMPT = config.initialPrompt;
-    if (config.absorbTasks)
-        extra.ABSORB_TASKS = "1";
-    if (config.agentCommand)
-        extra.AGENT_COMMAND = config.agentCommand;
-    return extra;
-}
-function isRemote(config) {
-    return !!(config.flyToken && config.flyApp);
-}
-// ---------------------------------------------------------------------------
-// Local container
-// ---------------------------------------------------------------------------
-async function startLocalContainer(config, repo) {
-    buildImage(config);
-    const uniqueId = Math.random().toString(36).slice(2, 8);
-    const prefix = config.namePrefix ?? "app-building";
-    const containerName = `${prefix}-${uniqueId}`;
-    const containerPort = 3000;
-    const hostPort = config.localPort ?? findFreePort();
-    const extra = buildExtraEnv(config, containerName);
-    extra.PORT = String(containerPort);
-    const containerEnv = buildContainerEnv(repo, config.infisical, extra);
-    const args = ["run", "--platform", "linux/amd64", "-d", "--rm", "--name", containerName];
-    args.push("-p", `${hostPort}:${containerPort}`);
-    for (const [k, v] of Object.entries(containerEnv)) {
-        args.push("--env", `${k}=${v}`);
-    }
-    args.push(IMAGE_NAME);
-    const containerId = execFileSync("docker", args, {
-        encoding: "utf-8",
-        timeout: 30000,
-    }).trim();
-    console.log(`Container started: ${containerId.slice(0, 12)} (${containerName})`);
-    const baseUrl = `http://127.0.0.1:${hostPort}`;
-    const maxWait = 120000;
-    const interval = 1000;
-    const start = Date.now();
-    let ready = false;
-    while (Date.now() - start < maxWait) {
-        try {
-            execFileSync("docker", ["inspect", "--format", "{{.State.Running}}", containerName], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 });
-        }
-        catch {
-            let logs = "";
-            try {
-                logs = execFileSync("docker", ["logs", "--tail", "30", containerName], {
-                    encoding: "utf-8",
-                    timeout: 5000,
-                });
-            }
-            catch {
-                // Container already removed (--rm)
-            }
-            throw new Error(`Container exited during startup.${logs ? `\n\n--- container logs ---\n${logs}` : " (no logs available, container was removed)"}`);
-        }
-        try {
-            const res = await fetch(`${baseUrl}/status`);
-            if (res.ok) {
-                ready = true;
-                break;
-            }
-        }
-        catch {
-            // Not ready yet
-        }
-        await new Promise((r) => setTimeout(r, interval));
-    }
-    if (!ready) {
-        throw new Error("Container did not become ready within timeout");
-    }
-    return { type: "local", containerName, port: hostPort, baseUrl };
-}
-function stopLocalContainer(containerName) {
-    try {
-        execFileSync("docker", ["stop", containerName], { stdio: "ignore", timeout: 30000 });
-    }
-    catch {
-        // Container may already be stopped
-    }
-}
-// ---------------------------------------------------------------------------
-// Remote container (Fly.io)
-// ---------------------------------------------------------------------------
-async function startRemoteContainerImpl(config, repo) {
-    if (!config.flyToken)
-        throw new Error("flyToken is required for remote containers");
-    if (!config.flyApp)
-        throw new Error("flyApp is required for remote containers");
-    const imageRef = config.imageRef ?? getImageRef();
-    const uniqueId = Math.random().toString(36).slice(2, 8);
-    const prefix = config.namePrefix ?? "app-building";
-    const machineName = `${prefix}-${uniqueId}`;
-    const extra = buildExtraEnv(config, machineName);
-    const containerEnv = buildContainerEnv(repo, config.infisical, extra);
-    const existing = await listMachines(config.flyApp, config.flyToken);
-    if (existing.length > 0) {
-        console.log(`${existing.length} existing machine(s) in ${config.flyApp}:`);
-        for (const m of existing) {
-            console.log(`  ${m.id} (${m.name}) — ${m.state}`);
-        }
-    }
-    console.log("Creating Fly machine (with volume)...");
-    let machineId = "";
-    let volumeId = "";
-    for (let attempt = 0; attempt < 5; attempt++) {
-        try {
-            const result = await createMachine(config.flyApp, config.flyToken, imageRef, containerEnv, machineName);
-            machineId = result.machineId;
-            volumeId = result.volumeId;
-            break;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (msg.includes("MANIFEST_UNKNOWN") && attempt < 4) {
-                console.log("Image not yet available in registry, retrying in 5s...");
-                await new Promise((r) => setTimeout(r, 5000));
-                continue;
-            }
-            throw err;
-        }
-    }
-    console.log(`Machine created: ${machineId} (volume: ${volumeId})`);
-    const baseUrl = `https://${config.flyApp}.fly.dev`;
-    const agentState = {
-        type: "remote",
-        containerName: machineName,
-        port: 443,
-        baseUrl,
-        flyApp: config.flyApp,
-        flyMachineId: machineId,
-        flyVolumeId: volumeId,
-    };
-    console.log("Waiting for machine to start...");
-    await waitForMachine(config.flyApp, config.flyToken, machineId);
-    console.log("Machine started.");
-    const maxWait = 180000;
-    const interval = 2000;
-    const start = Date.now();
-    let ready = false;
-    while (Date.now() - start < maxWait) {
-        try {
-            const res = await fetch(`${baseUrl}/status`, {
-                headers: { "fly-force-instance-id": machineId },
-            });
-            if (res.ok) {
-                ready = true;
-                break;
-            }
-        }
-        catch {
-            // Not ready yet
-        }
-        await new Promise((r) => setTimeout(r, interval));
-    }
-    if (!ready) {
-        console.log("Timed out waiting for machine, destroying...");
-        await destroyMachine(config.flyApp, config.flyToken, machineId, volumeId).catch(() => { });
-        throw new Error("Remote container did not become ready within timeout");
-    }
-    return agentState;
-}
-async function stopRemoteContainerImpl(config, state) {
-    if (!state.flyApp || !state.flyMachineId) {
-        throw new Error("Missing flyApp or flyMachineId in agent state");
-    }
-    if (!config.flyToken)
-        throw new Error("flyToken is required to stop remote container");
-    console.log(`Destroying Fly machine ${state.flyMachineId}...`);
-    await destroyMachine(state.flyApp, config.flyToken, state.flyMachineId, state.flyVolumeId);
-    console.log("Machine destroyed.");
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Start a container (local Docker or remote Fly.io based on config).
- * If flyToken and flyApp are set, starts remotely; otherwise locally.
- */
-export async function startContainer(config, repo) {
-    const { token, projectId, environment } = config.infisical;
-    if (!token || !projectId || !environment) {
-        const missing = [
-            !token && "token",
-            !projectId && "projectId",
-            !environment && "environment",
-        ].filter(Boolean);
-        throw new Error(`Missing Infisical credentials: ${missing.join(", ")}. Containers cannot start without Infisical.`);
-    }
-    debugLog("startContainer config:", {
-        projectRoot: config.projectRoot,
-        flyApp: config.flyApp,
-        imageRef: config.imageRef,
-        webhookUrl: config.webhookUrl,
-        detached: config.detached,
-        remote: isRemote(config),
-        initialPrompt: config.initialPrompt ? `${config.initialPrompt.slice(0, 100)}...` : undefined,
-    });
-    debugLog("startContainer repo:", repo);
-    const state = isRemote(config)
-        ? await startRemoteContainerImpl(config, repo)
-        : await startLocalContainer(config, repo);
-    config.registry.log(state);
-    return state;
-}
-/**
- * Stop a container by its state or registry entry.
- */
-export async function stopContainer(config, state) {
-    if (state.type === "remote") {
-        await stopRemoteContainerImpl(config, state);
-    }
-    else {
-        stopLocalContainer(state.containerName);
-    }
-    config.registry.markStopped(state.containerName);
-}
-/**
- * Spawn an interactive test container (local only).
- */
-export function spawnTestContainer(config) {
-    if (!config.projectRoot)
-        throw new Error("projectRoot is required for local Docker operations");
-    ensureImageExists(config.projectRoot);
-    const uniqueId = Math.random().toString(36).slice(2, 8);
-    const containerName = `app-building-test-${uniqueId}`;
-    const args = ["run", "--platform", "linux/amd64", "-it", "--rm", "--name", containerName];
-    args.push("-v", `${config.projectRoot}:/repo`);
-    args.push("-w", "/repo");
-    args.push("--network", "host");
-    args.push("--user", `${process.getuid()}:${process.getgid()}`);
-    args.push("--env", "HOME=/repo/.agent-home");
-    args.push("--env", "PLAYWRIGHT_BROWSERS_PATH=/opt/playwright");
-    args.push("--env", `INFISICAL_TOKEN=${config.infisical.token}`);
-    args.push("--env", `INFISICAL_PROJECT_ID=${config.infisical.projectId}`);
-    args.push("--env", `INFISICAL_ENVIRONMENT=${config.infisical.environment}`);
-    args.push(IMAGE_NAME, "bash");
-    return new Promise((resolvePromise, reject) => {
-        const child = spawn("docker", args, { stdio: "inherit" });
-        child.on("close", (code) => {
-            if (code === 0)
-                resolvePromise();
-            else
-                reject(new Error(`Container exited with code ${code}`));
-        });
-        child.on("error", reject);
-    });
-}

package/dist/fly.d.ts

@@ -1,55 +0,0 @@
-/**
- * Create a Fly app via the Machines API and allocate IPs so .fly.dev DNS works.
- */
-export declare function createApp(token: string, name: string, org?: string): Promise<void>;
-/**
- * Create a Fly Volume in the given region.
- * Returns the volume ID.
- */
-export declare function createVolume(app: string, token: string, name: string, region: string, sizeGb?: number): Promise<string>;
-/**
- * Delete a Fly Volume.
- */
-export declare function deleteVolume(app: string, token: string, volumeId: string): Promise<void>;
-export interface CreateMachineResult {
-    machineId: string;
-    volumeId: string;
-}
-/**
- * Create a Fly Machine with the given image and env vars.
- * Creates a volume mounted at /repo for storage.
- * Returns the machine ID and volume ID.
- */
-export declare function createMachine(app: string, token: string, image: string, env: Record<string, string>, name: string): Promise<CreateMachineResult>;
-/**
- * Wait for a Fly Machine to reach the "started" state.
- */
-export declare function waitForMachine(app: string, token: string, machineId: string, timeoutMs?: number): Promise<void>;
-/**
- * Destroy a Fly Machine (force) and its attached volume.
- */
-export declare function destroyMachine(app: string, token: string, machineId: string, volumeId?: string): Promise<void>;
-export interface FlyMachineInfo {
-    id: string;
-    name: string;
-    state: string;
-    created_at: string;
-    region: string;
-}
-/**
- * List all machines for a Fly app.
- */
-export declare function listMachines(app: string, token: string): Promise<FlyMachineInfo[]>;
-export interface FlyVolumeInfo {
-    id: string;
-    name: string;
-    state: string;
-    size_gb: number;
-    region: string;
-    created_at: string;
-    attached_machine_id: string | null;
-}
-/**
- * List all volumes for a Fly app.
- */
-export declare function listVolumes(app: string, token: string): Promise<FlyVolumeInfo[]>;