@clawscarf/cli 0.1.0-alpha.1

package/scripts/deployment/browser.js

@@ -0,0 +1,143 @@
+import { runtimeRelayHost } from "./relay.js";
+import { randomBytes } from "node:crypto";
+import { chmod, lstat, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { observedBrowserAddress } from "./networks.js";
+import { LocalSetupError, run } from "./process.js";
+import { ensurePrivateFile, resourceNames } from "./state.js";
+const tokenSchema = z.string().regex(/^[a-f0-9]{64}$/);
+/** Optional browser credentials are independent of model, account and controller keys. */
+export async function prepareBrowser(directory, state, command = run) {
+    if (!state.input.browser)
+        return undefined;
+    const path = join(directory, "private/browser-token");
+    let token;
+    try {
+        const metadata = await lstat(path);
+        if (!metadata.isFile() ||
+            (metadata.mode & 0o077) !== 0 ||
+            metadata.uid !== process.getuid?.())
+            throw new LocalSetupError("configuration_changed", "The browser credential must remain private and owned by this operator.");
+        token = tokenSchema.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            throw error;
+        token = randomBytes(32).toString("hex");
+        await ensurePrivateFile(path, token);
+    }
+    const address = await observedBrowserAddress(directory, state, command);
+    if (!address)
+        throw new LocalSetupError("network_unprepared", "The isolated browser network is not prepared.");
+    const acl = join(directory, "private/browser-source.acl");
+    const content = `${address}/32\n`;
+    // Public network data, within the operator's private directory; Squid's UID must read its bind mount.
+    try {
+        const metadata = await lstat(acl);
+        if (!metadata.isFile() ||
+            (metadata.mode & 0o777) !== 0o444 ||
+            metadata.uid !== process.getuid?.() ||
+            (await readFile(acl, "utf8")) !== content)
+            throw new LocalSetupError("configuration_changed", "The browser source rule differs from its reserved network address.");
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            throw error;
+        await writeFile(acl, content, { flag: "wx", mode: 0o444 });
+        await chmod(acl, 0o444);
+    }
+    await ensurePrivateFile(join(directory, "private/browser-seccomp.json"), await readFile(new URL("../../deploy/execution/browser/seccomp.json", import.meta.url)));
+    return { token, address };
+}
+/** Startup never repairs changed network constraints or substitutes browser credentials. */
+export async function verifyBrowserConfiguration(directory, state, command = run) {
+    if (!state.input.browser)
+        return;
+    const address = await observedBrowserAddress(directory, state, command);
+    if (!address)
+        throw new LocalSetupError("network_unprepared", "The isolated browser network is not prepared.");
+    const expected = [
+        {
+            name: "browser-source.acl",
+            mode: 0o444,
+            content: Buffer.from(`${address}/32\n`),
+        },
+        {
+            name: "browser-seccomp.json",
+            mode: 0o600,
+            content: await readFile(new URL("../../deploy/execution/browser/seccomp.json", import.meta.url)),
+        },
+    ];
+    for (const file of expected) {
+        const path = join(directory, "private", file.name);
+        const metadata = await lstat(path);
+        if (!metadata.isFile() ||
+            metadata.nlink !== 1 ||
+            metadata.uid !== process.getuid?.() ||
+            (metadata.mode & 0o777) !== file.mode ||
+            !file.content.equals(await readFile(path)))
+            throw new LocalSetupError("configuration_changed", "The prepared browser isolation settings have changed. Inspect them before starting.");
+    }
+    const path = join(directory, "private/browser-token");
+    const metadata = await lstat(path);
+    if (!metadata.isFile() ||
+        metadata.nlink !== 1 ||
+        metadata.uid !== process.getuid?.() ||
+        (metadata.mode & 0o077) !== 0)
+        throw new LocalSetupError("configuration_changed", "The browser credential must remain private and owned by this operator.");
+    tokenSchema.parse(await readFile(path, "utf8"));
+}
+export function browserDefaults(token) {
+    tokenSchema.parse(token);
+    return {
+        enabled: true,
+        allowSystemProfileImport: false,
+        defaultProfile: "team",
+        ssrfPolicy: { allowedHostnames: [runtimeRelayHost] },
+        profiles: {
+            team: {
+                cdpUrl: `http://openclaw:${token}@${runtimeRelayHost}:9223`,
+                attachOnly: true,
+            },
+        },
+    };
+}
+export async function initializeBrowserVolume(state, token) {
+    await run("docker", [
+        "run",
+        "--rm",
+        "-i",
+        "--pull",
+        "never",
+        "--network",
+        "none",
+        "--user",
+        "root",
+        "--mount",
+        `type=volume,source=${resourceNames(state).browserVolume},target=/state,volume-nocopy`,
+        "--entrypoint",
+        "node",
+        state.input.runtimeImage,
+        "/app/clawscarf/initialize-browser-main.js",
+    ], {
+        input: JSON.stringify({
+            ownerId: state.ownerId,
+            token: tokenSchema.parse(token),
+        }),
+    });
+}
+/** Readiness observes the authenticated CDP service without opening a page or changing state. */
+export async function verifyBrowserListener(directory, port) {
+    const token = tokenSchema.parse(await readFile(join(directory, "private/browser-token"), "utf8"));
+    const response = await fetch(`http://127.0.0.1:${String(port)}/json/version`, {
+        headers: { Authorization: `Bearer ${token}` },
+        redirect: "error",
+        signal: AbortSignal.timeout(3000),
+    });
+    if (!response.ok) {
+        await response.body?.cancel();
+        throw new LocalSetupError("browser_unavailable", "The shared browser has not become ready.");
+    }
+    z.object({ Browser: z.string().min(1), webSocketDebuggerUrl: z.url() }).parse(await response.json());
+}

package/scripts/deployment/certificates.js

@@ -0,0 +1,76 @@
+import { createPrivateKey, X509Certificate } from "node:crypto";
+import { lstat, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { LocalSetupError, run } from "./process.js";
+import { ensurePrivateFile } from "./state.js";
+const names = [
+    "management-cert.pem",
+    "management-key.pem",
+    "management-ca.pem",
+];
+export async function ensureCertificates(directory) {
+    const present = await Promise.all(names.map(async (name) => {
+        try {
+            const info = await lstat(join(directory, name));
+            if (!info.isFile() || (info.mode & 0o077) !== 0)
+                throw new LocalSetupError("invalid_certificate", "Management TLS files must be private regular files.");
+            return true;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "code" in error &&
+                error.code === "ENOENT")
+                return false;
+            throw error;
+        }
+    }));
+    if (present.some(Boolean)) {
+        if (!present.every(Boolean))
+            throw new LocalSetupError("incomplete_certificate", "Management TLS initialization is incomplete. Inspect the private TLS files; setup will not replace existing keys.");
+        const cert = new X509Certificate(await readFile(join(directory, "management-cert.pem")));
+        const ca = new X509Certificate(await readFile(join(directory, "management-ca.pem")));
+        const key = createPrivateKey(await readFile(join(directory, "management-key.pem")));
+        if (!cert.checkPrivateKey(key) ||
+            !cert.checkHost("host.docker.internal") ||
+            !cert.checkIP("127.0.0.1") ||
+            !cert.raw.equals(ca.raw) ||
+            !cert.ca ||
+            !cert.verify(cert.publicKey) ||
+            Date.parse(cert.validFrom) > Date.now() ||
+            Date.parse(cert.validTo) <= Date.now())
+            throw new LocalSetupError("invalid_certificate", "Management TLS material is invalid or expired; setup will not replace it.");
+        return;
+    }
+    const staging = join(directory, "management-tls");
+    // A retained staging directory makes an interrupted generation explicit.
+    await mkdir(staging, { mode: 0o700 });
+    // An explicit config avoids inheriting host-specific certificate extensions.
+    const requestConfig = join(staging, "request.cnf");
+    await writeFile(requestConfig, "[req]\ndistinguished_name=dn\n[dn]\n");
+    await run("openssl", [
+        "req",
+        "-config",
+        requestConfig,
+        "-x509",
+        "-newkey",
+        "rsa:3072",
+        "-nodes",
+        "-keyout",
+        join(staging, "key.pem"),
+        "-out",
+        join(staging, "cert.pem"),
+        "-days",
+        "365",
+        "-subj",
+        "/CN=ClawScarf local management",
+        "-addext",
+        "subjectAltName=DNS:localhost,DNS:host.docker.internal,IP:127.0.0.1",
+        "-addext",
+        "basicConstraints=critical,CA:TRUE",
+    ]);
+    const certificate = await readFile(join(staging, "cert.pem"));
+    await ensurePrivateFile(join(directory, "management-key.pem"), await readFile(join(staging, "key.pem")));
+    await ensurePrivateFile(join(directory, "management-ca.pem"), certificate);
+    await ensurePrivateFile(join(directory, "management-cert.pem"), certificate);
+    await rm(staging, { recursive: true });
+}

package/scripts/deployment/compose.js

@@ -0,0 +1,191 @@
+import { OperatorError } from "../errors.js";
+import { controllerServices } from "./controller-compose.js";
+import { browserNodeServices, browserNodeVolumes, } from "./browser-node-compose.js";
+import { join } from "node:path";
+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) {
+    const { input, ownerId } = state;
+    const names = resourceNames(state);
+    const privateDirectory = join(directory, "private");
+    const labels = { "clawscarf.installation": ownerId };
+    if (input.browser && (!browserAddress || !browserMachine))
+        throw new OperatorError("The isolated browser address and prepared native node are required.");
+    const constrained = {
+        read_only: true,
+        cap_drop: ["ALL"],
+        security_opt: ["no-new-privileges:true"],
+        init: true,
+        labels,
+    };
+    const configuration = {
+        name: names.project,
+        services: {
+            ...controllerServices(directory, state),
+            ...modelGatewayServices(directory, state),
+            ...(input.browser && browserAddress && browserMachine
+                ? browserNodeServices(state, directory, browserAddress, browserMachine)
+                : {}),
+            ...(input.browser
+                ? {
+                    browser: {
+                        ...constrained,
+                        image: input.browser.image,
+                        user: "1000:1000",
+                        networks: {
+                            browser: { ipv4_address: browserAddress, aliases: ["browser"] },
+                        },
+                        security_opt: [
+                            ...constrained.security_opt,
+                            `seccomp:${join(privateDirectory, "browser-seccomp.json")}`,
+                        ],
+                        environment: {
+                            CLAWSCARF_BROWSER_TOKEN_FILE: "/state/.clawscarf-browser/token",
+                            CLAWSCARF_BROWSER_PROXY_SERVER: "http://browser-egress:3128",
+                        },
+                        volumes: ["browser:/state"],
+                        tmpfs: ["/tmp:rw,nosuid,nodev,size=512m"],
+                        shm_size: "256m",
+                        mem_limit: "1g",
+                        pids_limit: 256,
+                        stop_grace_period: "15s",
+                        depends_on: ["browser-egress"],
+                    },
+                    "browser-egress": {
+                        ...constrained,
+                        image: input.browser.egressImage,
+                        networks: {
+                            default: {},
+                            browser: { aliases: ["browser-egress"] },
+                        },
+                        volumes: [
+                            `${join(privateDirectory, "browser-source.acl")}:/etc/squid/browser-source.acl:ro`,
+                        ],
+                        tmpfs: ["/tmp"],
+                        mem_limit: "128m",
+                        pids_limit: 64,
+                    },
+                }
+                : {}),
+            ...(input.relayImage
+                ? {
+                    "browser-relay": {
+                        ...constrained,
+                        image: input.relayImage,
+                        user: "1000:1000",
+                        networks: {
+                            runtime: {
+                                aliases: ["runtime.clawscarf.internal"],
+                            },
+                            ...(input.browser ? { browser: {} } : {}),
+                        },
+                        volumes: [
+                            `${join(privateDirectory, "browser-relay.cfg")}:/usr/local/etc/haproxy/haproxy.cfg:ro`,
+                        ],
+                        ...(input.browser
+                            ? {
+                                ports: [`127.0.0.1:${String(input.browser.port)}:9223`],
+                                depends_on: ["browser"],
+                            }
+                            : {}),
+                        mem_limit: "64m",
+                        pids_limit: 64,
+                    },
+                }
+                : {}),
+            postgres: {
+                image: postgresImage,
+                environment: {
+                    POSTGRES_DB: "clawscarf",
+                    POSTGRES_USER: "postgres",
+                    POSTGRES_PASSWORD_FILE: "/run/secrets/database_password",
+                },
+                secrets: ["database_password"],
+                volumes: ["database:/var/lib/postgresql/data"],
+                ports: [`127.0.0.1:${String(input.ports.database)}:5432`],
+                healthcheck: {
+                    test: ["CMD-SHELL", "pg_isready -U postgres -d clawscarf"],
+                    interval: "2s",
+                    timeout: "3s",
+                    retries: 30,
+                },
+                labels,
+            },
+            companion: {
+                image: input.companionImage,
+                user: `${String(process.getuid?.() ?? 1000)}:${String(process.getgid?.() ?? 1000)}`,
+                environment: {
+                    NODE_EXTRA_CA_CERTS: "/run/clawscarf/management-ca.pem",
+                    CLAWSCARF_COMPANION_CONFIG: "/run/clawscarf/companion.json",
+                },
+                volumes: [
+                    "access.json",
+                    "companion.json",
+                    "encryption.key",
+                    "management-ca.pem",
+                    "management-cert.pem",
+                    "management-key.pem",
+                    ...(input.connections?.managementKeyFile ? ["connections"] : []),
+                    "oidc-client-secret",
+                    ...(input.team.certificateFile
+                        ? ["application-cert.pem", "application-key.pem"]
+                        : []),
+                ].map((name) => `${join(privateDirectory, name)}:/run/clawscarf/${name}:ro`),
+                ports: [
+                    `${input.team.certificateFile ? "0.0.0.0" : "127.0.0.1"}:${String(input.ports.application)}:18800`,
+                    `127.0.0.1:${String(input.ports.management)}:18801`,
+                    `${input.team.certificateFile ? "0.0.0.0" : "127.0.0.1"}:${String(input.ports.widgets)}:18800`,
+                ],
+                read_only: true,
+                tmpfs: ["/tmp"],
+                cap_drop: ["ALL"],
+                security_opt: ["no-new-privileges:true"],
+                init: true,
+                depends_on: { postgres: { condition: "service_healthy" } },
+                labels,
+            },
+        },
+        secrets: {
+            database_password: {
+                file: join(privateDirectory, "database-admin-password"),
+            },
+        },
+        networks: {
+            ...(input.relayImage
+                ? { runtime: { external: true, name: names.sandbox } }
+                : {}),
+            default: { external: true, name: `${names.project}_default` },
+            ...(input.browser
+                ? {
+                    browser: { external: true, name: `${names.project}_browser` },
+                    machine: { external: true, name: `${names.project}_machine` },
+                }
+                : {}),
+        },
+        volumes: {
+            ...(input.modelGateway
+                ? {
+                    "models-database": {
+                        external: true,
+                        name: `${names.project}-models`,
+                    },
+                }
+                : {}),
+            database: { external: true, name: names.databaseVolume },
+            ...(input.browser
+                ? {
+                    browser: { external: true, name: names.browserVolume },
+                    ...browserNodeVolumes(state),
+                }
+                : {}),
+        },
+    };
+    for (const service of Object.values(configuration.services))
+        Object.assign(service, { restart: "unless-stopped", labels });
+    return configuration;
+}
+export function compose(directory, args, timeout = 120_000) {
+    return run("docker", ["compose", "-f", join(directory, "compose.json"), ...args], { timeout });
+}

package/scripts/deployment/configuration.js

@@ -0,0 +1,275 @@
+import { OperatorError } from "../errors.js";
+import { isAbsolute, join, resolve } from "node:path";
+import { z } from "zod";
+import { initialConfiguration } from "../../runtime/configuration.js";
+import { networkRequirementSchema } from "../packs/policy.js";
+const absolutePath = z
+    .string()
+    .min(1)
+    .refine(isAbsolute, "Use an absolute path.");
+const image = z
+    .string()
+    .regex(/^(?:sha256:[a-f0-9]{64}|[a-zA-Z0-9][a-zA-Z0-9._:/-]*@sha256:[a-f0-9]{64})$/, "Use an exact image ID or image reference with a SHA-256 digest.");
+const port = z.number().int().min(1024).max(65535);
+const cpu = z
+    .string()
+    .regex(/^(?:[1-9]\d*m|(?:[1-9]\d*(?:\.\d+)?|0\.\d*[1-9]\d*))$/, "Use a positive CPU quantity, such as 2 or 500m.");
+const memory = z
+    .string()
+    .regex(/^[1-9]\d*(?:Ki|Mi|Gi|Ti|K|M|G|T)$/, "Use a positive memory quantity, such as 512Mi or 2Gi.");
+const ports = z
+    .strictObject({
+    controller: port,
+    application: z.number().int().min(1).max(65535),
+    widgets: z.number().int().min(1).max(65535),
+    management: port,
+    native: port,
+    nativeWidgets: port,
+    database: port,
+})
+    .refine((value) => new Set(Object.values(value)).size === Object.keys(value).length, "Every local listener needs a distinct port.");
+const applicationOrigin = z.url().refine((value) => {
+    const u = new URL(value);
+    return ((u.protocol === "https:" ||
+        (u.protocol === "http:" &&
+            ["127.0.0.1", "localhost"].includes(u.hostname))) &&
+        u.origin === value &&
+        !u.username &&
+        !u.password);
+}, "Use an exact HTTPS origin, or HTTP on localhost.");
+export const connectionsBrokerUrlSchema = z
+    .string()
+    .min(1)
+    .max(2048)
+    .refine((value) => {
+    let endpoint;
+    try {
+        endpoint = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    return (/^https:\/\//iu.test(value) &&
+        value.trim() === value &&
+        Array.from(value).every((character) => character.charCodeAt(0) > 32 &&
+            character.charCodeAt(0) !== 127 &&
+            character !== "\\") &&
+        endpoint.protocol === "https:" &&
+        !endpoint.username &&
+        !endpoint.password &&
+        !endpoint.search &&
+        !endpoint.hash &&
+        !value.includes("?") &&
+        !value.includes("#") &&
+        networkRequirementSchema.safeParse({
+            host: endpoint.hostname,
+            port: Number(endpoint.port || "443"),
+            protocol: "tcp",
+            binary: "/usr/local/bin/node",
+        }).success);
+}, "Use an HTTPS DNS endpoint without credentials, query or fragment.");
+export const connectionsInputSchema = z.strictObject({
+    mode: z.literal("external"),
+    brokerUrl: connectionsBrokerUrlSchema,
+    managementKeyFile: absolutePath.optional(),
+    caFile: absolutePath.optional(),
+});
+const teamInput = z
+    .strictObject({
+    origin: applicationOrigin,
+    widgetOrigin: applicationOrigin,
+    certificateFile: absolutePath.optional(),
+    keyFile: absolutePath.optional(),
+    issuer: z.url().refine((value) => {
+        const u = new URL(value);
+        return (u.protocol === "https:" &&
+            !u.username &&
+            !u.password &&
+            !u.search &&
+            !u.hash);
+    }, "Use an HTTPS OIDC issuer without credentials, query or fragment."),
+    clientId: z.string().min(1),
+    clientSecretFile: absolutePath,
+    administratorSubject: z.string().min(1).optional(),
+    administratorEmail: z.email().optional(),
+})
+    .refine((value) => Boolean(value.administratorSubject) === Boolean(value.administratorEmail), "Provide both administrator subject and email, or neither for a setup link.")
+    .refine((value) => value.origin !== value.widgetOrigin, "Widgets need a separate origin.")
+    .refine((value) => {
+    const tls = new URL(value.origin).protocol === "https:";
+    return (tls === (new URL(value.widgetOrigin).protocol === "https:") &&
+        (tls
+            ? !!value.certificateFile && !!value.keyFile
+            : !value.certificateFile && !value.keyFile));
+}, "HTTPS requires both TLS files; loopback HTTP must not supply TLS files.");
+export const localInput = z
+    .strictObject({
+    team: teamInput,
+    name: z
+        .string()
+        .max(30)
+        .regex(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/),
+    administratorName: z
+        .string()
+        .min(1)
+        .max(256)
+        .refine((value) => value.trim().length > 0 &&
+        Array.from(value).every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127), "Use a display name without control characters."),
+    runtimeImage: image,
+    companionImage: image,
+    openshellCli: absolutePath,
+    openshellGateway: absolutePath,
+    openshellClientImage: image,
+    ports,
+    models: z
+        .strictObject({
+        configurationFile: absolutePath,
+        runtimeKeyFile: absolutePath,
+        caFile: absolutePath.optional(),
+    })
+        .optional(),
+    connections: connectionsInputSchema.optional(),
+    modelGateway: z
+        .strictObject({
+        configurationFile: absolutePath,
+        upstreamEnvironmentFile: absolutePath,
+        image,
+        port,
+    })
+        .optional(),
+    cpu,
+    memory,
+    relayImage: image.optional(),
+    browser: z
+        .strictObject({
+        image,
+        egressImage: image,
+        nodeImage: image,
+        dnsImage: image,
+        port,
+    })
+        .optional(),
+})
+    .superRefine((value, ctx) => {
+    if (value.modelGateway &&
+        (!value.models ||
+            [...Object.values(value.ports), value.browser?.port].includes(value.modelGateway.port)))
+        ctx.addIssue({
+            code: "custom",
+            message: "The model gateway requires native model configuration and a distinct port.",
+        });
+    if (Boolean(value.relayImage) !== Boolean(value.browser))
+        ctx.addIssue({
+            code: "custom",
+            path: ["relayImage"],
+            message: "Supply the relay image exactly when a browser is configured.",
+        });
+    if (value.browser &&
+        Object.values(value.ports).includes(value.browser.port))
+        ctx.addIssue({
+            code: "custom",
+            path: ["browser", "port"],
+            message: "The browser relay needs a distinct port.",
+        });
+    for (const [key, port] of [
+        ["origin", value.ports.application],
+        ["widgetOrigin", value.ports.widgets],
+    ]) {
+        if (Number(new URL(value.team[key]).port || "443") !== port)
+            ctx.addIssue({
+                code: "custom",
+                path: ["team", key],
+                message: "The public origin must use its configured published port.",
+            });
+    }
+});
+/** Hosted login and custom identity providers both use the same OIDC team profile. */
+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))
+        throw new OperatorError(`The local configuration requires ${name} in its private directory.`);
+    return `/run/clawscarf/${name}`;
+}
+export function generateLocalConfiguration(options) {
+    const input = parseLocalInput(options.input);
+    const directory = resolve(absolutePath.parse(options.directory));
+    const identity = z
+        .string()
+        .refine((value) => value.startsWith("clawscarf:") &&
+        z.uuid().safeParse(value.slice("clawscarf:".length)).success, "Use the local Access service's exact ClawScarf administrator identity.")
+        .parse(options.administratorIdentity);
+    const database = z
+        .url()
+        .refine((value) => ["postgres:", "postgresql:"].includes(new URL(value).protocol), "Use a PostgreSQL connection URL.")
+        .parse(options.runtimeDatabaseUrl);
+    const publicOrigin = input.team.origin;
+    const widgetOrigin = input.team.widgetOrigin;
+    const access = {
+        origin: publicOrigin,
+        host: "0.0.0.0",
+        port: 18800,
+        containerLoopbackPublication: !input.team.certificateFile,
+        databaseUrl: database,
+        encryptionKeyFile: mountedPrivateFile(directory, options.encryptionKeyPath, "encryption.key"),
+        managementTls: {
+            certificateFile: mountedPrivateFile(directory, options.managementCertificatePath, "management-cert.pem"),
+            keyFile: mountedPrivateFile(directory, options.managementKeyPath, "management-key.pem"),
+            host: "0.0.0.0",
+            port: 18801,
+        },
+        runtime: {
+            origin: `http://host.docker.internal:${String(input.ports.native)}`,
+            managementOrigin: managementOrigin(input),
+            widgetOrigin,
+            widgetUpstream: `http://host.docker.internal:${String(input.ports.nativeWidgets)}`,
+        },
+        ...(input.team.certificateFile
+            ? {
+                applicationTls: {
+                    certificateFile: "/run/clawscarf/application-cert.pem",
+                    keyFile: "/run/clawscarf/application-key.pem",
+                },
+            }
+            : {}),
+        identity: {
+            mode: "oidc",
+            issuer: input.team.issuer,
+            clientId: input.team.clientId,
+            clientSecretFile: "/run/clawscarf/oidc-client-secret",
+            administratorSubject: input.team.administratorSubject,
+            administratorEmail: input.team.administratorEmail,
+        },
+    };
+    const native = initialConfiguration({
+        publicOrigin,
+        widgetOrigin,
+        administratorIdentity: identity,
+    });
+    native.gateway.port = input.ports.native;
+    native.mcp.apps.sandboxPort = input.ports.nativeWidgets;
+    return {
+        access,
+        native,
+        companion: companionConfiguration(input),
+    };
+}
+export function companionConfiguration(input) {
+    return {
+        accessConfigurationFile: "/run/clawscarf/access.json",
+        ...(input.connections?.mode === "external" &&
+            input.connections.managementKeyFile
+            ? {
+                cloudConnections: {
+                    url: new URL(input.connections.brokerUrl).origin,
+                    managementKeyFile: "/run/clawscarf/connections/management-key",
+                },
+            }
+            : {}),
+    };
+}