@replayio/app-building 1.0.0

package/README.md

@@ -0,0 +1,92 @@
+# app-building
+
+Simple and extensible platform for dark factory agentic app building: creating apps
+according to a spec without human involvement along the way. Example use cases:
+
+* `npm run agent -- -p "Build me an app XYZ based on this spec: ..."`
+* `npm run agent -- -p "Continue maintaining app XYZ and fix these bugs: ..."`
+* `npm run agent -- -i` for interactive access to the agent.
+
+Core ideas:
+
+* The agent runs within a docker container that clones the target repo and exposes an HTTP server for control.
+* The host communicates with the container via HTTP — sending prompts, polling events/logs, and managing lifecycle.
+* The agent builds by following a set of skill documents with guides
+  for breaking its work down into jobs and directives for performing those tasks.
+* The agent commits logs for it to review later and improve its skills.
+* All code changes are committed and pushed back to the remote from inside the container.
+
+Containers can run locally or remotely.
+
+## Setup
+
+```bash
+npm install
+```
+
+Copy `.env.example` to `.env` and fill in all required API keys.
+
+## Running the Agent
+
+`npm run agent` starts a new container with the running agent. By default the container is local, add `--remote` to spawn the container remotely. This requires FLY_API_TOKEN in .env
+
+### Detached mode
+
+```bash
+npm run agent
+npm run agent -- -p "<prompt>"
+npm run agent -- --branch dev --push-branch feature/xyz -p "<prompt>"
+```
+
+Starts a container, optionally queues a prompt, then detaches. The container processes the prompt followed by any pending tasks, commits and pushes results, then exits.
+
+### Interactive mode
+
+```bash
+npm run agent -- -i
+```
+
+Chat with the agent inside a container. Output is streamed via event polling. Press ESC to interrupt the current message. On exit, the container is detached and finishes any remaining work.
+
+### Checking status
+
+```bash
+npm run status
+```
+
+Connects to the running container's HTTP API and shows state, revision, queue depth, cost, and recent log output. Tails logs in real-time (Ctrl+C to stop). Errors if no agent is running.
+
+### Stopping the agent
+
+```bash
+npm run stop
+npm run stop -- <containerName>
+```
+
+Sends an HTTP stop signal. Without arguments, finds and stops all running containers. Pass a container name to stop a specific one.
+
+## Skills
+
+The provided skill documents emphasize a structured approach for autonomously building
+high quality, well tested apps from the initial spec. During the initial app build
+it does the following:
+
+1. Designs a comprehensive test specification based on the initial spec.
+2. Builds the app and writes tests to match the spec.
+3. Gets all the tests to pass, deploys to production, and does further testing.
+
+The initial build will not come out perfect. The agent can followup with maintenance passes
+where it checks to make sure it closely followed the spec and skill directives and fixes
+any issues it finds. It will also fix reported bugs and update the skills to avoid
+similar problems in the future.
+
+As long as each individual step the agent takes is within its capabilities (it can usually
+do it but not always) the agent will converge on an app that follows the initial spec
+and skill directives.
+
+Key things to watch out for:
+
+* Best suited for CRUD and API-calling apps up to a medium level of complexity.
+  Overly complicated or specialized apps will not work as well yet.
+* Make sure to get a Replay API key and configure it. The agent will use Replay to identify
+  and debug problems it encounters in tests or the deployed app.

package/dist/package/container-registry.d.ts

@@ -0,0 +1,17 @@
+import type { AgentState } from "./container";
+export interface RegistryEntry extends AgentState {
+    startedAt: string;
+    stoppedAt?: string;
+}
+export declare class 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/package/container-registry.js

@@ -0,0 +1,78 @@
+import { readFileSync, writeFileSync, appendFileSync, existsSync } from "fs";
+import { probeAlive } from "./container-utils";
+export class ContainerRegistry {
+    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/package/container-utils.d.ts

@@ -0,0 +1,5 @@
+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/package/container-utils.js

@@ -0,0 +1,30 @@
+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/package/container.d.ts

@@ -0,0 +1,29 @@
+import type { ContainerRegistry } from "./container-registry";
+export interface AgentState {
+    type: "local" | "remote";
+    containerName: string;
+    port: number;
+    baseUrl: string;
+    flyApp?: string;
+    flyMachineId?: string;
+}
+export interface ContainerConfig {
+    projectRoot: string;
+    envVars: Record<string, string>;
+    registry: ContainerRegistry;
+    flyToken?: string;
+    flyApp?: string;
+    imageRef?: 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;
+export declare function startContainer(config: ContainerConfig, repo: RepoOptions): Promise<AgentState>;
+export declare function startRemoteContainer(config: ContainerConfig, repo: RepoOptions): Promise<AgentState>;
+export declare function stopRemoteContainer(config: ContainerConfig, state: AgentState): Promise<void>;
+export declare function stopContainer(config: ContainerConfig, containerName: string): void;
+export declare function spawnTestContainer(config: ContainerConfig): Promise<void>;

package/dist/package/container.js

@@ -0,0 +1,287 @@
+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";
+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) {
+    console.log("Building Docker image...");
+    execFileSync("docker", ["build", "--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", "--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, envVars, 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",
+        ...envVars,
+        ...extra,
+    };
+    if (process.env.DEBUG) {
+        env.DEBUG = process.env.DEBUG;
+    }
+    return env;
+}
+export async function startContainer(config, repo) {
+    buildImage(config);
+    const uniqueId = Math.random().toString(36).slice(2, 8);
+    const containerName = `app-building-${uniqueId}`;
+    const hostPort = findFreePort();
+    const containerEnv = buildContainerEnv(repo, config.envVars, {
+        PORT: String(hostPort),
+        CONTAINER_NAME: containerName,
+    });
+    // Build docker run args
+    const args = ["run", "-d", "--rm", "--name", containerName];
+    // --network host: container shares host network stack (no -p needed)
+    args.push("--network", "host");
+    for (const [k, v] of Object.entries(containerEnv)) {
+        args.push("--env", `${k}=${v}`);
+    }
+    // Image name — CMD is baked in (server.ts)
+    args.push(IMAGE_NAME);
+    const containerId = execFileSync("docker", args, {
+        encoding: "utf-8",
+        timeout: 30000,
+    }).trim();
+    console.log(`Container started: ${containerId.slice(0, 12)} (${containerName})`);
+    // Wait for the HTTP server to become ready
+    const baseUrl = `http://127.0.0.1:${hostPort}`;
+    const maxWait = 120000; // clone can take a while
+    const interval = 1000;
+    const start = Date.now();
+    let ready = false;
+    while (Date.now() - start < maxWait) {
+        // Check if the container is still alive (--rm removes it on exit)
+        try {
+            execFileSync("docker", ["inspect", "--format", "{{.State.Running}}", containerName], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 });
+        }
+        catch {
+            // Container is gone — grab logs from docker if possible, otherwise just report
+            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");
+    }
+    const agentState = { type: "local", containerName, port: hostPort, baseUrl };
+    config.registry.log(agentState);
+    return agentState;
+}
+export async function startRemoteContainer(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 machineName = `app-building-${uniqueId}`;
+    // Build env vars for the machine
+    const containerEnv = buildContainerEnv(repo, config.envVars, {
+        PORT: "3000",
+        CONTAINER_NAME: machineName,
+    });
+    // Remove Fly-specific vars from container env (not needed inside)
+    delete containerEnv.FLY_API_TOKEN;
+    delete containerEnv.FLY_APP_NAME;
+    // Log existing machines (but don't destroy — multiple containers may run concurrently)
+    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}`);
+        }
+    }
+    // Retry machine creation — the registry tag may take a moment to propagate
+    console.log("Creating Fly machine...");
+    let machineId = "";
+    for (let attempt = 0; attempt < 5; attempt++) {
+        try {
+            machineId = await createMachine(config.flyApp, config.flyToken, imageRef, containerEnv, machineName);
+            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}`);
+    // Register immediately so the container is tracked even if startup times out
+    const baseUrl = `https://${config.flyApp}.fly.dev`;
+    const agentState = {
+        type: "remote",
+        containerName: machineName,
+        port: 443,
+        baseUrl,
+        flyApp: config.flyApp,
+        flyMachineId: machineId,
+    };
+    config.registry.log(agentState);
+    console.log("Waiting for machine to start...");
+    await waitForMachine(config.flyApp, config.flyToken, machineId);
+    console.log("Machine started.");
+    // Poll the public URL until the HTTP server is ready, targeting this specific machine
+    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) {
+        // Clean up machine if we can't reach it
+        console.log("Timed out waiting for machine, destroying...");
+        await destroyMachine(config.flyApp, config.flyToken, machineId).catch(() => { });
+        throw new Error("Remote container did not become ready within timeout");
+    }
+    return agentState;
+}
+export async function stopRemoteContainer(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);
+    console.log("Machine destroyed.");
+    config.registry.markStopped(state.containerName);
+}
+export function stopContainer(config, containerName) {
+    try {
+        execFileSync("docker", ["stop", containerName], { stdio: "ignore", timeout: 30000 });
+    }
+    catch {
+        // Container may already be stopped
+    }
+    config.registry.markStopped(containerName);
+}
+export function spawnTestContainer(config) {
+    ensureImageExists(config.projectRoot);
+    const uniqueId = Math.random().toString(36).slice(2, 8);
+    const containerName = `app-building-test-${uniqueId}`;
+    const args = ["run", "-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");
+    for (const [k, v] of Object.entries(config.envVars)) {
+        args.push("--env", `${k}=${v}`);
+    }
+    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/package/fly.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 Machine with the given image and env vars.
+ * Returns the machine ID.
+ */
+export declare function createMachine(app: string, token: string, image: string, env: Record<string, string>, name: string): Promise<string>;
+/**
+ * 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).
+ */
+export declare function destroyMachine(app: string, token: string, machineId: 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[]>;

package/dist/package/fly.js

@@ -0,0 +1,118 @@
+const API_BASE = "https://api.machines.dev/v1";
+async function flyFetch(path, token, opts = {}) {
+    const res = await fetch(`${API_BASE}${path}`, {
+        ...opts,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+            ...(opts.headers ?? {}),
+        },
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`Fly API ${opts.method ?? "GET"} ${path} → ${res.status}: ${body}`);
+    }
+    return res;
+}
+/**
+ * Create a Fly app via the Machines API and allocate IPs so .fly.dev DNS works.
+ */
+export async function createApp(token, name, org) {
+    await flyFetch("/apps", token, {
+        method: "POST",
+        body: JSON.stringify({ app_name: name, org_slug: org ?? "personal" }),
+    });
+    // Allocate shared IPv4 and IPv6 via GraphQL so the app gets a .fly.dev domain
+    const gqlFetch = async (query, variables) => {
+        const res = await fetch("https://api.fly.io/graphql", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ query, variables }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`Fly GraphQL error ${res.status}: ${body}`);
+        }
+        const data = await res.json();
+        if (data.errors?.length) {
+            throw new Error(`Fly GraphQL: ${data.errors[0].message}`);
+        }
+    };
+    const allocateMutation = `
+    mutation($input: AllocateIPAddressInput!) {
+      allocateIpAddress(input: $input) {
+        ipAddress { id address type }
+      }
+    }
+  `;
+    await gqlFetch(allocateMutation, { input: { appId: name, type: "shared_v4" } });
+    await gqlFetch(allocateMutation, { input: { appId: name, type: "v6" } });
+}
+/**
+ * Create a Fly Machine with the given image and env vars.
+ * Returns the machine ID.
+ */
+export async function createMachine(app, token, image, env, name) {
+    const res = await flyFetch(`/apps/${app}/machines`, token, {
+        method: "POST",
+        body: JSON.stringify({
+            name,
+            config: {
+                image,
+                env,
+                restart: { policy: "no" },
+                guest: {
+                    cpu_kind: "shared",
+                    cpus: 4,
+                    memory_mb: 4096,
+                },
+                services: [
+                    {
+                        ports: [{ port: 443, handlers: ["tls", "http"] }],
+                        protocol: "tcp",
+                        internal_port: 3000,
+                        autostart: false,
+                        autostop: "off",
+                    },
+                ],
+            },
+        }),
+    });
+    const data = (await res.json());
+    return data.id;
+}
+/**
+ * Wait for a Fly Machine to reach the "started" state.
+ */
+export async function waitForMachine(app, token, machineId, timeoutMs = 180000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            await flyFetch(`/apps/${app}/machines/${machineId}/wait?state=started&timeout=60`, token);
+            return;
+        }
+        catch (e) {
+            const elapsed = Math.round((Date.now() - start) / 1000);
+            console.log(`Still waiting for machine to start (${elapsed}s elapsed): ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    throw new Error(`Machine ${machineId} did not reach started state within ${timeoutMs / 1000}s`);
+}
+/**
+ * Destroy a Fly Machine (force).
+ */
+export async function destroyMachine(app, token, machineId) {
+    await flyFetch(`/apps/${app}/machines/${machineId}?force=true`, token, {
+        method: "DELETE",
+    });
+}
+/**
+ * List all machines for a Fly app.
+ */
+export async function listMachines(app, token) {
+    const res = await flyFetch(`/apps/${app}/machines`, token);
+    return (await res.json());
+}

package/dist/package/http-client.d.ts

@@ -0,0 +1,6 @@
+export interface HttpOptions {
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+export declare function httpGet(url: string, opts?: HttpOptions): Promise<any>;
+export declare function httpPost(url: string, body?: unknown, opts?: HttpOptions): Promise<any>;

package/dist/package/http-client.js

@@ -0,0 +1,30 @@
+const DEFAULT_TIMEOUT = 30000;
+const MAX_RETRIES = 4;
+const RETRY_DELAY_MS = 2000;
+async function fetchWithRetry(url, init, timeout) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            const res = await fetch(url, { ...init, signal: AbortSignal.timeout(timeout) });
+            if (!res.ok)
+                throw new Error(`${init.method ?? "GET"} ${url}: ${res.status} ${res.statusText}`);
+            return res;
+        }
+        catch (err) {
+            if (attempt >= MAX_RETRIES)
+                throw err;
+            await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+        }
+    }
+}
+export async function httpGet(url, opts = {}) {
+    const res = await fetchWithRetry(url, { headers: opts.headers }, opts.timeout ?? DEFAULT_TIMEOUT);
+    return res.json();
+}
+export async function httpPost(url, body, opts = {}) {
+    const res = await fetchWithRetry(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...opts.headers },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    }, opts.timeout ?? DEFAULT_TIMEOUT);
+    return res.json();
+}

package/dist/package/image-ref.d.ts

@@ -0,0 +1 @@
+export declare function getImageRef(): string;

package/dist/package/image-ref.js

@@ -0,0 +1,4 @@
+const DEFAULT_IMAGE_REF = "ghcr.io/replayio/app-building:latest";
+export function getImageRef() {
+    return process.env.CONTAINER_IMAGE_REF ?? DEFAULT_IMAGE_REF;
+}

package/dist/package/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./fly";
+export * from "./container";
+export * from "./container-registry";
+export * from "./container-utils";
+export * from "./http-client";
+export * from "./image-ref";

package/dist/package/index.js

@@ -0,0 +1,6 @@
+export * from "./fly";
+export * from "./container";
+export * from "./container-registry";
+export * from "./container-utils";
+export * from "./http-client";
+export * from "./image-ref";

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@replayio/app-building",
+  "version": "1.0.0",
+  "description": "Simple agent loop for building apps with Claude Code CLI",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/package/index.js",
+      "types": "./dist/package/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/package"
+  ],
+  "scripts": {
+    "agent": "tsx src/agent.ts",
+    "status": "tsx src/status.ts",
+    "read-log": "tsx src/read-log.ts",
+    "reset-app": "tsx src/reset-app.ts",
+    "docker:build": "docker build --no-cache --network=host -t app-building .",
+    "test-container": "tsx src/test-container.ts",
+    "stop": "tsx src/stop.ts",
+    "fly-machines": "tsx src/fly-machines.ts",
+    "add-task": "tsx scripts/add-task.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0"
+  },
+  "dependencies": {
+    "commander": "^14.0.3"
+  }
+}