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

package/scripts/controller.js

@@ -11,6 +11,7 @@ const settingsSchema = z.strictObject({
     port: z.number().int().min(1024).max(65535),
     gateway: z.string().min(1),
     cli: z.string().min(1),
+    hostGatewayIp: z.ipv4().optional(),
 });
 const releaseInput = JSON.parse(await readFile(new URL("../release/components.json", import.meta.url), "utf8"));
 const release = z
@@ -75,6 +76,7 @@ gateway_id = ${JSON.stringify(settings.name)}
 ttl_secs = 0
 [openshell.drivers.docker]
 network_name = ${JSON.stringify(settings.name)}
+${settings.hostGatewayIp ? `host_gateway_ip = ${JSON.stringify(settings.hostGatewayIp)}` : ""}
 sandbox_namespace = ${JSON.stringify(settings.name)}
 supervisor_image = ${JSON.stringify(release.supervisorImage)}
 image_pull_policy = "IfNotPresent"
@@ -91,6 +93,7 @@ command
     .requiredOption("--directory <path>", "New private controller directory")
     .requiredOption("--gateway <path>", "Verified openshell-gateway executable")
     .requiredOption("--cli <path>", "Verified openshell executable")
+    .option("--host-gateway-ip <address>", "Controller address on the runtime bridge")
     .option("--name <name>", "Isolated controller name", "clawscarf")
     .option("--port <port>", "Loopback controller port", "17671")
     .action(async (options) => {
@@ -101,6 +104,7 @@ command
         port: Number(options.port),
         gateway: resolve(options.gateway),
         cli: resolve(options.cli),
+        hostGatewayIp: options.hostGatewayIp,
     });
     await verifyExecutable(settings.gateway);
     await verifyExecutable(settings.cli);
@@ -115,6 +119,8 @@ command
         "localhost",
         "--server-san",
         "host.openshell.internal",
+        "--server-san",
+        "controller.clawscarf.internal",
     ], { timeout: 30000 });
     const mtls = join(directory, "config/openshell/gateways", settings.name, "mtls");
     await mkdir(mtls, { recursive: true, mode: 0o700 });

package/scripts/deployment/browser-node-compose.js

@@ -41,7 +41,6 @@ export function browserNodeServices(state, directory, browserAddress, prepared)
             image: state.input.relayImage,
             user: String(process.getuid?.() ?? 1000),
             networks: { machine: { ipv4_address: addresses.ingress }, default: {} },
-            extra_hosts: ["host.docker.internal:host-gateway"],
             environment: {
                 CLAWSCARF_NODE_INGRESS_ADDRESS: addresses.ingress,
                 CLAWSCARF_NODE_GATEWAY_PORT: String(state.input.ports.native),

package/scripts/deployment/certificates.js

@@ -32,6 +32,7 @@ export async function ensureCertificates(directory) {
         const key = createPrivateKey(await readFile(join(directory, "management-key.pem")));
         if (!cert.checkPrivateKey(key) ||
             !cert.checkHost("host.docker.internal") ||
+            !cert.checkHost("companion") ||
             !cert.checkIP("127.0.0.1") ||
             !cert.raw.equals(ca.raw) ||
             !cert.ca ||
@@ -64,7 +65,7 @@ export async function ensureCertificates(directory) {
         "-subj",
         "/CN=ClawScarf local management",
         "-addext",
-        "subjectAltName=DNS:localhost,DNS:host.docker.internal,IP:127.0.0.1",
+        "subjectAltName=DNS:localhost,DNS:companion,DNS:host.docker.internal,DNS:models.clawscarf.internal,IP:127.0.0.1",
         "-addext",
         "basicConstraints=critical,CA:TRUE",
     ]);

package/scripts/deployment/compose.js

@@ -6,7 +6,7 @@ import { resourceNames } from "./state.js";
 import { run } from "./process.js";
 import { modelGatewayServices } from "./model-gateway-compose.js";
 import { postgresImage } from "./images.js";
-export function composeConfiguration(state, directory, browserAddress, browserMachine) {
+export function composeConfiguration(state, directory, controllerAddress, browserAddress, browserMachine, controllerSocketGroup = 0) {
     const { input, ownerId } = state;
     const names = resourceNames(state);
     const privateDirectory = join(directory, "private");
@@ -23,7 +23,7 @@ export function composeConfiguration(state, directory, browserAddress, browserMa
     const configuration = {
         name: names.project,
         services: {
-            ...controllerServices(directory, state),
+            ...controllerServices(directory, state, controllerAddress, controllerSocketGroup),
             ...modelGatewayServices(directory, state),
             ...(input.browser && browserAddress && browserMachine
                 ? browserNodeServices(state, directory, browserAddress, browserMachine)
@@ -153,9 +153,7 @@ export function composeConfiguration(state, directory, browserAddress, browserMa
             },
         },
         networks: {
-            ...(input.relayImage
-                ? { runtime: { external: true, name: names.sandbox } }
-                : {}),
+            runtime: { external: true, name: names.sandbox },
             default: { external: true, name: `${names.project}_default` },
             ...(input.browser
                 ? {

package/scripts/deployment/configuration.js

@@ -1,7 +1,7 @@
 import { OperatorError } from "../errors.js";
 import { isAbsolute, join, resolve } from "node:path";
 import { z } from "zod";
-import { initialConfiguration } from "../../runtime/configuration.js";
+import { initialConfiguration, configurationInput, } from "../../runtime/configuration.js";
 import { networkRequirementSchema } from "../packs/policy.js";
 const absolutePath = z
     .string()
@@ -105,6 +105,7 @@ const teamInput = z
 export const localInput = z
     .strictObject({
     team: teamInput,
+    agentName: configurationInput.shape.agentName,
     name: z
         .string()
         .max(30)
@@ -139,6 +140,7 @@ export const localInput = z
         .optional(),
     cpu,
     memory,
+    publicWeb: z.boolean().default(false),
     relayImage: image.optional(),
     browser: z
         .strictObject({
@@ -187,9 +189,6 @@ export const localInput = z
 export function parseLocalInput(value) {
     return localInput.parse(value);
 }
-export function managementOrigin(input) {
-    return `https://host.docker.internal:${String(input.ports.management)}`;
-}
 function mountedPrivateFile(directory, path, name) {
     absolutePath.parse(path);
     if (resolve(path) !== join(directory, name))
@@ -224,10 +223,11 @@ export function generateLocalConfiguration(options) {
             port: 18801,
         },
         runtime: {
-            origin: `http://host.docker.internal:${String(input.ports.native)}`,
-            managementOrigin: managementOrigin(input),
+            origin: `http://application:${String(input.ports.native)}`,
+            // Native proxy attribution needs the real Docker peer, not a loopback client.
+            managementOrigin: "https://companion:18801",
             widgetOrigin,
-            widgetUpstream: `http://host.docker.internal:${String(input.ports.nativeWidgets)}`,
+            widgetUpstream: `http://widgets:${String(input.ports.nativeWidgets)}`,
         },
         ...(input.team.certificateFile
             ? {
@@ -247,6 +247,7 @@ export function generateLocalConfiguration(options) {
         },
     };
     const native = initialConfiguration({
+        agentName: input.agentName,
         publicOrigin,
         widgetOrigin,
         administratorIdentity: identity,

package/scripts/deployment/connection-settings.js

@@ -5,7 +5,6 @@ import { companionConfiguration } from "./configuration.js";
 import { loadInitialConnections, prepareInitialConnections, readInitialConnectionToken, } from "./connections.js";
 import { configureConnectionsVolume } from "./connections-runtime.js";
 import { writePrivate } from "./state.js";
-import { initialRuntimePolicy } from "./policy.js";
 /** Explicit capability edit, with the installation stopped and its operator lock held. */
 export async function applyConnectionSettings(directory, state, previous, credentialFile) {
     const loaded = await loadInitialConnections(state.input.connections);
@@ -54,7 +53,4 @@ export async function applyConnectionSettings(directory, state, previous, creden
     if (loaded?.managementKey)
         config.services.companion.volumes.push(mount);
     await writePrivate(file, JSON.stringify(config));
-    const rule = initialRuntimePolicy("network_policies: {}", undefined, endpoint)
-        .network_policies.connections_broker ?? null;
-    await writePrivate(join(directory, "private/connection-policy-change.json"), JSON.stringify({ ownerId: state.ownerId, rule }));
 }

package/scripts/deployment/controller-compose.js

@@ -2,13 +2,14 @@ import { join } from "node:path";
 import { openshellGatewayImage } from "./images.js";
 import { resourceNames } from "./state.js";
 /** OpenShell alone receives Docker authority. Forwarders receive only client credentials. */
-export function controllerServices(directory, state) {
+export function controllerServices(directory, state, address, socketGroup) {
     const controller = join(directory, "controller");
     const { input } = state;
     const name = resourceNames(state).sandbox;
     const port = input.ports.controller;
     const forward = (target, port) => ({
         image: input.openshellClientImage,
+        user: `${String(process.getuid?.() ?? 1000)}:${String(process.getgid?.() ?? 1000)}`,
         init: true,
         read_only: true,
         cap_drop: ["ALL"],
@@ -21,23 +22,31 @@ export function controllerServices(directory, state) {
             XDG_DATA_HOME: "/tmp/data",
         },
         volumes: [`${join(controller, "config")}:/controller/config:ro`],
-        extra_hosts: ["host.openshell.internal:host-gateway"],
         command: [
             "forward",
-            "start",
+            "service",
+            "--target-port",
+            String(port),
+            "--local",
             `0.0.0.0:${String(port)}`,
             target,
             "--gateway",
             name,
             "--gateway-endpoint",
-            `https://host.openshell.internal:${String(input.ports.controller)}`,
+            `https://controller.clawscarf.internal:${String(input.ports.controller)}`,
         ],
         ports: [`127.0.0.1:${String(port)}:${String(port)}`],
     });
     return {
         controller: {
             image: openshellGatewayImage,
-            user: "0:0",
+            user: `${String(process.getuid?.() ?? 1000)}:${String(process.getgid?.() ?? 1000)}`,
+            // Desktop exposes a root-group socket; Linux Engine uses the host socket's group.
+            group_add: [...new Set(["0", String(socketGroup)])],
+            networks: {
+                default: { aliases: ["controller.clawscarf.internal"] },
+                runtime: { ipv4_address: address },
+            },
             command: ["--config", join(controller, "gateway.toml")],
             environment: {
                 XDG_CONFIG_HOME: join(controller, "config"),
@@ -51,7 +60,6 @@ export function controllerServices(directory, state) {
                 "/var/run/docker.sock:/var/run/docker.sock",
             ],
             ports: [`127.0.0.1:${String(port)}:${String(port)}`],
-            extra_hosts: ["host.openshell.internal:host-gateway"],
         },
         application: forward(name, input.ports.native),
         widgets: forward(name, input.ports.nativeWidgets),

package/scripts/deployment/entrypoint.js

@@ -3,5 +3,8 @@ import { fileURLToPath } from "node:url";
 export function nodeEntrypoint(relative) {
     const source = import.meta.url.endsWith(".ts");
     const file = new URL(relative + (source ? ".ts" : ".js"), import.meta.url);
-    return [...(source ? ["--import", "tsx"] : []), fileURLToPath(file)];
+    return [
+        ...(source ? ["--import", import.meta.resolve("tsx")] : []),
+        fileURLToPath(file),
+    ];
 }

package/scripts/deployment/launch.js

@@ -1,42 +1,29 @@
-import { applyConnectionPolicy } from "./connection-policy.js";
+import { verifyServiceRoutes } from "./service-network.js";
+import { applyNetworkPolicy } from "./network-policy.js";
 import { verifyRuntimeImage } from "./images.js";
 import { startBrowserNode } from "./browser-node-pairing.js";
 import { verifyBrowserNode } from "./browser-node.js";
 import { verifyRelayConfiguration } from "./relay.js";
 import { verifyBrowserListener, verifyBrowserConfiguration, } from "./browser.js";
 import { probeTeamAccess } from "./team.js";
-import { readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
-import { z } from "zod";
-import { readState, resourceNames } from "./state.js";
+import { readState, resourceNames, requirePrepared } from "./state.js";
 import { verifyLocalNetworks } from "./networks.js";
 import { compose } from "./compose.js";
-import { ensureRuntime, stopRuntime } from "./runtime.js";
+import { ensureRuntime, stopRuntime, runtimeEnvironment } from "./runtime.js";
 import { LocalSetupError, run } from "./process.js";
 import { verifyLocalExecutables, verifyLocalPorts } from "./preflight.js";
 import { verifyRuntimeBinding } from "./runtime-binding.js";
-import { requireNoUpgrade } from "./upgrade-state.js";
 /** Internal operation: the caller holds the installation lock for its full lifetime. */
 export async function launchLocal(directoryInput, report, control = {}) {
     const directory = resolve(directoryInput);
     const state = await readState(directory);
-    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);
     if (Object.keys(process.env).some((key) => key.startsWith("OPENSHELL_")))
         throw new LocalSetupError("configuration_changed", "Unset OPENSHELL_* overrides before starting this installation.");
-    const controller = join(directory, "controller");
-    const env = {
-        ...process.env,
-        XDG_CONFIG_HOME: join(controller, "config"),
-        XDG_STATE_HOME: join(controller, "state"),
-        XDG_DATA_HOME: join(controller, "data"),
-    };
+    const env = runtimeEnvironment(directory);
     const name = resourceNames(state).sandbox;
-    await requireNoUpgrade(directory);
     await verifyRuntimeImage(state.input.runtimeImage);
     await verifyLocalExecutables(state);
     await verifyLocalPorts(state);
@@ -83,7 +70,7 @@ export async function launchLocal(directoryInput, report, control = {}) {
         await waitFor(async () => {
             await run(state.input.openshellCli, ["sandbox", "list", "--gateway", name, "--output", "json"], { env, timeout: 5000 });
         });
-        await applyConnectionPolicy(directory, state, env);
+        await applyNetworkPolicy(directory, state, env);
         if (state.input.modelGateway) {
             report("Starting model gateway…");
             await compose(directory, [
@@ -113,7 +100,9 @@ export async function launchLocal(directoryInput, report, control = {}) {
             await response.body?.cancel();
         });
         await verifyRuntimeBinding(state, runtime);
-        await applyConnectionPolicy(directory, state, env, true);
+        await waitFor(() => applyNetworkPolicy(directory, state, env, true));
+        report("Checking runtime service routes…");
+        await verifyServiceRoutes(state, env);
         if (state.input.browser) {
             report("Starting native browser node…");
             await startBrowserNode(directory, state, cancellation.signal);
@@ -135,13 +124,7 @@ export async function launchLocal(directoryInput, report, control = {}) {
 /** Stop entry first, then the owned runtime, and only then its controller. */
 export async function stopLocal(directory) {
     const state = await readState(directory);
-    const controller = join(directory, "controller");
-    const env = {
-        ...process.env,
-        XDG_CONFIG_HOME: join(controller, "config"),
-        XDG_STATE_HOME: join(controller, "state"),
-        XDG_DATA_HOME: join(controller, "data"),
-    };
+    const env = runtimeEnvironment(directory);
     await compose(directory, [
         "stop",
         "companion",

package/scripts/deployment/model-gateway-compose.js

@@ -28,6 +28,12 @@ export function modelGatewayServices(directory, state) {
         },
         models: {
             image: input.image,
+            user: `${String(process.getuid?.() ?? 1000)}:${String(process.getgid?.() ?? 1000)}`,
+            environment: { HOME: "/tmp" },
+            networks: {
+                default: {},
+                runtime: { aliases: ["models.clawscarf.internal"] },
+            },
             init: true,
             read_only: true,
             cap_drop: ["ALL"],

package/scripts/deployment/model-gateway.js

@@ -43,6 +43,14 @@ export async function prepareModelGateway(directory, state, options = {}) {
         return;
     const loaded = await loadGatewayConfiguration(input.configurationFile, input.upstreamEnvironmentFile);
     const root = join(directory, "private/models");
+    let baseUrl = "https://models.clawscarf.internal:4000/v1";
+    if (options.replaceConfiguration) {
+        const current = configurationSchema.parse(JSON.parse(await readFile(join(root, "native.json"), "utf8")));
+        if (current.mode !== "litellm")
+            throw new LocalSetupError("invalid_model_setup", "Expected an existing model gateway.");
+        // Model choices do not change the installation's retained network endpoint.
+        baseUrl = current.baseUrl;
+    }
     await mkdir(root, { recursive: true, mode: 0o700 });
     for (const [name, prefix] of [
         ["master-key", "sk-"],
@@ -74,7 +82,7 @@ export async function prepareModelGateway(directory, state, options = {}) {
     await publish(join(root, "models.json"), JSON.stringify(liteLlmConfiguration(loaded.configuration)));
     await publish(join(root, "native.json"), JSON.stringify({
         ...loaded.configuration,
-        baseUrl: `https://host.docker.internal:${String(input.port)}/v1`,
+        baseUrl,
     }));
 }
 export async function prepareModelCredential(directory, state) {

package/scripts/deployment/models.js

@@ -70,7 +70,11 @@ export function withInitialModels(native, models) {
             },
         },
         agents: {
-            defaults: nativeModelDefaults(models.configuration),
+            ...native.agents,
+            defaults: {
+                ...native.agents.defaults,
+                ...nativeModelDefaults(models.configuration),
+            },
         },
     };
 }

package/scripts/deployment/network-policy.js

@@ -0,0 +1,147 @@
+import { isDeepStrictEqual } from "node:util";
+import { readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { run, LocalSetupError } from "./process.js";
+import { resourceNames, writePrivate } from "./state.js";
+import { composeNetworkRules, adjustmentsSchema, networkChangesSchema, } from "./public-web.js";
+import { runtimeEnvironment, runtimeManager } from "./runtime.js";
+const policySchema = z.looseObject({
+    network_policies: z.record(z.string(), z.unknown()),
+});
+const pendingSchema = z.strictObject({
+    ownerId: z.uuid(),
+    requested: networkChangesSchema,
+    changes: z.record(z.string(), z.strictObject({ before: z.unknown(), after: z.unknown() })),
+    adjustments: adjustmentsSchema,
+});
+async function optionalJson(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function observe(directory, state, env, command) {
+    const name = resourceNames(state).sandbox;
+    const control = runtimeManager(directory, state, env, command);
+    const { receipt } = await control.recorded();
+    if (!receipt)
+        return {
+            policy: policySchema.parse(JSON.parse(await readFile(join(directory, "private/runtime-policy.json"), "utf8"))),
+            effective: false,
+            recorded: false,
+        };
+    await control.confirm(receipt.id);
+    const observed = z
+        .object({
+        sandbox: z.literal(name),
+        policy_source: z.literal("sandbox"),
+        version: z.number().int(),
+        active_version: z.number().int(),
+        status: z.string(),
+        policy: policySchema,
+    })
+        .parse(JSON.parse(await command(state.input.openshellCli, [
+        "policy",
+        "get",
+        name,
+        "--gateway",
+        name,
+        "--base",
+        "--output",
+        "json",
+    ], { env })));
+    return {
+        policy: observed.policy,
+        effective: observed.active_version === observed.version &&
+            observed.status === "effective",
+        recorded: true,
+    };
+}
+/** Validate the whole selected change before service mutation. Caller holds the installation lock and starts its controller. */
+export async function planNetworkPolicyChange(directory, state, requested, command = run) {
+    const file = join(directory, "private/network-policy-change.json");
+    const saved = await optionalJson(file);
+    if (saved !== undefined) {
+        const pending = pendingSchema
+            .extend({ ownerId: z.literal(state.ownerId) })
+            .parse(saved);
+        if (!isDeepStrictEqual(pending.requested, requested))
+            throw new LocalSetupError("configuration_changed", "Resume the pending network change before selecting another policy.");
+        return pending;
+    }
+    const { policy } = await observe(directory, state, runtimeEnvironment(directory), command);
+    const owned = z
+        .strictObject({
+        ownerId: z.literal(state.ownerId),
+        rules: adjustmentsSchema,
+    })
+        .parse(JSON.parse(await readFile(join(directory, "private/network-policy-adjustments.json"), "utf8")));
+    const composed = composeNetworkRules(policy.network_policies, requested, owned.rules);
+    const keys = new Set([
+        ...Object.keys(policy.network_policies),
+        ...Object.keys(composed.rules),
+    ]);
+    const changes = Object.fromEntries([...keys]
+        .filter((key) => !isDeepStrictEqual(policy.network_policies[key], composed.rules[key]))
+        .map((key) => [
+        key,
+        {
+            before: policy.network_policies[key] ?? null,
+            after: composed.rules[key] ?? null,
+        },
+    ]));
+    return {
+        ownerId: state.ownerId,
+        requested,
+        changes,
+        adjustments: composed.adjustments,
+    };
+}
+export async function stageNetworkPolicyChange(directory, change) {
+    await writePrivate(join(directory, "private/network-policy-change.json"), JSON.stringify(change));
+}
+/** Compare selected rules with their reviewed values; preserve unrelated edits and reconcile uncertain policy-set outcomes. */
+export async function applyNetworkPolicy(directory, state, env, verify = false, command = run) {
+    const file = join(directory, "private/network-policy-change.json");
+    const saved = await optionalJson(file);
+    if (saved === undefined)
+        return;
+    const pending = pendingSchema
+        .extend({ ownerId: z.literal(state.ownerId) })
+        .parse(saved);
+    const observed = await observe(directory, state, env, command);
+    const rules = { ...observed.policy.network_policies };
+    let changed = false;
+    for (const [key, { before, after }] of Object.entries(pending.changes)) {
+        const actual = rules[key] ?? null;
+        if (isDeepStrictEqual(actual, after))
+            continue;
+        if (!isDeepStrictEqual(actual, before))
+            throw new LocalSetupError("configuration_changed", "A selected network rule changed after review. No policy was overwritten; inspect the pending change.");
+        changed = true;
+        if (after === null)
+            Reflect.deleteProperty(rules, key);
+        else
+            rules[key] = after;
+    }
+    if (verify) {
+        if (changed || !observed.effective)
+            throw new LocalSetupError("invalid_runtime_policy", "The selected network policy has not become effective in the runtime.");
+        await writePrivate(join(directory, "private/network-policy-adjustments.json"), JSON.stringify({ ownerId: state.ownerId, rules: pending.adjustments }));
+        await rm(file);
+        return;
+    }
+    if (!changed)
+        return;
+    const base = join(directory, "private/runtime-policy.json");
+    await writePrivate(base, JSON.stringify({ ...observed.policy, network_policies: rules }));
+    if (observed.recorded) {
+        const name = resourceNames(state).sandbox;
+        await command(state.input.openshellCli, ["policy", "set", name, "--gateway", name, "--policy", base], { env });
+    }
+}

package/scripts/deployment/networks.js

@@ -264,6 +264,10 @@ export async function ensureLocalNetworks(directory, state, command = run) {
                     "create",
                     "--driver",
                     "bridge",
+                    // Docker chooses a free subnet; declaring its size permits static endpoints.
+                    ...(intent.purpose !== "companion"
+                        ? ["--subnet", "0.0.0.0/24"]
+                        : []),
                     ...(intent.purpose === "runtime" ? ["--attachable"] : []),
                     ...(["browser", "machine"].includes(intent.purpose)
                         ? [
@@ -352,3 +356,20 @@ export async function observedBrowserMachineAddresses(directory, state, command
         changed();
     return { node: observed.isolated.address, ingress, dns };
 }
+/** Stable address on the owned runtime bridge for the containerized OpenShell controller. */
+export async function observedControllerAddress(directory, state) {
+    await verifyLocalNetworks(directory, state);
+    const configs = z
+        .array(z.object({ Subnet: z.string(), Gateway: z.string() }))
+        .parse(JSON.parse(await run("docker", [
+        "network",
+        "inspect",
+        resourceNames(state).sandbox,
+        "--format",
+        "{{json .IPAM.Config}}",
+    ])));
+    const config = configs.find((item) => isIP(item.Gateway) === 4);
+    if (!config)
+        changed();
+    return reservedAddress(config).address;
+}

package/scripts/deployment/policy.js

@@ -4,7 +4,17 @@ import { parseDocument } from "yaml";
 import { z } from "zod";
 import { LocalSetupError } from "./process.js";
 import { ensurePrivateFile } from "./state.js";
-export function initialRuntimePolicy(source, models, connections) {
+import { publicWebPolicy, composeNetworkRules } from "./public-web.js";
+export function serviceNetworkRule(name, network) {
+    return network
+        ? {
+            name,
+            endpoints: [{ host: network.host, port: network.port, tls: "skip" }],
+            binaries: [{ path: network.binary }],
+        }
+        : null;
+}
+export function initialRuntimePolicy(source, models, connections, publicWeb = false) {
     const document = parseDocument(source);
     if (document.errors.length || document.warnings.length)
         throw new LocalSetupError("invalid_runtime_policy", "The shipped runtime policy is invalid.");
@@ -14,43 +24,25 @@ export function initialRuntimePolicy(source, models, connections) {
         .safeParse(raw);
     if (!parsed.success)
         throw new LocalSetupError("invalid_runtime_policy", "Initial model setup requires the shipped deny-by-default runtime policy.");
+    const services = {
+        ...(models
+            ? { model_gateway: serviceNetworkRule("Model gateway", models.network) }
+            : {}),
+        ...(connections
+            ? {
+                connections_broker: serviceNetworkRule("Connections broker", connections.network),
+            }
+            : {}),
+    };
     return {
         ...parsed.data,
-        network_policies: {
-            ...(connections
-                ? {
-                    connections_broker: {
-                        name: "Connections broker",
-                        endpoints: [
-                            {
-                                host: connections.network.host,
-                                port: connections.network.port,
-                                tls: "skip",
-                            },
-                        ],
-                        binaries: [{ path: connections.network.binary }],
-                    },
-                }
-                : {}),
-            ...(models
-                ? {
-                    model_gateway: {
-                        name: "Model gateway",
-                        endpoints: [
-                            {
-                                host: models.network.host,
-                                port: models.network.port,
-                                tls: "skip",
-                            },
-                        ],
-                        binaries: [{ path: models.network.binary }],
-                    },
-                }
-                : {}),
-        },
+        network_policies: composeNetworkRules(services, { public_web: publicWebPolicy(publicWeb) }, {}).rules,
     };
 }
-export async function prepareRuntimePolicy(directory, models, connections) {
-    const policy = initialRuntimePolicy(await readFile(new URL("../../deploy/openshell/policy.yaml", import.meta.url), "utf8"), models, connections);
+export async function prepareRuntimePolicy(directory, ownerId, models, connections, publicWeb = false) {
+    const policy = initialRuntimePolicy(await readFile(new URL("../../deploy/openshell/policy.yaml", import.meta.url), "utf8"), models, connections, false);
+    const composed = composeNetworkRules(policy.network_policies, { public_web: publicWebPolicy(publicWeb) }, {});
+    await ensurePrivateFile(join(directory, "private/network-policy-adjustments.json"), JSON.stringify({ ownerId, rules: composed.adjustments }));
+    policy.network_policies = composed.rules;
     await ensurePrivateFile(join(directory, "private/runtime-policy.json"), JSON.stringify(policy));
 }