@clawscarf/cli 0.1.0-alpha.1 → 0.1.0-alpha.11

package/scripts/deployment/prepare.js

@@ -1,3 +1,4 @@
+import { validatePublicWebServices } from "./service-network.js";
 import { openshellGatewayImage, verifyRuntimeImage } from "./images.js";
 import { ensureOwnedVolume } from "./volumes.js";
 import { prepareModelGateway, prepareModelCredential, } from "./model-gateway.js";
@@ -8,29 +9,35 @@ import { prepareRelay } from "./relay.js";
 import { prepareRuntimePolicy } from "./policy.js";
 import { prepareBrowser, initializeBrowserVolume } from "./browser.js";
 import { readTeamMaterials, prepareTeamFiles } from "./team.js";
-import { readFile, lstat } from "node:fs/promises";
+import { readFile, lstat, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { prepareInitialModels, withInitialModels, } from "./models.js";
-import { ensureLocalNetworks } from "./networks.js";
+import { prepareInitialModels, loadInitialModels, withInitialModels, } from "./models.js";
+import { ensureLocalNetworks, observedControllerAddress } from "./networks.js";
 import { nodeEntrypoint } from "./entrypoint.js";
 import { ensureCertificates } from "./certificates.js";
 import { z } from "zod";
 import { PostgresAccessStore } from "../../services/access/repo/postgres.js";
 import { parseLocalInput, generateLocalConfiguration, } from "./configuration.js";
 import { withPreparedDatabase } from "./database.js";
-import { initializeState, writePrivate, ensurePrivateFile, resourceNames, } from "./state.js";
+import { initializeState, requirePrepared, writePrivate, ensurePrivateFile, resourceNames, } from "./state.js";
 import { composeConfiguration } from "./compose.js";
 import { run, LocalSetupError } from "./process.js";
 import { verifyLocalExecutables, verifyLocalPorts } from "./preflight.js";
-import { requireNoUpgrade } from "./upgrade-state.js";
 /** Internal operation: the caller holds the installation lock for its full lifetime. */
 export async function prepareLocal(directoryInput, inputValue, capabilities) {
     const directory = resolve(directoryInput);
     const input = parseLocalInput(inputValue);
     const connections = await loadInitialConnections(input.connections);
+    await validatePublicWebServices(input.publicWeb, {
+        models: input.publicWeb && !input.modelGateway
+            ? (await loadInitialModels(input.models))?.network
+            : undefined,
+        connections: connections?.endpoint.network,
+    });
     const teamMaterials = await readTeamMaterials(input.team);
-    if (process.platform !== "darwin" || process.arch !== "arm64")
-        throw new LocalSetupError("platform_unqualified", "This local assembly currently requires macOS arm64 with Docker Desktop; other platforms need qualification.");
+    if (!["darwin", "linux"].includes(process.platform) ||
+        !["arm64", "x64"].includes(process.arch))
+        throw new LocalSetupError("platform_unqualified", "Use macOS or Linux (including WSL2) with Linux Docker containers.");
     for (const image of [
         input.runtimeImage,
         input.openshellClientImage,
@@ -51,17 +58,12 @@ export async function prepareLocal(directoryInput, inputValue, capabilities) {
     await verifyRuntimeImage(input.runtimeImage);
     const state = await initializeState(directory, input);
     try {
-        z.strictObject({
-            ownerId: z.literal(state.ownerId),
-            settingsCandidate: z.string().optional(),
-            settingsReapply: z.enum(["models", "connections"]).optional(),
-        }).parse(JSON.parse(await readFile(join(directory, "prepared.json"), "utf8")));
+        await requirePrepared(directory);
     }
     catch (error) {
         if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
             throw new LocalSetupError("configuration_changed", "A retained settings change is unconfirmed. Inspect it before preparing or starting this installation.");
     }
-    await requireNoUpgrade(directory);
     if (capabilities)
         await ensurePrivateFile(join(directory, "inputs.sha256"), capabilities.inputFingerprint);
     await verifyLocalExecutables(state);
@@ -71,6 +73,7 @@ export async function prepareLocal(directoryInput, inputValue, capabilities) {
     const connectionsEndpoint = await prepareInitialConnections(directory, connections);
     await prepareModelGateway(directory, state);
     await ensureLocalNetworks(directory, state);
+    const controllerAddress = await observedControllerAddress(directory, state);
     const browser = await prepareBrowser(directory, state);
     const browserMachine = browser
         ? await prepareBrowserNode(directory, state, browser.token)
@@ -86,10 +89,12 @@ export async function prepareLocal(directoryInput, inputValue, capabilities) {
         await ensureOwnedVolume(names.browserVolume, state.ownerId);
         await initializeBrowserVolume(state, browser.token);
     }
-    await ensurePrivateFile(join(directory, "compose.json"), JSON.stringify(composeConfiguration(state, directory, browser?.address, browserMachine), null, 2));
+    await ensurePrivateFile(join(directory, "compose.json"), JSON.stringify(composeConfiguration(state, directory, controllerAddress, browser?.address, browserMachine, process.platform === "linux"
+        ? (await stat("/var/run/docker.sock")).gid
+        : 0), null, 2));
     await prepareModelCredential(directory, state);
     const models = await prepareInitialModels(directory, input.models);
-    await prepareRuntimePolicy(directory, models, connectionsEndpoint);
+    await prepareRuntimePolicy(directory, state.ownerId, models, connectionsEndpoint, state.input.publicWeb);
     await withPreparedDatabase(directory, state, async (pool, runtimeUrl) => {
         const store = new PostgresAccessStore(pool, await readFile(join(privateDirectory, "encryption.key")), {
             issuer: input.team.issuer,
@@ -151,6 +156,8 @@ export async function prepareLocal(directoryInput, inputValue, capabilities) {
             input.openshellGateway,
             "--cli",
             input.openshellCli,
+            "--host-gateway-ip",
+            controllerAddress,
             "--name",
             names.sandbox,
             "--port",

package/scripts/deployment/public-addresses.js

@@ -0,0 +1,30 @@
+import ipaddr from "ipaddr.js";
+import definition from "../../deploy/execution/network/public-addresses.json" with { type: "json" };
+/** Split only ranges containing an exclusion; no address enumeration. */
+function subtract(subnet, excluded) {
+    const [address, prefix] = subnet;
+    const [blocked, blockedPrefix] = excluded;
+    if (address.kind() !== blocked.kind())
+        return [subnet];
+    if (prefix >= blockedPrefix)
+        return address.match(blocked, blockedPrefix) ? [] : [subnet];
+    if (!blocked.match(address, prefix))
+        return [subnet];
+    const bytes = address.toByteArray();
+    const index = Math.floor(prefix / 8);
+    bytes[index] = (bytes[index] ?? 0) | (1 << (7 - (prefix % 8)));
+    return [
+        ...subtract([address, prefix + 1], excluded),
+        ...subtract([ipaddr.fromByteArray(bytes), prefix + 1], excluded),
+    ];
+}
+export const publicWebAddresses = definition.excluded
+    .reduce((ranges, excluded) => ranges.flatMap((range) => subtract(range, ipaddr.parseCIDR(excluded))), definition.families.map((cidr) => ipaddr.parseCIDR(cidr)))
+    .map(([address, prefix]) => `${address.toString()}/${String(prefix)}`);
+export function isPublicAddress(value) {
+    const address = ipaddr.parse(value);
+    return publicWebAddresses.some((cidr) => {
+        const [network, prefix] = ipaddr.parseCIDR(cidr);
+        return address.kind() === network.kind() && address.match(network, prefix);
+    });
+}

package/scripts/deployment/public-web.js

@@ -0,0 +1,132 @@
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+import { LocalSetupError } from "./process.js";
+import { publicWebAddresses } from "./public-addresses.js";
+export { publicWebAddresses } from "./public-addresses.js";
+export function publicWebPolicy(enabled) {
+    return enabled
+        ? {
+            name: "Public web",
+            endpoints: [
+                { ports: [80, 443], allowed_ips: publicWebAddresses, tls: "skip" },
+            ],
+            binaries: [{ path: "/**" }],
+        }
+        : null;
+}
+const endpointSchema = z.looseObject({
+    host: z.string().optional(),
+    port: z.number().int().optional(),
+    ports: z.array(z.number().int()).optional(),
+    allowed_ips: z.array(z.string()).optional(),
+});
+const ruleSchema = z.looseObject({ endpoints: z.array(endpointSchema) });
+export const adjustmentsSchema = z.record(z.string(), z.strictObject({
+    before: z.array(endpointSchema),
+    after: z.array(endpointSchema),
+}));
+const rule = z.record(z.string(), z.unknown());
+export const networkChangesSchema = z.strictObject({
+    connections_broker: rule.nullable().optional(),
+    public_web: rule.nullable().optional(),
+});
+const ports = (endpoint) => endpoint.ports?.length
+    ? endpoint.ports
+    : endpoint.port
+        ? [endpoint.port]
+        : [];
+const webPort = (port) => port === 80 || port === 443;
+function conflict() {
+    throw new LocalSetupError("invalid_runtime_policy", "Public web conflicts with an operator's service policy. Keep public web off or reconcile the policy explicitly; existing restrictions were not changed.");
+}
+/** Only a recorded before/after edit can be undone. Equal address lists do not establish ownership. */
+export function composeNetworkRules(current, changes, owned) {
+    const rules = { ...current };
+    const adjustments = { ...owned };
+    const toggle = Object.hasOwn(changes, "public_web");
+    const selected = new Set(Object.keys(changes));
+    if (toggle)
+        for (const key of Object.keys(adjustments))
+            selected.add(key);
+    for (const key of selected) {
+        const adjustment = adjustments[key];
+        if (adjustment) {
+            const actual = ruleSchema.safeParse(rules[key]);
+            if (actual.success &&
+                isDeepStrictEqual(actual.data.endpoints, adjustment.after))
+                rules[key] = { ...actual.data, endpoints: adjustment.before };
+            Reflect.deleteProperty(adjustments, key);
+        }
+    }
+    for (const [key, replacement] of Object.entries(changes)) {
+        if (replacement === null) {
+            Reflect.deleteProperty(rules, key);
+            continue;
+        }
+        if (key === "connections_broker" && rules[key]) {
+            const before = ruleSchema.parse(rules[key]);
+            const after = ruleSchema.parse(replacement);
+            // Selected service updates retain explicit address restrictions on the same endpoint.
+            for (const endpoint of before.endpoints.filter((entry) => entry.allowed_ips?.length)) {
+                const target = after.endpoints.find((entry) => entry.host === endpoint.host &&
+                    isDeepStrictEqual(ports(entry), ports(endpoint)));
+                if (!target)
+                    conflict();
+                target.allowed_ips = endpoint.allowed_ips;
+            }
+            rules[key] = after;
+        }
+        else
+            rules[key] = replacement;
+    }
+    if (rules.public_web !== undefined) {
+        for (const key of ["connections_broker", "model_gateway"]) {
+            if (!toggle && !selected.has(key))
+                continue;
+            if (rules[key] === undefined)
+                continue;
+            const parsed = ruleSchema.parse(rules[key]);
+            const after = parsed.endpoints.flatMap((endpoint) => {
+                const covered = ports(endpoint).filter(webPort);
+                if (!covered.length)
+                    return [endpoint];
+                if (endpoint.allowed_ips?.length) {
+                    if (!isDeepStrictEqual([...endpoint.allowed_ips].sort(), [...publicWebAddresses].sort()))
+                        conflict();
+                    return [endpoint];
+                }
+                const other = ports(endpoint).filter((port) => !webPort(port));
+                if (!other.length)
+                    return [{ ...endpoint, allowed_ips: publicWebAddresses }];
+                const { port: _port, ports: _ports, ...rest } = endpoint;
+                return [
+                    { ...rest, ports: other },
+                    { ...rest, ports: covered, allowed_ips: publicWebAddresses },
+                ];
+            });
+            if (!isDeepStrictEqual(parsed.endpoints, after)) {
+                adjustments[key] = { before: parsed.endpoints, after };
+                rules[key] = { ...parsed, endpoints: after };
+            }
+        }
+        // The wildcard overlaps every host on these ports. Never rewrite unrelated rules to make it fit.
+        if (toggle || selected.has("connections_broker")) {
+            for (const [key, value] of Object.entries(rules)) {
+                if (!toggle && key !== "connections_broker")
+                    continue;
+                const parsed = ruleSchema.safeParse(value);
+                if (!parsed.success)
+                    continue;
+                for (const endpoint of parsed.data.endpoints) {
+                    if (!ports(endpoint).some(webPort))
+                        continue;
+                    if (endpoint.tls !== "skip" ||
+                        endpoint.protocol === "tcp" ||
+                        !isDeepStrictEqual([...(endpoint.allowed_ips ?? [])].sort(), [...publicWebAddresses].sort()))
+                        conflict();
+                }
+            }
+        }
+    }
+    return { rules, adjustments };
+}

package/scripts/deployment/runtime.js

@@ -26,12 +26,23 @@ async function readOptional(path) {
         throw error;
     }
 }
-function uncertain() {
-    throw new LocalSetupError("runtime_outcome_unknown", "Runtime creation was attempted but its owned target is absent. Inspect this installation; setup will not create another runtime automatically.");
+function uncertain(error) {
+    const failure = error instanceof LocalSetupError ? error : undefined;
+    throw new LocalSetupError("runtime_outcome_unknown", "Runtime creation was attempted but its owned target is absent. Inspect this installation; setup will not create another runtime automatically." +
+        (failure ? ` Creation failure: ${failure.message}` : ""), failure?.commandFailure);
 }
 function changed() {
     throw new LocalSetupError("runtime_identity_changed", "The runtime identity or ownership differs from this installation. No further runtime command was sent.");
 }
+export function runtimeEnvironment(directory) {
+    const controller = join(directory, "controller");
+    return {
+        ...process.env,
+        XDG_CONFIG_HOME: join(controller, "config"),
+        XDG_STATE_HOME: join(controller, "state"),
+        XDG_DATA_HOME: join(controller, "data"),
+    };
+}
 export function runtimeManager(directory, state, env, command) {
     const name = resourceNames(state).sandbox;
     const intent = {
@@ -183,10 +194,10 @@ export async function ensureRuntime(directory, state, env, command = run) {
         try {
             await command(state.input.openshellCli, args, { env, timeout: 180000 });
         }
-        catch {
+        catch (error) {
             target = await control.observe();
             if (!target)
-                uncertain();
+                uncertain(error);
         }
         target ??= await control.observe();
         if (!target)

package/scripts/deployment/service-network.js

@@ -0,0 +1,86 @@
+import { lookup } from "node:dns/promises";
+import { isPublicAddress } from "./public-addresses.js";
+import { LocalSetupError, run } from "./process.js";
+import { loadInitialModels } from "./models.js";
+import { loadInitialConnections } from "./connections.js";
+import { resourceNames } from "./state.js";
+/** Host DNS is an early compatibility check, not proof of runtime connectivity. */
+export async function validatePublicWebServices(enabled, services, resolve = (host) => lookup(host, { all: true })) {
+    if (!enabled)
+        return;
+    for (const name of ["models", "connections"]) {
+        const endpoint = services[name];
+        if (!endpoint || ![80, 443].includes(endpoint.port))
+            continue;
+        let addresses;
+        try {
+            addresses = await resolve(endpoint.host);
+        }
+        catch {
+            throw new LocalSetupError("invalid_runtime_policy", `The ${name} endpoint could not be resolved for public-web validation. Check its DNS configuration before continuing.`);
+        }
+        if (!addresses.length ||
+            addresses.some(({ address }) => !isPublicAddress(address)))
+            throw new LocalSetupError("invalid_runtime_policy", `The ${name} endpoint resolves to private or reserved addresses on port ${String(endpoint.port)}. Turn Public web off or use a service port outside 80/443. This OpenShell version cannot combine those policies.`);
+    }
+}
+// Runs inside the protected runtime. A CONNECT success proves the actual proxy route,
+// without sending service credentials or treating TLS/application health as established.
+const proxyProbe = `
+import http from 'node:http';
+const [host, port] = process.argv.slice(1);
+const outcome = await new Promise(resolve => {
+  const request = http.request(process.env.HTTPS_PROXY, {
+    method: 'CONNECT', path: host + ':' + port, agent: false,
+  });
+  request.setTimeout(8000, () => request.destroy(new Error('timeout')));
+  request.on('error', () => resolve('unavailable'));
+  request.on('connect', (response, socket) => {
+    socket.destroy();
+    resolve(response.statusCode === 200 ? 'connected' : response.statusCode === 403 ? 'blocked' : 'unavailable');
+  });
+  request.end();
+});
+console.log(outcome);
+`;
+export async function verifyServiceRoutes(state, env, command = run) {
+    const services = {
+        models: (await loadInitialModels(state.input.models))?.network,
+        connections: (await loadInitialConnections(state.input.connections))
+            ?.endpoint.network,
+    };
+    const name = resourceNames(state).sandbox;
+    for (const service of ["models", "connections"]) {
+        const endpoint = services[service];
+        if (!endpoint)
+            continue;
+        let outcome;
+        try {
+            outcome = (await command(state.input.openshellCli, [
+                "sandbox",
+                "exec",
+                "--name",
+                name,
+                "--gateway",
+                name,
+                "--no-tty",
+                "--timeout",
+                "15",
+                "--",
+                "node",
+                "--input-type=module",
+                "-e",
+                proxyProbe,
+                endpoint.host,
+                String(endpoint.port),
+            ], { env, timeout: 25000 })).trim();
+        }
+        catch (error) {
+            throw new LocalSetupError("native_unavailable", `The runtime ${service} network check did not complete. Inspect the runtime before retrying.`, error instanceof LocalSetupError ? error.commandFailure : undefined);
+        }
+        if (outcome !== "connected")
+            throw new LocalSetupError("invalid_runtime_policy", outcome === "blocked"
+                ? `The runtime network policy blocks the configured ${service} endpoint. Review Public web and the service policy before starting.`
+                : `The configured ${service} endpoint is unreachable through the runtime proxy. Check the service and its DNS/network settings before starting.`);
+    }
+}

package/scripts/deployment/state.js

@@ -13,6 +13,22 @@ const identitySchema = z.object({
 const stateSchema = identitySchema
     .extend({ input: z.unknown().transform(parseLocalInput) })
     .strict();
+const preparationSchema = z.strictObject({
+    ownerId: z.uuid(),
+    settingsCandidate: z.string().optional(),
+    settingsPending: z.string().optional(),
+    settingsReapply: z.enum(["models", "connections"]).optional(),
+});
+export async function readPreparation(directory) {
+    const record = preparationSchema.parse(JSON.parse(await readFile(join(directory, "prepared.json"), "utf8")));
+    if (record.ownerId !== (await readInstallationIdentity(directory)).ownerId)
+        throw new LocalSetupError("configuration_changed", "Preparation belongs to another installation.");
+    return record;
+}
+export async function requirePrepared(directory) {
+    if ((await readPreparation(directory)).settingsPending)
+        throw new LocalSetupError("configuration_changed", "A retained settings change is unconfirmed. Run configure to review and resume it before starting.");
+}
 export async function writePrivate(path, value) {
     const temporary = path + "." + randomUUID();
     try {

package/scripts/installation/command.js

@@ -12,7 +12,6 @@ import { readJson } from "./files.js";
 import { startInstallation, controlInstallation, installationLogs, } from "./lifecycle.js";
 import { doctorInstallation } from "./doctor.js";
 import { localLogNames } from "../deployment/logs.js";
-import { upgradeLocal } from "../deployment/upgrade.js";
 import { installationCatalog } from "./recipes/catalog.js";
 import { defaultInstallationDirectory } from "./location.js";
 import { progress } from "./installer/prompts.js";
@@ -20,12 +19,13 @@ import { runConfiguration } from "./installer/run.js";
 import { installationOptions } from "./options.js";
 import { InstallationError } from "./errors.js";
 import { administratorSetup } from "./administrator.js";
-export function installationCommand() {
+export function installationCommand(observation) {
     const program = new Command("clawscarf")
         .description("Install and operate a protected OpenClaw team server.")
         .option("--json", "Print machine-readable results; diagnostics go to stderr");
     program.addCommand(peopleCommand(program));
     const output = (value, human) => {
+        observation?.result(value);
         writeResult(program, value, human);
     };
     installationOptions(program.command("configure"))
@@ -43,9 +43,11 @@ export function installationCommand() {
         const result = await runConfiguration({
             ...options,
             ...program.opts(),
-        });
+        }, (mode) => observation?.configurationMode(mode));
         if (options.nonInteractive)
             output(result);
+        else
+            observation?.result(result);
     });
     program
         .command("recipes")
@@ -91,7 +93,7 @@ export function installationCommand() {
                 });
                 const directory = await resolveLocation(options);
                 const result = await progress("Deleting installation", (signal) => deleteInstallation(directory, signal), program.opts());
-                output(result, "Installation deleted from Docker. You can now remove its installation folder.");
+                output(result, "Installation deleted from Docker. The local folder still contains configuration and credentials. To install again, move or remove that folder, or configure a new --directory.");
                 return;
             }
             if (options.confirmDelete !== undefined || options.acceptDataLoss)
@@ -125,16 +127,6 @@ export function installationCommand() {
         }
         output(await doctorInstallation(config));
     });
-    withLocation(program.command("upgrade"))
-        .requiredOption("--runtime-image <digest>")
-        .requiredOption("--python <executable>")
-        .requiredOption("--yes")
-        .action(async (options) => {
-        await upgradeLocal(await resolveLocation(options), options.runtimeImage, options.python, (message) => {
-            process.stderr.write(message + "\n");
-        });
-        output({ state: "upgraded" }, "Upgrade completed.");
-    });
     const connections = program
         .command("connections")
         .description("Manage connected accounts and their agent access");

package/scripts/installation/configuration.js

@@ -22,6 +22,7 @@ export const installationSchema = z
     .strictObject({
     schemaVersion: z.literal(1),
     name: localInput.shape.name,
+    agentName: localInput.shape.agentName,
     recipe: z
         .strictObject({
         id: z.string().min(1),
@@ -65,6 +66,7 @@ export const installationSchema = z
         }),
     ]),
     resources: z.strictObject({ runtime: resources }),
+    publicWeb: z.boolean().default(false),
     browser: z.strictObject({ enabled: z.boolean() }),
     models: z.discriminatedUnion("mode", [
         externalLiteLlmSchema,

package/scripts/installation/configure.js

@@ -117,6 +117,7 @@ export async function configurationChanges(before, after) {
     return {
         models: !isDeepStrictEqual(await models(before), await models(after)),
         connections: !isDeepStrictEqual(before.connections, after.connections),
+        publicWeb: before.publicWeb !== after.publicWeb,
         packs: !isDeepStrictEqual(await packs(before), await packs(after)),
     };
 }

package/scripts/installation/installer/cloud.js

@@ -7,7 +7,7 @@ export function registerWithBrowser(configFile, ui, task, register = registerClo
     return task("Connecting selected cloud services", (signal) => register(configFile, (url, file, administrator) => authorizeCloud(url, file, {
         wait: true,
         present: async (link, code, expiresAt) => {
-            ui.note(`${administrator ? "Sign in or create an account to set up this installation and become its first administrator." : "Sign in or create an account to authorize the selected cloud services."}\n\n${terminalLink(link)}\n\nApproval code: ${code} — check that it matches the website.\n\nExpires at ${expiresAt}. Return to this terminal after approval.`, styleText(["bold", "yellow"], "ACTION REQUIRED — Sign in to ClawScarf"));
+            ui.note(`${administrator ? "Create an account or sign in to set up this installation and become its first administrator." : "Create an account or sign in to authorize the selected cloud services."}\n\n${terminalLink(link)}\n\nApproval code: ${code} — check that it matches the website.\n\nExpires at ${expiresAt}. Return to this terminal after approval.`, styleText(["bold", "yellow"], "ACTION REQUIRED — Create an account or sign in"));
             await ui.openBrowser(link);
         },
         signal,

package/scripts/installation/installer/collect.js

@@ -127,9 +127,11 @@ export async function collectInstallation(ui, options, retained) {
                     case "identity": {
                         const name = await field(ui, "Installation name", localInput.shape.name, config.name);
                         const administratorName = await field(ui, "Administrator display name", localInput.shape.administratorName, config.access.administratorName);
+                        const agentName = await field(ui, "Default agent name", installationSchema.shape.agentName, config.agentName);
                         config = {
                             ...config,
                             name,
+                            agentName,
                             access: { ...config.access, administratorName },
                         };
                         break;
@@ -175,6 +177,21 @@ export async function collectInstallation(ui, options, retained) {
                     case "resources":
                         config.resources = await collectResources(ui, config.resources);
                         break;
+                    case "public-web":
+                        config.publicWeb =
+                            (await ui.select("Public web access", [
+                                {
+                                    value: "on",
+                                    label: "On",
+                                    hint: "Public HTTP(S); agents can send team data to public services",
+                                },
+                                {
+                                    value: "off",
+                                    label: "Off",
+                                    hint: "Only configured services and explicit policies",
+                                },
+                            ], config.publicWeb ? "on" : "off")) === "on";
+                        break;
                     case "browser":
                         ui.note("Explicit browser node use works. Ordinary model-selected browsing is not qualified because of an upstream routing issue.", "Experimental browser");
                         config.browser.enabled =

package/scripts/installation/installer/menu.js

@@ -20,11 +20,12 @@ export function installationMenu(config, directory, browserAvailable, packIssues
                 : "Credentials come next",
         },
         row("location", "Location", location.length > 40 ? "…" + location.slice(-39) : location, directory),
-        row("identity", "Name and administrator", `${config.name} · ${config.access.administratorName}`),
+        row("identity", "Names", `${config.name} · ${config.agentName} · ${config.access.administratorName}`),
         row("access", "Access", config.access.mode === "hosted" ? "ClawScarf login" : "Custom OIDC", "Configure your own OIDC provider (optional)"),
         row("exposure", "Network", config.exposure.mode === "local"
             ? "This computer"
             : config.exposure.applicationOrigin),
+        row("public-web", "Public web", config.publicWeb ? "On" : "Off", "HTTP(S) for agents and tools; private destinations blocked"),
         row("models", "Models", modelSummary ?? "Choose a model"),
         row("connections", "Connections", config.connections.mode === "disabled" ? "Off" : "On"),
         row("packs", "Packs", packIssues.length
@@ -42,7 +43,7 @@ export function installationMenu(config, directory, browserAvailable, packIssues
     ];
     return existing
         ? [
-            ...choices.filter(({ value }) => ["review", "models", "connections", "packs"].includes(value)),
+            ...choices.filter(({ value }) => ["review", "models", "connections", "packs", "public-web"].includes(value)),
             { value: "model-credentials", label: "Change LLM API keys" },
         ]
         : choices;

package/scripts/installation/installer/prompts.js

@@ -66,7 +66,11 @@ export const terminalPrompts = {
     note: clack.note,
     async openBrowser(url) {
         try {
-            await promisify(execFile)(process.platform === "darwin" ? "open" : "xdg-open", [url], { timeout: 5000 });
+            await promisify(execFile)(process.platform === "darwin"
+                ? "open"
+                : process.env.WSL_DISTRO_NAME
+                    ? "explorer.exe"
+                    : "xdg-open", [url], { timeout: 5000 });
         }
         catch {
             process.stderr.write("Could not open a browser. Open the link above manually.\n");
@@ -91,7 +95,7 @@ export async function progress(message, work, options = {}) {
     const report = (detail) => {
         if (spinner && detail.includes("\n")) {
             spinner.stop(message);
-            process.stderr.write(detail + "\n");
+            clack.log.info(detail, { output: process.stderr });
             spinner.start(message);
         }
         else if (spinner)