@akira-tl/forgerelay 0.1.0

package/dist/cli.js

@@ -0,0 +1,597 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { stdin as input, stdout as output } from "node:process";
+import { spawn } from "node:child_process";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as prompts from "@clack/prompts";
+import { getShellConfig } from "@earendil-works/pi-coding-agent";
+import { satisfies } from "semver";
+import { loadConfig } from "./config.js";
+import { runLocalAgentProvider } from "./local-agent-adapters.js";
+import { isLocalAgentProvider, loadLocalAgentProfiles, } from "./local-agent-profiles.js";
+import { assertLocalAgentProviderAvailable, formatLocalAgentProviderAvailabilitySummary, } from "./local-agent-availability.js";
+import { formatAvailableLocalAgentTargets, parseLocalAgentRunArgs, resolveLocalAgentTarget, } from "./local-agent-targets.js";
+import { createLocalAgentStore } from "./local-agent-store.js";
+import { ensureDevspaceDefaultSkills, generateOwnerToken, loadDevspaceFiles, resolveSubagentsFlag, writeDevspaceAuth, writeDevspaceConfig, } from "./user-config.js";
+import { expandHomePath } from "./roots.js";
+import { shutdownHttpServer } from "./server-shutdown.js";
+const require = createRequire(import.meta.url);
+const SUPPORTED_NODE_RANGE = ">=20.12 <27";
+async function main(argv) {
+    assertSupportedNode();
+    const [rawCommand, ...args] = argv;
+    const command = normalizeCommand(rawCommand);
+    switch (command) {
+        case "serve":
+            await ensureConfigured();
+            await serve();
+            return;
+        case "init":
+            await runInit({ force: args.includes("--force") });
+            return;
+        case "doctor":
+            await runDoctor();
+            return;
+        case "config":
+            runConfigCommand(args);
+            return;
+        case "agents":
+            await runAgentsCommand(args);
+            return;
+        case "help":
+            printHelp();
+            return;
+        case "version":
+            printVersion();
+            return;
+    }
+}
+function normalizeCommand(command) {
+    if (!command || command === "serve" || command === "start")
+        return "serve";
+    if (command === "init" || command === "doctor" || command === "config" || command === "agents")
+        return command;
+    if (command === "help" || command === "--help" || command === "-h")
+        return "help";
+    if (command === "version" || command === "--version" || command === "-v")
+        return "version";
+    throw new Error(`Unknown command: ${command}`);
+}
+async function ensureConfigured() {
+    const files = loadDevspaceFiles();
+    if (files.configExists && files.authExists)
+        return;
+    if (process.env.FORGERELAY_OAUTH_OWNER_TOKEN ?? process.env.DEVSPACE_OAUTH_OWNER_TOKEN)
+        return;
+    if (!input.isTTY || !output.isTTY) {
+        throw new Error([
+            "ForgeRelay is not configured and this terminal is non-interactive.",
+            "",
+            "Run:",
+            "  forgerelay init",
+            "",
+            "Or provide FORGERELAY_OAUTH_OWNER_TOKEN and FORGERELAY_ALLOWED_ROOTS.",
+        ].join("\n"));
+    }
+    await runInit({ force: false });
+}
+async function runInit({ force }) {
+    const files = loadDevspaceFiles();
+    if (!force && files.configExists && files.authExists) {
+        prompts.log.info(`ForgeRelay is already configured at ${files.dir}`);
+        prompts.log.info("Run `forgerelay init --force` to update it.");
+        return;
+    }
+    try {
+        prompts.intro("ForgeRelay setup");
+        const defaultRoots = files.config.allowedRoots?.join(", ") || process.cwd();
+        const rootsAnswer = await textPrompt({
+            message: `Where are your projects located? Press Enter to use ${defaultRoots}`,
+            placeholder: defaultRoots,
+            defaultValue: defaultRoots,
+            validate: (value) => value?.trim() ? undefined : "Enter at least one project root.",
+        });
+        const allowedRoots = rootsAnswer
+            .split(",")
+            .map((root) => resolve(expandHomePath(root.trim())))
+            .filter(Boolean);
+        const defaultPort = String(files.config.port ?? 7676);
+        const portAnswer = await textPrompt({
+            message: `Which local port should ForgeRelay use? Press Enter to use ${defaultPort}`,
+            placeholder: defaultPort,
+            defaultValue: defaultPort,
+            validate: validatePort,
+        });
+        const port = Number(portAnswer);
+        prompts.note([
+            "ForgeRelay needs a public base URL so ChatGPT or Claude can reach this MCP server.",
+            "Create a tunnel or reverse proxy with Cloudflare Tunnel, ngrok, Pinggy, Tailscale Funnel, or your own HTTPS proxy.",
+            "Paste the public origin here, without /mcp.",
+            "",
+            "Example: https://your-tunnel-host.example.com",
+        ].join("\n"), "Public URL required");
+        const publicBaseUrl = normalizePublicBaseUrl(await textPrompt({
+            message: files.config.publicBaseUrl
+                ? `What is the public base URL? Press Enter to keep ${files.config.publicBaseUrl}`
+                : "What is the public base URL?",
+            placeholder: files.config.publicBaseUrl ?? "https://your-tunnel-host.example.com",
+            defaultValue: files.config.publicBaseUrl ?? "",
+            validate: validateRequiredPublicBaseUrl,
+        }));
+        const config = {
+            host: files.config.host ?? "127.0.0.1",
+            port,
+            allowedRoots,
+            publicBaseUrl,
+            workflowInstructions: files.config.workflowInstructions,
+            appendInstructions: files.config.appendInstructions,
+            subagents: resolveSubagentsFlag(files.config),
+        };
+        const auth = {
+            ownerToken: files.auth.ownerToken ?? generateOwnerToken(),
+        };
+        const configPath = writeDevspaceConfig(config);
+        const authPath = writeDevspaceAuth(auth);
+        const seededSkillPaths = config.subagents ? ensureDevspaceDefaultSkills() : [];
+        const lines = [
+            `Config: ${configPath}`,
+            `Auth: ${authPath}`,
+            ...seededSkillPaths.map((path) => `Default skill: ${path}`),
+            `Local MCP URL: http://${config.host}:${config.port}/mcp`,
+            ...(publicBaseUrl ? [`Public MCP URL: ${publicBaseUrl}/mcp`] : []),
+        ];
+        prompts.note(lines.join("\n"), "ForgeRelay configured");
+        prompts.note([
+            `Owner password: ${auth.ownerToken}`,
+            "Use this when ChatGPT or Claude asks you to approve ForgeRelay access.",
+            `Stored at: ${authPath}`,
+        ].join("\n"), "Owner password");
+        prompts.outro("Run `forgerelay serve` to start the MCP server.");
+    }
+    catch (error) {
+        if (error instanceof SetupCancelledError) {
+            prompts.cancel("Setup cancelled");
+            return;
+        }
+        throw error;
+    }
+}
+async function serve() {
+    const sqliteStatus = checkSqliteNative();
+    if (sqliteStatus !== "ok") {
+        throw new Error([
+            "better-sqlite3 could not load for this Node runtime.",
+            sqliteStatus,
+            "",
+            "Try reinstalling or rebuilding dependencies under the active Node version:",
+            "  npm rebuild better-sqlite3",
+        ].join("\n"));
+    }
+    const { createServer } = await import("./server.js");
+    const config = loadConfig();
+    const { app, close, localAgentProviders } = createServer(config);
+    const httpServer = app.listen(config.port, config.host, () => {
+        console.log(`forgerelay listening on http://${config.host}:${config.port}/mcp`);
+        console.log(`public base url: ${config.publicBaseUrl}`);
+        console.log(`allowed roots: ${config.allowedRoots.join(", ")}`);
+        console.log(`allowed hosts: ${config.allowedHosts.join(", ")}`);
+        if (config.allowedHosts.includes("*")) {
+            console.warn("warning: Host header allowlist is disabled because FORGERELAY_ALLOWED_HOSTS=*");
+        }
+        console.log("auth: Owner password approval required");
+        console.log(`logging: ${config.logging.level} ${config.logging.format}`);
+        if (config.subagents) {
+            console.log(`subagent providers: ${formatLocalAgentProviderAvailabilitySummary(localAgentProviders)}`);
+        }
+    });
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        await shutdownHttpServer(httpServer, close);
+        process.exit(0);
+    };
+    const handleShutdown = () => {
+        void shutdown().catch((error) => {
+            console.error("forgerelay shutdown failed", error);
+            process.exit(1);
+        });
+    };
+    process.once("SIGINT", handleShutdown);
+    process.once("SIGTERM", handleShutdown);
+}
+async function runDoctor() {
+    const files = loadDevspaceFiles();
+    console.log(`Config dir: ${files.dir}`);
+    console.log(`Config file: ${files.configExists ? files.configPath : "missing"}`);
+    console.log(`Auth file: ${files.authExists ? files.authPath : "missing"}`);
+    console.log(`Node: ${process.version} (${nodeVersionStatus()})`);
+    console.log(`Node ABI: ${process.versions.modules}`);
+    console.log(`Platform: ${process.platform} ${process.arch}`);
+    console.log(`Git: ${checkGitAvailable()}`);
+    console.log(`Bash shell: ${checkBashShell()}`);
+    console.log(`SQLite native dependency: ${checkSqliteNative()}`);
+    try {
+        const config = loadConfig();
+        console.log(`Local MCP URL: http://${config.host}:${config.port}/mcp`);
+        console.log(`Public MCP URL: ${new URL("/mcp", config.publicBaseUrl).toString()}`);
+        console.log(`Allowed roots: ${config.allowedRoots.join(", ")}`);
+        console.log(`Allowed hosts: ${config.allowedHosts.join(", ")}`);
+    }
+    catch (error) {
+        console.log(`Config status: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function runConfigCommand(args) {
+    const [subcommand, key, ...rest] = args;
+    const files = loadDevspaceFiles();
+    if (!subcommand || subcommand === "get") {
+        console.log(JSON.stringify(files.config, null, 2));
+        return;
+    }
+    if (subcommand !== "set") {
+        throw new Error(`Unknown config command: ${subcommand}`);
+    }
+    if (key !== "publicBaseUrl") {
+        throw new Error("Only `forgerelay config set publicBaseUrl <url|null>` is supported right now.");
+    }
+    const value = rest.join(" ").trim();
+    if (!value) {
+        throw new Error("Missing publicBaseUrl value.");
+    }
+    writeDevspaceConfig({
+        ...files.config,
+        publicBaseUrl: normalizeOptionalPublicBaseUrl(value),
+    });
+    console.log(`Updated ${files.configPath}`);
+}
+function printHelp() {
+    console.log([
+        "ForgeRelay",
+        "",
+        "Usage:",
+        "  forgerelay                 Run first-time setup if needed, then start the server",
+        "  forgerelay serve           Start the server",
+        "  forgerelay init            Create or update ~/.forgerelay/config.json and auth.json",
+        "  forgerelay doctor          Show config, runtime, and native dependency status",
+        "  forgerelay config get      Print persisted config",
+        "  forgerelay config set publicBaseUrl <url|null>",
+        "  forgerelay agents ls       List subagent sessions",
+        "  forgerelay agents run <profile-or-provider-or-id> [--model <model>] <prompt>",
+        "  forgerelay agents show <id>",
+        "  forgerelay -v, --version   Print the installed version",
+        "",
+        "For temporary tunnels:",
+        "  FORGERELAY_PUBLIC_BASE_URL=https://example.trycloudflare.com forgerelay serve",
+    ].join("\n"));
+}
+async function runAgentsCommand(args) {
+    const [subcommand, ...rest] = args;
+    switch (subcommand) {
+        case "ls":
+        case "list":
+            await runAgentsList();
+            return;
+        case "run":
+            await runAgentsRun(rest);
+            return;
+        case "show":
+            await runAgentsShow(rest);
+            return;
+        case "__worker":
+            await runAgentsWorker(rest);
+            return;
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            printAgentsHelp();
+            return;
+        default:
+            throw new Error(`Unknown agents command: ${subcommand}`);
+    }
+}
+async function runAgentsList() {
+    const config = loadConfig();
+    const store = createLocalAgentStore(config);
+    const agents = store.list(resolveCurrentWorkspaceScope());
+    if (agents.length === 0) {
+        console.log("No subagent sessions found for this workspace.");
+        return;
+    }
+    for (const agent of agents) {
+        console.log(formatAgentLine(agent));
+    }
+}
+async function runAgentsRun(args) {
+    const parsed = parseLocalAgentRunArgs(args);
+    const config = loadConfig();
+    const workspaceRoot = resolveCurrentWorkspaceRoot();
+    const store = createLocalAgentStore(config);
+    const existing = store.get(parsed.target);
+    if (existing) {
+        if (!isLocalAgentProvider(existing.provider)) {
+            throw new Error(`Unknown subagent provider for existing session: ${existing.provider}`);
+        }
+        assertLocalAgentProviderAvailable(existing.provider);
+        const promptFile = writeAgentPromptFile(parsed.prompt);
+        store.update(existing.id, {
+            status: "starting",
+            model: parsed.model ?? existing.model,
+            thinking: parsed.thinking ?? existing.thinking,
+            latestResponse: undefined,
+            error: undefined,
+        });
+        spawnAgentWorker(existing.id, promptFile);
+        console.log(formatAgentLine({
+            ...existing,
+            status: "running",
+            model: parsed.model ?? existing.model,
+            thinking: parsed.thinking ?? existing.thinking,
+        }));
+        return;
+    }
+    const profiles = await loadLocalAgentProfiles(config, workspaceRoot);
+    const target = resolveLocalAgentTarget(parsed.target, profiles, parsed.model, parsed.thinking);
+    if (!target) {
+        throw new Error(`Unknown subagent profile, provider, or id: ${parsed.target}. Available ${formatAvailableLocalAgentTargets(profiles)}`);
+    }
+    assertLocalAgentProviderAvailable(target.provider);
+    const promptFile = writeAgentPromptFile(parsed.prompt);
+    const record = store.create({
+        workspaceId: process.env.FORGERELAY_WORKSPACE_ID ?? process.env.DEVSPACE_WORKSPACE_ID,
+        workspaceRoot,
+        profileName: target.name,
+        provider: target.provider,
+        model: target.model,
+        thinking: target.thinking,
+    });
+    spawnAgentWorker(record.id, promptFile);
+    console.log(formatAgentLine({ ...record, status: "running" }));
+}
+async function runAgentsShow(args) {
+    const [id] = args;
+    if (!id)
+        throw new Error("Usage: forgerelay agents show <id>");
+    const config = loadConfig();
+    const store = createLocalAgentStore(config);
+    let record = store.get(id);
+    if (!record)
+        throw new Error(`Unknown subagent id: ${id}`);
+    const deadline = Date.now() + 15_000;
+    while ((record.status === "starting" || record.status === "running") && Date.now() < deadline) {
+        await sleep(500);
+        record = store.get(id) ?? record;
+    }
+    console.log(formatAgentLine(record));
+    if (record.latestResponse) {
+        console.log(record.latestResponse);
+        return;
+    }
+    if (record.error) {
+        console.log(record.error);
+        return;
+    }
+    if (record.status === "starting" || record.status === "running") {
+        console.log(`No final response yet. Call \`forgerelay agents show ${record.id}\` again later.`);
+    }
+}
+async function runAgentsWorker(args) {
+    const [id, promptFileFlag, promptFile] = args;
+    if (!id || promptFileFlag !== "--prompt-file" || !promptFile) {
+        throw new Error("Usage: forgerelay agents __worker <id> --prompt-file <path>");
+    }
+    const config = loadConfig();
+    const store = createLocalAgentStore(config);
+    const record = store.get(id);
+    if (!record)
+        throw new Error(`Unknown subagent id: ${id}`);
+    store.update(record.id, { status: "running", error: undefined });
+    try {
+        const profiles = await loadLocalAgentProfiles(config, record.workspaceRoot);
+        const profile = profiles.find((candidate) => candidate.name === record.profileName);
+        const prompt = await readFile(promptFile, "utf8");
+        const result = profile
+            ? await runLocalAgentProfile(profile, record, prompt)
+            : await runRawLocalAgentProvider(record, prompt);
+        store.update(record.id, {
+            providerSessionId: result.providerSessionId ?? undefined,
+            status: "idle",
+            latestResponse: result.finalResponse,
+            error: undefined,
+        });
+    }
+    catch (error) {
+        store.update(record.id, {
+            status: "error",
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function runLocalAgentProfile(profile, record, prompt) {
+    const body = profile.body.trim();
+    const fullPrompt = body ? `${body}\n\nTask:\n${prompt}` : prompt;
+    return runLocalAgentProvider(profile.provider, {
+        prompt: fullPrompt,
+        workspace: record.workspaceRoot,
+        providerSessionId: record.providerSessionId,
+        writeMode: "allowed",
+        model: record.model ?? profile.model,
+        thinking: record.thinking ?? profile.thinking,
+    });
+}
+async function runRawLocalAgentProvider(record, prompt) {
+    if (record.profileName !== record.provider || !isLocalAgentProvider(record.provider)) {
+        throw new Error(`Subagent profile not found: ${record.profileName}`);
+    }
+    return runLocalAgentProvider(record.provider, {
+        prompt,
+        workspace: record.workspaceRoot,
+        providerSessionId: record.providerSessionId,
+        writeMode: "allowed",
+        model: record.model,
+        thinking: record.thinking,
+    });
+}
+function spawnAgentWorker(agentId, promptFile) {
+    const child = spawn(process.execPath, [
+        ...process.execArgv,
+        fileURLToPath(import.meta.url),
+        "agents",
+        "__worker",
+        agentId,
+        "--prompt-file",
+        promptFile,
+    ], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env,
+    });
+    child.unref();
+}
+function writeAgentPromptFile(prompt) {
+    const directory = mkdtempSync(join(tmpdir(), "forgerelay-agent-prompt-"));
+    const filePath = join(directory, "prompt.txt");
+    writeFileSync(filePath, prompt, { mode: 0o600 });
+    return filePath;
+}
+function resolveCurrentWorkspaceRoot() {
+    return resolve(process.env.FORGERELAY_WORKSPACE_ROOT ?? process.env.DEVSPACE_WORKSPACE_ROOT ?? process.cwd());
+}
+function resolveCurrentWorkspaceScope() {
+    return {
+        workspaceId: process.env.FORGERELAY_WORKSPACE_ID ?? process.env.DEVSPACE_WORKSPACE_ID,
+        workspaceRoot: resolveCurrentWorkspaceRoot(),
+    };
+}
+function formatAgentLine(agent) {
+    const model = agent.model ? ` ${agent.model}` : "";
+    const thinking = agent.thinking ? ` thinking=${agent.thinking}` : "";
+    return `${agent.id} ${agent.status} ${agent.profileName} ${agent.provider}${model}${thinking}`;
+}
+function sleep(ms) {
+    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function printAgentsHelp() {
+    console.log([
+        "ForgeRelay agents",
+        "",
+        "Usage:",
+        "  forgerelay agents ls",
+        "  forgerelay agents run <profile-or-provider-or-id> [--model <model>] [--thinking <level>] <prompt>",
+        "  forgerelay agents show <id>",
+    ].join("\n"));
+}
+function printVersion() {
+    const packageJson = require("../package.json");
+    if (typeof packageJson.version !== "string") {
+        throw new Error("Unable to read ForgeRelay package version.");
+    }
+    console.log(packageJson.version);
+}
+function normalizeOptionalPublicBaseUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === "null" || trimmed === "none")
+        return null;
+    return normalizePublicBaseUrl(trimmed);
+}
+function normalizePublicBaseUrl(value) {
+    const trimmed = value.trim();
+    const parsed = new URL(trimmed);
+    parsed.hash = "";
+    parsed.search = "";
+    parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+    return parsed.toString().replace(/\/$/, "");
+}
+async function textPrompt(options) {
+    const result = await prompts.text({
+        ...options,
+        validate: (value) => options.validate?.(value?.trim() ? value : options.defaultValue),
+    });
+    if (prompts.isCancel(result))
+        throw new SetupCancelledError();
+    const value = String(result).trim();
+    return value || options.defaultValue;
+}
+function validatePort(value) {
+    const port = Number(value);
+    return Number.isInteger(port) && port >= 1 && port <= 65535
+        ? undefined
+        : "Enter a port between 1 and 65535.";
+}
+function validateRequiredPublicBaseUrl(value) {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed)
+        return "Enter the public URL from your tunnel or reverse proxy.";
+    if (trimmed.endsWith("/mcp"))
+        return "Enter the base URL only, without /mcp.";
+    return validatePublicBaseUrl(trimmed);
+}
+function validatePublicBaseUrl(value) {
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === "http:" || parsed.protocol === "https:"
+            ? undefined
+            : "Use an http or https URL.";
+    }
+    catch {
+        return "Enter a valid URL, for example https://your-tunnel-host.example.com.";
+    }
+}
+function assertSupportedNode() {
+    if (satisfies(process.versions.node, SUPPORTED_NODE_RANGE))
+        return;
+    throw new Error([
+        `ForgeRelay requires Node ${SUPPORTED_NODE_RANGE}.`,
+        `Current Node: ${process.version}`,
+        "",
+        "Install Node 22 LTS or use a version manager such as nvm, fnm, or mise.",
+    ].join("\n"));
+}
+function nodeVersionStatus() {
+    return satisfies(process.versions.node, SUPPORTED_NODE_RANGE)
+        ? `supported ${SUPPORTED_NODE_RANGE}`
+        : `unsupported, requires ${SUPPORTED_NODE_RANGE}`;
+}
+class SetupCancelledError extends Error {
+}
+function checkSqliteNative() {
+    try {
+        const Database = require("better-sqlite3");
+        const db = new Database(":memory:");
+        db.close();
+        return "ok";
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+function checkGitAvailable() {
+    try {
+        const { execFileSync } = require("node:child_process");
+        return execFileSync("git", ["--version"], { encoding: "utf8" }).trim();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `unavailable (${message})`;
+    }
+}
+function checkBashShell() {
+    try {
+        const { shell, args } = getShellConfig();
+        return `${shell} ${args.join(" ")}`;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `unavailable (${message})`;
+    }
+}
+main(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});