@instafy/cli 0.1.7 → 0.1.8-staging.348

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import kleur from "kleur";
@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
 import os from "node:os";
 import { ensureRatholeBinary } from "./rathole.js";
+import { resolveConfiguredAccessToken } from "./config.js";
 const INSTAFY_DIR = path.join(os.homedir(), ".instafy");
 const STATE_FILE = path.join(INSTAFY_DIR, "cli-runtime-state.json");
 const LOG_DIR = path.join(INSTAFY_DIR, "cli-runtime-logs");
@@ -27,7 +28,82 @@ function resolveRuntimeBinary() {
             return candidate;
         }
     }
-    throw new Error("runtime-agent binary not found. Build it with `cargo build -p runtime-agent`.");
+    throw new Error("runtime-agent binary not found. If you're in the instafy repo, run `cargo build -p runtime-agent`. Otherwise install Docker and rerun `instafy runtime:start`.");
+}
+function tryResolveRuntimeBinary() {
+    try {
+        return resolveRuntimeBinary();
+    }
+    catch {
+        return null;
+    }
+}
+function isDockerAvailable() {
+    try {
+        const result = spawnSync("docker", ["version"], { stdio: "ignore" });
+        return result.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeControllerUrlForDocker(controllerUrl) {
+    const trimmed = controllerUrl.trim().replace(/\/$/, "");
+    if (!trimmed) {
+        return trimmed;
+    }
+    try {
+        const url = new URL(trimmed);
+        const host = url.hostname.toLowerCase();
+        if (host === "127.0.0.1" || host === "localhost" || host === "::1" || host === "0.0.0.0") {
+            url.hostname = "host.docker.internal";
+        }
+        return url.toString().replace(/\/$/, "");
+    }
+    catch {
+        return trimmed
+            .replace("127.0.0.1", "host.docker.internal")
+            .replace("localhost", "host.docker.internal")
+            .replace("0.0.0.0", "host.docker.internal")
+            .replace(/\/$/, "");
+    }
+}
+function resolveRuntimeAgentImage() {
+    const fromEnv = normalizeToken(process.env["INSTAFY_RUNTIME_AGENT_IMAGE"]) ??
+        normalizeToken(process.env["RUNTIME_AGENT_IMAGE"]) ??
+        null;
+    return fromEnv ?? "ghcr.io/instafy-dev/instafy-runtime-agent:latest";
+}
+function dockerContainerRunning(containerId) {
+    const id = containerId.trim();
+    if (!id) {
+        return false;
+    }
+    try {
+        const result = spawnSync("docker", ["inspect", "-f", "{{.State.Running}}", id], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (result.status !== 0) {
+            return false;
+        }
+        return String(result.stdout ?? "").trim() === "true";
+    }
+    catch {
+        return false;
+    }
+}
+function stopDockerContainer(containerId) {
+    const id = containerId.trim();
+    if (!id) {
+        return;
+    }
+    try {
+        spawnSync("docker", ["rm", "-f", id], { stdio: "ignore" });
+    }
+    catch {
+        // ignore
+    }
 }
 function printStatus(label, value) {
     console.log(`${kleur.cyan(label)} ${value}`);
@@ -131,6 +207,14 @@ function findRatholeOnPath() {
     }
     return null;
 }
+function resolveControllerAccessTokenForCli(options, env, supabaseAccessToken) {
+    return (normalizeToken(options.controllerAccessToken) ??
+        normalizeToken(env["INSTAFY_ACCESS_TOKEN"]) ??
+        normalizeToken(env["CONTROLLER_ACCESS_TOKEN"]) ??
+        supabaseAccessToken ??
+        normalizeToken(env["SUPABASE_ACCESS_TOKEN"]) ??
+        resolveConfiguredAccessToken());
+}
 export async function resolveRatholeBinaryForCli(options) {
     const warn = options.warn ??
         ((message) => {
@@ -212,33 +296,34 @@ function isProcessAlive(pid) {
     }
 }
 export async function runtimeStart(options) {
-    const bin = resolveRuntimeBinary();
     const env = { ...process.env };
     const existing = readState();
-    if (existing && isProcessAlive(existing.pid)) {
-        throw new Error(`Runtime already running (pid ${existing.pid}) for project ${existing.projectId}. Stop it first.`);
+    if (existing) {
+        if (existing.runner === "docker" && existing.containerId && dockerContainerRunning(existing.containerId)) {
+            throw new Error(`Runtime already running (docker container ${existing.containerId}) for project ${existing.projectId}. Stop it first.`);
+        }
+        if ((!existing.runner || existing.runner === "process") && isProcessAlive(existing.pid)) {
+            throw new Error(`Runtime already running (pid ${existing.pid}) for project ${existing.projectId}. Stop it first.`);
+        }
     }
-    const manifestInfo = findProjectManifest(options.workspace ?? process.cwd());
+    const manifestInfo = findProjectManifest(process.cwd());
     const projectId = options.project ?? env["PROJECT_ID"] ?? manifestInfo.manifest?.projectId ?? null;
     if (!projectId) {
-        throw new Error("Project ID is required (--project or PROJECT_ID)");
+        throw new Error("No project configured. Run `instafy project:init` in this folder (recommended) or pass --project.");
     }
     env["PROJECT_ID"] = projectId;
     const supabaseAccessToken = resolveSupabaseAccessToken(options, env);
     if (supabaseAccessToken) {
         env["SUPABASE_ACCESS_TOKEN"] = supabaseAccessToken;
     }
-    let controllerAccessToken = normalizeToken(options.controllerAccessToken) ??
-        normalizeToken(env["INSTAFY_ACCESS_TOKEN"]) ??
-        normalizeToken(env["CONTROLLER_ACCESS_TOKEN"]) ??
-        supabaseAccessToken;
+    let controllerAccessToken = resolveControllerAccessTokenForCli(options, env, supabaseAccessToken);
     let runtimeAccessToken = normalizeToken(options.runtimeToken) ?? normalizeToken(env["RUNTIME_ACCESS_TOKEN"]);
     const agentKey = options.controllerToken ??
         env["INSTAFY_SERVICE_TOKEN"] ??
         env["AGENT_LOGIN_KEY"] ??
         env["AGENT_KEY"];
     if (!agentKey && !controllerAccessToken && !runtimeAccessToken) {
-        throw new Error("Provide either --runtime-token/RUNTIME_ACCESS_TOKEN, --access-token/INSTAFY_ACCESS_TOKEN, --supabase-access-token/SUPABASE_ACCESS_TOKEN, or --service-token/INSTAFY_SERVICE_TOKEN (advanced).");
+        throw new Error("Login required. Run `instafy login`, or pass --access-token / --supabase-access-token, or provide --runtime-token.");
     }
     if (agentKey) {
         env["AGENT_LOGIN_KEY"] = agentKey;
@@ -250,6 +335,7 @@ export async function runtimeStart(options) {
         options.controllerUrl ??
             env["INSTAFY_SERVER_URL"] ??
             env["CONTROLLER_BASE_URL"] ??
+            manifestInfo.manifest?.controllerUrl ??
             "http://127.0.0.1:8788";
     if (!runtimeAccessToken && controllerAccessToken) {
         runtimeAccessToken = await mintRuntimeAccessToken({
@@ -320,47 +406,123 @@ export async function runtimeStart(options) {
     if (options.runtimeLeaseId && options.runtimeLeaseId.trim()) {
         env["RUNTIME_LEASE_ID"] = options.runtimeLeaseId.trim();
     }
-    if (!env["ORIGIN_ENDPOINT"]) {
-        const ratholeResolved = await resolveRatholeBinaryForCli({
-            env,
-            version: process.env["RATHOLE_VERSION"] ?? null,
-            cacheDir: process.env["RATHOLE_CACHE_DIR"] ?? null,
-            logger: (message) => console.log(kleur.cyan(`[rathole] ${message}`)),
-            warn: (message) => console.warn(kleur.yellow(message)),
-        });
-        if (!ratholeResolved) {
-            throw new Error("Tunnel is required but rathole is unavailable. Set RATHOLE_BIN (recommended) or pass --origin-endpoint to use a reachable URL.");
+    const runtimeMode = (options.runtimeMode ?? "auto").toLowerCase();
+    const runtimeBin = runtimeMode === "docker" ? null : tryResolveRuntimeBinary();
+    const useDocker = runtimeMode === "docker" ||
+        (runtimeMode === "auto" && !runtimeBin);
+    if (!useDocker) {
+        if (!env["ORIGIN_ENDPOINT"]) {
+            const ratholeResolved = await resolveRatholeBinaryForCli({
+                env,
+                version: process.env["RATHOLE_VERSION"] ?? null,
+                cacheDir: process.env["RATHOLE_CACHE_DIR"] ?? null,
+                logger: (message) => console.log(kleur.cyan(`[rathole] ${message}`)),
+                warn: (message) => console.warn(kleur.yellow(message)),
+            });
+            if (!ratholeResolved) {
+                throw new Error("Tunnel is required but rathole is unavailable. Set RATHOLE_BIN (recommended) or pass --origin-endpoint to use a reachable URL.");
+            }
+        }
+        const bin = runtimeBin ?? resolveRuntimeBinary();
+        printStatus("Starting runtime-agent:", bin);
+        printStatus("Project:", projectId);
+        printStatus("Workspace:", workspace);
+        printStatus("Origin:", originId);
+        const detached = Boolean(options.detach);
+        const logFile = options.logFile?.trim()
+            ? path.resolve(options.logFile)
+            : detached
+                ? path.join(LOG_DIR, `runtime-${Date.now()}.log`)
+                : undefined;
+        if (logFile) {
+            ensureLogDir();
+        }
+        let stdio;
+        if (!logFile && !detached) {
+            stdio = "inherit";
         }
+        else {
+            const out = logFile ? openSync(logFile, "a") : "ignore";
+            stdio = ["ignore", out, out];
+        }
+        const spawnOptions = { env, stdio, detached };
+        const child = spawn(bin, spawnOptions);
+        if (detached) {
+            child.unref();
+        }
+        const startedAt = new Date().toISOString();
+        writeState({
+            runner: "process",
+            pid: child.pid ?? -1,
+            projectId,
+            workspace,
+            controllerUrl: env["CONTROLLER_BASE_URL"],
+            originId,
+            runtimeId: env["RUNTIME_ID"] ?? null,
+            displayName: env["RUNTIME_DISPLAY_NAME"],
+            startedAt,
+            logFile,
+            detached,
+        });
+        child.on("exit", (code, signal) => {
+            const msg = code !== null ? `code ${code}` : `signal ${signal}`;
+            console.log(kleur.yellow(`runtime-agent exited (${msg})`));
+            const current = readState();
+            if (current && current.pid === child.pid) {
+                clearState();
+            }
+        });
+        return;
     }
-    printStatus("Starting runtime-agent:", bin);
+    if (!isDockerAvailable()) {
+        throw new Error("runtime-agent is not available (no local binary and docker is not installed). Install Docker Desktop, or build runtime-agent from source.");
+    }
+    const image = resolveRuntimeAgentImage();
+    const containerName = `instafy-runtime-${originId}`;
+    const hostPort = String(options.bindPort ?? env["ORIGIN_BIND_PORT"] ?? 54332);
+    const hostBindHost = options.bindHost ?? "127.0.0.1";
+    const dockerEnv = { ...env };
+    dockerEnv["WORKSPACE_DIR"] = "/workspace";
+    dockerEnv["CODEX_HOME"] = "/workspace/.codex";
+    dockerEnv["ORIGIN_BIND_HOST"] = "0.0.0.0";
+    dockerEnv["CONTROLLER_BASE_URL"] = normalizeControllerUrlForDocker(env["CONTROLLER_BASE_URL"] ?? "");
+    const envArgs = [];
+    for (const [key, value] of Object.entries(dockerEnv)) {
+        if (typeof value !== "string" || value.length === 0)
+            continue;
+        envArgs.push("-e", `${key}=${value}`);
+    }
+    const runArgs = [
+        "run",
+        "--detach",
+        "--name",
+        containerName,
+        "--add-host",
+        "host.docker.internal:host-gateway",
+        "-p",
+        `${hostBindHost}:${hostPort}:${hostPort}`,
+        "-v",
+        `${workspace}:/workspace`,
+        ...envArgs,
+        image,
+    ];
+    printStatus("Starting runtime-agent (docker):", image);
     printStatus("Project:", projectId);
     printStatus("Workspace:", workspace);
     printStatus("Origin:", originId);
-    const detached = Boolean(options.detach);
-    const logFile = options.logFile?.trim()
-        ? path.resolve(options.logFile)
-        : detached
-            ? path.join(LOG_DIR, `runtime-${Date.now()}.log`)
-            : undefined;
-    if (logFile) {
-        ensureLogDir();
-    }
-    let stdio;
-    if (!logFile && !detached) {
-        stdio = "inherit";
+    const started = spawnSync("docker", runArgs, { encoding: "utf8" });
+    if (started.status !== 0) {
+        const stderr = String(started.stderr ?? "").trim();
+        throw new Error(`docker run failed: ${stderr || "unknown error"}`);
     }
-    else {
-        const out = logFile ? openSync(logFile, "a") : "ignore";
-        stdio = ["ignore", out, out];
-    }
-    const spawnOptions = { env, stdio, detached };
-    const child = spawn(bin, spawnOptions);
-    if (detached) {
-        child.unref();
+    const containerId = String(started.stdout ?? "").trim();
+    if (!containerId) {
+        throw new Error("docker run did not return a container id");
     }
     const startedAt = new Date().toISOString();
     writeState({
-        pid: child.pid ?? -1,
+        runner: "docker",
+        pid: -1,
         projectId,
         workspace,
         controllerUrl: env["CONTROLLER_BASE_URL"],
@@ -368,22 +530,40 @@ export async function runtimeStart(options) {
         runtimeId: env["RUNTIME_ID"] ?? null,
         displayName: env["RUNTIME_DISPLAY_NAME"],
         startedAt,
-        logFile,
-        detached,
+        detached: Boolean(options.detach),
+        containerId,
+        containerName,
     });
-    child.on("exit", (code, signal) => {
-        const msg = code !== null ? `code ${code}` : `signal ${signal}`;
-        console.log(kleur.yellow(`runtime-agent exited (${msg})`));
+    if (options.detach) {
+        printStatus("Container:", containerId);
+        console.log(kleur.gray(`Use: docker logs -f ${containerId}`));
+        return;
+    }
+    const logs = spawn("docker", ["logs", "-f", containerId], { stdio: "inherit" });
+    const handleExit = async () => {
+        stopDockerContainer(containerId);
         const current = readState();
-        if (current && current.pid === child.pid) {
+        if (current?.containerId === containerId) {
             clearState();
         }
+    };
+    process.once("SIGINT", () => {
+        void handleExit();
+    });
+    process.once("SIGTERM", () => {
+        void handleExit();
+    });
+    logs.on("exit", () => {
+        void handleExit();
     });
 }
 function formatStatus(state, running) {
     return {
         running,
+        runner: state.runner ?? "process",
         pid: state.pid,
+        containerId: state.containerId ?? null,
+        containerName: state.containerName ?? null,
         projectId: state.projectId,
         workspace: state.workspace,
         controllerUrl: state.controllerUrl ?? null,
@@ -404,7 +584,8 @@ async function sendOfflineBeat(state) {
     let bearer = directToken;
     if (!bearer) {
         const controllerAccessToken = normalizeToken(process.env["CONTROLLER_ACCESS_TOKEN"]) ??
-            normalizeToken(process.env["SUPABASE_ACCESS_TOKEN"]);
+            normalizeToken(process.env["SUPABASE_ACCESS_TOKEN"]) ??
+            resolveConfiguredAccessToken();
         if (controllerAccessToken) {
             try {
                 bearer = await mintRuntimeAccessToken({
@@ -465,14 +646,25 @@ export async function runtimeStatus(options) {
         }
         return;
     }
-    const alive = isProcessAlive(state.pid);
+    const alive = state.runner === "docker"
+        ? Boolean(state.containerId && dockerContainerRunning(state.containerId))
+        : isProcessAlive(state.pid);
     const payload = formatStatus(state, alive);
     if (options?.json) {
         console.log(JSON.stringify(payload));
         return;
     }
     console.log(alive ? kleur.green("Runtime is running") : kleur.red("Runtime is not running"));
-    printStatus("PID:", String(state.pid));
+    printStatus("Runner:", state.runner ?? "process");
+    if (state.runner === "docker") {
+        if (state.containerId)
+            printStatus("Container:", state.containerId);
+        if (state.containerName)
+            printStatus("Name:", state.containerName);
+    }
+    else {
+        printStatus("PID:", String(state.pid));
+    }
     printStatus("Project:", state.projectId);
     printStatus("Workspace:", state.workspace);
     if (state.controllerUrl)
@@ -482,13 +674,13 @@ export async function runtimeStatus(options) {
     if (state.runtimeId)
         printStatus("Runtime:", state.runtimeId);
     if (state.displayName)
-        printStatus("Name:", state.displayName);
+        printStatus("Display:", state.displayName);
     printStatus("Started:", state.startedAt);
     if (state.logFile)
         printStatus("Log:", state.logFile);
     printStatus("Detached:", state.detached ? "yes" : "no");
     if (!alive) {
-        console.log(kleur.yellow("State file exists but process is not alive."));
+        console.log(kleur.yellow(`State file exists but ${state.runner === "docker" ? "container" : "process"} is not alive.`));
     }
 }
 export async function runtimeStop(options) {
@@ -502,6 +694,22 @@ export async function runtimeStop(options) {
         }
         return;
     }
+    if (state.runner === "docker") {
+        const running = Boolean(state.containerId && dockerContainerRunning(state.containerId));
+        if (state.containerId) {
+            stopDockerContainer(state.containerId);
+        }
+        clearState();
+        await sendOfflineBeat(state);
+        const result = { stopped: running, containerId: state.containerId ?? null };
+        if (options?.json) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            console.log(running ? kleur.green("Runtime stopped.") : kleur.yellow("Runtime not running."));
+        }
+        return;
+    }
     if (!isProcessAlive(state.pid)) {
         clearState();
         if (options?.json) {
@@ -552,9 +760,10 @@ export async function runtimeToken(options) {
     const token = options.controllerAccessToken ??
         process.env["INSTAFY_ACCESS_TOKEN"] ??
         process.env["CONTROLLER_ACCESS_TOKEN"] ??
-        process.env["SUPABASE_ACCESS_TOKEN"];
+        process.env["SUPABASE_ACCESS_TOKEN"] ??
+        resolveConfiguredAccessToken();
     if (!token) {
-        throw new Error("Access token is required (--access-token, INSTAFY_ACCESS_TOKEN, or SUPABASE_ACCESS_TOKEN).");
+        throw new Error("Login required. Run `instafy login` or pass --access-token / set SUPABASE_ACCESS_TOKEN.");
     }
     const minted = await mintRuntimeAccessToken({
         controllerUrl,