spawnfile 0.1.11 → 0.1.13

package/dist/runtime/install.js

@@ -9,6 +9,27 @@ const convertRemoteToHttps = (remote) => {
     return remote.replace(/^git\+/, "");
 };
 const installHints = new Map([
+    [
+        "daimon",
+        {
+            container_image: {
+                ecosystem: "node",
+                installHint: "Copy a pinned Daimon runtime image."
+            },
+            github_release_archive: {
+                ecosystem: "node",
+                installHint: "Download a pinned Daimon runtime release archive."
+            },
+            npm: {
+                ecosystem: "node",
+                installHint: "Install the pinned Daimon package and Pi SDK dependencies inside the generated runtime app."
+            },
+            source_repo: {
+                ecosystem: "node",
+                installHint: "Checkout the pinned Daimon repo ref and install from the repository root."
+            }
+        }
+    ],
     [
         "openclaw",
         {
@@ -20,10 +41,6 @@ const installHints = new Map([
                 ecosystem: "node",
                 installHint: "Download the pinned OpenClaw artifact archive from the release."
             },
-            github_release_bundle: {
-                ecosystem: "node",
-                installHint: "Download the pinned OpenClaw bundle artifact from the release."
-            },
             npm: {
                 ecosystem: "node",
                 installHint: "Install the pinned OpenClaw package version from npm."
@@ -45,10 +62,6 @@ const installHints = new Map([
                 ecosystem: "go",
                 installHint: "Download the pinned PicoClaw release archive for the target platform."
             },
-            github_release_bundle: {
-                ecosystem: "node",
-                installHint: "Download the pinned PicoClaw bundle artifact from the release."
-            },
             npm: {
                 ecosystem: "node",
                 installHint: "Install the pinned PicoClaw package version from npm."
@@ -60,27 +73,23 @@ const installHints = new Map([
         }
     ],
     [
-        "tinyclaw",
+        "pi",
         {
             container_image: {
                 ecosystem: "node",
-                installHint: "Copy the pinned TinyClaw runtime files from the official container image."
+                installHint: "Copy a pinned Pi harness runtime image."
             },
             github_release_archive: {
-                ecosystem: "go",
-                installHint: "Download the pinned TinyClaw release archive for the target platform."
-            },
-            github_release_bundle: {
                 ecosystem: "node",
-                installHint: "Download the pinned TinyClaw bundle artifact from the release."
+                installHint: "Download a pinned Pi harness release archive."
             },
             npm: {
                 ecosystem: "node",
-                installHint: "Install the pinned TinyClaw package version from npm."
+                installHint: "Install pinned Pi SDK dependencies inside the generated runtime app."
             },
             source_repo: {
                 ecosystem: "node",
-                installHint: "Checkout the pinned repo ref and run the TinyAGI install flow from the repository root."
+                installHint: "Checkout the pinned Pi repo ref and install from the repository root."
             }
         }
     ]
@@ -94,7 +103,7 @@ export const resolveRuntimeInstallSelection = async (runtimeName) => {
     switch (runtime.install?.kind) {
         case "container_image":
             return {
-                ecosystem: "node",
+                ecosystem: installProfile.container_image.ecosystem,
                 image: runtime.install.image,
                 installHint: installProfile.container_image.installHint,
                 kind: "container_image",
@@ -127,18 +136,6 @@ export const resolveRuntimeInstallSelection = async (runtimeName) => {
                 tag: runtime.install.tag,
                 versionedAssets: runtime.install.assets
             };
-        case "github_release_bundle":
-            return {
-                ecosystem: "node",
-                installHint: installProfile.github_release_bundle.installHint,
-                asset: runtime.install.asset,
-                kind: "github_release_bundle",
-                repository: runtime.install.repository,
-                runtimeName: runtime.name,
-                runtimeRef: runtime.ref,
-                selectionSource: "runtime_registry_install",
-                tag: runtime.install.tag
-            };
         case "source_repo":
         case undefined:
             return {

package/dist/runtime/openclaw/adapter.js

@@ -1,10 +1,12 @@
 import { listEffectiveExecutionModelTargets } from "../../compiler/modelEnv.js";
 import { createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles } from "../common.js";
 import { SpawnfileError } from "../../shared/index.js";
+import { applyOpenClawImportAuthConfig, resolveOpenClawImportAuthModes } from "./configAuth.js";
 import { prepareOpenClawRuntimeAuth } from "./runAuth.js";
 import { createOpenClawAgentScaffold } from "./scaffold.js";
 import { assertSupportedOpenClawSurfaces, buildOpenClawChannelConfig, buildOpenClawSurfaceEnvBindings } from "./surfaces.js";
 import { buildOpenClawMoltnetConfig, buildOpenClawMoltnetEnvBindings, validateOpenClawMoltnetRuntimeOptions } from "./moltnet.js";
+import { openClawStatusProbes } from "./statusProbes.js";
 const buildEnvSecretRef = (envName) => ({
     id: envName,
     provider: "default",
@@ -86,7 +88,10 @@ const buildOpenClawConfig = (node) => {
     if (moltnet) {
         config.moltnet = moltnet;
     }
-    return `${JSON.stringify(config, null, 2)}\n`;
+    // Bake the import-auth (claude-code/codex) OAuth structure at compile time so
+    // the image is self-sufficient; only the credential tokens are injected later.
+    const authBaked = applyOpenClawImportAuthConfig(config, resolveOpenClawImportAuthModes(node));
+    return `${JSON.stringify(authBaked, null, 2)}\n`;
 };
 const createOpenClawStateFiles = () => [
     {
@@ -107,6 +112,7 @@ const createContainerTargets = async (inputs) => inputs.map((input) => {
             ? [
                 {
                     envName: "OPENCLAW_HOOKS_TOKEN",
+                    generated: true,
                     jsonPath: "hooks.token"
                 }
             ]
@@ -153,6 +159,7 @@ export const openClawAdapter = {
         env: [
             {
                 description: "Gateway auth token required for non-loopback OpenClaw access",
+                generated: true,
                 name: "OPENCLAW_GATEWAY_TOKEN",
                 required: true
             }
@@ -217,6 +224,7 @@ export const openClawAdapter = {
     name: "openclaw",
     prepareRuntimeAuth: prepareOpenClawRuntimeAuth,
     scaffoldAgentProject: createOpenClawAgentScaffold,
+    statusProbes: openClawStatusProbes,
     validateRuntimeOptions(options) {
         const diagnostics = validateOpenClawMoltnetRuntimeOptions(options).map((message) => createDiagnostic("error", message));
         if ("profile" in options && typeof options.profile !== "string") {

package/dist/runtime/openclaw/configAuth.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+export interface OpenClawImportAuthModes {
+    useClaudeCode: boolean;
+    useCodex: boolean;
+}
+/** Determines which import-based auth modes an agent's models declare. */
+export declare const resolveOpenClawImportAuthModes: (node: ResolvedAgentNode) => OpenClawImportAuthModes;
+export declare const normalizeOpenClawCodexModel: (model: string) => string;
+/**
+ * Applies the import-auth structure (OAuth profiles, provider order, and the
+ * Codex model rename) to an OpenClaw config. This is deterministic from the
+ * declared auth methods, so it is baked into the image at compile time. Only
+ * the OAuth credential tokens are injected at run time.
+ */
+export declare const applyOpenClawImportAuthConfig: (config: Record<string, unknown>, modes: OpenClawImportAuthModes) => Record<string, unknown>;

package/dist/runtime/openclaw/configAuth.js

@@ -0,0 +1,46 @@
+import { listEffectiveExecutionModelTargets } from "../../compiler/modelEnv.js";
+/** Determines which import-based auth modes an agent's models declare. */
+export const resolveOpenClawImportAuthModes = (node) => {
+    const targets = listEffectiveExecutionModelTargets(node.execution);
+    return {
+        useClaudeCode: targets.some((target) => target.provider === "anthropic" && target.auth.method === "claude-code"),
+        useCodex: targets.some((target) => target.provider === "openai" && target.auth.method === "codex")
+    };
+};
+export const normalizeOpenClawCodexModel = (model) => {
+    const modelName = model.slice("openai/".length);
+    return modelName === "gpt-5" ? "gpt-5.4" : modelName;
+};
+/**
+ * Applies the import-auth structure (OAuth profiles, provider order, and the
+ * Codex model rename) to an OpenClaw config. This is deterministic from the
+ * declared auth methods, so it is baked into the image at compile time. Only
+ * the OAuth credential tokens are injected at run time.
+ */
+export const applyOpenClawImportAuthConfig = (config, modes) => {
+    if (!modes.useClaudeCode && !modes.useCodex) {
+        return config;
+    }
+    const agents = config.agents ?? {};
+    const defaults = agents.defaults ?? {};
+    const model = defaults.model;
+    const auth = config.auth ?? {};
+    const profiles = auth.profiles ?? {};
+    const order = auth.order ?? {};
+    if (modes.useCodex && typeof model === "string" && model.startsWith("openai/")) {
+        defaults.model = `openai-codex/${normalizeOpenClawCodexModel(model)}`;
+    }
+    if (modes.useClaudeCode) {
+        profiles["anthropic:default"] = { mode: "oauth", provider: "anthropic" };
+        order.anthropic = ["anthropic:default"];
+    }
+    if (modes.useCodex) {
+        profiles["openai-codex:default"] = { mode: "oauth", provider: "openai-codex" };
+        order["openai-codex"] = ["openai-codex:default"];
+    }
+    return {
+        ...config,
+        agents: { ...agents, defaults },
+        auth: { ...auth, order, profiles }
+    };
+};

package/dist/runtime/openclaw/runAuth.d.ts

@@ -1,2 +1,8 @@
 import type { RuntimeAuthPreparationInput, RuntimeAuthPreparationResult } from "../types.js";
+/**
+ * Injects the consumer's imported OAuth credentials for an OpenClaw instance.
+ * The OAuth-mode config is already baked into the image at compile time, so this
+ * only materializes and mounts the credential tokens — no source rootfs needed,
+ * which is what lets it run for both project deployments and sourceless images.
+ */
 export declare const prepareOpenClawRuntimeAuth: (input: RuntimeAuthPreparationInput) => Promise<RuntimeAuthPreparationResult>;

package/dist/runtime/openclaw/runAuth.js

@@ -1,7 +1,6 @@
 import path from "node:path";
 import { loadImportedClaudeCodeCredential, loadImportedCodexCredential } from "../../auth/index.js";
-import { ensureDirectory, readUtf8File, writeUtf8File } from "../../filesystem/index.js";
-const resolveRootfsSourcePath = (outputDirectory, containerPath) => path.join(outputDirectory, "container", "rootfs", ...path.posix.relative("/", containerPath).split("/"));
+import { ensureDirectory, writeUtf8File } from "../../filesystem/index.js";
 const writeJsonFile = async (tempRoot, relativePath, value) => {
     const hostPath = path.join(tempRoot, relativePath);
     await ensureDirectory(path.dirname(hostPath));
@@ -35,47 +34,12 @@ const createOpenClawCredential = (provider, credential) => credential && "type"
         refresh: credential.refresh,
         type: "oauth"
     };
-const normalizeOpenClawCodexModel = (model) => {
-    const modelName = model.slice("openai/".length);
-    return modelName === "gpt-5" ? "gpt-5.4" : modelName;
-};
-const patchOpenClawConfig = (config, options) => {
-    const agents = config.agents ?? {};
-    const defaults = agents.defaults ?? {};
-    const model = defaults.model;
-    const auth = config.auth ?? {};
-    const profiles = auth.profiles ?? {};
-    const order = auth.order ?? {};
-    if (options.useCodex && typeof model === "string" && model.startsWith("openai/")) {
-        defaults.model = `openai-codex/${normalizeOpenClawCodexModel(model)}`;
-    }
-    if (options.useClaudeCode) {
-        profiles["anthropic:default"] = {
-            mode: "oauth",
-            provider: "anthropic"
-        };
-        order.anthropic = ["anthropic:default"];
-    }
-    if (options.useCodex) {
-        profiles["openai-codex:default"] = {
-            mode: "oauth",
-            provider: "openai-codex"
-        };
-        order["openai-codex"] = ["openai-codex:default"];
-    }
-    return {
-        ...config,
-        agents: {
-            ...agents,
-            defaults
-        },
-        auth: {
-            ...auth,
-            order,
-            profiles
-        }
-    };
-};
+/**
+ * Injects the consumer's imported OAuth credentials for an OpenClaw instance.
+ * The OAuth-mode config is already baked into the image at compile time, so this
+ * only materializes and mounts the credential tokens — no source rootfs needed,
+ * which is what lets it run for both project deployments and sourceless images.
+ */
 export const prepareOpenClawRuntimeAuth = async (input) => {
     if (!input.instance.home_path) {
         return { coveredModelSecrets: [], mountArgs: [] };
@@ -88,7 +52,6 @@ export const prepareOpenClawRuntimeAuth = async (input) => {
         : null;
     const coveredModelSecrets = [];
     const authProfiles = {};
-    let patchedConfig = null;
     const useClaudeCode = input.instance.model_auth_methods.anthropic === "claude-code" && claudeCode;
     const useCodex = input.instance.model_auth_methods.openai === "codex" && codex;
     if (useClaudeCode) {
@@ -99,13 +62,6 @@ export const prepareOpenClawRuntimeAuth = async (input) => {
         authProfiles["openai-codex:default"] = createOpenClawCredential("openai-codex", codex);
         coveredModelSecrets.push("OPENAI_API_KEY");
     }
-    if (useClaudeCode || useCodex) {
-        const sourceConfig = JSON.parse(await readUtf8File(resolveRootfsSourcePath(input.outputDirectory, input.instance.config_path)));
-        patchedConfig = patchOpenClawConfig(sourceConfig, {
-            useClaudeCode: Boolean(useClaudeCode),
-            useCodex: Boolean(useCodex)
-        });
-    }
     const mountArgs = [];
     if (Object.keys(authProfiles).length > 0) {
         const authStorePath = await writeJsonFile(input.tempRoot, path.join("runtime-auth", "openclaw", input.instance.id, "auth-profiles.json"), {
@@ -114,10 +70,6 @@ export const prepareOpenClawRuntimeAuth = async (input) => {
         });
         mountArgs.push(...createMountArgs(authStorePath, path.posix.join(input.instance.home_path, ".openclaw", "agents", "main", "agent", "auth-profiles.json")));
     }
-    if (patchedConfig) {
-        const patchedConfigPath = await writeJsonFile(input.tempRoot, path.join("runtime-auth", "openclaw", input.instance.id, "openclaw.json"), patchedConfig);
-        mountArgs.push(...createMountArgs(patchedConfigPath, input.instance.config_path));
-    }
     return {
         coveredModelSecrets,
         mountArgs

package/dist/runtime/openclaw/statusProbes.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeStatusProbe } from "../types.js";
+export declare const openClawStatusProbes: RuntimeStatusProbe[];

package/dist/runtime/openclaw/statusProbes.js

@@ -0,0 +1,31 @@
+import { createRuntimeHttpProbe, createRuntimePathProbe } from "../statusProbes.js";
+export const openClawStatusProbes = [
+    createRuntimePathProbe({
+        id: "home",
+        key: "runtime.home",
+        label: "OpenClaw home",
+        pathFor: (instance) => instance.home_path,
+        testFlag: "-d"
+    }),
+    createRuntimePathProbe({
+        id: "workspace",
+        key: "runtime.workspace",
+        label: "OpenClaw workspace",
+        pathFor: (instance) => instance.workspace_path,
+        testFlag: "-d"
+    }),
+    createRuntimePathProbe({
+        id: "config",
+        key: "runtime.config",
+        label: "OpenClaw config",
+        pathFor: (instance) => instance.config_path,
+        testFlag: "-f"
+    }),
+    createRuntimeHttpProbe({
+        id: "healthz",
+        key: "runtime.health",
+        label: "OpenClaw gateway",
+        path: "/healthz",
+        portFor: (instance) => instance.internal_port
+    })
+];

package/dist/runtime/pi/adapter.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeAdapter } from "../types.js";
+export declare const piAdapter: RuntimeAdapter;
+export declare const daimonAdapter: RuntimeAdapter;
+export declare const PI_RUNTIME_PACKAGE = "@earendil-works/pi-coding-agent@0.79.9";

package/dist/runtime/pi/adapter.js

@@ -0,0 +1,198 @@
+import path from "node:path";
+import { listExecutionModelSecretNames } from "../../compiler/modelEnv.js";
+import { SpawnfileError } from "../../shared/index.js";
+import { createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles } from "../common.js";
+import { createPiAgentConfig, PI_PACKAGE_NAME, PI_PACKAGE_VERSION, renderPiApp, renderPiAppConfig, renderPiModelsConfig, renderPiPackageJson } from "./appTemplate.js";
+import { preparePiRuntimeAuth } from "./runAuth.js";
+const PI_CONFIG_FILE = "pi-app.json";
+const PI_CONTROL_PORT = 19690;
+const PI_MODELS_FILE = "home/.pi/agent/models.json";
+const moveWorkspaceFileToAgentWorkspace = (file, agentSlug) => {
+    if (!file.path.startsWith("workspace/")) {
+        return file;
+    }
+    const relativePath = file.path.slice("workspace/".length);
+    return {
+        ...file,
+        path: path.posix.join("workspace", "agents", agentSlug, relativePath)
+    };
+};
+const createContainerTargets = async (inputs) => {
+    const agentInputs = inputs.filter((input) => input.kind === "agent" && input.value.kind === "agent");
+    if (agentInputs.length === 0) {
+        return [];
+    }
+    const agents = agentInputs.map((input) => createPiAgentConfig(input.value, input.slug, input.id));
+    const envFiles = [
+        ...new Set(agentInputs.flatMap((input) => listExecutionModelSecretNames(input.value.execution)))
+    ].map((secretName) => ({
+        envName: secretName,
+        relativePath: `secrets/${secretName}`
+    }));
+    return [
+        {
+            envFiles,
+            files: [
+                ...agentInputs.flatMap((input) => input.emittedFiles.map((file) => moveWorkspaceFileToAgentWorkspace(file, input.slug))),
+                {
+                    content: renderPiAppConfig(agents),
+                    path: PI_CONFIG_FILE
+                },
+                {
+                    content: renderPiModelsConfig(agentInputs.map((input) => input.value)),
+                    path: PI_MODELS_FILE
+                },
+                {
+                    content: renderPiPackageJson(),
+                    path: "runtime/package.json"
+                },
+                {
+                    content: renderPiApp(),
+                    mode: 0o755,
+                    path: "runtime/app.mjs"
+                }
+            ],
+            id: "pi-app",
+            sourceIds: agentInputs.map((input) => input.id).sort()
+        }
+    ];
+};
+const scheduleOutcomeFor = (node) => {
+    if (!node.schedule) {
+        return {};
+    }
+    if (node.schedule.kind === "every" || node.schedule.kind === "disabled") {
+        return {
+            message: "Pi generated runtime app owns this schedule",
+            outcome: "supported"
+        };
+    }
+    return {
+        message: "Pi generated runtime app supports every schedules in Spawnfile v0.1",
+        outcome: "degraded"
+    };
+};
+const createScheduleDiagnostics = (node) => node.schedule?.kind === "cron"
+    ? [
+        createDiagnostic("warn", "Pi generated runtime app supports every schedules in Spawnfile v0.1; cron schedules are degraded")
+    ]
+    : [];
+const moltnetCapabilityOptions = (node) => node.surfaces?.moltnet
+    ? {
+        moltnetMessage: "Pi generated runtime app exposes a control endpoint for Moltnet bridge wake delivery",
+        moltnetOutcome: "supported"
+    }
+    : {};
+const assertSupportedPiSurfaces = (surfaces) => {
+    if (!surfaces) {
+        return;
+    }
+    const unsupported = [
+        surfaces.discord ? "discord" : null,
+        surfaces.http ? "http" : null,
+        surfaces.slack ? "slack" : null,
+        surfaces.telegram ? "telegram" : null,
+        surfaces.webhook ? "webhook" : null,
+        surfaces.whatsapp ? "whatsapp" : null
+    ].filter((surface) => surface !== null);
+    if (unsupported.length > 0) {
+        throw new SpawnfileError("validation_error", `Pi runtime only supports Moltnet surfaces in Spawnfile v0.1; unsupported surfaces: ${unsupported.join(", ")}`);
+    }
+};
+export const piAdapter = {
+    assertSupportedModelTarget(target) {
+        if (target.endpoint) {
+            if (target.provider !== "custom" && target.provider !== "local") {
+                throw new SpawnfileError("validation_error", "Pi runtime only supports endpoints on custom or local model providers");
+            }
+            if (target.auth.method === "none" || target.auth.method === "api_key") {
+                return;
+            }
+            throw new SpawnfileError("validation_error", `Pi runtime endpoint models only support none or api_key auth, got ${target.auth.method}`);
+        }
+        if (target.provider === "openai") {
+            if (target.auth.method === "api_key" || target.auth.method === "codex") {
+                return;
+            }
+        }
+        if (target.provider === "anthropic" && target.auth.method === "api_key") {
+            return;
+        }
+        if (target.provider === "anthropic" && target.auth.method === "claude-code") {
+            return;
+        }
+        throw new SpawnfileError("validation_error", `Pi runtime does not support model auth method ${target.auth.method} for provider ${target.provider}`);
+    },
+    assertSupportedSurfaces(surfaces) {
+        assertSupportedPiSurfaces(surfaces);
+    },
+    container: {
+        configFileName: PI_CONFIG_FILE,
+        configPathEnv: "SPAWNFILE_PI_CONFIG",
+        homeEnv: "SPAWNFILE_PI_HOME",
+        instancePaths: {
+            configPathTemplate: "<instance-root>/pi/<config-file>",
+            homePathTemplate: "<instance-root>/home",
+            sourceWorkspacePathTemplate: "<instance-root>/workspace/agents/<source-slug>",
+            workspacePathTemplate: "<instance-root>/workspace"
+        },
+        port: PI_CONTROL_PORT,
+        portEnv: "SPAWNFILE_PI_CONTROL_PORT",
+        standaloneBaseImage: "node:24-bookworm-slim",
+        startCommand: ["node", "<runtime-root>/app.mjs", "<config-path>"],
+        systemDeps: ["bash", "ca-certificates", "curl", "git", "procps"]
+    },
+    systemInstructionSurface: {
+        placement: "append_pointer",
+        resolvePath() {
+            return "workspace/AGENTS.md";
+        }
+    },
+    async compileAgent(node) {
+        const scheduleOutcome = scheduleOutcomeFor(node);
+        return {
+            capabilities: createAgentCapabilities(node, {
+                ...moltnetCapabilityOptions(node),
+                mcpOutcome: node.mcpServers.length > 0 ? "degraded" : "supported",
+                sandboxOutcome: node.execution?.sandbox ? "degraded" : "supported",
+                scheduleMessage: scheduleOutcome.message,
+                scheduleOutcome: scheduleOutcome.outcome,
+                subagentOutcome: node.subagents.length > 0 ? "degraded" : "supported"
+            }),
+            diagnostics: [
+                ...createScheduleDiagnostics(node),
+                ...(node.execution?.sandbox
+                    ? [createDiagnostic("warn", "Pi runtime relies on container and workspace isolation; Pi itself is not a sandbox engine")]
+                    : []),
+                ...(node.mcpServers.length > 0
+                    ? [createDiagnostic("warn", "Pi runtime does not lower MCP server declarations in Spawnfile v0.1")]
+                    : []),
+                ...(node.subagents.length > 0
+                    ? [createDiagnostic("warn", "Pi runtime groups compiled agents but does not preserve native parent-owned subagent semantics in v0.1")]
+                    : [])
+            ],
+            files: [
+                ...createDocumentFiles("workspace", node.docs),
+                ...createSkillFiles("workspace/skills", node.skills)
+            ]
+        };
+    },
+    async createContainerTargets(inputs) {
+        return createContainerTargets(inputs);
+    },
+    name: "pi",
+    prepareRuntimeAuth: preparePiRuntimeAuth,
+    validateRuntimeOptions(options) {
+        const diagnostics = [];
+        const unsupported = Object.keys(options).filter((key) => key !== "restrict_to_workspace");
+        for (const key of unsupported) {
+            diagnostics.push(createDiagnostic("warn", `Pi runtime option ${key} is not used yet`));
+        }
+        return diagnostics;
+    }
+};
+export const daimonAdapter = {
+    ...piAdapter,
+    name: "daimon"
+};
+export const PI_RUNTIME_PACKAGE = `${PI_PACKAGE_NAME}@${PI_PACKAGE_VERSION}`;

package/dist/runtime/pi/appActivitySource.d.ts

@@ -0,0 +1 @@
+export declare const renderPiActivitySource: () => string;

package/dist/runtime/pi/appActivitySource.js

@@ -0,0 +1,87 @@
+export const renderPiActivitySource = () => String.raw `
+const maxActivityEvents = 500;
+
+const createActivityBroker = () => {
+  let sequence = 0;
+  const events = [];
+  const clients = new Set();
+
+  const normalizeFilter = (value) => typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : "";
+  const matchesFilter = (event, filter) => {
+    const normalized = normalizeFilter(filter);
+    return normalized === "" ||
+      event.agent_id === normalized ||
+      event.agent_slug === normalized ||
+      event.agent_name === normalized ||
+      event.agent_id === "agent:" + normalized;
+  };
+  const parseTail = (value) => {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : maxActivityEvents;
+  };
+
+  const publish = (event) => {
+    const full = {
+      version: "spawnfile.activity.v1",
+      sequence: ++sequence,
+      created_at: new Date().toISOString(),
+      ...event
+    };
+    events.push(full);
+    if (events.length > maxActivityEvents) {
+      events.splice(0, events.length - maxActivityEvents);
+    }
+    const frame = "data: " + JSON.stringify(full) + "\n\n";
+    for (const client of [...clients]) {
+      if (!matchesFilter(full, client.filter)) {
+        continue;
+      }
+      try {
+        client.response.write(frame);
+      } catch {
+        clients.delete(client);
+      }
+    }
+    return full;
+  };
+
+  const list = (filter, tail) => {
+    const selected = events.filter((event) => matchesFilter(event, filter));
+    return selected.slice(Math.max(0, selected.length - parseTail(tail)));
+  };
+
+  const stream = (request, response, filter, tail) => {
+    response.writeHead(200, {
+      "cache-control": "no-cache",
+      "connection": "keep-alive",
+      "content-type": "text/event-stream"
+    });
+    response.write("event: ready\ndata: {\"status\":\"ok\"}\n\n");
+    for (const event of list(filter, tail)) {
+      response.write("data: " + JSON.stringify(event) + "\n\n");
+    }
+    const client = { filter: normalizeFilter(filter), response };
+    clients.add(client);
+    request.on("close", () => clients.delete(client));
+  };
+
+  return { list, publish, stream };
+};
+
+const redactActivityText = (value) => {
+  let redacted = String(value);
+  redacted = redacted.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi, "Bearer [REDACTED]");
+  redacted = redacted.replace(/\bmagt_v1_[A-Za-z0-9_-]{16,}\b/g, "[REDACTED]");
+  redacted = redacted.replace(/\b(?:sk|sk-proj)-[A-Za-z0-9_-]{20,}\b/g, "[REDACTED]");
+  redacted = redacted.replace(
+    /("([^"]*(?:api[_-]?key|token|secret|password)[^"]*)"\s*:\s*")([^"]+)(")/gi,
+    "$1[REDACTED]$4"
+  );
+  redacted = redacted.replace(/\/(?:Users|home|private|tmp|var|opt|run)\/[^\s"']+/g, "[path]");
+  return redacted.length > 1000 ? redacted.slice(0, 1000) + "..." : redacted;
+};
+
+const formatActivityError = (error) => redactActivityText(error instanceof Error ? error.message : String(error));
+`;

package/dist/runtime/pi/appCoreSource.d.ts

@@ -0,0 +1 @@
+export declare const renderPiCoreSource: () => string;