@clawscarf/cli 0.1.0-alpha.1

package/deploy/execution/browser-node/configuration.js

@@ -0,0 +1,85 @@
+import { isDeepStrictEqual } from "node:util";
+/** The node's policy is operator-owned; only its fixed CDP destination varies. */
+export function browserNodeConfiguration(cdpUrl) {
+    const url = new URL(cdpUrl);
+    if (!["http:", "https:"].includes(url.protocol) ||
+        !url.hostname ||
+        url.username !== "openclaw" ||
+        decodeURIComponent(url.password).length < 32 ||
+        url.hash ||
+        url.search ||
+        (url.pathname !== "/" && url.pathname !== "")) {
+        throw new Error("Browser node requires an authenticated HTTP CDP origin");
+    }
+    return {
+        tools: { exec: { mode: "deny" } },
+        plugins: { allow: ["browser"], entries: { browser: { enabled: true } } },
+        nodeHost: {
+            workerRuns: { enabled: false },
+            agentRuns: { claude: { enabled: false } },
+            skills: { enabled: false },
+            browserProxy: { enabled: true, allowProfiles: ["team"] },
+        },
+        desktop: { host: { enabled: false } },
+        browser: {
+            enabled: true,
+            defaultProfile: "team",
+            profiles: { team: { cdpUrl, attachOnly: true } },
+            ssrfPolicy: { allowedHostnames: [url.hostname] },
+        },
+    };
+}
+export function validateBrowserNodeConfiguration(value) {
+    function object(input) {
+        if (!input || typeof input !== "object" || Array.isArray(input)) {
+            throw new Error("Invalid browser node configuration");
+        }
+        return Object.fromEntries(Object.entries(input));
+    }
+    const root = object(value);
+    const profiles = object(object(root.browser).profiles);
+    const cdpUrl = object(profiles.team).cdpUrl;
+    if (typeof cdpUrl !== "string" ||
+        !isDeepStrictEqual(value, browserNodeConfiguration(cdpUrl))) {
+        throw new Error("Browser node configuration must retain its fixed policy");
+    }
+}
+export function nodeArguments(input) {
+    const url = new URL(input.gatewayUrl);
+    if (!["ws:", "wss:"].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        !input.displayName.trim() ||
+        (url.protocol === "ws:" && !input.allowPrivatePlaintext)) {
+        throw new Error("Browser node requires an explicit secure Gateway endpoint");
+    }
+    if (input.tlsFingerprint &&
+        !/^(?:[a-f\d]{2}:?){32}$/i.test(input.tlsFingerprint)) {
+        throw new Error("Invalid Gateway certificate fingerprint");
+    }
+    if (input.tlsFingerprint && url.protocol !== "wss:") {
+        throw new Error("Gateway certificate pin requires TLS");
+    }
+    return [
+        process.execPath,
+        "/app/openclaw.mjs",
+        "node",
+        "run",
+        "--host",
+        url.hostname,
+        "--port",
+        url.port || (url.protocol === "wss:" ? "443" : "80"),
+        "--context-path",
+        url.pathname,
+        url.protocol === "wss:" ? "--tls" : "--no-tls",
+        "--display-name",
+        input.displayName,
+        "--no-share-installed-apps",
+        ...(input.tlsFingerprint
+            ? ["--tls-fingerprint", input.tlsFingerprint]
+            : []),
+        ...(input.pairingCode ? ["--pair", input.pairingCode] : []),
+    ];
+}

package/deploy/execution/browser-node/operator.js

@@ -0,0 +1,167 @@
+import fs from "node:fs";
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+const owner = z.uuid();
+const inputSchema = z.discriminatedUnion("command", [
+    z.strictObject({
+        command: z.literal("initialize"),
+        ownerId: owner,
+        configuration: z.record(z.string(), z.unknown()),
+    }),
+    z.strictObject({ command: z.literal("issue"), gatewayUrl: z.url() }),
+    z.strictObject({
+        command: z.literal("observe"),
+        name: z.string(),
+        nodeId: z.string().optional(),
+    }),
+    z.strictObject({
+        command: z.literal("write-code"),
+        ownerId: owner,
+        setupCode: z.string().min(1),
+    }),
+    z.strictObject({ command: z.literal("remove-code"), ownerId: owner }),
+]);
+const paired = z.object({
+    deviceId: z.string(),
+    displayName: z.string().optional(),
+    roles: z.array(z.string()).optional(),
+    scopes: z.array(z.string()).optional(),
+    tokens: z
+        .object({
+        node: z.object({ revokedAtMs: z.number().optional() }).optional(),
+    })
+        .optional(),
+    nodeSurface: z
+        .object({
+        displayName: z.string().optional(),
+        commands: z.array(z.string()).optional(),
+        lastConnectedAtMs: z.number().optional(),
+        lastDisconnectedAtMs: z.number().optional(),
+    })
+        .optional(),
+});
+function owned(path, ownerId) {
+    const marker = path + "/.clawscarf-owner";
+    const stat = fs.lstatSync(marker);
+    if (!stat.isFile() ||
+        stat.nlink !== 1 ||
+        fs.readFileSync(marker, "utf8") !== ownerId)
+        throw new Error("Volume ownership differs");
+}
+async function sdkCall(name, args) {
+    const specifier = "openclaw/plugin-sdk/device-bootstrap";
+    const loaded = await import(specifier);
+    const sdk = z.record(z.string(), z.unknown()).parse(loaded);
+    const method = sdk[name];
+    if (typeof method !== "function")
+        throw new Error("Native SDK unavailable");
+    const result = await Reflect.apply(method, undefined, args);
+    return result;
+}
+/** Operator-only helper; its stdout is private transport, never diagnostic output. */
+async function main() {
+    let text = "";
+    for await (const chunk of process.stdin) {
+        text += String(chunk);
+        if (text.length > 131072)
+            throw new Error("Input too large");
+    }
+    const input = inputSchema.parse(JSON.parse(text));
+    if (input.command === "issue") {
+        const issued = z
+            .object({ token: z.string(), expiresAtMs: z.number() })
+            .parse(await sdkCall("issueDeviceBootstrapToken", [
+            {
+                baseDir: "/home/node/.openclaw",
+                profile: { roles: ["node"], scopes: [] },
+            },
+        ]));
+        return {
+            setupCode: encodeBrowserSetupCode(input.gatewayUrl, issued),
+        };
+    }
+    if (input.command === "observe") {
+        const result = z
+            .object({ paired: z.array(paired) })
+            .parse(await sdkCall("listDevicePairing", ["/home/node/.openclaw"]));
+        return result.paired
+            .filter((value) => input.nodeId
+            ? value.deviceId === input.nodeId
+            : (value.nodeSurface?.displayName ?? value.displayName) ===
+                input.name)
+            .map((value) => ({
+            nodeId: value.deviceId,
+            admitted: value.roles?.length === 1 &&
+                value.roles[0] === "node" &&
+                !value.scopes?.length &&
+                value.tokens?.node !== undefined &&
+                value.tokens.node.revokedAtMs === undefined &&
+                value.nodeSurface?.commands?.includes("browser.proxy") === true,
+            connectedAt: value.nodeSurface?.lastConnectedAtMs ?? null,
+            disconnectedAt: value.nodeSurface?.lastDisconnectedAtMs ?? null,
+        }));
+    }
+    if (input.command === "initialize") {
+        for (const path of ["/state", "/configuration"]) {
+            const marker = path + "/.clawscarf-owner";
+            if (fs.existsSync(marker))
+                owned(path, input.ownerId);
+            else {
+                if (fs.readdirSync(path).length)
+                    throw new Error("Unowned data");
+                fs.writeFileSync(marker, input.ownerId, { flag: "wx", mode: 0o444 });
+                fs.chownSync(path, 1000, 1000);
+                fs.chmodSync(path, 0o700);
+            }
+        }
+        const path = "/configuration/openclaw.json";
+        if (fs.existsSync(path)) {
+            const stat = fs.lstatSync(path);
+            if (!stat.isFile() ||
+                stat.nlink !== 1 ||
+                !isDeepStrictEqual(JSON.parse(fs.readFileSync(path, "utf8")), input.configuration))
+                throw new Error("Configuration differs");
+        }
+        else {
+            fs.writeFileSync(path, JSON.stringify(input.configuration), {
+                flag: "wx",
+                mode: 0o600,
+            });
+            fs.chownSync(path, 1000, 1000);
+        }
+        return { ok: true };
+    }
+    owned("/configuration", input.ownerId);
+    const path = "/configuration/pairing-code";
+    if (input.command === "write-code") {
+        fs.writeFileSync(path, input.setupCode, { flag: "wx", mode: 0o600 });
+        fs.chownSync(path, 1000, 1000);
+    }
+    else
+        fs.rmSync(path, { force: true });
+    return { ok: true };
+}
+export async function runBrowserOperator() {
+    try {
+        process.stdout.write(JSON.stringify(await main()));
+    }
+    catch {
+        process.stderr.write("Browser operator helper failed; private inputs omitted.\n");
+        process.exitCode = 1;
+    }
+}
+export function encodeBrowserSetupCode(gatewayUrl, issued) {
+    const url = new URL(gatewayUrl);
+    if (url.protocol !== "wss:" ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        url.pathname !== "/")
+        throw new Error("A private TLS Gateway origin is required");
+    return Buffer.from(JSON.stringify({
+        url: url.origin,
+        bootstrapToken: issued.token,
+        expiresAtMs: issued.expiresAtMs,
+    })).toString("base64url");
+}

package/deploy/execution/network/node-ingress.cfg

@@ -0,0 +1,35 @@
+global
+  maxconn 64
+  nbthread 1
+
+defaults
+  mode http
+  timeout connect 5s
+  timeout http-request 10s
+  timeout http-keep-alive 5s
+  timeout client 30s
+  timeout server 30s
+  timeout tunnel 0
+
+resolvers docker
+  nameserver dns 127.0.0.11:53
+  resolve_retries 3
+  timeout resolve 1s
+  timeout retry 1s
+  hold valid 10s
+
+frontend native_node
+  bind "${CLAWSCARF_NODE_INGRESS_ADDRESS}:18803" ssl crt /run/clawscarf/node-ingress.pem
+  http-request deny deny_status 404 unless { method GET } { path / } { hdr(Upgrade) -i websocket }
+  http-request deny deny_status 403 if { req.hdr(Origin) -m found }
+  http-request del-header x-openclaw- -m beg
+  http-request del-header x-forwarded- -m beg
+  http-request del-header forwarded
+  http-request del-header x-real-ip
+  http-request del-header remote-user
+  http-request del-header authorization
+  http-request del-header cookie
+  default_backend native_gateway
+
+backend native_gateway
+  server gateway "host.docker.internal:${CLAWSCARF_NODE_GATEWAY_PORT}" resolvers docker init-addr libc,none

package/deploy/models/catalog.json

@@ -0,0 +1,275 @@
+[
+  {
+    "provider": "OpenAI",
+    "model": {
+      "id": "gpt-6-astra",
+      "name": "OpenAI: GPT-6 Astra",
+      "enabled": true,
+      "contextWindow": 1050000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openai/gpt-6-astra",
+        "apiKeyEnv": "OPENAI_API_KEY"
+      },
+      "api": "openai-responses"
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenAI",
+    "model": {
+      "id": "gpt-5.6-terra",
+      "name": "OpenAI: GPT-5.6 Terra",
+      "enabled": true,
+      "contextWindow": 1050000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openai/gpt-5.6-terra",
+        "apiKeyEnv": "OPENAI_API_KEY"
+      },
+      "api": "openai-responses"
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenAI",
+    "model": {
+      "id": "gpt-5.6-luna",
+      "name": "OpenAI: GPT-5.6 Luna",
+      "enabled": true,
+      "contextWindow": 1050000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openai/gpt-5.6-luna",
+        "apiKeyEnv": "OPENAI_API_KEY"
+      },
+      "api": "openai-responses"
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "Anthropic",
+    "model": {
+      "id": "claude-fable-5.1",
+      "name": "Anthropic: Claude Fable 5.1",
+      "enabled": true,
+      "contextWindow": 1000000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "anthropic/claude-fable-5.1",
+        "apiKeyEnv": "ANTHROPIC_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "Anthropic",
+    "model": {
+      "id": "claude-opus-5",
+      "name": "Claude Opus 5",
+      "enabled": true,
+      "contextWindow": 1000000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "anthropic/claude-opus-5",
+        "apiKeyEnv": "ANTHROPIC_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "Anthropic",
+    "model": {
+      "id": "claude-sonnet-5",
+      "name": "Anthropic: Claude Sonnet 5",
+      "enabled": true,
+      "contextWindow": 1000000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "anthropic/claude-sonnet-5",
+        "apiKeyEnv": "ANTHROPIC_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "Google AI Studio",
+    "model": {
+      "id": "gemini-3.8-flash",
+      "name": "Google: Gemini 3.8 Flash",
+      "enabled": true,
+      "contextWindow": 1048576,
+      "maxTokens": 65536,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "gemini/gemini-3.8-flash",
+        "apiKeyEnv": "GEMINI_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenRouter",
+    "model": {
+      "id": "gpt-6-astra",
+      "name": "OpenAI: GPT-6 Astra",
+      "enabled": true,
+      "contextWindow": 1050000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openrouter/openai/gpt-6-astra",
+        "apiKeyEnv": "OPENROUTER_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenRouter",
+    "model": {
+      "id": "gpt-5.6-terra",
+      "name": "OpenAI: GPT-5.6 Terra",
+      "enabled": true,
+      "contextWindow": 1050000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openrouter/openai/gpt-5.6-terra",
+        "apiKeyEnv": "OPENROUTER_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenRouter",
+    "model": {
+      "id": "gpt-5.6-luna",
+      "name": "OpenAI: GPT-5.6 Luna",
+      "enabled": true,
+      "contextWindow": 1050000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openrouter/openai/gpt-5.6-luna",
+        "apiKeyEnv": "OPENROUTER_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenRouter",
+    "model": {
+      "id": "claude-fable-5.1",
+      "name": "Anthropic: Claude Fable 5.1",
+      "enabled": true,
+      "contextWindow": 1000000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openrouter/anthropic/claude-fable-5.1",
+        "apiKeyEnv": "OPENROUTER_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenRouter",
+    "model": {
+      "id": "claude-opus-5",
+      "name": "Claude Opus 5",
+      "enabled": true,
+      "contextWindow": 1000000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openrouter/anthropic/claude-opus-5",
+        "apiKeyEnv": "OPENROUTER_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenRouter",
+    "model": {
+      "id": "claude-sonnet-5",
+      "name": "Anthropic: Claude Sonnet 5",
+      "enabled": true,
+      "contextWindow": 1000000,
+      "maxTokens": 128000,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openrouter/anthropic/claude-sonnet-5",
+        "apiKeyEnv": "OPENROUTER_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenRouter",
+    "model": {
+      "id": "gemini-3.8-flash",
+      "name": "Google: Gemini 3.8 Flash",
+      "enabled": true,
+      "contextWindow": 1048576,
+      "maxTokens": 65536,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openrouter/google/gemini-3.8-flash",
+        "apiKeyEnv": "OPENROUTER_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "medium", "high"]
+  },
+  {
+    "provider": "OpenRouter",
+    "model": {
+      "id": "kimi-k3",
+      "name": "MoonshotAI: Kimi K3",
+      "enabled": true,
+      "contextWindow": 1048576,
+      "maxTokens": 943718,
+      "reasoning": true,
+      "tools": true,
+      "input": ["text"],
+      "route": {
+        "model": "openrouter/moonshotai/kimi-k3",
+        "apiKeyEnv": "OPENROUTER_API_KEY"
+      }
+    },
+    "reasoningLevels": ["low", "high"]
+  }
+]

package/deploy/openshell/policy.yaml

@@ -0,0 +1,24 @@
+version: 1
+filesystem_policy:
+  include_workdir: true
+  read_only:
+    - /app
+    - /usr
+    - /lib
+    - /etc
+    - /proc
+    - /sys/fs/cgroup
+    - /sys/devices/system/cpu
+    - /dev/urandom
+    - /dev/random
+  read_write:
+    - /home/node
+    - /tmp
+    - /dev/null
+    - /dev/shm
+landlock:
+  compatibility: hard_requirement
+process:
+  run_as_user: "1000"
+  run_as_group: "1000"
+network_policies: {}

package/generated/http/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Hey API
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/generated/http/client/client.gen.d.ts

@@ -0,0 +1,2 @@
+import type { Client, Config } from './types.gen.js';
+export declare const createClient: (config?: Config) => Client;