@instafy/cli 0.1.0-staging.138

package/dist/tunnel.js

@@ -0,0 +1,180 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import kleur from "kleur";
+import { resolveRatholeBinaryForCli } from "./runtime.js";
+function cleanUrl(raw) {
+    return raw.replace(/\/+$/, "");
+}
+function readEnv(key) {
+    const value = process.env[key];
+    if (value && value.trim())
+        return value.trim();
+    return undefined;
+}
+function resolveProject(opts) {
+    return (opts.project?.trim() ||
+        readEnv("PROJECT_ID") ||
+        readEnv("CONTROLLER_PROJECT_ID") ||
+        (() => {
+            throw new Error("Project id is required (--project or PROJECT_ID)");
+        })());
+}
+function resolveControllerUrl(opts) {
+    return (opts.controllerUrl?.trim() ||
+        readEnv("CONTROLLER_URL") ||
+        readEnv("CONTROLLER_BASE_URL") ||
+        "http://localhost:8788");
+}
+function resolveControllerToken(opts) {
+    return (opts.controllerToken?.trim() ||
+        readEnv("CONTROLLER_BEARER") ||
+        readEnv("SERVICE_ROLE_KEY") ||
+        readEnv("SUPABASE_SERVICE_ROLE_KEY") ||
+        readEnv("CONTROLLER_INTERNAL_TOKEN") ||
+        (() => {
+            throw new Error("Controller token is required (--controller-token or SERVICE_ROLE_KEY)");
+        })());
+}
+function resolvePort(opts) {
+    const fromEnv = readEnv("WEBHOOK_LOCAL_PORT") ||
+        readEnv("TUNNEL_LOCAL_PORT") ||
+        undefined;
+    const parsedEnv = fromEnv ? Number(fromEnv) : NaN;
+    return opts.port ?? (Number.isFinite(parsedEnv) ? parsedEnv : 3000);
+}
+async function requestTunnel(controllerUrl, token, projectId, metadata) {
+    const target = `${cleanUrl(controllerUrl)}/projects/${encodeURIComponent(projectId)}/tunnels/request`;
+    const response = await fetch(target, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${token}`,
+            "content-type": "application/json",
+            accept: "application/json",
+        },
+        body: JSON.stringify({ metadata }),
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new Error(`Tunnel request failed (${response.status} ${response.statusText}): ${text}`);
+    }
+    const body = (await response.json());
+    const tunnelId = typeof body["tunnelId"] === "string"
+        ? body["tunnelId"]
+        : typeof body["tunnel_id"] === "string"
+            ? body["tunnel_id"]
+            : null;
+    const hostname = typeof body["hostname"] === "string" ? body["hostname"] : null;
+    if (!tunnelId || !hostname) {
+        throw new Error("Tunnel response missing tunnelId/hostname");
+    }
+    return {
+        tunnelId,
+        hostname,
+        url: typeof body["url"] === "string" ? body["url"] : undefined,
+        credentials: (body["credentials"] ?? null),
+    };
+}
+async function revokeTunnel(controllerUrl, token, projectId, tunnelId) {
+    const target = `${cleanUrl(controllerUrl)}/projects/${encodeURIComponent(projectId)}/tunnels/${encodeURIComponent(tunnelId)}/revoke`;
+    await fetch(target, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${token}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({ metadata: { reason: "instafy-cli-tunnel:stop" } }),
+    }).catch(() => { });
+}
+function buildRatholeConfig(creds, port) {
+    const server = typeof creds["server"] === "string" ? creds["server"] : null;
+    const token = typeof creds["token"] === "string" ? creds["token"] : null;
+    const service = (typeof creds["service"] === "string" && creds["service"]) ||
+        (typeof creds["serviceName"] === "string" && creds["serviceName"]) ||
+        "runtime";
+    const protocol = (typeof creds["protocol"] === "string" && creds["protocol"]) || "tcp";
+    if (!server || !token) {
+        throw new Error("Tunnel credentials missing server/token");
+    }
+    return (`[client]
+remote_addr = "${server}"
+default_token = "${token}"
+
+[client.services.${service}]
+type = "${protocol}"
+local_addr = "127.0.0.1:${port}"
+`);
+}
+export async function startTunnelSession(opts) {
+    const projectId = resolveProject(opts);
+    const controllerUrl = resolveControllerUrl(opts);
+    const controllerToken = resolveControllerToken(opts);
+    const port = resolvePort(opts);
+    let cleanedUp = false;
+    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);
+    const creds = grant.credentials && typeof grant.credentials === "object"
+        ? grant.credentials
+        : {};
+    const configBody = buildRatholeConfig(creds, port);
+    const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "instafy-cli-tunnel-"));
+    const configPath = path.join(workdir, "rathole.toml");
+    fs.writeFileSync(configPath, configBody, "utf8");
+    const child = spawn(rathole, ["-c", configPath], {
+        stdio: "inherit",
+        cwd: workdir,
+    });
+    const cleanup = async () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        child.kill("SIGTERM");
+        await revokeTunnel(controllerUrl, controllerToken, projectId, grant.tunnelId);
+        fs.rmSync(workdir, { recursive: true, force: true });
+    };
+    child.on("exit", () => {
+        void cleanup();
+    });
+    return {
+        url: grant.url ?? `https://${grant.hostname}`,
+        hostname: grant.hostname,
+        tunnelId: grant.tunnelId,
+        close: cleanup,
+    };
+}
+export async function runTunnelCommand(opts, options) {
+    const session = await startTunnelSession(opts);
+    console.log(kleur.green(`Tunnel ready: ${session.url} (tunnelId=${session.tunnelId})`));
+    const timeoutMs = options?.timeoutMs ?? null;
+    await new Promise((resolve) => {
+        let timeout = null;
+        if (timeoutMs && timeoutMs > 0) {
+            timeout = setTimeout(async () => {
+                await session.close();
+                resolve();
+            }, timeoutMs);
+        }
+        const handle = async () => {
+            await session.close();
+            if (timeout)
+                clearTimeout(timeout);
+            resolve();
+        };
+        process.once("SIGINT", handle);
+        process.once("SIGTERM", handle);
+    });
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@instafy/cli",
+  "version": "0.1.0-staging.138",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "bin": {
+    "instafy": "bin/instafy.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "ts-node src/index.ts",
+    "test": "pnpm test:unit",
+    "test:unit": "pnpm build && vitest run",
+    "test:live": "pnpm build && TUNNEL_E2E_LIVE=1 vitest run test/tunnel-live.e2e.spec.ts"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "kleur": "^4.1.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.8.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5",
+    "vitest": "^1.6.0"
+  }
+}