spawnfile 0.1.0 → 0.1.2

package/dist/e2e/dockerAuth.js

@@ -1,212 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { mkdtemp } from "node:fs/promises";
-import { requireAuthProfile } from "../auth/index.js";
-import { buildProject, createDockerRunInvocation, runDockerContainer, syncProjectAuth } from "../compiler/index.js";
-import { removeDirectory } from "../filesystem/index.js";
-import { SpawnfileError } from "../shared/index.js";
-import { materializeDockerAuthFixture } from "./fixtures.js";
-import { waitForRuntimeReady, promptRuntime } from "./runtimePrompts.js";
-import { filterDockerAuthE2EScenarios } from "./scenarios.js";
-const DEFAULT_ENV_FILE = path.resolve(process.cwd(), "../headhunter/.env");
-const createLogger = (logger) => logger ?? {
-    error: (message) => console.error(message),
-    info: (message) => console.log(message)
-};
-const createScenarioImageTag = (scenario) => `spawnfile-e2e-${scenario.id}-${Date.now()}`;
-const createScenarioPrompt = (scenarioId, runtime) => `Reply with exactly SF-E2E-${scenarioId.toUpperCase()}-${runtime.toUpperCase()} and nothing else.`;
-const extractSentinel = (prompt) => prompt.replace("Reply with exactly ", "").replace(" and nothing else.", "");
-const findPromptInstance = (scenario, instances, runtime) => {
-    const runtimeInstances = instances.filter((instance) => instance.runtime === runtime);
-    if (runtimeInstances.length === 0) {
-        return null;
-    }
-    if (scenario.kind === "single-agent") {
-        return runtimeInstances[0] ?? null;
-    }
-    return runtimeInstances[0] ?? null;
-};
-const resolveEnvFilePath = (inputPath) => inputPath ?? DEFAULT_ENV_FILE;
-const withSpawnfileHome = async (spawnfileHome, fn) => {
-    const previousValue = process.env.SPAWNFILE_HOME;
-    process.env.SPAWNFILE_HOME = spawnfileHome;
-    try {
-        return await fn();
-    }
-    finally {
-        if (typeof previousValue === "string") {
-            process.env.SPAWNFILE_HOME = previousValue;
-        }
-        else {
-            delete process.env.SPAWNFILE_HOME;
-        }
-    }
-};
-const runDockerCommand = async (dockerCommand, args) => {
-    const { spawn } = await import("node:child_process");
-    return new Promise((resolve, reject) => {
-        const child = spawn(dockerCommand, args, {
-            stdio: ["ignore", "pipe", "pipe"]
-        });
-        const stdout = [];
-        const stderr = [];
-        child.stdout.on("data", (chunk) => stdout.push(String(chunk)));
-        child.stderr.on("data", (chunk) => stderr.push(String(chunk)));
-        child.once("error", (error) => {
-            reject(new SpawnfileError("runtime_error", `Unable to start docker command ${dockerCommand}: ${error.message}`));
-        });
-        child.once("exit", (code, signal) => {
-            if (code === 0) {
-                resolve(stdout.join("").trim());
-                return;
-            }
-            reject(new SpawnfileError("runtime_error", signal
-                ? `Docker command exited from signal ${signal}: ${dockerCommand} ${args.join(" ")}`
-                : `Docker command failed with exit code ${code ?? "unknown"}: ${dockerCommand} ${args.join(" ")}\n${stderr.join("")}`.trim()));
-        });
-    });
-};
-const cleanupDockerArtifacts = async (dockerCommand, containerName, imageTag, options) => {
-    try {
-        await runDockerCommand(dockerCommand, ["rm", "-f", containerName]);
-    }
-    catch {
-        // Ignore best-effort cleanup failures.
-    }
-    if (options.keepImages) {
-        return;
-    }
-    try {
-        await runDockerCommand(dockerCommand, ["image", "rm", "-f", imageTag]);
-    }
-    catch {
-        // Ignore best-effort cleanup failures.
-    }
-};
-const readDockerLogs = async (dockerCommand, containerName) => {
-    try {
-        return await runDockerCommand(dockerCommand, ["logs", containerName]);
-    }
-    catch {
-        return "";
-    }
-};
-const runScenario = async (scenario, options) => {
-    const startedAt = Date.now();
-    const logger = createLogger(options.logger);
-    const scenarioRoot = await mkdtemp(path.join(os.tmpdir(), `spawnfile-e2e-${scenario.id}-`));
-    const projectDirectory = path.join(scenarioRoot, "project");
-    const outputDirectory = path.join(scenarioRoot, "dist");
-    const spawnfileHome = path.join(scenarioRoot, "spawnfile-home");
-    const profileName = "e2e";
-    const imageTag = createScenarioImageTag(scenario);
-    const containerName = `spawnfile-e2e-${scenario.id}`;
-    logger.info(`scenario ${scenario.id}: materializing fixture`);
-    try {
-        await materializeDockerAuthFixture(scenario, projectDirectory);
-        await withSpawnfileHome(spawnfileHome, async () => {
-            logger.info(`scenario ${scenario.id}: syncing auth`);
-            await syncProjectAuth(projectDirectory, {
-                claudeCodeDirectory: options.claudeCodeDirectory,
-                codexDirectory: options.codexDirectory,
-                envFilePath: resolveEnvFilePath(options.envFilePath),
-                profileName
-            });
-            logger.info(`scenario ${scenario.id}: building image ${imageTag}`);
-            const buildResult = await buildProject(projectDirectory, {
-                dockerCommand: options.dockerCommand,
-                imageTag,
-                outputDirectory
-            });
-            const runtimeInstances = buildResult.report.container?.runtime_instances ?? [];
-            const authProfile = await requireAuthProfile(profileName);
-            const invocation = await createDockerRunInvocation(buildResult, imageTag, {
-                authProfile,
-                containerName,
-                detach: true,
-                dockerCommand: options.dockerCommand
-            });
-            try {
-                logger.info(`scenario ${scenario.id}: starting container ${containerName}`);
-                await runDockerContainer(invocation);
-                for (const check of scenario.promptChecks) {
-                    const prompt = createScenarioPrompt(scenario.id, check.runtime);
-                    const sentinel = extractSentinel(prompt);
-                    const promptInstance = findPromptInstance(scenario, runtimeInstances, check.runtime);
-                    logger.info(`scenario ${scenario.id}: waiting for ${check.runtime}`);
-                    await waitForRuntimeReady(check.runtime);
-                    logger.info(`scenario ${scenario.id}: prompting ${check.runtime}`);
-                    const output = await promptRuntime(check.runtime, {
-                        agentName: check.agentName,
-                        command: options.dockerCommand,
-                        configPath: promptInstance?.config_path,
-                        containerName,
-                        homePath: promptInstance?.home_path ?? undefined,
-                        prompt
-                    });
-                    if (!output.includes(sentinel)) {
-                        throw new SpawnfileError("runtime_error", `Scenario ${scenario.id} did not return sentinel ${sentinel} for ${check.runtime}`);
-                    }
-                }
-            }
-            catch (error) {
-                const logs = await readDockerLogs(options.dockerCommand, containerName);
-                throw new SpawnfileError("runtime_error", `${error instanceof Error ? error.message : String(error)}${logs ? `\n\nDocker logs:\n${logs}` : ""}`);
-            }
-            finally {
-                await cleanupDockerArtifacts(options.dockerCommand, containerName, imageTag, {
-                    keepImages: options.keepImages
-                });
-                await removeDirectory(invocation.supportDirectory);
-            }
-        });
-        if (!options.keepArtifacts) {
-            await removeDirectory(scenarioRoot);
-        }
-        return {
-            durationMs: Date.now() - startedAt,
-            id: scenario.id,
-            success: true
-        };
-    }
-    catch (error) {
-        if (!options.keepArtifacts) {
-            await removeDirectory(scenarioRoot);
-        }
-        return {
-            durationMs: Date.now() - startedAt,
-            errorMessage: error instanceof Error ? error.message : String(error),
-            id: scenario.id,
-            success: false
-        };
-    }
-};
-const formatFailures = (results) => results
-    .filter((result) => !result.success)
-    .map((result) => `- ${result.id}: ${result.errorMessage ?? "unknown error"}`)
-    .join("\n");
-export const runDockerAuthE2E = async (options = {}) => {
-    const logger = createLogger(options.logger);
-    const scenarios = filterDockerAuthE2EScenarios(options);
-    if (scenarios.length === 0) {
-        throw new SpawnfileError("validation_error", "No Docker auth E2E scenarios matched the filter");
-    }
-    const results = [];
-    for (const scenario of scenarios) {
-        const result = await runScenario(scenario, {
-            claudeCodeDirectory: options.claudeCodeDirectory,
-            codexDirectory: options.codexDirectory,
-            dockerCommand: options.dockerCommand ?? "docker",
-            envFilePath: options.envFilePath,
-            keepArtifacts: options.keepArtifacts ?? false,
-            keepImages: options.keepImages ?? false,
-            logger
-        });
-        results.push(result);
-        logger.info(`${result.success ? "PASS" : "FAIL"} ${result.id} (${Math.round(result.durationMs / 1000)}s)`);
-    }
-    if (results.some((result) => !result.success)) {
-        throw new SpawnfileError("runtime_error", `Docker auth E2E failed:\n${formatFailures(results)}`);
-    }
-    return { results };
-};

package/dist/e2e/fixtures.d.ts

@@ -1,2 +0,0 @@
-import type { DockerAuthE2EScenario } from "./types.js";
-export declare const materializeDockerAuthFixture: (scenario: DockerAuthE2EScenario, destinationDirectory: string) => Promise<void>;

package/dist/e2e/fixtures.js

@@ -1,49 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import YAML from "yaml";
-import { copyDirectory, readUtf8File, writeUtf8File } from "../filesystem/index.js";
-const FIXTURES_ROOT = fileURLToPath(new URL("../../fixtures/e2e", import.meta.url));
-const readYamlFile = async (filePath) => YAML.parse(await readUtf8File(filePath));
-const writeYamlFile = async (filePath, value) => {
-    await writeUtf8File(filePath, YAML.stringify(value));
-};
-const applyAgentSpec = (manifest, spec) => ({
-    ...manifest,
-    execution: {
-        ...(manifest.execution ?? {}),
-        model: {
-            ...((manifest.execution?.model ?? {})),
-            auth: {
-                method: spec.authMethod
-            },
-            primary: {
-                name: spec.modelName,
-                provider: spec.provider
-            }
-        }
-    },
-    kind: "agent",
-    name: spec.name,
-    runtime: spec.runtime
-});
-const patchSingleAgentFixture = async (destinationDirectory, scenario) => {
-    const manifestPath = path.join(destinationDirectory, "Spawnfile");
-    const manifest = await readYamlFile(manifestPath);
-    await writeYamlFile(manifestPath, applyAgentSpec(manifest, scenario.agents[0]));
-};
-const patchTeamFixture = async (destinationDirectory, scenario) => {
-    for (const agent of scenario.agents) {
-        const manifestPath = path.join(destinationDirectory, "agents", agent.directoryName, "Spawnfile");
-        const manifest = await readYamlFile(manifestPath);
-        await writeYamlFile(manifestPath, applyAgentSpec(manifest, agent));
-    }
-};
-export const materializeDockerAuthFixture = async (scenario, destinationDirectory) => {
-    const sourceDirectory = path.join(FIXTURES_ROOT, scenario.fixture);
-    await copyDirectory(sourceDirectory, destinationDirectory);
-    if (scenario.fixture === "agent") {
-        await patchSingleAgentFixture(destinationDirectory, scenario);
-        return;
-    }
-    await patchTeamFixture(destinationDirectory, scenario);
-};

package/dist/e2e/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./dockerAuth.js";
-export * from "./fixtures.js";
-export * from "./scenarios.js";
-export * from "./types.js";

package/dist/e2e/index.js

@@ -1,4 +0,0 @@
-export * from "./dockerAuth.js";
-export * from "./fixtures.js";
-export * from "./scenarios.js";
-export * from "./types.js";

package/dist/e2e/runtimePrompts.d.ts

@@ -1,13 +0,0 @@
-import type { E2ERuntime } from "./types.js";
-interface RuntimePromptOptions {
-    agentName?: string;
-    command?: string;
-    configPath?: string;
-    containerName: string;
-    homePath?: string;
-    prompt: string;
-    timeoutMs?: number;
-}
-export declare const waitForRuntimeReady: (runtime: E2ERuntime, timeoutMs?: number) => Promise<void>;
-export declare const promptRuntime: (runtime: E2ERuntime, options: RuntimePromptOptions) => Promise<string>;
-export {};

package/dist/e2e/runtimePrompts.js

@@ -1,132 +0,0 @@
-import { spawn } from "node:child_process";
-import { SpawnfileError } from "../shared/index.js";
-const wait = async (delayMs) => new Promise((resolve) => {
-    setTimeout(resolve, delayMs);
-});
-const runCommand = async (command, args, timeoutMs = 180_000) => new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-        stdio: ["ignore", "pipe", "pipe"]
-    });
-    const stdout = [];
-    const stderr = [];
-    const timer = setTimeout(() => {
-        child.kill("SIGTERM");
-        reject(new SpawnfileError("runtime_error", `Command timed out after ${timeoutMs}ms: ${command} ${args.join(" ")}`));
-    }, timeoutMs);
-    child.stdout.on("data", (chunk) => {
-        stdout.push(String(chunk));
-    });
-    child.stderr.on("data", (chunk) => {
-        stderr.push(String(chunk));
-    });
-    child.once("error", (error) => {
-        clearTimeout(timer);
-        reject(new SpawnfileError("runtime_error", `Unable to start command ${command}: ${error.message}`));
-    });
-    child.once("exit", (code, signal) => {
-        clearTimeout(timer);
-        if (code === 0) {
-            resolve({
-                stderr: stderr.join(""),
-                stdout: stdout.join("")
-            });
-            return;
-        }
-        reject(new SpawnfileError("runtime_error", signal
-            ? `Command exited from signal ${signal}: ${command} ${args.join(" ")}`
-            : `Command failed with exit code ${code ?? "unknown"}: ${command} ${args.join(" ")}\n${stderr.join("")}`.trim()));
-    });
-});
-const fetchText = async (url) => {
-    const response = await fetch(url);
-    return {
-        body: await response.text(),
-        status: response.status
-    };
-};
-const getHealthUrl = (runtime) => runtime === "openclaw"
-    ? "http://127.0.0.1:18789/healthz"
-    : runtime === "picoclaw"
-        ? "http://127.0.0.1:18790/health"
-        : "http://127.0.0.1:3777/api/agents";
-export const waitForRuntimeReady = async (runtime, timeoutMs = 120_000) => {
-    const startedAt = Date.now();
-    const url = getHealthUrl(runtime);
-    while (Date.now() - startedAt <= timeoutMs) {
-        try {
-            const response = await fetch(url);
-            if (response.ok) {
-                return;
-            }
-        }
-        catch {
-            // Ignore readiness races and keep polling.
-        }
-        await wait(2_000);
-    }
-    throw new SpawnfileError("runtime_error", `Runtime ${runtime} did not become ready within ${timeoutMs}ms (${url})`);
-};
-const promptOpenClaw = async (options) => {
-    const result = await runCommand(options.command ?? "docker", [
-        "exec",
-        "-u",
-        "0",
-        ...(options.homePath ? ["-e", `OPENCLAW_HOME=${options.homePath}`] : []),
-        ...(options.configPath ? ["-e", `OPENCLAW_CONFIG_PATH=${options.configPath}`] : []),
-        options.containerName,
-        "openclaw",
-        "agent",
-        "--local",
-        "--agent",
-        "main",
-        "--message",
-        options.prompt,
-        "--json"
-    ], options.timeoutMs);
-    return `${result.stdout}\n${result.stderr}`;
-};
-const promptPicoClaw = async (options) => {
-    const result = await runCommand(options.command ?? "docker", [
-        "exec",
-        ...(options.homePath ? ["-e", `HOME=${options.homePath}`, "-e", `PICOCLAW_HOME=${options.homePath}`] : []),
-        ...(options.configPath ? ["-e", `PICOCLAW_CONFIG=${options.configPath}`] : []),
-        options.containerName,
-        "picoclaw",
-        "agent",
-        "-m",
-        options.prompt
-    ], options.timeoutMs);
-    return `${result.stdout}\n${result.stderr}`;
-};
-const promptTinyClaw = async (options) => {
-    const enqueueResponse = await fetch("http://127.0.0.1:3777/api/message", {
-        body: JSON.stringify({
-            ...(options.agentName ? { agent: options.agentName } : {}),
-            channel: "spawnfile-e2e",
-            message: options.prompt,
-            sender: "spawnfile-e2e"
-        }),
-        headers: {
-            "Content-Type": "application/json"
-        },
-        method: "POST"
-    });
-    if (!enqueueResponse.ok) {
-        throw new SpawnfileError("runtime_error", `TinyClaw enqueue failed with status ${enqueueResponse.status}`);
-    }
-    const startedAt = Date.now();
-    const timeoutMs = options.timeoutMs ?? 180_000;
-    while (Date.now() - startedAt <= timeoutMs) {
-        const { body, status } = await fetchText("http://127.0.0.1:3777/api/responses?limit=20");
-        if (status === 200 && body.includes(options.prompt.replace("Reply with exactly ", "").replace(" and nothing else.", ""))) {
-            return body;
-        }
-        await wait(2_000);
-    }
-    throw new SpawnfileError("runtime_error", `TinyClaw did not return a response within ${timeoutMs}ms`);
-};
-export const promptRuntime = async (runtime, options) => runtime === "openclaw"
-    ? promptOpenClaw(options)
-    : runtime === "picoclaw"
-        ? promptPicoClaw(options)
-        : promptTinyClaw(options);

package/dist/e2e/scenarios.d.ts

@@ -1,3 +0,0 @@
-import type { DockerAuthE2EFilters, DockerAuthE2EScenario } from "./types.js";
-export declare const listDockerAuthE2EScenarios: () => DockerAuthE2EScenario[];
-export declare const filterDockerAuthE2EScenarios: (filters?: DockerAuthE2EFilters) => DockerAuthE2EScenario[];

package/dist/e2e/scenarios.js

@@ -1,84 +0,0 @@
-const createSingleAgentScenario = (runtime, provider, modelName, authMethod) => {
-    const id = `${runtime}-${authMethod}`;
-    const agent = {
-        authMethod,
-        directoryName: runtime,
-        modelName,
-        name: `${runtime}-assistant`,
-        provider,
-        runtime
-    };
-    return {
-        agents: [agent],
-        description: `${runtime} single-agent Docker auth smoke using ${authMethod}`,
-        fixture: "agent",
-        id,
-        kind: "single-agent",
-        promptChecks: [{ runtime }]
-    };
-};
-const SINGLE_AGENT_SCENARIOS = [
-    createSingleAgentScenario("openclaw", "openai", "gpt-5", "api_key"),
-    createSingleAgentScenario("openclaw", "openai", "gpt-5", "codex"),
-    createSingleAgentScenario("openclaw", "anthropic", "claude-sonnet-4-5", "claude-code"),
-    createSingleAgentScenario("picoclaw", "openai", "gpt-5", "api_key"),
-    createSingleAgentScenario("picoclaw", "openai", "gpt-5", "codex"),
-    createSingleAgentScenario("picoclaw", "anthropic", "claude-sonnet-4-5", "claude-code"),
-    createSingleAgentScenario("tinyclaw", "openai", "gpt-5", "codex"),
-    createSingleAgentScenario("tinyclaw", "anthropic", "claude-sonnet-4-5", "claude-code")
-];
-const TEAM_SCENARIOS = [
-    {
-        agents: [
-            {
-                authMethod: "codex",
-                directoryName: "openclaw",
-                modelName: "gpt-5",
-                name: "openclaw",
-                provider: "openai",
-                runtime: "openclaw"
-            },
-            {
-                authMethod: "api_key",
-                directoryName: "picoclaw",
-                modelName: "gpt-5",
-                name: "picoclaw",
-                provider: "openai",
-                runtime: "picoclaw"
-            },
-            {
-                authMethod: "codex",
-                directoryName: "tinyclaw",
-                modelName: "gpt-5",
-                name: "tinyclaw",
-                provider: "openai",
-                runtime: "tinyclaw"
-            }
-        ],
-        description: "multi-runtime Docker auth smoke team",
-        fixture: "team",
-        id: "team-multi-runtime",
-        kind: "team",
-        promptChecks: [
-            { runtime: "openclaw" },
-            { runtime: "picoclaw" },
-            { agentName: "tinyclaw", runtime: "tinyclaw" }
-        ]
-    }
-];
-export const listDockerAuthE2EScenarios = () => [
-    ...SINGLE_AGENT_SCENARIOS,
-    ...TEAM_SCENARIOS
-];
-const includesScenarioId = (filters, scenario) => !filters.scenarioIds ||
-    filters.scenarioIds.length === 0 ||
-    filters.scenarioIds.includes(scenario.id);
-const includesAuthMethod = (filters, scenario) => !filters.authMethods ||
-    filters.authMethods.length === 0 ||
-    scenario.agents.some((agent) => filters.authMethods.includes(agent.authMethod));
-const includesRuntime = (filters, scenario) => !filters.runtimes ||
-    filters.runtimes.length === 0 ||
-    scenario.agents.some((agent) => filters.runtimes.includes(agent.runtime));
-export const filterDockerAuthE2EScenarios = (filters = {}) => listDockerAuthE2EScenarios().filter((scenario) => includesScenarioId(filters, scenario) &&
-    includesAuthMethod(filters, scenario) &&
-    includesRuntime(filters, scenario));

package/dist/e2e/types.d.ts

@@ -1,35 +0,0 @@
-import type { ModelAuthMethod } from "../shared/index.js";
-export type E2ERuntime = "openclaw" | "picoclaw" | "tinyclaw";
-export type E2EFixtureKind = "agent" | "team";
-export type E2EScenarioKind = "single-agent" | "team";
-export interface E2EAgentSpec {
-    authMethod: ModelAuthMethod;
-    directoryName: string;
-    modelName: string;
-    name: string;
-    provider: string;
-    runtime: E2ERuntime;
-}
-export interface E2EPromptCheck {
-    agentName?: string;
-    runtime: E2ERuntime;
-}
-export interface DockerAuthE2EScenario {
-    agents: E2EAgentSpec[];
-    description: string;
-    fixture: E2EFixtureKind;
-    id: string;
-    kind: E2EScenarioKind;
-    promptChecks: E2EPromptCheck[];
-}
-export interface DockerAuthE2EFilters {
-    authMethods?: ModelAuthMethod[];
-    runtimes?: E2ERuntime[];
-    scenarioIds?: string[];
-}
-export interface DockerAuthE2EScenarioResult {
-    durationMs: number;
-    errorMessage?: string;
-    id: string;
-    success: boolean;
-}

package/dist/entrypoint.sh

@@ -1,71 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-require_env() {
-  local name="$1"
-  if [ -z "${!name:-}" ]; then
-    echo "Missing required env: $name" >&2
-    exit 1
-  fi
-}
-
-require_file() {
-  local target="$1"
-  if [ ! -f "$target" ]; then
-    echo "Missing required file: $target" >&2
-    exit 1
-  fi
-}
-
-write_env_file() {
-  local name="$1"
-  local target="$2"
-  if [ -z "${!name:-}" ]; then
-    return
-  fi
-  mkdir -p "$(dirname "$target")"
-  printf %s "${!name:-}" > "$target"
-}
-
-apply_json_env_value() {
-  local target="$1"
-  local name="$2"
-  local json_path="$3"
-  if [ -z "${!name:-}" ]; then
-    return
-  fi
-  python3 - "$target" "$name" "$json_path" <<'PY'
-import json
-import os
-import sys
-
-target_path = sys.argv[1]
-env_name = sys.argv[2]
-json_path = sys.argv[3].split('.')
-value = os.environ.get(env_name)
-if value is None:
-    raise SystemExit(0)
-
-with open(target_path, encoding='utf-8') as handle:
-    data = json.load(handle)
-
-cursor = data
-for part in json_path[:-1]:
-    child = cursor.get(part)
-    if not isinstance(child, dict):
-        child = {}
-        cursor[part] = child
-    cursor = child
-
-cursor[json_path[-1]] = value
-
-with open(target_path, 'w', encoding='utf-8') as handle:
-    json.dump(data, handle, indent=2)
-    handle.write('\n')
-PY
-}
-
-mkdir -p '/var/lib/spawnfile/instances/picoclaw/agent-assistant/picoclaw/workspace'
-require_file '/var/lib/spawnfile/instances/picoclaw/agent-assistant/picoclaw/config.json'
-write_env_file 'ANTHROPIC_API_KEY' '/var/lib/spawnfile/instances/picoclaw/agent-assistant/picoclaw/secrets/ANTHROPIC_API_KEY'
-HOME='/var/lib/spawnfile/instances/picoclaw/agent-assistant/picoclaw' PICOCLAW_HOME='/var/lib/spawnfile/instances/picoclaw/agent-assistant/picoclaw' PICOCLAW_CONFIG='/var/lib/spawnfile/instances/picoclaw/agent-assistant/picoclaw/config.json' PICOCLAW_GATEWAY_PORT='18790' PICOCLAW_GATEWAY_HOST='0.0.0.0' exec 'picoclaw' 'gateway' '--allow-empty'

package/dist/runtimes/picoclaw/agents/assistant/config.json

@@ -1,16 +0,0 @@
-{
-  "agents": {
-    "defaults": {
-      "workspace": "<workspace-path>",
-      "restrict_to_workspace": true,
-      "model_name": "claude-sonnet-4.6"
-    }
-  },
-  "model_list": [
-    {
-      "api_key": "file://secrets/ANTHROPIC_API_KEY",
-      "model_name": "claude-sonnet-4.6",
-      "model": "anthropic/claude-sonnet-4.6"
-    }
-  ]
-}

package/dist/runtimes/picoclaw/agents/assistant/workspace/AGENTS.md

@@ -1 +0,0 @@
-You are a concise assistant. Reply with exactly the requested token and nothing else.