@instafy/cli 0.1.7 → 0.1.8-staging.348

package/dist/tunnel.js

@@ -2,8 +2,15 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import kleur from "kleur";
-import { resolveRatholeBinaryForCli } from "./runtime.js";
+import { findProjectManifest, resolveRatholeBinaryForCli } from "./runtime.js";
+import { resolveConfiguredControllerUrl, resolveUserAccessToken } from "./config.js";
+import { formatAuthRequiredError } from "./errors.js";
+const INSTAFY_DIR = path.join(os.homedir(), ".instafy");
+const TUNNEL_STATE_FILE = path.join(INSTAFY_DIR, "cli-tunnel-state.json");
+const TUNNEL_LOG_DIR = path.join(INSTAFY_DIR, "cli-tunnel-logs");
+const TUNNEL_WORKDIR_DIR = path.join(INSTAFY_DIR, "cli-tunnel-workdirs");
 function cleanUrl(raw) {
     return raw.replace(/\/+$/, "");
 }
@@ -14,31 +21,62 @@ function readEnv(key) {
     return undefined;
 }
 function resolveProject(opts) {
-    return (opts.project?.trim() ||
+    const explicit = opts.project?.trim() ||
         readEnv("PROJECT_ID") ||
         readEnv("CONTROLLER_PROJECT_ID") ||
-        (() => {
-            throw new Error("Project id is required (--project or PROJECT_ID)");
-        })());
+        null;
+    if (explicit) {
+        return explicit;
+    }
+    const manifest = findProjectManifest(process.cwd()).manifest;
+    if (manifest?.projectId) {
+        return manifest.projectId;
+    }
+    throw new Error("No project configured for this folder.\n\nNext:\n- instafy project:init\n\nOr pass --project <uuid> / set PROJECT_ID.");
 }
 function resolveControllerUrl(opts) {
-    return (opts.controllerUrl?.trim() ||
-        readEnv("INSTAFY_SERVER_URL") ||
+    const explicit = opts.controllerUrl?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    const envUrl = readEnv("INSTAFY_SERVER_URL") ||
         readEnv("INSTAFY_URL") ||
         readEnv("CONTROLLER_URL") ||
         readEnv("CONTROLLER_BASE_URL") ||
-        "http://127.0.0.1:8788");
+        null;
+    if (envUrl) {
+        return envUrl;
+    }
+    const manifestControllerUrl = findProjectManifest(process.cwd()).manifest?.controllerUrl?.trim() ?? null;
+    if (manifestControllerUrl) {
+        return manifestControllerUrl;
+    }
+    return resolveConfiguredControllerUrl() ?? "http://127.0.0.1:8788";
 }
 function resolveControllerToken(opts) {
-    return (opts.controllerToken?.trim() ||
-        readEnv("INSTAFY_SERVICE_TOKEN") ||
+    const explicit = opts.controllerToken?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    const accessToken = resolveUserAccessToken();
+    if (accessToken) {
+        return accessToken;
+    }
+    const serviceToken = readEnv("INSTAFY_SERVICE_TOKEN") ||
         readEnv("CONTROLLER_BEARER") ||
+        readEnv("CONTROLLER_TOKEN") ||
         readEnv("SERVICE_ROLE_KEY") ||
+        readEnv("CONTROLLER_SERVICE_ROLE_KEY") ||
         readEnv("SUPABASE_SERVICE_ROLE_KEY") ||
         readEnv("CONTROLLER_INTERNAL_TOKEN") ||
-        (() => {
-            throw new Error("Service token is required (--service-token, INSTAFY_SERVICE_TOKEN, or SERVICE_ROLE_KEY).");
-        })());
+        null;
+    if (serviceToken) {
+        return serviceToken;
+    }
+    throw formatAuthRequiredError({
+        retryCommand: "instafy tunnel",
+        advancedHint: "pass --access-token / --service-token, or set INSTAFY_ACCESS_TOKEN / SUPABASE_ACCESS_TOKEN / INSTAFY_SERVICE_TOKEN",
+    });
 }
 function resolvePort(opts) {
     const fromEnv = readEnv("WEBHOOK_LOCAL_PORT") ||
@@ -47,6 +85,77 @@ function resolvePort(opts) {
     const parsedEnv = fromEnv ? Number(fromEnv) : NaN;
     return opts.port ?? (Number.isFinite(parsedEnv) ? parsedEnv : 3000);
 }
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function safePathSegment(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return randomUUID();
+    return trimmed.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function writeStateFile(state) {
+    ensureDir(INSTAFY_DIR);
+    fs.writeFileSync(TUNNEL_STATE_FILE, JSON.stringify(state, null, 2), "utf8");
+    try {
+        fs.chmodSync(TUNNEL_STATE_FILE, 0o600);
+    }
+    catch {
+        // ignore chmod failures (windows / unusual fs)
+    }
+}
+function readStateFile() {
+    try {
+        const raw = fs.readFileSync(TUNNEL_STATE_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return { version: 1, tunnels: [] };
+        if (!Array.isArray(parsed.tunnels))
+            return { version: 1, tunnels: [] };
+        return {
+            version: 1,
+            tunnels: parsed.tunnels.filter(Boolean),
+        };
+    }
+    catch {
+        return { version: 1, tunnels: [] };
+    }
+}
+function isProcessAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error instanceof Error ? error.code : null;
+        // EPERM means the process exists but we don't have permission to signal it.
+        return code === "EPERM";
+    }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return !isProcessAlive(pid);
+}
+function upsertTunnelState(entry) {
+    const state = readStateFile();
+    const next = state.tunnels.filter((tunnel) => tunnel.tunnelId !== entry.tunnelId);
+    next.unshift(entry);
+    writeStateFile({ version: 1, tunnels: next });
+}
+function removeTunnelState(tunnelId) {
+    const state = readStateFile();
+    const existing = state.tunnels.find((tunnel) => tunnel.tunnelId === tunnelId) ?? null;
+    const next = state.tunnels.filter((tunnel) => tunnel.tunnelId !== tunnelId);
+    writeStateFile({ version: 1, tunnels: next });
+    return existing;
+}
 async function requestTunnel(controllerUrl, token, projectId, metadata) {
     const target = `${cleanUrl(controllerUrl)}/projects/${encodeURIComponent(projectId)}/tunnels/request`;
     const response = await fetch(target, {
@@ -181,3 +290,181 @@ export async function runTunnelCommand(opts, options) {
         process.once("SIGTERM", handle);
     });
 }
+export async function startTunnelDetached(opts) {
+    const projectId = resolveProject(opts);
+    const controllerUrl = resolveControllerUrl(opts);
+    const controllerToken = resolveControllerToken(opts);
+    const port = resolvePort(opts);
+    if (opts.ratholeBin) {
+        process.env.RATHOLE_BIN = opts.ratholeBin;
+    }
+    const rathole = await resolveRatholeBinaryForCli({
+        env: process.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 (!rathole) {
+        throw new Error("rathole is required to start a tunnel. Set RATHOLE_BIN or ensure it is on PATH.");
+    }
+    const metadata = { localPort: port, source: "instafy-cli" };
+    const grant = await requestTunnel(controllerUrl, controllerToken, projectId, metadata);
+    ensureDir(TUNNEL_WORKDIR_DIR);
+    ensureDir(TUNNEL_LOG_DIR);
+    const tunnelIdSafe = safePathSegment(grant.tunnelId);
+    const workdir = path.join(TUNNEL_WORKDIR_DIR, tunnelIdSafe);
+    ensureDir(workdir);
+    const creds = grant.credentials && typeof grant.credentials === "object"
+        ? grant.credentials
+        : {};
+    const configBody = buildRatholeConfig(creds, port);
+    const configPath = path.join(workdir, "rathole.toml");
+    fs.writeFileSync(configPath, configBody, { encoding: "utf8", mode: 0o600 });
+    const logFile = opts.logFile?.trim()
+        ? path.resolve(opts.logFile.trim())
+        : path.join(TUNNEL_LOG_DIR, `tunnel-${tunnelIdSafe}.log`);
+    const logFd = fs.openSync(logFile, "a");
+    const child = spawn(rathole, ["-c", configPath], {
+        stdio: ["ignore", logFd, logFd],
+        cwd: workdir,
+        detached: true,
+    });
+    let exitedEarly = false;
+    let exitMessage = "";
+    child.on("exit", (code, signal) => {
+        exitedEarly = true;
+        exitMessage = code !== null ? `code ${code}` : `signal ${signal}`;
+    });
+    // Give rathole a moment to fail fast, so `instafy tunnel` can report errors.
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    if (exitedEarly || !isProcessAlive(child.pid ?? -1)) {
+        const logTail = (() => {
+            try {
+                const text = fs.readFileSync(logFile, "utf8");
+                const lines = text.split(/\r?\n/).filter(Boolean);
+                return lines.slice(-20).join("\n");
+            }
+            catch {
+                return "";
+            }
+        })();
+        const suffix = logTail ? `\n\nLast logs:\n${logTail}` : "";
+        throw new Error(`Tunnel process exited (${exitMessage || "unknown"}).${suffix}`);
+    }
+    child.unref();
+    const entry = {
+        tunnelId: grant.tunnelId,
+        projectId,
+        hostname: grant.hostname,
+        url: grant.url ?? `https://${grant.hostname}`,
+        localPort: port,
+        controllerUrl: cleanUrl(controllerUrl),
+        pid: child.pid ?? -1,
+        logFile,
+        workdir,
+        startedAt: new Date().toISOString(),
+    };
+    upsertTunnelState(entry);
+    return entry;
+}
+export function listTunnelSessions(options) {
+    const state = readStateFile();
+    if (options?.all) {
+        return state.tunnels;
+    }
+    return state.tunnels.filter((entry) => isProcessAlive(entry.pid));
+}
+export async function stopTunnelSession(opts) {
+    const tunnelId = opts.tunnelId?.trim() ?? "";
+    if (!tunnelId) {
+        const active = listTunnelSessions({ all: false });
+        if (active.length === 1) {
+            return stopTunnelSession({ ...opts, tunnelId: active[0]?.tunnelId });
+        }
+        throw new Error("Tunnel id is required. Use `instafy tunnel:list` to find it.");
+    }
+    const entry = removeTunnelState(tunnelId);
+    if (!entry) {
+        throw new Error(`Tunnel not found in local state: ${tunnelId}`);
+    }
+    if (isProcessAlive(entry.pid)) {
+        try {
+            process.kill(entry.pid, "SIGTERM");
+        }
+        catch {
+            // ignore
+        }
+        const stopped = await waitForProcessExit(entry.pid, 4000);
+        if (!stopped) {
+            try {
+                process.kill(entry.pid, "SIGKILL");
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    const controllerToken = resolveControllerToken(opts);
+    await revokeTunnel(entry.controllerUrl, controllerToken, entry.projectId, entry.tunnelId);
+    try {
+        fs.rmSync(entry.workdir, { recursive: true, force: true });
+    }
+    catch {
+        // ignore
+    }
+    return { ok: true, tunnelId: entry.tunnelId };
+}
+export function resolveTunnelLogFile(tunnelId) {
+    const chosen = tunnelId?.trim() ?? "";
+    const all = readStateFile().tunnels;
+    if (chosen) {
+        const entry = all.find((tunnel) => tunnel.tunnelId === chosen);
+        if (!entry) {
+            throw new Error(`Tunnel not found in local state: ${chosen}`);
+        }
+        return entry;
+    }
+    const active = all.filter((entry) => isProcessAlive(entry.pid));
+    if (active.length === 1) {
+        return active[0];
+    }
+    throw new Error("Tunnel id is required. Use `instafy tunnel:list` to find it.");
+}
+export async function tailTunnelLogs(options) {
+    const entry = resolveTunnelLogFile(options.tunnelId);
+    const logFile = entry.logFile;
+    const lines = Number.isFinite(options.lines) ? options.lines : NaN;
+    const lineCount = Number.isFinite(lines) && lines > 0 ? Math.floor(lines) : 200;
+    const follow = Boolean(options.follow);
+    if (options.json) {
+        console.log(JSON.stringify({ tunnelId: entry.tunnelId, logFile, follow, lines: lineCount }, null, 2));
+        return;
+    }
+    if (!follow) {
+        const raw = fs.existsSync(logFile) ? fs.readFileSync(logFile, "utf8") : "";
+        const rows = raw.split(/\r?\n/);
+        const tail = rows.slice(Math.max(0, rows.length - lineCount));
+        console.log(tail.join("\n"));
+        return;
+    }
+    // Follow mode: prefer system tail tools.
+    const child = process.platform === "win32"
+        ? spawn("powershell.exe", [
+            "-NoProfile",
+            "-Command",
+            `Get-Content -LiteralPath '${logFile.replace(/'/g, "''")}' -Tail ${lineCount} -Wait`,
+        ], { stdio: "inherit" })
+        : spawn("tail", ["-n", String(lineCount), "-f", logFile], { stdio: "inherit" });
+    const handleExit = () => {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // ignore
+        }
+    };
+    process.once("SIGINT", handleExit);
+    process.once("SIGTERM", handleExit);
+    await new Promise((resolve) => child.on("exit", () => resolve()));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instafy/cli",
-  "version": "0.1.7",
+  "version": "0.1.8-staging.348",
   "description": "Run Instafy projects locally, link folders to Studio, and share previews/webhooks via tunnels.",
   "private": false,
   "publishConfig": {
@@ -17,6 +17,7 @@
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "prepack": "tsc -p tsconfig.json",
     "dev": "ts-node src/index.ts",
     "test": "pnpm test:unit",
     "test:unit": "pnpm build && vitest run",