spawnfile 0.1.3 → 0.1.5

package/dist/runtime/picoclaw/runAuth.js

@@ -1,12 +1,12 @@
 import path from "node:path";
-import { loadImportedClaudeCodeCredential, loadImportedCodexCredential } from "../../auth/index.js";
+import { loadImportedClaudeCodeCredential } from "../../auth/index.js";
 import { copyDirectory, ensureDirectory, readUtf8File, writeUtf8File } from "../../filesystem/index.js";
 const resolveRootfsSourcePath = (outputDirectory, containerPath) => path.join(outputDirectory, "container", "rootfs", ...path.posix.relative("/", containerPath).split("/"));
 const createMountArgs = (hostPath, containerPath) => [
     "-v",
     `${hostPath}:${containerPath}`
 ];
-const createMountedHomeDirectory = async (input, patchedConfig, authStore) => {
+const createMountedHomeDirectory = async (input, patchedConfig) => {
     const sourceHomePath = resolveRootfsSourcePath(input.outputDirectory, input.instance.home_path);
     const mountedHomePath = path.join("runtime-auth", "picoclaw", input.instance.id, "home");
     const hostHomePath = path.join(input.tempRoot, mountedHomePath);
@@ -14,26 +14,10 @@ const createMountedHomeDirectory = async (input, patchedConfig, authStore) => {
     await copyDirectory(sourceHomePath, hostHomePath);
     const relativeConfigPath = path.posix.relative(input.instance.home_path, input.instance.config_path);
     const hostConfigPath = path.join(hostHomePath, ...relativeConfigPath.split("/"));
-    const hostAuthPath = path.join(hostHomePath, "auth.json");
     await ensureDirectory(path.dirname(hostConfigPath));
     await writeUtf8File(hostConfigPath, `${JSON.stringify(patchedConfig, null, 2)}\n`);
-    if (authStore) {
-        await writeUtf8File(hostAuthPath, `${JSON.stringify(authStore, null, 2)}\n`);
-    }
     return hostHomePath;
 };
-const createPicoClawCredential = (provider, credential) => ({
-    access_token: credential.access,
-    ...("type" in credential && credential.type === "oauth" && credential.refresh
-        ? { refresh_token: credential.refresh }
-        : !("type" in credential)
-            ? { refresh_token: credential.refresh }
-            : {}),
-    ...("accountId" in credential && credential.accountId ? { account_id: credential.accountId } : {}),
-    auth_method: "oauth",
-    expires_at: new Date(credential.expires).toISOString(),
-    provider
-});
 const normalizeClaudeCliModelName = (modelName) => modelName.replaceAll(".", "-");
 const patchPicoClawConfig = (config, options) => {
     const agents = config.agents ?? {};
@@ -55,21 +39,11 @@ const patchPicoClawConfig = (config, options) => {
                 record.model = `claude-cli/${normalizeClaudeCliModelName(modelName)}`;
             }
         }
-        if (options.useCodex && typeof model === "string" && model.startsWith("openai/")) {
-            delete record.api_key;
-            record.auth_method = "oauth";
-        }
         return record;
     });
     if (options.useClaudeCode) {
         delete nextProviders.anthropic;
     }
-    if (options.useCodex) {
-        nextProviders.openai = {
-            ...(nextProviders.openai ?? {}),
-            auth_method: "oauth"
-        };
-    }
     return {
         ...config,
         agents: {
@@ -87,29 +61,19 @@ export const preparePicoClawRuntimeAuth = async (input) => {
     const claudeCode = input.authProfile.imports["claude-code"]
         ? await loadImportedClaudeCodeCredential(input.authProfile.imports["claude-code"].path)
         : null;
-    const codex = input.authProfile.imports.codex
-        ? await loadImportedCodexCredential(input.authProfile.imports.codex.path)
-        : null;
     const useClaudeCode = input.instance.model_auth_methods.anthropic === "claude-code" && claudeCode;
-    const useCodex = input.instance.model_auth_methods.openai === "codex" && codex;
-    if (!useClaudeCode && !useCodex) {
+    if (!useClaudeCode) {
         return { coveredModelSecrets: [], mountArgs: [] };
     }
-    const credentials = {};
     const coveredModelSecrets = [];
-    if (useCodex) {
-        credentials.openai = createPicoClawCredential("openai", codex);
-        coveredModelSecrets.push("OPENAI_API_KEY");
-    }
     if (useClaudeCode) {
         coveredModelSecrets.push("ANTHROPIC_API_KEY");
     }
     const sourceConfig = JSON.parse(await readUtf8File(resolveRootfsSourcePath(input.outputDirectory, input.instance.config_path)));
     const patchedConfig = patchPicoClawConfig(sourceConfig, {
-        useClaudeCode: Boolean(useClaudeCode),
-        useCodex: Boolean(useCodex)
+        useClaudeCode: Boolean(useClaudeCode)
     });
-    const mountedHomePath = await createMountedHomeDirectory(input, patchedConfig, Object.keys(credentials).length > 0 ? { credentials } : null);
+    const mountedHomePath = await createMountedHomeDirectory(input, patchedConfig);
     return {
         coveredModelSecrets,
         mountArgs: createMountArgs(mountedHomePath, input.instance.home_path)

package/dist/runtime/tinyclaw/adapter.js

@@ -4,6 +4,7 @@ import { createCapability, createAgentCapabilities, createDocumentFiles, createS
 import { prepareTinyClawRuntimeAuth } from "./runAuth.js";
 import { createTinyClawAgentScaffold } from "./scaffold.js";
 import { assertSupportedTinyClawSurfaces, buildTinyClawChannels, resolveTinyClawSurfaceTokenBindings } from "./surfaces.js";
+import { createScheduleDiagnostics, createTinyClawSchedulesFile, scheduleOutcomeFor } from "./schedules.js";
 const WORKSPACE_PLACEHOLDER = "<workspace-path>";
 const SUPPORTED_TINYCLAW_OPENAI_MODEL_PREFIXES = ["gpt-5"];
 const TINYCLAW_START_SCRIPT = `
@@ -106,6 +107,7 @@ const mergeTinyClawTargets = async (inputs) => {
     let hasWhatsappChannel = false;
     let hasTelegramChannel = false;
     const workspaceFiles = agentInputs.flatMap((input) => input.emittedFiles.filter((file) => file.path !== "settings.json"));
+    const schedulesFile = createTinyClawSchedulesFile(agentInputs);
     let mergedBase = null;
     for (const input of agentInputs) {
         const settings = parseJsonFile(input, "settings.json");
@@ -153,6 +155,7 @@ const mergeTinyClawTargets = async (inputs) => {
         {
             files: [
                 ...workspaceFiles,
+                ...(schedulesFile ? [schedulesFile] : []),
                 {
                     content: `${JSON.stringify(mergedSettings, null, 2)}\n`,
                     path: "settings.json"
@@ -207,6 +210,7 @@ export const tinyClawAdapter = {
         instancePaths: {
             configPathTemplate: "<instance-root>/tinyagi/<config-file>",
             homePathTemplate: "<instance-root>/tinyagi",
+            sourceWorkspacePathTemplate: "<instance-root>/workspace/<agent-name>",
             workspacePathTemplate: "<instance-root>/workspace"
         },
         port: 3777,
@@ -222,11 +226,14 @@ export const tinyClawAdapter = {
         }
     },
     async compileAgent(node) {
+        const scheduleOutcome = scheduleOutcomeFor(node);
         return {
             capabilities: createAgentCapabilities(node, {
-                mcpOutcome: node.mcpServers.length > 0 ? "degraded" : "supported"
+                mcpOutcome: node.mcpServers.length > 0 ? "degraded" : "supported",
+                scheduleMessage: scheduleOutcome.message,
+                scheduleOutcome: scheduleOutcome.outcome
             }),
-            diagnostics: [],
+            diagnostics: createScheduleDiagnostics(node),
             files: [
                 ...createDocumentFiles(`workspace/${node.name}`, node.docs),
                 ...createSkillFiles(`workspace/${node.name}/.agents/skills`, node.skills),

package/dist/runtime/tinyclaw/schedules.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+import type { CapabilityReport } from "../../report/index.js";
+import type { ContainerTargetInput, EmittedFile } from "../types.js";
+export declare const createTinyClawSchedulesFile: (inputs: ContainerTargetInput[]) => EmittedFile | null;
+export declare const scheduleOutcomeFor: (node: ResolvedAgentNode) => {
+    message?: string;
+    outcome?: CapabilityReport["outcome"];
+};
+export declare const createScheduleDiagnostics: (node: ResolvedAgentNode) => import("../../report/types.js").DiagnosticReport[];

package/dist/runtime/tinyclaw/schedules.js

@@ -0,0 +1,62 @@
+import { createDiagnostic } from "../common.js";
+const TINYCLAW_SCHEDULE_CHANNEL = "schedule";
+const TINYCLAW_SCHEDULE_SENDER = "Spawnfile Scheduler";
+const createTinyClawSchedule = (node) => {
+    if (!node.schedule || node.schedule.kind !== "cron") {
+        return null;
+    }
+    return {
+        agentId: node.name,
+        channel: TINYCLAW_SCHEDULE_CHANNEL,
+        createdAt: 0,
+        cron: node.schedule.cron,
+        enabled: true,
+        id: `spawnfile-${node.name}`,
+        label: `Spawnfile schedule for ${node.name}`,
+        message: node.schedule.prompt ?? "Run the scheduled Spawnfile task.",
+        sender: TINYCLAW_SCHEDULE_SENDER
+    };
+};
+export const createTinyClawSchedulesFile = (inputs) => {
+    const schedules = inputs
+        .flatMap((input) => {
+        if (input.kind !== "agent" || input.value.kind !== "agent") {
+            return [];
+        }
+        return [createTinyClawSchedule(input.value)];
+    })
+        .filter((schedule) => Boolean(schedule))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    return schedules.length > 0
+        ? {
+            content: `${JSON.stringify(schedules, null, 2)}\n`,
+            path: "home/schedules.json"
+        }
+        : null;
+};
+export const scheduleOutcomeFor = (node) => {
+    if (!node.schedule) {
+        return {};
+    }
+    if (node.schedule.kind === "cron") {
+        return {
+            message: "TinyClaw native cron scheduler is emitted as schedules.json",
+            outcome: "supported"
+        };
+    }
+    if (node.schedule.kind === "disabled") {
+        return {
+            message: "Disabled schedule emits no wake registration",
+            outcome: "supported"
+        };
+    }
+    return {
+        message: "TinyClaw native schedule lowering supports cron schedules in Spawnfile v0.1",
+        outcome: "degraded"
+    };
+};
+export const createScheduleDiagnostics = (node) => node.schedule?.kind === "every"
+    ? [
+        createDiagnostic("warn", "TinyClaw native schedule lowering supports cron schedules in Spawnfile v0.1; every schedules are degraded")
+    ]
+    : [];

package/dist/runtime/types.d.ts

@@ -33,6 +33,7 @@ export interface ContainerTarget {
 export interface RuntimeContainerInstancePaths {
     configPathTemplate: string;
     homePathTemplate?: string;
+    sourceWorkspacePathTemplate?: string;
     workspacePathTemplate: string;
 }
 export interface RuntimeContainerConfigEnvBinding {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spawnfile",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Canonical source compiler for autonomous agents and teams.",
   "license": "MIT",
   "type": "module",
@@ -29,6 +29,7 @@
     "runtimes:sync": "./scripts/runtimes.sh && ./scripts/blueprints.sh",
     "test:e2e:docker-auth": "tsx src/e2e/cli.ts",
     "test:e2e:moltnet-team-chat": "tsx src/e2e/cli.ts moltnet-team-chat",
+    "test:e2e:operational-smoke": "tsx src/e2e/cli.ts operational-smoke",
     "test": "vitest run",
     "typecheck": "tsc --project tsconfig.json --noEmit"
   },