@clawscarf/cli 0.1.0-alpha.1

package/recipes/README.md

@@ -0,0 +1,37 @@
+# Recipes
+
+Recipes are bundled with the CLI. Each folder contains a [recipe.json](team-server/recipe.json), validated by
+[the recipe schema](../scripts/installation/recipes/definition.ts).
+
+```text
+recipes/team-server/recipe.json
+runtime/releases/0.1.0-dev.json
+packs/research-team/pack.json
+```
+
+Each recipe has an ID and a version. Accepted installations retain that provenance
+alongside their actual settings; a CLI update never reapplies new defaults. Bump the
+recipe version when its defaults, pack selections or runtime pin change.
+
+A recipe's `runtime` points to an exact runtime definition, relative to the recipe
+file. Runtime images and tools are fixed; its other fields are defaults that users
+can change in the settings menu or through CLI flags. Recipes cannot disable
+OpenShell protection or authenticated entry, admission and revocation. They contain
+no executable hooks, secrets or user identities.
+
+- `models` selects model ID, provider and reasoning from the bundled
+  [model catalog](../deploy/models/catalog.json).
+- `defaults` selects resources, browser and Connections enablement.
+- `packs: [{ id, members }]` selects agents from the bundled [packs](../packs/README.md).
+  The installer checks members and collects required credentials after settings review.
+
+`clawscarf configure` lists the bundled recipes. `--recipe team-server` skips that
+menu; `--recipe /path/to/recipe.json` uses a custom definition. Both use the same
+validation and editable settings. `clawscarf recipes` lists available choices.
+Recipe changes never reconfigure an existing server automatically.
+
+**Team server:** GPT-6 Astra through OpenAI, medium reasoning,
+hosted login, Connections enabled, browser off, and no packs selected. It supplies
+a basic team server, not a document ingestion or question-answering workflow. A future document recipe remains separate in [TODO.md](../TODO.md).
+
+See [runtime and package distribution](../release/README.md).

package/recipes/team-server/recipe.json

@@ -0,0 +1,28 @@
+{
+  "id": "team-server",
+  "version": "0.1.0",
+  "runtime": "../../runtime/releases/0.1.0-alpha.1.json",
+  "name": "Team server",
+  "description": "A protected OpenClaw server for your team, with hosted login, managed models and optional Connections.",
+  "maturity": "supported",
+  "defaults": {
+    "resources": {
+      "runtime": {
+        "cpu": "4",
+        "memory": "4Gi"
+      }
+    },
+    "browser": {
+      "enabled": false
+    },
+    "connections": {
+      "enabled": true
+    }
+  },
+  "models": {
+    "model": "gpt-6-astra",
+    "provider": "openai",
+    "reasoning": "medium"
+  },
+  "packs": []
+}

package/release/README.md

@@ -0,0 +1,137 @@
+# Runtime releases, recipes and packs
+
+These have separate responsibilities:
+
+| Definition      | Owns                                                                                             | Location                                               |
+| --------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------------------------ |
+| Runtime release | Exact software images, OpenShell executables, checksums and supported platforms                  | [runtime/releases](../runtime/releases/0.1.0-dev.json) |
+| Recipe          | A fixed runtime reference plus editable model, reasoning, resource, capability and pack defaults | [recipes](../recipes/README.md)                        |
+| Pack            | Native agent, skill and workflow files with declared prerequisites                               | [packs](../packs/README.md)                            |
+
+Several recipes can use the same runtime. A runtime contains no recipes, model
+catalog or pack selections. Changing a recipe does not require rebuilding its runtime.
+Recipes and packs ship with the CLI; there is no separate registry or dependency resolver.
+The [model catalog](../deploy/models/catalog.json) is also a CLI asset. Recipe IDs select
+catalog entries; model protocols and limits have one definition.
+
+## Current development use
+
+```sh
+clawscarf configure
+# Or use staging for hosted login and Connections:
+clawscarf configure --cloud-url https://cloud-staging.clawscarf.com
+```
+
+No recipe argument opens the bundled recipe menu. `--recipe team-server` selects
+that bundled definition; `--recipe /path/to/recipe.json` reads a custom one. Its
+`runtime` path resolves relative to the recipe file. The runtime cannot be changed
+in the settings menu. `--directory` defaults to `~/clawscarf-team`.
+
+The tracked [development runtime](../runtime/releases/0.1.0-dev.json) currently names
+locally built Docker image IDs and checksum-pinned OpenShell tools under ignored
+`runtime/tools/0.0.116/`. It works on the prepared development machine; it is **not a
+published, clean-machine release**. Definitions belong in the tracked directories
+above. Compiled images, binaries and test artifacts are not source definitions.
+
+The current platform is macOS arm64 with Docker Desktop. Setup validates the host,
+tools and ports; it pulls registry images by digest and downloads missing runtime tools
+when their definition supplies an HTTPS URL and SHA-256. It cannot recover a missing
+local development image ID. See the
+[installation guide](../deploy/deployment/installation.md) for diagnostics.
+
+## Publishing structure
+
+Release candidates contain:
+
+- npm `@clawscarf/cli`: compiled CLI, recipes, pack files, model catalog and runtime
+  definitions. No Docker images or large OpenShell executables in npm.
+- GitHub Releases: versioned runtime tool archives, checksums and required notices.
+- GHCR: runtime/companion images referenced by immutable registry digest.
+
+Installing a newer CLI supplies newer recipes. Each recipe still selects an exact
+runtime; startup never resolves “latest.” Existing installations retain their
+accepted settings and runtime. Explicit configuration changes preserve unrelated
+native edits. The CLI package version and a runtime version need not be the same.
+
+New installations copy their runtime definition and tools into their own `runtime/`
+directory and retain selected pack files under `state/pack-sources/`. Removing the
+checkout, an npm cache entry or an older CLI package does not remove those files.
+Downloads are bounded, checked before becoming executable inputs, and reused on
+subsequent configuration. Corrupt retained tools fail verification rather than being
+silently replaced. Docker verifies image digests. No start command resolves latest.
+
+## Build and publish
+
+[Build release candidate](../.github/workflows/build-release.yml) is manually dispatched
+with an exact version, such as `0.1.0-alpha.1`. It:
+
+1. Runs checks and tests the compiled operator outside the checkout on macOS arm64.
+2. Builds the pinned OpenClaw source and ClawScarf images on Linux arm64, checks
+   runtime capabilities and the Chromium sandbox, and pushes candidate images to GHCR.
+3. Downloads checksum-pinned OpenShell tools, records the image digests, and assembles
+   the runtime archive, individual executable assets, npm CLI, checksums and notices.
+4. Installs the resulting npm archive into a temporary prefix and checks its CLI/catalog.
+
+The [image builder](../scripts/release/build-images.sh) and
+[candidate assembler](../scripts/release/candidate.ts) contain the build commands;
+Actions supplies runners and registry credentials. The source recipe pins the development
+runtime. Packaging resolves that same runtime to the candidate's immutable definition;
+it does not make recipes select latest. The first release uses the same CLI/runtime
+version. Recipe versions remain independent; bump them when defaults, pack selection
+or the selected runtime changes. Published definitions must not be overwritten.
+
+The `release-candidate` Actions artifact is the reviewable output. Download it and test
+a fresh supported installation, administrator login, real inference and stop/start
+before publication. GitHub's macOS runner does not provide our Docker Desktop journey;
+its packaging checks alone do not establish that journey. The browser-selection bug
+remains a separate, explicit limit; the Team server recipe leaves browser disabled.
+
+[Publish release candidate](../.github/workflows/publish-release.yml) accepts a successful
+build run from `main`. It checks the source commit and artifact checksums, creates the
+GitHub Release and publishes the already-built npm tarball. It never rebuilds images
+or packages. Prereleases use npm's `next` tag; stable versions use `latest`. Repeating
+a GitHub upload is allowed only when the existing checksums match exactly.
+
+Repository setup before first publication:
+
+- GHCR image packages must be publicly readable; a private candidate digest is not
+  usable by an unauthenticated installer. The build uses GitHub's scoped job token.
+- Configure the GitHub `release` environment and npm trusted publishing for
+  `@clawscarf/cli`, repository `clawscarf/clawscarf`, workflow [publish-release.yml](../.github/workflows/publish-release.yml),
+  environment `release`. npm ownership/initial package setup is separate from code.
+- Check transitive notices/source obligations before distributing the first images.
+  Debian copyright files remain in the images; runtime assets include upstream notices
+  and the image build exports its network-tool sources. Those files are not a claim of
+  a completed license audit. Pinned Debian packages still depend on mirror retention.
+
+No npm/GitHub release has been published by adding these workflows. The first Actions
+run, clean-machine journey, registry access and publication remain in [TODO.md](../TODO.md).
+
+## Assemble runtime artifacts
+
+For release development, the existing builder copies already-built tools into a
+movable directory:
+
+```sh
+clawscarf release-create --input /absolute/built-components.json \
+  --output /absolute/runtime-bundle
+```
+
+The input follows the [runtime schema](../scripts/release/definition.ts), except
+`tools.openshell.cli` and `gateway` are source executable paths. Relative inputs
+resolve beside that input file. The result is:
+
+```text
+runtime-bundle/
+  clawscarf-release.json
+  LICENSE
+  THIRD_PARTY_NOTICES.md
+  tools/openshell
+  tools/openshell-gateway
+```
+
+The builder checks executable files, computes their checksums, refuses overwriting
+an existing output directory and removes incomplete output on failure. It does not
+build images, copy recipes/packs or publish artifacts. A custom recipe can point to
+the resulting runtime definition. The [component pins](components.json) record
+upstream sources; [operator packaging](operator.md) describes the CLI archive.

package/release/components.json

@@ -0,0 +1,29 @@
+{
+  "openclaw": {
+    "version": "2026.9.4",
+    "sourceRevision": "7bc487d39dc9e059bb9b19ea08152883022f83fe",
+    "image": "clawscarf-openclaw:7bc487d39dc9e059bb9b19ea08152883022f83fe"
+  },
+  "openshell": {
+    "version": "0.0.116",
+    "sourceRevision": "d1155aa70042d3e2ee49dbfa15346b108b7c1d92",
+    "supervisorImage": "ghcr.io/nvidia/openshell/supervisor:0.0.116@sha256:c8c42aef16c200063e32cbf72e553e4ead027085427b555efafd95063ecead42",
+    "cli": {
+      "darwin-arm64": {
+        "url": "https://github.com/NVIDIA/OpenShell/releases/download/v0.0.116/openshell-aarch64-apple-darwin.tar.gz",
+        "sha256": "e582f2374053bebac8e6aaeb4a369931b7d4bb97bd55055e2c02e85502627e22"
+      }
+    },
+    "gateway": {
+      "darwin-arm64": {
+        "url": "https://github.com/NVIDIA/OpenShell/releases/download/v0.0.116/openshell-gateway-aarch64-apple-darwin.tar.gz",
+        "sha256": "f192d3d737c125264e13ef73458541df2ca6a9eb2fa599736a7f2587d5d2ce8d"
+      }
+    },
+    "gatewayImage": "ghcr.io/nvidia/openshell/gateway:0.0.116@sha256:05cf77bbb022a739aed6f22daa0e7e164415f4ab273b5f84319e46d91eb8f645"
+  },
+  "companionNode": {
+    "version": "24.19.0",
+    "image": "node@sha256:4196d66a565c6f195728d9952f161f4adfe2ad753052a08b7ec7f1c5a6bda42b"
+  }
+}

package/release/operator.md

@@ -0,0 +1,63 @@
+# ClawScarf operator
+
+The operator archive contains the compiled configuration/lifecycle CLI and its controller, model and pack
+operators. It runs outside the contributor checkout. It is not the complete
+distribution: runtime/companion images and the pinned OpenShell executables are
+separate inputs. The archive includes recipes, packs, the model catalog and runtime definitions.
+The interactive menu lists those recipes; each fixes its runtime. For a published runtime it downloads missing OpenShell tools by checksum and pulls
+registry images by digest. Local development image IDs cannot be downloaded. The npm
+package is named `@clawscarf/cli` and exposes the `clawscarf` command. Development archives
+remain private; the release candidate builder makes the package publishable. [Release contents](README.md) defines the publication model.
+
+## Run the archive
+
+Verify the archive against its accompanying `SHA256SUMS`, then extract it into a new
+directory. Use Node 24.16 or later in the Node 24 line, or Node 26.1 or later, and
+pnpm 10.33.0. In the extracted `package` directory:
+
+```sh
+pnpm install --prod --frozen-lockfile --ignore-scripts
+node scripts/clawscarf.js --help
+node scripts/clawscarf.js configure --directory /absolute/new-team
+node scripts/clawscarf.js configure --help
+node scripts/clawscarf.js people --help
+node scripts/clawscarf.js connections --help
+```
+
+Dependencies are installed from the included frozen lockfile. Its root importer
+contains only the production dependencies referenced by the staged operator;
+publisher and browser dependencies are omitted. Locked transitive versions are retained.
+No TypeScript compiler, contributor source or build step is needed to run the commands.
+The current local assembly supports macOS arm64 with Docker Desktop only.
+
+The installer reviews recipe settings before credentials, prepares the installation,
+and offers **Start now**. It starts Docker services and protected OpenShell containers, then exits; closing
+the terminal leaves them running. Administrator setup supplies a private sign-in link and waits for successful
+browser setup, with replacement links offered on expiry. The same public
+operations use `configure` for new or existing installations, with `--non-interactive`
+for automation. `start`, `stop`, `status` and `logs` operate the selected `--directory`.
+Validation and preview/apply are internal. See the source installation guide for
+supported retained changes and administrator setup.
+
+Recipes select runtime definitions relative to their own files. New installations
+retain the runtime and selected packs outside the package. The development descriptor
+still uses local image IDs and tools prepared separately; that development archive alone
+cannot install on a clean machine. Published candidates instead contain registry digests
+and checksummed tool download URLs. Custom recipes can point to a separately prepared
+runtime bundle. Team server supplies a basic team server, not a document workflow.
+
+Keep installation data outside this extracted package. Stop retains state; replacing
+an operator archive is not a runtime upgrade or backup. Docker services keep running after
+terminal exit; Docker must remain available. No host service is installed.
+The pack operator additionally needs the pinned Python environment from
+`scripts/packs/requirements.txt`. Models require an external LiteLLM gateway or the unified configuration’s pinned local
+LiteLLM service. This archive contains no model/provider credentials. Unified preparation
+can issue initial scoped model and Connections credentials for fresh installations;
+normal start never rotates or reactivates them. Use `configure` for capability changes;
+`connections` manages application accounts and grants.
+
+The source checkout owns full local setup, model and pack qualification instructions.
+[Third-party notices](../THIRD_PARTY_NOTICES.md) are retained verbatim; their relative source references refer
+to the source checkout, not additional runtime payload in this archive. Installed
+dependencies retain their own notices. Full binary-release license qualification
+remains separate from this operator packaging check.

package/runtime/configuration.js

@@ -0,0 +1,135 @@
+import { z } from "zod";
+const origin = z.url().refine((value) => {
+    const url = new URL(value);
+    return (url.origin === value &&
+        !url.username &&
+        !url.password &&
+        (url.protocol === "https:" ||
+            (url.protocol === "http:" &&
+                ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))));
+}, "Use HTTPS, or HTTP on loopback, without a path.");
+export const configurationInput = z
+    .strictObject({
+    publicOrigin: origin,
+    widgetOrigin: origin,
+    standaloneNavigation: z.boolean().default(true),
+    administratorIdentity: z
+        .string()
+        .min(1)
+        .max(512)
+        .refine((value) => value.trim() === value &&
+        [...value].every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127), "Use the exact trusted-ingress identity without whitespace or control characters."),
+})
+    .refine((value) => value.publicOrigin !== value.widgetOrigin, {
+    message: "Widgets require a separate origin.",
+    path: ["widgetOrigin"],
+});
+export function initialConfiguration(input) {
+    const settings = configurationInput.parse(input);
+    const identity = settings.administratorIdentity;
+    return {
+        gateway: {
+            publicOrigin: settings.publicOrigin,
+            mode: "local",
+            bind: "loopback",
+            port: 18789,
+            terminal: { enabled: false },
+            trustedProxies: ["127.0.0.1"],
+            controlUi: {
+                allowedOrigins: [settings.publicOrigin],
+                communityInvite: false,
+                experimental: { customPlugins: settings.standaloneNavigation },
+            },
+            auth: {
+                mode: "trusted-proxy",
+                trustedProxy: {
+                    userHeader: "x-openclaw-user",
+                    requiredHeaders: ["x-forwarded-proto", "x-forwarded-host"],
+                    allowUsers: [identity],
+                    allowLoopback: true,
+                    deviceAutoApprove: { enabled: true, scopes: ["operator.read"] },
+                },
+                identityScopes: { [identity]: ["operator.admin"] },
+            },
+            roles: {
+                default: "admin",
+                definitions: {
+                    admin: {
+                        agents: "*",
+                        scopes: ["operator.admin"],
+                        sessions: { others: "write" },
+                    },
+                    member: {
+                        agents: "*",
+                        scopes: ["operator.read", "operator.write", "operator.talk"],
+                        sessions: { others: "none" },
+                        sandbox: "inherit",
+                    },
+                },
+            },
+        },
+        agents: {
+            defaults: {
+                workspace: "/home/node/.openclaw/workspace",
+                sandbox: { mode: "off" },
+            },
+        },
+        plugins: {
+            load: {
+                paths: [
+                    "/app/clawscarf/connections",
+                    "/app/clawscarf/native-plugins/node_modules/@openclaw/lobster",
+                    ...(settings.standaloneNavigation ? ["/app/clawscarf/access"] : []),
+                ],
+            },
+            entries: {
+                "clawscarf-connections": { enabled: false },
+                "clawscarf-access": { enabled: settings.standaloneNavigation },
+                lobster: { enabled: true },
+                codex: {
+                    enabled: true,
+                    config: {
+                        sessionCatalog: { enabled: false },
+                        appServer: {
+                            networkProxy: {
+                                enabled: true,
+                                baseProfile: "workspace",
+                                mode: "full",
+                            },
+                        },
+                        codexDynamicToolsExclude: [
+                            "gateway_exec",
+                            "gateway_process",
+                            "gateway",
+                            "nodes",
+                            "computer",
+                            "mobile_ui",
+                            "terminal",
+                        ],
+                    },
+                },
+                anthropic: { config: { sessionCatalog: { enabled: false } } },
+            },
+        },
+        mcp: {
+            apps: {
+                enabled: true,
+                sandboxPort: 18790,
+                sandboxOrigin: settings.widgetOrigin,
+            },
+        },
+        tools: {
+            alsoAllow: ["lobster"],
+            exec: { host: "gateway", mode: "auto" },
+            sessions: { visibility: "self" },
+            elevated: { enabled: false },
+        },
+        browser: {
+            headless: true,
+            noSandbox: false,
+            executablePath: "/usr/bin/chromium",
+        },
+        models: { catalogRefresh: { enabled: false } },
+        discovery: { mdns: { mode: "off" } },
+    };
+}

package/runtime/connections-configuration.js

@@ -0,0 +1,70 @@
+import { X509Certificate } from "node:crypto";
+import { z } from "zod";
+const maximumBytes = 1024 * 1024;
+const brokerUrl = z
+    .url()
+    .max(2048)
+    .refine((value) => {
+    const url = new URL(value);
+    return (url.protocol === "https:" &&
+        !url.username &&
+        !url.password &&
+        !url.search &&
+        !url.hash);
+});
+const credentialSchema = z.strictObject({
+    token: z
+        .string()
+        .min(1)
+        .max(512)
+        .regex(/^[\x21-\x7e]+$/u),
+    ca: z
+        .string()
+        .min(1)
+        .max(maximumBytes)
+        .refine((value) => {
+        try {
+            new X509Certificate(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    })
+        .optional(),
+});
+export const connectionsConfigurationInputSchema = z
+    .strictObject({
+    kind: z.enum(["configure", "observe", "disable"]),
+    ownerId: z.uuid(),
+    serverId: z.uuid(),
+    brokerUrl,
+    enable: z.boolean().optional(),
+    credential: credentialSchema.optional(),
+})
+    .refine((value) => value.kind !== "configure" || value.credential !== undefined, "Configuration requires a scoped credential.");
+export const nativeConnectionsConfigurationResultSchema = z.discriminatedUnion("state", [
+    z.strictObject({ state: z.literal("not_installed") }),
+    z.strictObject({
+        state: z.literal("unconfigured"),
+        enabled: z.boolean(),
+        expectedPackage: z.boolean(),
+    }),
+    z.strictObject({
+        state: z.literal("configured"),
+        enabled: z.boolean(),
+        brokerUrl,
+        configHash: z.string().min(1).max(256),
+    }),
+]);
+export const connectionsConfigurationResultSchema = z.discriminatedUnion("state", [
+    nativeConnectionsConfigurationResultSchema.options[0].extend({
+        credentialMatches: z.boolean().optional(),
+    }),
+    nativeConnectionsConfigurationResultSchema.options[1].extend({
+        credentialMatches: z.boolean().optional(),
+    }),
+    nativeConnectionsConfigurationResultSchema.options[2].extend({
+        credentialMatches: z.boolean().optional(),
+    }),
+]);

package/runtime/model-contract.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+const assignmentSchema = z.discriminatedUnion("path", [
+    z.strictObject({
+        path: z.literal("secrets.providers.clawscarf-models"),
+        value: z.strictObject({
+            source: z.literal("env"),
+            allowlist: z.tuple([z.literal("CLAWSCARF_MODEL_TOKEN")]),
+        }),
+    }),
+    z.strictObject({
+        path: z.literal("models.providers.clawscarf"),
+        value: z.strictObject({
+            baseUrl: z.url(),
+            api: z.literal("openai-completions"),
+            agentRuntime: z.strictObject({ id: z.literal("openclaw") }),
+            apiKey: z.strictObject({
+                source: z.literal("env"),
+                provider: z.literal("clawscarf-models"),
+                id: z.literal("CLAWSCARF_MODEL_TOKEN"),
+            }),
+            models: z
+                .array(z.strictObject({
+                id: z.string().min(1),
+                name: z.string().min(1),
+                api: z.enum(["openai-completions", "openai-responses"]).optional(),
+                input: z.array(z.enum(["text", "image"])).min(1),
+                reasoning: z.boolean(),
+                contextWindow: z.number().int().positive(),
+                maxTokens: z.number().int().positive(),
+                compat: z.strictObject({
+                    supportsTools: z.boolean(),
+                    supportsUsageInStreaming: z.literal(true),
+                    supportsStrictMode: z.literal(true),
+                }),
+            }))
+                .min(1)
+                .max(512),
+        }),
+    }),
+    z.strictObject({
+        path: z.literal("agents.defaults.model.primary"),
+        value: z.string().startsWith("clawscarf/").min(11),
+    }),
+    z.strictObject({
+        path: z.literal("agents.defaults.thinkingDefault"),
+        value: z.enum(["low", "medium", "high"]),
+    }),
+]);
+export const modelInputSchema = z
+    .strictObject({
+    assignments: z.array(assignmentSchema).min(2).max(4),
+    token: z.string().trim().min(1).max(65536),
+    ca: z.string().min(1).max(262144).nullable(),
+    apply: z.boolean(),
+})
+    .superRefine(({ assignments }, context) => {
+    const paths = new Set(assignments.map((assignment) => assignment.path));
+    if (paths.size !== assignments.length ||
+        !paths.has("models.providers.clawscarf") ||
+        !paths.has("secrets.providers.clawscarf-models"))
+        context.addIssue({
+            code: "custom",
+            message: "Require unique paths and both provider assignments.",
+        });
+});
+export const modelFailureCodeSchema = z.enum([
+    "invalid_input",
+    "invalid_state",
+    "unavailable",
+    "validation_rejected",
+    "outcome_unknown",
+]);
+export class ModelConfigurationError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ModelConfigurationError";
+    }
+}
+export const modelStateSchema = z.enum([
+    "configured",
+    "configured_restart_required",
+    "validated",
+]);
+export const modelResultSchema = z.discriminatedUnion("ok", [
+    z.strictObject({
+        ok: z.literal(true),
+        state: modelStateSchema,
+    }),
+    z.strictObject({ ok: z.literal(false), error: modelFailureCodeSchema }),
+]);

package/runtime/releases/0.1.0-alpha.1.json

@@ -0,0 +1,37 @@
+{
+  "schemaVersion": 1,
+  "version": "0.1.0-alpha.1",
+  "sourceRevision": "a53e95251321e61d8ffd6d06a6984f651c0b0db4",
+  "platforms": [
+    "darwin-arm64"
+  ],
+  "images": {
+    "postgres": "postgres@sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193",
+    "gateway": "ghcr.io/clawscarf/clawscarf/runtime@sha256:eaa25c8e487970176b95de657df8bf4faff605f9f265ca760197800d9a1e5fcf",
+    "companion": "ghcr.io/clawscarf/clawscarf/companion@sha256:97cfeb78ab56ba625b30aafe2249633d9b69f7f3c75de7116453385010e6281f",
+    "openshellClient": "ghcr.io/clawscarf/clawscarf/openshell-client@sha256:669f37f654926fc7714783cc8b1b76bae9666895c2a4da959580037d281ebf56",
+    "relay": "ghcr.io/clawscarf/clawscarf/browser-relay@sha256:5ee13e9496e3b76e076e91c59a861a10ad7a31a13b145384fba314d7f0b686b5",
+    "models": "ghcr.io/berriai/litellm:v1.100.1@sha256:a3715fa7ad8387941ab697259bd2881d68931657247a41984f90fae6d11c62bf",
+    "browser": {
+      "chromium": "ghcr.io/clawscarf/clawscarf/browser@sha256:28ca9e4007d3b7c1bb9cb8f4bbaf275d1bc36ee2744079326b151b1f9eec78fd",
+      "node": "ghcr.io/clawscarf/clawscarf/browser-node@sha256:2837d8b75df69fb39c7f7ca8fa68249d9de6e20d4e028213792de5f8f9ef1bd7",
+      "dns": "ghcr.io/clawscarf/clawscarf/browser-dns@sha256:9f14cb85df522014c2bfc068e2b5788568f26b6e8d948cebe1250aff7630847b",
+      "egress": "ghcr.io/clawscarf/clawscarf/browser-egress@sha256:bd819dffa4e1f60fbeed3b459a26b3b274300a4e5836bb90cbd080f6681d594c"
+    }
+  },
+  "tools": {
+    "openshell": {
+      "version": "0.0.116",
+      "cli": {
+        "file": "tools/openshell",
+        "sha256": "0baeeffe0e4c184b08fde910ac9e8815fb0b8cfb808e49c0e634d7db65fb03bb",
+        "url": "https://github.com/clawscarf/clawscarf/releases/download/v0.1.0-alpha.1/openshell-darwin-arm64"
+      },
+      "gateway": {
+        "file": "tools/openshell-gateway",
+        "sha256": "298706259ef18350f334c222e981e91583558511d50bce22727c689d261203e6",
+        "url": "https://github.com/clawscarf/clawscarf/releases/download/v0.1.0-alpha.1/openshell-gateway-darwin-arm64"
+      }
+    }
+  }
+}