@fusionkit/cli 0.1.3 → 0.1.4

package/dist/commands/fusion.js

@@ -4,6 +4,7 @@ import { loadFusionConfig } from "../fusion-config.js";
 import { runFusionInit } from "../fusion-init.js";
 import { fail } from "../shared/errors.js";
 import { collect, parseFusionTool, parseIdValue, parsePanelModelSpec, parsePort } from "../shared/options.js";
+import { reapFusionServices } from "../shared/portless.js";
 /** Attach the panel/gateway flags shared by `fusion` and the per-tool launchers. */
 function applyFusionOptions(command) {
     return command
@@ -23,6 +24,8 @@ function applyFusionOptions(command) {
         .option("--yes", "skip the interactive cloud-panel cost confirmation")
         .option("--auth-token <token>", "require a bearer token on the gateway")
         .option("--port <n>", "gateway port (default: ephemeral)")
+        .option("--portless", "route services through portless stable URLs (default; needs the proxy)")
+        .option("--no-portless", "disable portless; use raw loopback ports (same as PORTLESS=0)")
         .allowUnknownOption()
         .passThroughOptions();
 }
@@ -52,6 +55,8 @@ function resolveOptions(opts) {
         options.observe = opts.observe;
     if (opts.yes === true)
         options.yes = true;
+    if (opts.portless !== undefined)
+        options.portless = opts.portless;
     if (opts.authToken !== undefined)
         options.authToken = opts.authToken;
     if (opts.port !== undefined)
@@ -92,6 +97,8 @@ function mergeConfig(options, config) {
         options.local = config.local;
     if (options.observe === undefined && config.observe !== undefined)
         options.observe = config.observe;
+    if (options.portless === undefined && config.portless !== undefined)
+        options.portless = config.portless;
     if (options.cursorKitDir === undefined && config.cursorKitDir != null)
         options.cursorKitDir = config.cursorKitDir;
     if (options.port === undefined && config.port != null)
@@ -126,12 +133,13 @@ export function registerFusion(program) {
     applyFusionOptions(program
         .command("fusion")
         .description("one command: real model fusion backs a coding agent")
-        .argument("[tool]", `${FUSION_TOOLS.join(" | ")} | init (omit on a TTY to pick interactively)`)
+        .argument("[tool]", `${FUSION_TOOLS.join(" | ")} | init | stop (omit on a TTY to pick interactively)`)
         .argument("[args...]", "arguments forwarded to the tool")
         .option("--tool <tool>", `coding agent to launch (${FUSION_TOOLS.join(" | ")})`)
         .option("--force", "overwrite an existing fusionkit.json (with `fusion init`)"))
         .addHelpText("after", "\nfusionkit's own flags must precede the tool name; everything after the tool is forwarded to it." +
-        "\nRun `fusionkit fusion init` to scaffold a committed fusionkit.json for this repo.")
+        "\nRun `fusionkit fusion init` to scaffold a committed fusionkit.json for this repo." +
+        "\nRun `fusionkit fusion stop` to reap portless singleton services (router, dashboard, ...).")
         .action(async (positionalTool, args, opts) => {
         // `fusion init` scaffolds the per-repo config instead of launching a tool.
         if (positionalTool === "init") {
@@ -139,6 +147,13 @@ export function registerFusion(program) {
             const code = await runFusionInit({ repoRoot, force: opts.force === true });
             process.exit(code);
         }
+        // `fusion stop` reaps persistent portless singletons left running by prior
+        // runs (the router, dashboard, ...).
+        if (positionalTool === "stop") {
+            const stopped = await reapFusionServices((line) => console.error(line));
+            console.error(`fusion: stopped ${stopped} portless service(s)`);
+            process.exit(0);
+        }
         const { options, configTool } = resolveContext(opts);
         let tool = opts.tool ? parseFusionTool(opts.tool) : undefined;
         let toolArgs = [...args];

package/dist/commands/plane.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { Plane, startPlaneServer } from "@fusionkit/plane";
 import { loadHome, secretStoreFor } from "../config.js";
 import { resolveDir } from "../shared/plane.js";
+import { createPortlessSession } from "../shared/portless.js";
 export function registerPlane(program) {
     const plane = program.command("plane").description("control plane + control panel");
     plane
@@ -24,7 +25,14 @@ export function registerPlane(program) {
         const port = opts.port ? Number(opts.port) : home.config.port;
         const host = opts.host ?? home.config.host;
         const started = await startPlaneServer(planeInstance, { port, host });
-        console.log(`warrant plane listening on http://${started.host}:${started.port}`);
-        console.log(`control panel: http://${started.host}:${started.port}/ui/`);
+        // Register a stable portless name for the control panel (enabled unless
+        // PORTLESS=0 or no proxy is detected; falls back to the loopback URL).
+        const portless = await createPortlessSession({
+            enabled: process.env.PORTLESS !== "0",
+            log: (line) => console.error(line)
+        });
+        const baseUrl = portless.register("plane", started.port);
+        console.log(`warrant plane listening on ${baseUrl}`);
+        console.log(`control panel: ${baseUrl}/ui/`);
     });
 }

package/dist/fusion-config.d.ts

@@ -8,6 +8,7 @@ export type FusionConfig = {
     judgeModel?: string;
     local?: boolean;
     observe?: boolean;
+    portless?: boolean;
     cursorKitDir?: string | null;
     port?: number | null;
 };

package/dist/fusion-config.js

@@ -91,6 +91,11 @@ export function parseFusionConfig(raw, source) {
             throw new FusionConfigError(`${source}: observe must be a boolean`);
         config.observe = raw.observe;
     }
+    if (raw.portless !== undefined) {
+        if (typeof raw.portless !== "boolean")
+            throw new FusionConfigError(`${source}: portless must be a boolean`);
+        config.portless = raw.portless;
+    }
     if (raw.cursorKitDir !== undefined && raw.cursorKitDir !== null) {
         if (typeof raw.cursorKitDir !== "string") {
             throw new FusionConfigError(`${source}: cursorKitDir must be a string or null`);

package/dist/fusion-quickstart.d.ts

@@ -13,6 +13,7 @@
  */
 import type { ChildProcess } from "node:child_process";
 import type { EnsembleModel } from "@fusionkit/ensemble";
+import type { PortlessSession } from "./shared/portless.js";
 export type FusionTool = "codex" | "claude" | "cursor" | "serve";
 export declare const FUSION_TOOLS: readonly FusionTool[];
 export type PanelProvider = "mlx" | "openai" | "anthropic" | "google" | "openai-compatible";
@@ -34,7 +35,7 @@ export type PanelModelSpec = {
  * synthesizer (`fusionkit serve`) and the single-model OpenAI shim
  * (`fusionkit serve-endpoint`). Pinned so `uvx` resolves a reproducible build.
  */
-export declare const FUSIONKIT_PYPI_VERSION = "0.1.1";
+export declare const FUSIONKIT_PYPI_VERSION = "0.2.0";
 /**
  * Default cloud panel — works cross-platform with only `OPENAI_API_KEY` and
  * `ANTHROPIC_API_KEY` set. The judge defaults to the first entry.
@@ -94,23 +95,29 @@ export type Observability = {
     traceDir: string;
     close: () => Promise<void>;
 };
-/**
- * Start the scope dashboard on the fixed port, backed by a fresh per-run SQLite
- * file and trace dir, and return the URLs the caller injects (as
- * FUSION_TRACE_URL / FUSION_TRACE_DIR) into every spawned process. Prefers the
- * prebuilt bundle shipped inside the npm package; falls back to building the
- * app from source in a monorepo dev checkout.
- */
 export declare function startObservability(input: {
     log: (line: string) => void;
     logFile?: string;
     report?: StackReporter;
+    portless: PortlessSession;
 }): Promise<Observability>;
-export type ModelServers = {
+/**
+ * The single `fusionkit serve` router: one process that fronts every panel
+ * model (passthrough, routed by the endpoint id in the request `model` field)
+ * and also performs trajectory synthesis. `endpoints` maps each panel id to the
+ * router URL so the harness reaches its model through the one base URL.
+ */
+export type Router = {
+    url: string;
+    port: number;
+    /** The router process pid (owns its portless route across runs). */
+    pid?: number;
     endpoints: Record<string, string>;
-    judgeUrl: string;
-    judgeModel: string;
     models: EnsembleModel[];
+    /** The endpoint id used as the judge/synthesizer. */
+    judgeModel: string;
+    /** Sorted endpoint ids — the router's discover-or-spawn identity token. */
+    identity: string;
     close: () => Promise<void>;
 };
 /**
@@ -152,19 +159,20 @@ export type StackEvent = {
 };
 export type StackReporter = (event: StackEvent) => void;
 /**
- * Bring up one real model server per panel model and return an id -> base URL
- * map. `mlx` specs run locally; cloud specs are fronted by FusionKit. When
- * `endpoints` is supplied (pre-running servers or tests), those are used
- * verbatim and nothing is spawned.
+ * Spawn the single `fusionkit serve` router fronting every panel model + the
+ * synthesizer. MLX specs first get an in-process OpenAI-compatible gateway
+ * (loopback) that the router proxies to; cloud specs call their provider
+ * directly. Returns the router URL, an id->routerUrl endpoint map, and a close
+ * that tears down the router process and any MLX gateways it fronts.
  */
-export declare function startModelServers(options: {
+export declare function startRouter(options: {
     specs: PanelModelSpec[];
-    endpoints?: Record<string, string>;
+    judgeModel?: string;
     fusionkitDir?: string;
     logsDir?: string;
     report?: StackReporter;
     log: (line: string) => void;
-}): Promise<ModelServers>;
+}): Promise<Router>;
 export type FusionStack = {
     fusionUrl: string;
     endpoints: Record<string, string>;
@@ -185,24 +193,10 @@ export type StartFusionStackOptions = {
     timeoutMs?: number;
     logsDir?: string;
     report?: StackReporter;
+    /** Active portless session; defaults to a disabled (loopback) session. */
+    portless?: PortlessSession;
     log: (line: string) => void;
 };
-/**
- * Spawn a `fusionkit serve` as the trajectory-synthesis backend, configured
- * with the judge model. FusionKit owns synthesis, so the agent harness fuses
- * its trajectories through this server's `/v1/fusion/trajectories:fuse`.
- */
-export declare function startSynthesisServer(input: {
-    fusionkitDir?: string;
-    judgeModel: string;
-    judgeBaseUrl: string;
-    env: Record<string, string | undefined>;
-    logFile?: string;
-    log: (line: string) => void;
-}): Promise<{
-    url: string;
-    child: ChildProcess;
-}>;
 export declare function startFusionStack(options: StartFusionStackOptions): Promise<FusionStack>;
 /**
  * Start the Cursorkit bridge with its local-model backend pointed at the fusion
@@ -212,6 +206,7 @@ export declare function startCursorBridge(input: {
     cursorKitDir: string;
     fusionUrl: string;
     logFile?: string;
+    caCertPath?: string;
     log: (line: string) => void;
 }): Promise<{
     child: ChildProcess;
@@ -234,8 +229,12 @@ export type RunFusionOptions = {
     observe?: boolean;
     /** Skip the interactive cost/scope confirmation for the cloud panel. */
     yes?: boolean;
+    /** Route services through portless (stable named URLs + singletons). Default on. */
+    portless?: boolean;
     log?: (line: string) => void;
 };
+/** Whether portless is enabled: explicit flag/config wins, else on unless PORTLESS=0. */
+export declare function portlessEnabled(options: RunFusionOptions): boolean;
 export declare function runFusion(tool: FusionTool, toolArgs: string[], options?: RunFusionOptions): Promise<number>;
 /** Interactive tool picker for when no `--tool` was provided on a TTY. */
 export declare function pickTool(): Promise<FusionTool>;