spawnfile 0.1.0

package/dist/auth/profileStore.js

@@ -0,0 +1,125 @@
+import path from "node:path";
+import { z } from "zod";
+import { ensureDirectory, fileExists, readUtf8File, removeDirectory, writeUtf8File } from "../filesystem/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { resolveAuthHome, resolveImportedAuthDirectory, resolveProfileDirectory, resolveProfilePath } from "./paths.js";
+const importedAuthEntrySchema = z.object({
+    kind: z.enum(["claude-code", "codex"]),
+    relativePath: z.string().min(1)
+});
+const authProfileSchema = z.object({
+    env: z.record(z.string(), z.string()).default({}),
+    imports: z
+        .object({
+        "claude-code": importedAuthEntrySchema.optional(),
+        codex: importedAuthEntrySchema.optional()
+    })
+        .default({}),
+    version: z.literal(1)
+});
+const createEmptyProfile = () => ({
+    env: {},
+    imports: {},
+    version: 1
+});
+export const createResolvedAuthProfile = (profileName, profile) => ({
+    authHome: resolveAuthHome(),
+    env: { ...profile.env },
+    imports: Object.fromEntries(Object.entries(profile.imports).map(([kind, entry]) => [
+        kind,
+        {
+            kind: entry.kind,
+            path: path.join(resolveProfileDirectory(profileName), entry.relativePath)
+        }
+    ])),
+    name: profileName,
+    profileDirectory: resolveProfileDirectory(profileName),
+    profilePath: resolveProfilePath(profileName),
+    version: 1
+});
+export const loadAuthProfile = async (profileName) => {
+    const profilePath = resolveProfilePath(profileName);
+    if (!(await fileExists(profilePath))) {
+        return null;
+    }
+    const fileContent = await readUtf8File(profilePath);
+    let raw;
+    try {
+        raw = JSON.parse(fileContent);
+    }
+    catch (error) {
+        throw new SpawnfileError("validation_error", `Invalid auth profile ${profileName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const parsed = authProfileSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new SpawnfileError("validation_error", `Invalid auth profile ${profileName}: ${parsed.error.issues[0]?.message ?? "unknown error"}`);
+    }
+    return createResolvedAuthProfile(profileName, parsed.data);
+};
+export const requireAuthProfile = async (profileName) => {
+    const profile = await loadAuthProfile(profileName);
+    if (profile) {
+        return profile;
+    }
+    throw new SpawnfileError("validation_error", `Auth profile does not exist: ${profileName}`);
+};
+export const ensureAuthProfile = async (profileName) => {
+    const existing = await loadAuthProfile(profileName);
+    if (existing) {
+        return existing;
+    }
+    const profileDirectory = resolveProfileDirectory(profileName);
+    await ensureDirectory(profileDirectory);
+    await writeUtf8File(resolveProfilePath(profileName), `${JSON.stringify(createEmptyProfile(), null, 2)}\n`);
+    return createResolvedAuthProfile(profileName, createEmptyProfile());
+};
+const writeProfile = async (profileName, profile) => {
+    const profileDirectory = resolveProfileDirectory(profileName);
+    await ensureDirectory(profileDirectory);
+    await writeUtf8File(resolveProfilePath(profileName), `${JSON.stringify(profile, null, 2)}\n`);
+    return createResolvedAuthProfile(profileName, profile);
+};
+export const setAuthProfileEnv = async (profileName, env) => {
+    const current = (await loadAuthProfile(profileName)) ?? (await ensureAuthProfile(profileName));
+    return writeProfile(profileName, {
+        env: {
+            ...current.env,
+            ...env
+        },
+        imports: Object.fromEntries(Object.entries(current.imports).map(([kind, entry]) => [
+            kind,
+            {
+                kind: entry.kind,
+                relativePath: path.relative(current.profileDirectory, entry.path)
+            }
+        ])),
+        version: 1
+    });
+};
+export const registerImportedAuth = async (profileName, kind) => {
+    const current = (await loadAuthProfile(profileName)) ?? (await ensureAuthProfile(profileName));
+    const importDirectory = resolveImportedAuthDirectory(profileName, kind);
+    await removeDirectory(importDirectory);
+    await ensureDirectory(importDirectory);
+    const nextProfile = {
+        env: { ...current.env },
+        imports: {
+            ...Object.fromEntries(Object.entries(current.imports).map(([entryKind, entry]) => [
+                entryKind,
+                {
+                    kind: entry.kind,
+                    relativePath: path.relative(current.profileDirectory, entry.path)
+                }
+            ])),
+            [kind]: {
+                kind,
+                relativePath: path.relative(current.profileDirectory, importDirectory)
+            }
+        },
+        version: 1
+    };
+    return {
+        directory: importDirectory,
+        profile: await writeProfile(profileName, nextProfile)
+    };
+};

package/dist/auth/runtimeCredentials.d.ts

@@ -0,0 +1,14 @@
+export interface ClaudeCodeImportedCredential {
+    access: string;
+    expires: number;
+    refresh?: string;
+    type: "oauth" | "token";
+}
+export interface CodexImportedCredential {
+    access: string;
+    accountId?: string;
+    expires: number;
+    refresh: string;
+}
+export declare const loadImportedClaudeCodeCredential: (sourceDirectory: string) => Promise<ClaudeCodeImportedCredential | null>;
+export declare const loadImportedCodexCredential: (sourceDirectory: string) => Promise<CodexImportedCredential | null>;

package/dist/auth/runtimeCredentials.js

@@ -0,0 +1,76 @@
+import path from "node:path";
+import { stat } from "node:fs/promises";
+import { fileExists, readUtf8File } from "../filesystem/index.js";
+import { SpawnfileError } from "../shared/index.js";
+const parseJson = (filePath, content) => {
+    try {
+        const parsed = JSON.parse(content);
+        if (!parsed || typeof parsed !== "object") {
+            throw new Error("top-level JSON value must be an object");
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new SpawnfileError("validation_error", `Invalid imported auth file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+export const loadImportedClaudeCodeCredential = async (sourceDirectory) => {
+    const credentialsPath = path.join(sourceDirectory, ".credentials.json");
+    if (!(await fileExists(credentialsPath))) {
+        return null;
+    }
+    const parsed = parseJson(credentialsPath, await readUtf8File(credentialsPath));
+    const oauth = parsed.claudeAiOauth;
+    if (!oauth || typeof oauth !== "object") {
+        return null;
+    }
+    const access = oauth.accessToken;
+    const refresh = oauth.refreshToken;
+    const expires = oauth.expiresAt;
+    if (typeof access !== "string" || access.length === 0) {
+        return null;
+    }
+    if (typeof expires !== "number" || !Number.isFinite(expires) || expires <= 0) {
+        return null;
+    }
+    if (typeof refresh === "string" && refresh.length > 0) {
+        return {
+            access,
+            expires,
+            refresh,
+            type: "oauth"
+        };
+    }
+    return {
+        access,
+        expires,
+        type: "token"
+    };
+};
+export const loadImportedCodexCredential = async (sourceDirectory) => {
+    const authPath = path.join(sourceDirectory, "auth.json");
+    if (!(await fileExists(authPath))) {
+        return null;
+    }
+    const parsed = parseJson(authPath, await readUtf8File(authPath));
+    const tokens = parsed.tokens;
+    if (!tokens || typeof tokens !== "object") {
+        return null;
+    }
+    const access = tokens.access_token;
+    const refresh = tokens.refresh_token;
+    const accountId = tokens.account_id;
+    if (typeof access !== "string" ||
+        access.length === 0 ||
+        typeof refresh !== "string" ||
+        refresh.length === 0) {
+        return null;
+    }
+    const fileStats = await stat(authPath);
+    return {
+        access,
+        ...(typeof accountId === "string" && accountId.length > 0 ? { accountId } : {}),
+        expires: fileStats.mtimeMs + 60 * 60 * 1000,
+        refresh
+    };
+};

package/dist/auth/types.d.ts

@@ -0,0 +1,22 @@
+export type ImportedAuthKind = "claude-code" | "codex";
+export interface ImportedAuthEntry {
+    kind: ImportedAuthKind;
+    relativePath: string;
+}
+export interface AuthProfile {
+    env: Record<string, string>;
+    imports: Partial<Record<ImportedAuthKind, ImportedAuthEntry>>;
+    version: 1;
+}
+export interface ResolvedAuthProfile {
+    authHome: string;
+    env: Record<string, string>;
+    imports: Partial<Record<ImportedAuthKind, {
+        kind: ImportedAuthKind;
+        path: string;
+    }>>;
+    name: string;
+    profileDirectory: string;
+    profilePath: string;
+    version: 1;
+}

package/dist/auth/types.js

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

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCli } from "./runCli.js";
+const exitCode = await runCli(process.argv.slice(2));
+process.exit(exitCode);

package/dist/cli/runCli.d.ts

@@ -0,0 +1,27 @@
+import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/index.js";
+import { addAgentProject, addProjectModelFallback, addSubagentProject, addTeamProject, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, runProject, setProjectPrimaryModel, syncProjectAuth } from "../compiler/index.js";
+import { listRuntimeAdapters } from "../runtime/index.js";
+export interface CliStreams {
+    stderr: (message: string) => void;
+    stdout: (message: string) => void;
+}
+export interface CliHandlers {
+    buildCompilePlan: typeof buildCompilePlan;
+    buildProject: typeof buildProject;
+    compileProject: typeof compileProject;
+    addAgentProject: typeof addAgentProject;
+    addProjectModelFallback: typeof addProjectModelFallback;
+    addSubagentProject: typeof addSubagentProject;
+    addTeamProject: typeof addTeamProject;
+    clearProjectModelFallbacks: typeof clearProjectModelFallbacks;
+    importClaudeCodeAuth: typeof importClaudeCodeAuth;
+    importCodexAuth: typeof importCodexAuth;
+    importEnvFile: typeof importEnvFile;
+    initProject: typeof initProject;
+    listRuntimeAdapters: typeof listRuntimeAdapters;
+    requireAuthProfile: typeof requireAuthProfile;
+    runProject: typeof runProject;
+    setProjectPrimaryModel: typeof setProjectPrimaryModel;
+    syncProjectAuth: typeof syncProjectAuth;
+}
+export declare const runCli: (argv: string[], streams?: CliStreams, handlerOverrides?: Partial<CliHandlers>) => Promise<number>;

package/dist/cli/runCli.js

@@ -0,0 +1,314 @@
+import { Command } from "commander";
+import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/index.js";
+import { addAgentProject, addProjectModelFallback, addSubagentProject, addTeamProject, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, runProject, setProjectPrimaryModel, syncProjectAuth } from "../compiler/index.js";
+import { isSpawnfileError } from "../shared/index.js";
+import { listRuntimeAdapters } from "../runtime/index.js";
+const createDefaultStreams = () => ({
+    stderr: (message) => process.stderr.write(`${message}\n`),
+    stdout: (message) => process.stdout.write(`${message}\n`)
+});
+const createDefaultHandlers = () => ({
+    buildCompilePlan,
+    buildProject,
+    compileProject,
+    addAgentProject,
+    addProjectModelFallback,
+    addSubagentProject,
+    addTeamProject,
+    clearProjectModelFallbacks,
+    importClaudeCodeAuth,
+    importCodexAuth,
+    importEnvFile,
+    initProject,
+    listRuntimeAdapters,
+    requireAuthProfile,
+    runProject,
+    setProjectPrimaryModel,
+    syncProjectAuth
+});
+const formatPlanSummary = (plan) => [
+    `root: ${plan.root}`,
+    `nodes: ${plan.nodes.length}`,
+    `runtimes: ${Object.keys(plan.runtimes).sort().join(", ") || "none"}`
+].join("\n");
+const formatAuthProfileSummary = (profile) => {
+    const envKeys = Object.keys(profile.env).sort();
+    const importedKinds = Object.keys(profile.imports).sort();
+    return [
+        `profile: ${profile.name}`,
+        `env: ${envKeys.length > 0 ? envKeys.join(", ") : "none"}`,
+        `imports: ${importedKinds.length > 0 ? importedKinds.join(", ") : "none"}`
+    ];
+};
+export const runCli = async (argv, streams = createDefaultStreams(), handlerOverrides = {}) => {
+    const handlers = { ...createDefaultHandlers(), ...handlerOverrides };
+    const program = new Command();
+    program.name("spawnfile").description("Spawnfile v0.1 compiler");
+    program
+        .command("compile")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("-o, --out <directory>", "Output directory")
+        .action(async (inputPath, options) => {
+        const result = await handlers.compileProject(inputPath, { outputDirectory: options.out });
+        streams.stdout(`compiled to ${result.outputDirectory}`);
+        streams.stdout(`report: ${result.reportPath}`);
+    });
+    program
+        .command("build")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("-o, --out <directory>", "Output directory")
+        .option("-t, --tag <image>", "Docker image tag")
+        .action(async (inputPath, options) => {
+        const result = await handlers.buildProject(inputPath, {
+            imageTag: options.tag,
+            outputDirectory: options.out
+        });
+        streams.stdout(`built image ${result.imageTag}`);
+        streams.stdout(`compiled to ${result.outputDirectory}`);
+        streams.stdout(`report: ${result.reportPath}`);
+    });
+    program
+        .command("run")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("-o, --out <directory>", "Output directory")
+        .option("-t, --tag <image>", "Docker image tag")
+        .option("--auth-profile <name>", "Local Spawnfile auth profile")
+        .option("--name <container>", "Docker container name")
+        .option("-d, --detach", "Run the container in detached mode")
+        .action(async (inputPath, options) => {
+        const result = await handlers.runProject(inputPath, {
+            authProfile: options.authProfile,
+            containerName: options.name,
+            detach: options.detach,
+            imageTag: options.tag,
+            outputDirectory: options.out
+        });
+        if (options.detach) {
+            streams.stdout(`running container ${result.containerName ?? "unknown"}`);
+            streams.stdout(`image: ${result.imageTag}`);
+        }
+    });
+    program
+        .command("init")
+        .argument("[path]", "Directory to initialize", process.cwd())
+        .option("--team", "Initialize a team project")
+        .option("--runtime <name>", "Runtime for agent scaffolds")
+        .action(async (inputPath, options) => {
+        const result = await handlers.initProject({
+            directory: inputPath,
+            runtime: options.runtime,
+            team: options.team
+        });
+        streams.stdout(`initialized ${result.directory}`);
+        for (const filePath of result.createdFiles) {
+            streams.stdout(`created ${filePath}`);
+        }
+    });
+    const addCommand = program.command("add").description("Add children to an existing Spawnfile project");
+    addCommand
+        .command("agent")
+        .argument("<id>", "Agent member id")
+        .argument("[path]", "Team project directory or Spawnfile path", process.cwd())
+        .option("--runtime <name>", "Runtime for the new agent member")
+        .action(async (id, inputPath, options) => {
+        const result = await handlers.addAgentProject({
+            id,
+            path: inputPath,
+            runtime: options.runtime
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+        for (const filePath of result.createdFiles) {
+            streams.stdout(`created ${filePath}`);
+        }
+    });
+    addCommand
+        .command("subagent")
+        .argument("<id>", "Subagent id")
+        .argument("[path]", "Agent project directory or Spawnfile path", process.cwd())
+        .action(async (id, inputPath) => {
+        const result = await handlers.addSubagentProject({
+            id,
+            path: inputPath
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+        for (const filePath of result.createdFiles) {
+            streams.stdout(`created ${filePath}`);
+        }
+    });
+    addCommand
+        .command("team")
+        .argument("<id>", "Nested team id")
+        .argument("[path]", "Team project directory or Spawnfile path", process.cwd())
+        .action(async (id, inputPath) => {
+        const result = await handlers.addTeamProject({
+            id,
+            path: inputPath
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+        for (const filePath of result.createdFiles) {
+            streams.stdout(`created ${filePath}`);
+        }
+    });
+    const modelCommand = program
+        .command("model")
+        .description("Edit primary and fallback model declarations");
+    modelCommand
+        .command("set")
+        .argument("<provider>", "Model provider")
+        .argument("<name>", "Model name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--auth <method>", "Model auth method")
+        .option("--key <env>", "Environment variable for api_key auth")
+        .option("--compat <compatibility>", "Endpoint compatibility for custom/local models")
+        .option("--base-url <url>", "Endpoint base URL for custom/local models")
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (provider, name, inputPath, options) => {
+        const result = await handlers.setProjectPrimaryModel({
+            authKey: options.key,
+            authMethod: options.auth,
+            endpointBaseUrl: options.baseUrl,
+            endpointCompatibility: options.compat,
+            name,
+            path: inputPath,
+            provider,
+            recursive: options.recursive
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+    modelCommand
+        .command("add-fallback")
+        .argument("<provider>", "Model provider")
+        .argument("<name>", "Model name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--auth <method>", "Model auth method")
+        .option("--key <env>", "Environment variable for api_key auth")
+        .option("--compat <compatibility>", "Endpoint compatibility for custom/local models")
+        .option("--base-url <url>", "Endpoint base URL for custom/local models")
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (provider, name, inputPath, options) => {
+        const result = await handlers.addProjectModelFallback({
+            authKey: options.key,
+            authMethod: options.auth,
+            endpointBaseUrl: options.baseUrl,
+            endpointCompatibility: options.compat,
+            name,
+            path: inputPath,
+            provider,
+            recursive: options.recursive
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+    modelCommand
+        .command("clear-fallbacks")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (inputPath, options) => {
+        const result = await handlers.clearProjectModelFallbacks({
+            path: inputPath,
+            recursive: options.recursive
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+    program
+        .command("validate")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .action(async (inputPath) => {
+        const plan = await handlers.buildCompilePlan(inputPath);
+        streams.stdout("validation succeeded");
+        streams.stdout(formatPlanSummary(plan));
+    });
+    program
+        .command("runtimes")
+        .description("List bundled runtime adapters")
+        .action(() => {
+        for (const runtimeName of handlers.listRuntimeAdapters()) {
+            streams.stdout(runtimeName);
+        }
+    });
+    const authCommand = program.command("auth").description("Manage local Spawnfile auth profiles");
+    const authImportCommand = authCommand
+        .command("import")
+        .description("Import auth material into a local auth profile");
+    authImportCommand
+        .command("env")
+        .argument("<file>", "Path to an env file")
+        .option("-p, --profile <name>", "Auth profile name", "default")
+        .action(async (filePath, options) => {
+        const profile = await handlers.importEnvFile(options.profile, filePath);
+        for (const line of formatAuthProfileSummary(profile)) {
+            streams.stdout(line);
+        }
+    });
+    authImportCommand
+        .command("claude-code")
+        .option("-p, --profile <name>", "Auth profile name", "default")
+        .option("--from <directory>", "Source Claude Code config directory")
+        .action(async (options) => {
+        const profile = await handlers.importClaudeCodeAuth(options.profile, options.from);
+        for (const line of formatAuthProfileSummary(profile)) {
+            streams.stdout(line);
+        }
+    });
+    authImportCommand
+        .command("codex")
+        .option("-p, --profile <name>", "Auth profile name", "default")
+        .option("--from <directory>", "Source Codex config directory")
+        .action(async (options) => {
+        const profile = await handlers.importCodexAuth(options.profile, options.from);
+        for (const line of formatAuthProfileSummary(profile)) {
+            streams.stdout(line);
+        }
+    });
+    authCommand
+        .command("sync")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("-p, --profile <name>", "Auth profile name", "default")
+        .option("--env-file <file>", "Path to an env file with model API keys")
+        .option("--claude-from <directory>", "Source Claude Code config directory")
+        .option("--codex-from <directory>", "Source Codex config directory")
+        .action(async (inputPath, options) => {
+        const profile = await handlers.syncProjectAuth(inputPath, {
+            claudeCodeDirectory: options.claudeFrom,
+            codexDirectory: options.codexFrom,
+            envFilePath: options.envFile,
+            profileName: options.profile
+        });
+        for (const line of formatAuthProfileSummary(profile)) {
+            streams.stdout(line);
+        }
+    });
+    authCommand
+        .command("show")
+        .option("-p, --profile <name>", "Auth profile name", "default")
+        .action(async (options) => {
+        const profile = await handlers.requireAuthProfile(options.profile);
+        for (const line of formatAuthProfileSummary(profile)) {
+            streams.stdout(line);
+        }
+    });
+    try {
+        await program.parseAsync(argv, { from: "user" });
+        return 0;
+    }
+    catch (error) {
+        const message = isSpawnfileError(error)
+            ? `${error.code}: ${error.message}`
+            : error instanceof Error
+                ? error.message
+                : String(error);
+        streams.stderr(message);
+        return 1;
+    }
+};

package/dist/compiler/addProjectNode.d.ts

@@ -0,0 +1,21 @@
+export interface AddAgentProjectOptions {
+    id: string;
+    path?: string;
+    runtime?: string;
+}
+export interface AddSubagentProjectOptions {
+    id: string;
+    path?: string;
+}
+export interface AddTeamProjectOptions {
+    id: string;
+    path?: string;
+}
+export interface AddProjectNodeResult {
+    createdFiles: string[];
+    targetDirectory: string;
+    updatedFiles: string[];
+}
+export declare const addAgentProject: (options: AddAgentProjectOptions) => Promise<AddProjectNodeResult>;
+export declare const addSubagentProject: (options: AddSubagentProjectOptions) => Promise<AddProjectNodeResult>;
+export declare const addTeamProject: (options: AddTeamProjectOptions) => Promise<AddProjectNodeResult>;