@loucompanion/forge-bridge 0.1.3-dev.8777774c67bc → 0.1.3-dev.88e93f53db5b

package/dist/cli/cli.help.js

@@ -16,10 +16,11 @@ export function helpText() {
         "  connect *        Start the runner bridge and wait for Forge dispatches",
         "  pair *           Pair this machine with Forge and save runner credentials",
         "  status *         Show config, runner identity, repos, provider CLIs, and updates",
+        "  server *         Show or change the saved Forge server URL",
         "  add-repo *       Map a Forge repo label/name to a local checkout path",
         "  remove-repo *    Remove a saved repo mapping",
         "  cleanup *        Prune managed bridge worktrees",
-        "  sandbox *        Initialize, diagnose, or reap Docker sandboxes",
+        "  sandbox *        Initialize, diagnose, smoke-test, or reap Docker sandboxes",
         "  version *        Print the installed bridge package version",
         "  help *           Display help for command",
         "  run-once *       Internal: run one dispatch packet from JSON",
@@ -30,6 +31,7 @@ export function helpText() {
         "  forge-bridge pair 1234-5678 --server https://srv1493013.tail66073d.ts.net:8443 --repo-root \"%USERPROFILE%\\ForgeRepos\"",
         "  forge-bridge connect",
         "  forge-bridge status --check-updates",
+        "  forge-bridge server set http://localhost:5208",
         "  forge-bridge add-repo Forge D:\\Programming\\repos\\Forge",
         "  forge-bridge cleanup --stale",
         "",
@@ -100,6 +102,23 @@ export function commandHelpText(command) {
                 "  forge-bridge status --check-updates",
                 "",
             ].join("\n");
+        case "server":
+            return [
+                "Forge Bridge — server",
+                "Show or change the saved Forge server URL.",
+                "",
+                "Usage:",
+                "  forge-bridge server show",
+                "  forge-bridge server set <url>",
+                "",
+                "The saved runner credentials are retained. Pair again when switching to a different Forge deployment.",
+                "FORGE_URL overrides the saved server when that environment variable is set.",
+                "",
+                "Examples:",
+                "  forge-bridge server set http://localhost:5208",
+                "  forge-bridge server set https://srv1493013.tail66073d.ts.net:8443",
+                "",
+            ].join("\n");
         case "add-repo":
             return [
                 "Forge Bridge — add-repo",
@@ -137,13 +156,28 @@ export function commandHelpText(command) {
         case "sandbox":
             return [
                 "Forge Bridge — sandbox",
-                "Initialize or diagnose a repository-owned Forge sandbox contract.",
+                "Configure local Docker sandbox placement or inspect a repository-owned sandbox contract.",
                 "",
                 "Usage:",
+                "  forge-bridge sandbox on [--allow-open-public]",
+                "  forge-bridge sandbox off",
+                "  forge-bridge sandbox status",
                 "  forge-bridge sandbox init [--repo <path>]",
                 "  forge-bridge sandbox doctor [--repo <path>] [--require-pinned-base]",
+                "  forge-bridge sandbox smoke [--repo <path>] [--report <path>] [--require-pinned-base] [--probe-loopback-port]",
                 "  forge-bridge sandbox reap",
                 "",
+                "`sandbox on` keeps unrestricted public networking denied unless the explicit",
+                "developer-only --allow-open-public option is supplied. The local policy is",
+                "saved in bridge.json and takes effect after the connected bridge restarts.",
+                "Environment variables remain higher-priority operator overrides.",
+                "",
+                "The smoke command builds the repository Dockerfile, runs a disposable hardened",
+                "container, verifies exact-label teardown, and writes a redacted JSON report.",
+                "The optional port probe publishes 127.0.0.1::8080 only for the disposable fixture",
+                "and verifies Docker-assigned host-port discovery; normal sandboxes publish no ports.",
+                "Stop the connected bridge first so the Docker ownership lock can be acquired.",
+                "",
             ].join("\n");
         case "run-once":
             return [
@@ -160,7 +194,7 @@ export function commandHelpText(command) {
                 "Internal MCP server used by provider CLIs to report Forge phase artifacts.",
                 "",
                 "Usage:",
-                "  forge-bridge mcp --worktree <path> --work-item-id <id> --phase <phase>",
+                "  forge-bridge mcp --worktree <path> --work-item-id <id> --phase <phase>  # includes ci-repair",
                 "",
             ].join("\n");
         case "version":

package/dist/cli/cli.service.d.ts

@@ -1,12 +1,15 @@
 import type { BridgeService } from "../bridge/bridge.base.js";
 import type { BridgeServiceConfig } from "../bridge/bridge.types.js";
+import type { CleanupMode } from "../cleanup/cleanup.types.js";
+import type { CleanupService } from "../cleanup/cleanup.base.js";
 import type { SessionService } from "../session/session.base.js";
 import type { CliIo, CliService } from "./cli.base.js";
 export declare class ForgeBridgeCliService implements CliService {
     private readonly sessions;
     private readonly bridgeFactory;
     private readonly pairRunner;
-    constructor(sessions?: SessionService, bridgeFactory?: (config: BridgeServiceConfig) => BridgeService, pairRunner?: PairRunnerClient);
+    private readonly cleanupFactory;
+    constructor(sessions?: SessionService, bridgeFactory?: (config: BridgeServiceConfig) => BridgeService, pairRunner?: PairRunnerClient, cleanupFactory?: CleanupServiceFactory);
     run(argv: readonly string[], io?: CliIo): Promise<number>;
 }
 export declare function parseArgs(argv: readonly string[]): {
@@ -34,6 +37,14 @@ export declare function parseArgs(argv: readonly string[]): {
     readonly ok: true;
     readonly command: "remove-repo";
     readonly label: string;
+} | {
+    readonly ok: true;
+    readonly command: "server-show";
+    readonly config: BridgeServiceConfig;
+} | {
+    readonly ok: true;
+    readonly command: "server-set";
+    readonly serverUrl: string;
 } | {
     readonly ok: true;
     readonly command: "status";
@@ -54,9 +65,26 @@ export declare function parseArgs(argv: readonly string[]): {
     readonly command: "sandbox-doctor";
     readonly repoPath: string;
     readonly requirePinnedBase: boolean;
+} | {
+    readonly ok: true;
+    readonly command: "sandbox-smoke";
+    readonly repoPath: string;
+    readonly reportPath?: string;
+    readonly requirePinnedBase: boolean;
+    readonly probeLoopbackPort: boolean;
 } | {
     readonly ok: true;
     readonly command: "sandbox-reap";
+} | {
+    readonly ok: true;
+    readonly command: "sandbox-on";
+    readonly allowOpenPublic: boolean;
+} | {
+    readonly ok: true;
+    readonly command: "sandbox-off";
+} | {
+    readonly ok: true;
+    readonly command: "sandbox-status";
 } | {
     readonly ok: false;
     readonly error: string;
@@ -78,5 +106,5 @@ interface PairRunnerClaim {
 type PairRunnerClient = (args: PairArgs) => Promise<PairRunnerClaim>;
 export declare function parseCodexModelCatalog(raw: string): string[];
 export declare function parseCursorModelList(raw: string): string[];
-type CleanupMode = "stale" | "merged" | "all";
+type CleanupServiceFactory = (stateRoot: string) => CleanupService;
 export {};

package/dist/cli/cli.service.js

@@ -7,14 +7,17 @@ import { promisify } from "node:util";
 import { resolveCursorAgentDirectLaunch } from "../shared/cursor-agent/cursor-agent.launch.js";
 import { buildWindowsCmdLaunch } from "../shared/process/windows-launch.js";
 import { supportsDraftImageAttachmentsFor } from "../shared/provider-capabilities.js";
-import { redactSecrets, redactText } from "../shared/redaction/redaction.js";
+import { redactText } from "../shared/redaction/redaction.js";
 import { defaultBridgeServiceConfig, ForgeBridgeService } from "../bridge/bridge.service.js";
 import { forgeBridgeVersion } from "../version.js";
-import { addRepoMapping, applyLocalConfigDefaults, providerStatusesFor, readLocalConfigSync, removeRepoMapping, resolveLocalConfigPath, writeLocalConfig } from "./local-config.js";
+import { ManagedWorktreeCleanupService } from "../cleanup/cleanup.service.js";
+import { addRepoMapping, applyLocalConfigDefaults, providerStatusesFor, readLocalConfigSync, removeRepoMapping, resolveLocalConfigPath, setSandboxPolicy, setServerUrl, writeLocalConfig } from "./local-config.js";
 import { BridgeSessionService } from "../session/session.service.js";
+import { redactRunnerDispatchEvent, redactRunOnceResultPacket } from "../session/session-redaction.js";
 import { validateDockerfilePolicy, validateSandboxContract } from "../sandbox/contract.js";
 import { DockerPreflight } from "../sandbox/preflight.js";
 import { DockerSandboxRuntime } from "../sandbox/runtime.js";
+import { DockerSandboxSmoke } from "../sandbox/smoke.js";
 import { parseCompletionMcpArgs, runCompletionMcpServer } from "../session/phase-completion.js";
 import { failureResult, parseRunOnceDispatchPacket } from "../session/session.types.js";
 import { commandHelpText, helpText } from "./cli.help.js";
@@ -24,10 +27,12 @@ export class ForgeBridgeCliService {
     sessions;
     bridgeFactory;
     pairRunner;
-    constructor(sessions = new BridgeSessionService(), bridgeFactory = (config) => new ForgeBridgeService(config), pairRunner = claimBridgeRunner) {
+    cleanupFactory;
+    constructor(sessions = new BridgeSessionService(), bridgeFactory = (config) => new ForgeBridgeService(config), pairRunner = claimBridgeRunner, cleanupFactory = stateRoot => new ManagedWorktreeCleanupService(stateRoot)) {
         this.sessions = sessions;
         this.bridgeFactory = bridgeFactory;
         this.pairRunner = pairRunner;
+        this.cleanupFactory = cleanupFactory;
     }
     async run(argv, io = { stdout: process.stdout, stderr: process.stderr }) {
         if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
@@ -67,6 +72,10 @@ export class ForgeBridgeCliService {
             process.once("SIGINT", stop);
             process.once("SIGTERM", stop);
             try {
+                if (config.cleanupWorktrees && config.repoMappings.some(mapping => mapping.localPath?.trim())) {
+                    io.stdout.write("Cleaning stale managed worktrees before accepting dispatches.\n");
+                    await cleanupRepos(config, "stale", true, this.cleanupFactory(config.sandboxStateRoot), io);
+                }
                 io.stdout.write(connectStartupText(config));
                 await this.bridgeFactory(config).run(controller.signal);
                 return 0;
@@ -122,12 +131,38 @@ export class ForgeBridgeCliService {
                 return 2;
             }
         }
+        if (args.command === "server-show") {
+            const saved = readLocalConfigSync().serverUrl ?? "not configured";
+            io.stdout.write(`Saved server: ${saved}\n`);
+            if (process.env.FORGE_URL?.trim()) {
+                io.stdout.write(`Effective server: ${process.env.FORGE_URL.trim()} (FORGE_URL override)\n`);
+            }
+            else {
+                io.stdout.write(`Effective server: ${args.config.serverUrl || "not configured"}\n`);
+            }
+            return 0;
+        }
+        if (args.command === "server-set") {
+            try {
+                const config = await setServerUrl(args.serverUrl);
+                io.stdout.write(`Saved Forge server: ${config.serverUrl}\n`);
+                io.stdout.write("Existing runner credentials were retained. Re-run `forge-bridge pair --server <url>` if this is a different Forge deployment.\n");
+                if (process.env.FORGE_URL?.trim()) {
+                    io.stdout.write(`Warning: FORGE_URL is set to ${process.env.FORGE_URL.trim()} and overrides the saved server.\n`);
+                }
+                return 0;
+            }
+            catch (error) {
+                io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 2;
+            }
+        }
         if (args.command === "status") {
             await writeStatus(args.config, args.checkUpdates, io);
             return 0;
         }
         if (args.command === "cleanup") {
-            return await cleanupRepos(args.config, args.mode, args.force, io);
+            return await cleanupRepos(args.config, args.mode, args.force, this.cleanupFactory(args.config.sandboxStateRoot), io);
         }
         if (args.command === "sandbox-init") {
             return await initializeSandbox(args.repoPath, io);
@@ -135,9 +170,28 @@ export class ForgeBridgeCliService {
         if (args.command === "sandbox-doctor") {
             return await diagnoseSandbox(args.repoPath, args.requirePinnedBase, io);
         }
+        if (args.command === "sandbox-smoke") {
+            return await smokeSandbox(args.repoPath, args.reportPath, args.requirePinnedBase, args.probeLoopbackPort, io);
+        }
         if (args.command === "sandbox-reap") {
             return await reapSandboxes(io);
         }
+        if (args.command === "sandbox-on") {
+            const saved = await setSandboxPolicy(true, args.allowOpenPublic);
+            io.stdout.write("Saved local Docker sandbox policy. Restart the bridge to apply it.\n");
+            writeSandboxPolicyStatus(saved, io);
+            return 0;
+        }
+        if (args.command === "sandbox-off") {
+            const saved = await setSandboxPolicy(false, false);
+            io.stdout.write("Disabled local Docker sandbox placement. Restart the bridge to apply it.\n");
+            writeSandboxPolicyStatus(saved, io);
+            return 0;
+        }
+        if (args.command === "sandbox-status") {
+            writeSandboxPolicyStatus(readLocalConfigSync(), io);
+            return 0;
+        }
         if (args.command === "mcp") {
             const parsed = parseCompletionMcpArgs(args.argv);
             if (!parsed.ok) {
@@ -156,12 +210,12 @@ export class ForgeBridgeCliService {
                 emit: async (event) => {
                     const line = {
                         type: "runner_event",
-                        event: redactSecrets(event, redactionSecrets)
+                        event: redactRunnerDispatchEvent(event, redactionSecrets)
                     };
                     io.stdout.write(`${JSON.stringify(line)}\n`);
                 }
             });
-            await writeJsonAtomic(args.resultPath, redactSecrets(result, redactionSecrets));
+            await writeJsonAtomic(args.resultPath, redactRunOnceResultPacket(result, redactionSecrets));
             return result.exitCode;
         }
         catch (error) {
@@ -247,6 +301,15 @@ export function parseArgs(argv) {
         }
         return { ok: true, command: "remove-repo", label: argv[1] };
     }
+    if (argv[0] === "server") {
+        if (argv.length === 1 || (argv[1] === "show" && argv.length === 2)) {
+            return { ok: true, command: "server-show", config: configuredBridgeServiceConfig() };
+        }
+        if (argv[1] === "set" && argv[2] && argv.length === 3) {
+            return { ok: true, command: "server-set", serverUrl: argv[2] };
+        }
+        return { ok: false, error: "Usage: forge-bridge server <show|set <url>>" };
+    }
     if (argv[0] === "status") {
         let checkUpdates = false;
         for (let index = 1; index < argv.length; index += 1) {
@@ -301,8 +364,26 @@ export function parseArgs(argv) {
 }
 function parseSandboxArgs(argv) {
     const action = argv[1];
+    if (action === "on") {
+        let allowOpenPublic = false;
+        for (let index = 2; index < argv.length; index += 1) {
+            if (argv[index] === "--allow-open-public") {
+                allowOpenPublic = true;
+            }
+            else {
+                return { ok: false, error: `Unknown sandbox argument: ${argv[index]}` };
+            }
+        }
+        return { ok: true, command: "sandbox-on", allowOpenPublic };
+    }
+    if (action === "off" && argv.length === 2)
+        return { ok: true, command: "sandbox-off" };
+    if (action === "status" && argv.length === 2)
+        return { ok: true, command: "sandbox-status" };
     let repoPath = process.cwd();
+    let reportPath;
     let requirePinnedBase = false;
+    let probeLoopbackPort = false;
     for (let index = 2; index < argv.length; index += 1) {
         const arg = argv[index];
         if (arg === "--repo") {
@@ -310,9 +391,17 @@ function parseSandboxArgs(argv) {
             if (!repoPath)
                 return { ok: false, error: "--repo requires a path." };
         }
-        else if (arg === "--require-pinned-base" && action === "doctor") {
+        else if (arg === "--report" && action === "smoke") {
+            reportPath = argv[++index];
+            if (!reportPath)
+                return { ok: false, error: "--report requires a path." };
+        }
+        else if (arg === "--require-pinned-base" && (action === "doctor" || action === "smoke")) {
             requirePinnedBase = true;
         }
+        else if (arg === "--probe-loopback-port" && action === "smoke") {
+            probeLoopbackPort = true;
+        }
         else {
             return { ok: false, error: `Unknown sandbox argument: ${arg}` };
         }
@@ -321,9 +410,18 @@ function parseSandboxArgs(argv) {
         return { ok: true, command: "sandbox-init", repoPath: path.resolve(repoPath) };
     if (action === "doctor")
         return { ok: true, command: "sandbox-doctor", repoPath: path.resolve(repoPath), requirePinnedBase };
+    if (action === "smoke")
+        return {
+            ok: true,
+            command: "sandbox-smoke",
+            repoPath: path.resolve(repoPath),
+            reportPath: reportPath ? path.resolve(reportPath) : undefined,
+            requirePinnedBase,
+            probeLoopbackPort,
+        };
     if (action === "reap" && argv.length === 2)
         return { ok: true, command: "sandbox-reap" };
-    return { ok: false, error: "Usage: forge-bridge sandbox <init|doctor|reap> [--repo <path>] [--require-pinned-base]" };
+    return { ok: false, error: "Usage: forge-bridge sandbox <on|off|status|init|doctor|smoke|reap> [--allow-open-public] [--repo <path>] [--report <path>] [--require-pinned-base] [--probe-loopback-port]" };
 }
 const sandboxContractTemplate = `schemaVersion: 1
 workingDirectory: /workspace
@@ -389,6 +487,10 @@ async function diagnoseSandbox(repoPath, requirePinnedBase, io) {
             diskHighWatermarkPercent: config.diskHighWatermarkPercent,
             diskLowWatermarkPercent: config.diskLowWatermarkPercent,
             minimumWorkspaceBytes: config.minimumWorkspaceBytes,
+            hostMemoryReserveBytes: config.sandboxHostMemoryReserveBytes,
+            defaultWorkerMemoryLimitBytes: config.defaultSandboxWorkerMemoryLimitBytes,
+            defaultServiceMemoryLimitBytes: config.defaultSandboxServiceMemoryLimitBytes,
+            runtimeOverheadBytes: config.sandboxRuntimeOverheadBytes,
             requireRootless: config.requireRootlessDocker
         });
         try {
@@ -409,6 +511,42 @@ async function diagnoseSandbox(repoPath, requirePinnedBase, io) {
         return 1;
     }
 }
+async function smokeSandbox(repoPath, reportPath, requirePinnedBase, probeLoopbackPort, io) {
+    try {
+        const result = await new DockerSandboxSmoke(defaultBridgeServiceConfig()).run({
+            repoPath,
+            reportPath,
+            requirePinnedBase,
+            probeLoopbackPort,
+            onProgress: (stage) => io.stdout.write(`Smoke: ${stage}...\n`),
+        });
+        const { report } = result;
+        if (report.repository.contractDigest)
+            io.stdout.write(`Contract: valid (${report.repository.contractDigest})\n`);
+        for (const warning of report.repository.policyWarnings)
+            io.stdout.write(`Warning: ${warning}\n`);
+        if (report.docker.runtimeVersion) {
+            io.stdout.write(`Docker: healthy (${report.docker.runtimeVersion}; capacity ${report.docker.capacity})\n`);
+        }
+        io.stdout.write(`Attempt: ${report.dispatchAttemptId}\n`);
+        io.stdout.write(`Resource lease: ${report.resourceLeaseId}\n`);
+        if (report.publishedPortProbe) {
+            io.stdout.write(`Loopback port: ${report.publishedPortProbe.hostIp}:${report.publishedPortProbe.hostPort} -> ${report.publishedPortProbe.containerPort}/tcp\n`);
+        }
+        io.stdout.write(`Cleanup: ${report.cleanup.verified ? "verified (zero exact-label resources)" : "failed"}\n`);
+        io.stdout.write(`Report: ${result.reportPath}\n`);
+        if (report.status === "passed") {
+            io.stdout.write("Sandbox smoke: PASS\n");
+            return 0;
+        }
+        io.stderr.write(`Sandbox smoke: FAIL (${report.failure?.code ?? "sandbox_smoke_failed"} at ${report.failure?.stage ?? "unknown"}): ${report.failure?.message ?? "unknown failure"}\n`);
+        return 1;
+    }
+    catch (error) {
+        io.stderr.write(`Sandbox smoke could not write its report: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}
 async function reapSandboxes(io) {
     const config = defaultBridgeServiceConfig();
     if (!/^[0-9a-f-]{32,36}$/iu.test(config.runnerId)) {
@@ -423,6 +561,10 @@ async function reapSandboxes(io) {
         diskHighWatermarkPercent: config.diskHighWatermarkPercent,
         diskLowWatermarkPercent: config.diskLowWatermarkPercent,
         minimumWorkspaceBytes: config.minimumWorkspaceBytes,
+        hostMemoryReserveBytes: config.sandboxHostMemoryReserveBytes,
+        defaultWorkerMemoryLimitBytes: config.defaultSandboxWorkerMemoryLimitBytes,
+        defaultServiceMemoryLimitBytes: config.defaultSandboxServiceMemoryLimitBytes,
+        runtimeOverheadBytes: config.sandboxRuntimeOverheadBytes,
         requireRootless: config.requireRootlessDocker
     });
     try {
@@ -576,7 +718,7 @@ function parsePairArgs(argv) {
         name: name?.trim() || defaultName,
         fingerprint: fingerprint?.trim() || `local-bridge:${os.hostname()}:${user}`,
         repoRoot: repoRoot?.trim() ? path.resolve(repoRoot) : undefined,
-        cleanupWorktrees: cleanupWorktrees ?? localConfig.cleanupWorktrees ?? false,
+        cleanupWorktrees: cleanupWorktrees ?? defaultConfig.cleanupWorktrees,
         cliProviders: cliProviders.length > 0 ? cliProviders : localConfig.cliProviders && localConfig.cliProviders.length > 0 ? [...localConfig.cliProviders] : ["codex"],
         projectLabels: projectLabels.length > 0 ? projectLabels : localConfig.projectLabels ? [...localConfig.projectLabels] : []
     };
@@ -731,11 +873,27 @@ function connectStartupText(config) {
         `  repo folder: ${config.defaultRepoRoot || "not configured"}`,
         `  providers: ${formatList(config.cliProviders)}`,
         `  cleanup worktrees: ${config.cleanupWorktrees ? "enabled" : "disabled"}`,
+        `  open public sandbox networking: ${config.allowOpenPublicSandbox ? "enabled" : "disabled"}`,
         "",
         "Press Ctrl+C to stop.",
         "",
     ].join("\n");
 }
+function writeSandboxPolicyStatus(local, io) {
+    const effective = configuredBridgeServiceConfig({}, local);
+    io.stdout.write(`Config: ${resolveLocalConfigPath()}\n`);
+    io.stdout.write(`Docker sandbox placement: ${effective.dockerEnabled ? "on" : "off"}\n`);
+    io.stdout.write(`Open public sandbox networking: ${effective.allowOpenPublicSandbox ? "allowed" : "denied"}\n`);
+    if (process.env.FORGE_DOCKER_SANDBOX !== undefined) {
+        io.stdout.write("Docker setting source: FORGE_DOCKER_SANDBOX override\n");
+    }
+    if (process.env.FORGE_ALLOW_OPEN_PUBLIC_SANDBOX !== undefined) {
+        io.stdout.write("Open public setting source: FORGE_ALLOW_OPEN_PUBLIC_SANDBOX override\n");
+    }
+    if (effective.allowOpenPublicSandbox) {
+        io.stdout.write("Warning: open_public permits unrestricted outbound network access from developer sandboxes.\n");
+    }
+}
 function formatList(values) {
     return values.length > 0 ? values.join(", ") : "none";
 }
@@ -772,7 +930,7 @@ async function writeStatus(config, checkUpdates, io) {
         io.stdout.write("Update check: no update channel configured.\n");
     }
 }
-async function cleanupRepos(config, mode, force, io) {
+async function cleanupRepos(config, mode, force, cleanup, io) {
     const repos = config.repoMappings.filter((mapping) => mapping.localPath?.trim());
     if (repos.length === 0) {
         io.stdout.write("No repos configured.\n");
@@ -781,20 +939,28 @@ async function cleanupRepos(config, mode, force, io) {
     let failures = 0;
     for (const repo of repos) {
         const repoPath = path.resolve(repo.localPath);
-        const worktreeRoot = path.join(path.dirname(repoPath), ".forge-worktrees", path.basename(repoPath));
-        if (!force) {
-            const action = mode === "all" ? "remove" : "prune";
-            io.stdout.write(`[dry-run] Would ${action} ${worktreeRoot}\n`);
-            continue;
-        }
         try {
-            if (mode === "all") {
-                await fs.rm(worktreeRoot, { recursive: true, force: true });
-                await runGit(repoPath, ["worktree", "prune"]);
-                io.stdout.write(`Removed ${worktreeRoot}\n`);
+            const result = await cleanup.run({
+                repoRoot: repoPath,
+                allowedRepoRoot: config.defaultRepoRoot || undefined,
+                mode,
+                force,
+            });
+            if (!force) {
+                const action = mode === "all"
+                    ? "remove"
+                    : mode === "stale"
+                        ? `remove ${result.candidateWorktrees} stale managed ${result.candidateWorktrees === 1 ? "worktree" : "worktrees"} from`
+                        : "prune";
+                io.stdout.write(`[dry-run] Would ${action} ${result.worktreeRoot}\n`);
+            }
+            else if (mode === "all") {
+                io.stdout.write(`Removed ${result.worktreeRoot}\n`);
+            }
+            else if (mode === "stale") {
+                io.stdout.write(`Removed ${result.removedWorktrees} stale managed ${result.removedWorktrees === 1 ? "worktree" : "worktrees"} from ${result.worktreeRoot}\n`);
             }
             else {
-                await runGit(repoPath, ["worktree", "prune"]);
                 io.stdout.write(`Pruned stale worktree metadata for ${repoPath}\n`);
             }
         }
@@ -943,8 +1109,8 @@ function uniqueModels(models) {
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
-async function withDetectedCliProviders(config) {
-    const detected = await detectCliProviders(configuredProviderCandidates(config.cliProviders));
+async function withDetectedCliProviders(config, candidates = config.cliProviders) {
+    const detected = await detectCliProviders(uniqueProviders(candidates));
     const found = detected.filter((result) => result.found);
     if (found.length === 0) {
         return config;
@@ -968,6 +1134,7 @@ async function withDetectedCliProviders(config) {
     };
 }
 async function withDetectedPairCliProviders(args) {
+    const configured = configuredProviderCandidates(args.cliProviders);
     const detectedConfig = await withDetectedCliProviders({
         ...defaultBridgeServiceConfig({
             serverUrl: args.serverUrl,
@@ -977,7 +1144,7 @@ async function withDetectedPairCliProviders(args) {
             cleanupWorktrees: args.cleanupWorktrees,
             defaultRepoRoot: args.repoRoot ?? defaultBridgeServiceConfig().defaultRepoRoot
         })
-    });
+    }, configured);
     return {
         ...args,
         cliProviders: detectedConfig.cliProviders
@@ -992,6 +1159,3 @@ function uniqueProviders(providers) {
         .filter((provider) => provider.length > 0)
         .filter((provider, index, all) => all.findIndex((candidate) => candidate.toLowerCase() === provider.toLowerCase()) === index);
 }
-async function runGit(cwd, args) {
-    await execFileAsync("git", args, { cwd, timeout: 10_000 });
-}

package/dist/cli/local-config.d.ts

@@ -7,6 +7,8 @@ export interface BridgeLocalConfig {
     readonly deviceName?: string;
     readonly defaultRepoRoot?: string;
     readonly cleanupWorktrees?: boolean;
+    readonly dockerEnabled?: boolean;
+    readonly allowOpenPublicSandbox?: boolean;
     readonly cliProviders?: readonly string[];
     readonly providerStatuses?: Readonly<Record<string, BridgeProviderStatus>>;
     readonly projectLabels?: readonly string[];
@@ -34,4 +36,6 @@ export declare function removeRepoMapping(label: string): Promise<{
     readonly config: BridgeLocalConfig;
     readonly removed: boolean;
 }>;
+export declare function setServerUrl(serverUrl: string): Promise<BridgeLocalConfig>;
+export declare function setSandboxPolicy(dockerEnabled: boolean, allowOpenPublicSandbox: boolean): Promise<BridgeLocalConfig>;
 export declare function providerStatusesFor(providers: readonly string[]): Readonly<Record<string, BridgeProviderStatus>>;

package/dist/cli/local-config.js

@@ -45,6 +45,12 @@ export function applyLocalConfigDefaults(config, local) {
         deviceName: process.env.FORGE_DEVICE_NAME ?? local.deviceName ?? config.deviceName,
         defaultRepoRoot: process.env.FORGE_REPO_ROOT ?? local.defaultRepoRoot ?? config.defaultRepoRoot,
         cleanupWorktrees: local.cleanupWorktrees ?? config.cleanupWorktrees,
+        dockerEnabled: process.env.FORGE_DOCKER_SANDBOX === undefined
+            ? local.dockerEnabled ?? config.dockerEnabled
+            : config.dockerEnabled,
+        allowOpenPublicSandbox: process.env.FORGE_ALLOW_OPEN_PUBLIC_SANDBOX === undefined
+            ? local.allowOpenPublicSandbox ?? config.allowOpenPublicSandbox
+            : config.allowOpenPublicSandbox,
         cliProviders,
         providerStatuses: normalizeProviderStatuses(local.providerStatuses) ?? providerStatusesFor(cliProviders),
         projectLabels: local.projectLabels ?? config.projectLabels,
@@ -88,6 +94,19 @@ export async function removeRepoMapping(label) {
     await writeLocalConfig(next);
     return { config: next, removed: after.length !== before.length };
 }
+export async function setServerUrl(serverUrl) {
+    const normalized = normalizeServerUrl(serverUrl);
+    const current = await readLocalConfig();
+    const next = normalizeLocalConfig({ ...current, serverUrl: normalized });
+    await writeLocalConfig(next);
+    return next;
+}
+export async function setSandboxPolicy(dockerEnabled, allowOpenPublicSandbox) {
+    const current = await readLocalConfig();
+    const next = normalizeLocalConfig({ ...current, dockerEnabled, allowOpenPublicSandbox });
+    await writeLocalConfig(next);
+    return next;
+}
 export function providerStatusesFor(providers) {
     return Object.fromEntries(providers.map((provider) => [provider, { signedIn: true, version: "", models: configuredModelsFor(provider) }]));
 }
@@ -106,6 +125,8 @@ function normalizeLocalConfig(config) {
         deviceName: cleanString(config.deviceName),
         defaultRepoRoot: cleanString(config.defaultRepoRoot),
         cleanupWorktrees: config.cleanupWorktrees,
+        dockerEnabled: config.dockerEnabled,
+        allowOpenPublicSandbox: config.allowOpenPublicSandbox,
         cliProviders: cleanList(config.cliProviders),
         providerStatuses: normalizeProviderStatuses(config.providerStatuses),
         projectLabels: cleanList(config.projectLabels),
@@ -200,10 +221,11 @@ function normalizeQaAppLaunchTarget(value) {
         command: cleanString(value.command),
         working_directory: cleanString(value.working_directory),
         ready_url: cleanString(value.ready_url),
+        managed_runtime_port: cleanString(value.managed_runtime_port),
         routes,
         notes: cleanString(value.notes)
     };
-    return normalized.url || normalized.command || normalized.ready_url || routes?.length
+    return normalized.url || normalized.command || normalized.ready_url || normalized.managed_runtime_port
         ? normalized
         : undefined;
 }
@@ -211,6 +233,24 @@ function cleanString(value) {
     const clean = value?.trim();
     return clean ? clean : undefined;
 }
+function normalizeServerUrl(value) {
+    const clean = value.trim();
+    let parsed;
+    try {
+        parsed = new URL(clean);
+    }
+    catch {
+        throw new Error(`Invalid Forge server URL: ${value}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Forge server URL must use http or https.");
+    }
+    if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+        throw new Error("Forge server URL cannot include credentials, a query string, or a fragment.");
+    }
+    parsed.pathname = parsed.pathname.replace(/\/+$/u, "") || "/";
+    return parsed.toString().replace(/\/$/u, "");
+}
 function cleanList(values) {
     const clean = [...new Set((values ?? []).map((value) => value.trim()).filter(Boolean))];
     return clean.length > 0 ? clean : undefined;