spawnfile 0.1.0

package/dist/e2e/dockerAuth.js

@@ -0,0 +1,212 @@
+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

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

package/dist/e2e/fixtures.js

@@ -0,0 +1,49 @@
+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

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

package/dist/e2e/index.js

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

package/dist/e2e/runtimePrompts.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,132 @@
+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

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

package/dist/e2e/scenarios.js

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,35 @@
+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/e2e/types.js

@@ -0,0 +1 @@
+export {};

package/dist/entrypoint.sh

@@ -0,0 +1,71 @@
+#!/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/filesystem/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./io.js";
+export * from "./paths.js";

package/dist/filesystem/index.js

@@ -0,0 +1,2 @@
+export * from "./io.js";
+export * from "./paths.js";

package/dist/filesystem/io.d.ts

@@ -0,0 +1,11 @@
+export interface CopyDirectoryOptions {
+    filter?: (sourcePath: string, destinationPath: string) => boolean;
+}
+export declare const copyDirectory: (sourcePath: string, destinationPath: string, options?: CopyDirectoryOptions) => Promise<void>;
+export declare const ensureDirectory: (directoryPath: string) => Promise<void>;
+export declare const fileExists: (filePath: string) => Promise<boolean>;
+export declare const isSymlink: (filePath: string) => Promise<boolean>;
+export declare const readUtf8File: (filePath: string) => Promise<string>;
+export declare const ensureGitignoreEntry: (directoryPath: string, entry: string) => Promise<boolean>;
+export declare const removeDirectory: (directoryPath: string) => Promise<void>;
+export declare const writeUtf8File: (filePath: string, content: string) => Promise<void>;