spawnfile 0.1.11 → 0.1.13

package/dist/distribution/consumeImageSupport.js

@@ -0,0 +1,63 @@
+import { randomBytes } from "node:crypto";
+const GENERATED_RUNTIME_SECRET_NAMES = new Set([
+    "OPENCLAW_GATEWAY_TOKEN",
+    "OPENCLAW_HOOKS_TOKEN"
+]);
+/** Derives a kebab-case deployment name from the image repository component. */
+export const deriveDeploymentName = (ref) => {
+    const base = ref.name.split("/").pop() ?? ref.name;
+    const normalized = base
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return normalized || "deployment";
+};
+/** Per-deployment volume name so two deployments never share a store. */
+export const deriveVolumeName = (deploymentName, mountId) => {
+    const safeMount = mountId.replace(/[^A-Za-z0-9_.-]+/g, "-");
+    return `spawnfile_${deploymentName}_${safeMount}`;
+};
+/**
+ * Builds the container environment for a sourceless deployment: auth-profile
+ * and env-file values, process-env overrides for declared secrets, and
+ * generated runtime tokens that the user must never supply.
+ */
+export const resolveImageEnvironment = (input) => {
+    const env = {
+        ...input.authValues,
+        ...(input.envFileEnv ?? {})
+    };
+    const declaredSecrets = new Set();
+    for (const category of ["model", "project", "runtime", "surface"]) {
+        for (const entry of input.report.secrets[category]) {
+            declaredSecrets.add(entry.name);
+        }
+    }
+    for (const name of new Set([...Object.keys(env), ...declaredSecrets])) {
+        const processValue = process.env[name];
+        if (typeof processValue === "string" && processValue.length > 0) {
+            env[name] = processValue;
+        }
+    }
+    for (const category of ["runtime"]) {
+        for (const entry of input.report.secrets[category]) {
+            if (!entry.generated) {
+                continue;
+            }
+            const hasValue = typeof env[entry.name] === "string" && env[entry.name].length > 0;
+            if (!hasValue && GENERATED_RUNTIME_SECRET_NAMES.has(entry.name)) {
+                env[entry.name] = randomBytes(24).toString("hex");
+            }
+        }
+    }
+    for (const [name, value] of Object.entries(env)) {
+        if (value.includes("\n")) {
+            delete env[name];
+        }
+    }
+    return env;
+};
+export const renderEnvFileContent = (env) => Object.entries(env)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([name, value]) => `${name}=${value}`)
+    .join("\n") + "\n";

package/dist/distribution/distributionReportSchema.d.ts

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import type { DistributionReport } from "./types.js";
+export declare const distributionReportSchema: z.ZodObject<{
+    compile_fingerprint: z.ZodString;
+    generated_at: z.ZodString;
+    internal_ports: z.ZodArray<z.ZodNumber>;
+    model_auth_methods: z.ZodRecord<z.ZodString, z.ZodString>;
+    moltnet: z.ZodObject<{
+        networks: z.ZodArray<z.ZodObject<{
+            binding: z.ZodOptional<z.ZodLiteral<"env">>;
+            id: z.ZodString;
+            server_mode: z.ZodUnion<readonly [z.ZodLiteral<"external">, z.ZodLiteral<"managed">]>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    organization: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            runtime: z.ZodNullable<z.ZodString>;
+            teams: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        project: z.ZodString;
+        teams: z.ZodArray<z.ZodObject<{
+            agents: z.ZodArray<z.ZodString>;
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    persistent_mounts: z.ZodArray<z.ZodObject<{
+        durability: z.ZodLiteral<"persistent">;
+        id: z.ZodString;
+        kind: z.ZodLiteral<"volume">;
+        target: z.ZodString;
+    }, z.core.$strict>>;
+    port_mappings: z.ZodArray<z.ZodObject<{
+        internal_port: z.ZodNumber;
+        published_port: z.ZodNumber;
+    }, z.core.$strict>>;
+    ports: z.ZodArray<z.ZodNumber>;
+    resources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"git">, z.ZodLiteral<"volume">]>;
+        link_path: z.ZodString;
+        mode: z.ZodUnion<readonly [z.ZodLiteral<"mutable">, z.ZodLiteral<"readonly">]>;
+        mount: z.ZodString;
+        sharing: z.ZodUnion<readonly [z.ZodLiteral<"per_agent">, z.ZodLiteral<"team">]>;
+    }, z.core.$strict>>;
+    runtime_instances: z.ZodArray<z.ZodObject<{
+        config_path: z.ZodString;
+        home_path: z.ZodNullable<z.ZodString>;
+        id: z.ZodString;
+        internal_port: z.ZodNullable<z.ZodNumber>;
+        model_auth_methods: z.ZodRecord<z.ZodString, z.ZodString>;
+        model_secrets_required: z.ZodArray<z.ZodString>;
+        node_ids: z.ZodArray<z.ZodString>;
+        published_port: z.ZodNullable<z.ZodNumber>;
+        runtime: z.ZodString;
+        workspace_path: z.ZodString;
+    }, z.core.$strict>>;
+    secrets: z.ZodObject<{
+        model: z.ZodArray<z.ZodObject<{
+            generated: z.ZodBoolean;
+            name: z.ZodString;
+            required: z.ZodBoolean;
+        }, z.core.$strict>>;
+        project: z.ZodArray<z.ZodObject<{
+            generated: z.ZodBoolean;
+            name: z.ZodString;
+            required: z.ZodBoolean;
+        }, z.core.$strict>>;
+        runtime: z.ZodArray<z.ZodObject<{
+            generated: z.ZodBoolean;
+            name: z.ZodString;
+            required: z.ZodBoolean;
+        }, z.core.$strict>>;
+        surface: z.ZodArray<z.ZodObject<{
+            generated: z.ZodBoolean;
+            name: z.ZodString;
+            required: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    version: z.ZodLiteral<"spawnfile.distribution-report.v1">;
+}, z.core.$strict>;
+export declare const parseDistributionReport: (source: unknown, sourceLabel?: string) => DistributionReport;

package/dist/distribution/distributionReportSchema.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { SpawnfileError } from "../shared/index.js";
+import { DISTRIBUTION_REPORT_VERSION } from "./types.js";
+const secretEntrySchema = z.object({
+    generated: z.boolean(),
+    name: z.string().min(1),
+    required: z.boolean()
+}).strict();
+// Path fields from an untrusted image flow into `docker run -v` mount specs. A
+// crafted value containing `:` would inject extra mount fields (e.g. drop `:ro`
+// or add options), and `..` could redirect the mount target. Constrain every
+// path the consumer interpolates to a clean absolute POSIX path so a hostile
+// report is rejected up front; a legitimately compiled image always satisfies this.
+const containerPathSchema = z
+    .string()
+    .min(1)
+    .refine((value) => value.startsWith("/") &&
+    !value.includes(":") &&
+    !/\s/.test(value) &&
+    !value.split("/").includes(".."), { message: "must be a clean absolute POSIX path (no ':', whitespace, or '..' segment)" });
+// Ports are interpolated into `-p host:container`; bound them to the valid TCP range.
+const portSchema = z.number().int().min(1).max(65535);
+// A runtime instance id is interpolated into a host path (the auth-profiles temp
+// file) and then into a `docker run -v` source by the runtime adapters, so an
+// unconstrained value could traverse with `..` or inject mount fields with `:`.
+// Legitimate ids are compile-generated `<kind>-<slug>` identifiers.
+const instanceIdSchema = z
+    .string()
+    .min(1)
+    .refine((value) => /^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(value) && !value.includes(".."), {
+    message: "must be an identifier (letters, digits, '_', '.', '-'; no '/', ':', whitespace, or '..')"
+});
+const runtimeInstanceSchema = z.object({
+    config_path: containerPathSchema,
+    home_path: containerPathSchema.nullable(),
+    id: instanceIdSchema,
+    internal_port: portSchema.nullable(),
+    model_auth_methods: z.record(z.string(), z.string()),
+    model_secrets_required: z.array(z.string()),
+    node_ids: z.array(z.string()),
+    published_port: portSchema.nullable(),
+    runtime: z.string().min(1),
+    workspace_path: containerPathSchema
+}).strict();
+export const distributionReportSchema = z.object({
+    compile_fingerprint: z.string().min(1),
+    generated_at: z.string().min(1),
+    internal_ports: z.array(portSchema),
+    model_auth_methods: z.record(z.string(), z.string()),
+    moltnet: z.object({
+        networks: z.array(z.object({
+            binding: z.literal("env").optional(),
+            id: z.string().min(1),
+            server_mode: z.union([z.literal("external"), z.literal("managed")])
+        }).strict())
+    }).strict(),
+    organization: z.object({
+        agents: z.array(z.object({
+            id: z.string().min(1),
+            name: z.string(),
+            runtime: z.string().nullable(),
+            teams: z.array(z.string())
+        }).strict()),
+        project: z.string().min(1),
+        teams: z.array(z.object({
+            agents: z.array(z.string()),
+            id: z.string().min(1),
+            name: z.string()
+        }).strict())
+    }).strict(),
+    persistent_mounts: z.array(z.object({
+        durability: z.literal("persistent"),
+        // Sanitized by deriveVolumeName before use, but constrained here too so the
+        // schema alone keeps the volume-name source clean (defense in depth).
+        id: instanceIdSchema,
+        kind: z.literal("volume"),
+        target: containerPathSchema
+    }).strict()),
+    port_mappings: z.array(z.object({
+        internal_port: portSchema,
+        published_port: portSchema
+    }).strict()),
+    ports: z.array(portSchema),
+    resources: z.array(z.object({
+        id: z.string().min(1),
+        kind: z.union([z.literal("git"), z.literal("volume")]),
+        link_path: z.string(),
+        mode: z.union([z.literal("mutable"), z.literal("readonly")]),
+        mount: z.string(),
+        sharing: z.union([z.literal("per_agent"), z.literal("team")])
+    }).strict()),
+    runtime_instances: z.array(runtimeInstanceSchema),
+    secrets: z.object({
+        model: z.array(secretEntrySchema),
+        project: z.array(secretEntrySchema),
+        runtime: z.array(secretEntrySchema),
+        surface: z.array(secretEntrySchema)
+    }).strict(),
+    version: z.literal(DISTRIBUTION_REPORT_VERSION)
+}).strict();
+export const parseDistributionReport = (source, sourceLabel = "distribution report") => {
+    const parsed = distributionReportSchema.safeParse(source);
+    if (!parsed.success) {
+        throw new SpawnfileError("validation_error", `Invalid ${sourceLabel}: ${z.prettifyError(parsed.error)}`);
+    }
+    return parsed.data;
+};

package/dist/distribution/dockerRunner.d.ts

@@ -0,0 +1,5 @@
+export interface DockerCommandRunner {
+    /** Runs docker with args; resolves stdout as a Buffer. Rejects on non-zero exit. */
+    (args: string[]): Promise<Buffer>;
+}
+export declare const createConsumerDockerRunner: (dockerCommand: string, baseArgs: string[]) => DockerCommandRunner;

package/dist/distribution/dockerRunner.js

@@ -0,0 +1,21 @@
+import { spawn } from "node:child_process";
+import { SpawnfileError } from "../shared/index.js";
+export const createConsumerDockerRunner = (dockerCommand, baseArgs) => async (args) => new Promise((resolve, reject) => {
+    const finalArgs = [...baseArgs, ...args];
+    const child = spawn(dockerCommand, finalArgs, {
+        env: { ...process.env },
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(String(chunk)));
+    child.on("error", reject);
+    child.on("close", (code) => {
+        if (code === 0) {
+            resolve(Buffer.concat(stdout));
+            return;
+        }
+        reject(new SpawnfileError("runtime_error", `docker ${finalArgs[0]} failed (${code}): ${stderr.join("").trim()}`));
+    });
+});

package/dist/distribution/extractImage.d.ts

@@ -0,0 +1,25 @@
+import type { DockerCommandRunner } from "./dockerRunner.js";
+import type { DistributionReport } from "./types.js";
+export type { DockerCommandRunner } from "./dockerRunner.js";
+export interface ImageInspection {
+    compileFingerprint: string;
+    labels: Record<string, string>;
+    report: DistributionReport;
+}
+export interface ExtractImageOptions {
+    dockerCommand?: string;
+    dockerContext?: string;
+    dockerHost?: string;
+    pull?: boolean;
+    runDocker?: DockerCommandRunner;
+}
+export declare const resolveDockerBaseArgs: (options: {
+    dockerContext?: string;
+    dockerHost?: string;
+}) => string[];
+/**
+ * Pulls (optionally), inspects labels, and extracts the embedded distribution
+ * report from an image without starting its entrypoint. Uses a stopped helper
+ * container and guarantees cleanup.
+ */
+export declare const extractImageReport: (imageRef: string, options?: ExtractImageOptions) => Promise<ImageInspection>;

package/dist/distribution/extractImage.js

@@ -0,0 +1,96 @@
+import { SpawnfileError } from "../shared/index.js";
+import { createConsumerDockerRunner } from "./dockerRunner.js";
+import { parseDistributionReport } from "./distributionReportSchema.js";
+import { extractSingleFileFromTar } from "./tarReader.js";
+import { DISTRIBUTION_REPORT_IMAGE_PATH, IMAGE_CONTRACT_VERSION } from "./types.js";
+const REPORT_SIZE_CAP_BYTES = 4 * 1024 * 1024;
+const LABEL_VALUE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/;
+export const resolveDockerBaseArgs = (options) => {
+    if (options.dockerContext) {
+        return ["--context", options.dockerContext];
+    }
+    if (options.dockerHost) {
+        return ["--host", options.dockerHost];
+    }
+    return [];
+};
+const assertContractLabels = (labels) => {
+    const contract = labels["com.spawnfile.image_contract"];
+    if (!contract) {
+        throw new SpawnfileError("validation_error", "Image is not a Spawnfile image: missing com.spawnfile.image_contract label");
+    }
+    if (contract !== IMAGE_CONTRACT_VERSION) {
+        throw new SpawnfileError("validation_error", `Unsupported image contract ${contract}; this CLI supports ${IMAGE_CONTRACT_VERSION}`);
+    }
+    for (const key of ["com.spawnfile.project", "com.spawnfile.compile_fingerprint"]) {
+        const value = labels[key];
+        if (!value || !LABEL_VALUE_PATTERN.test(value)) {
+            throw new SpawnfileError("validation_error", `Image label ${key} is missing or not identifier-only`);
+        }
+    }
+};
+/**
+ * Pulls (optionally), inspects labels, and extracts the embedded distribution
+ * report from an image without starting its entrypoint. Uses a stopped helper
+ * container and guarantees cleanup.
+ */
+export const extractImageReport = async (imageRef, options = {}) => {
+    const dockerCommand = options.dockerCommand ?? "docker";
+    const baseArgs = resolveDockerBaseArgs(options);
+    const runDocker = options.runDocker ?? createConsumerDockerRunner(dockerCommand, baseArgs);
+    if (options.pull) {
+        await runDocker(["pull", imageRef]);
+    }
+    let labelsRaw;
+    try {
+        labelsRaw = (await runDocker([
+            "image",
+            "inspect",
+            "--format",
+            "{{json .Config.Labels}}",
+            imageRef
+        ])).toString("utf8").trim();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/No such image|not found/i.test(message)) {
+            throw new SpawnfileError("validation_error", `Image ${imageRef} is not available locally. Pull it first with --pull, or publish it with 'spawnfile publish'.`);
+        }
+        throw error;
+    }
+    let labels;
+    try {
+        labels = JSON.parse(labelsRaw) ?? {};
+    }
+    catch {
+        throw new SpawnfileError("validation_error", `Unable to read labels for image ${imageRef}`);
+    }
+    assertContractLabels(labels);
+    const reportPath = labels["com.spawnfile.report"] ?? DISTRIBUTION_REPORT_IMAGE_PATH;
+    const helperName = `spawnfile-inspect-${Date.now().toString(36)}-${Math.floor(Number(process.pid)).toString(36)}`;
+    await runDocker(["create", "--name", helperName, imageRef]);
+    let tar;
+    try {
+        tar = await runDocker(["cp", `${helperName}:${reportPath}`, "-"]);
+    }
+    finally {
+        await runDocker(["rm", "-f", helperName]).catch(() => undefined);
+    }
+    const reportBytes = extractSingleFileFromTar(tar, { maxBytes: REPORT_SIZE_CAP_BYTES });
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(reportBytes.toString("utf8"));
+    }
+    catch {
+        throw new SpawnfileError("validation_error", `Embedded report in ${imageRef} is not valid JSON`);
+    }
+    const report = parseDistributionReport(parsedJson, `embedded report in ${imageRef}`);
+    if (report.compile_fingerprint !== labels["com.spawnfile.compile_fingerprint"]) {
+        throw new SpawnfileError("validation_error", `Embedded report fingerprint does not match the image label for ${imageRef}`);
+    }
+    return {
+        compileFingerprint: report.compile_fingerprint,
+        labels,
+        report
+    };
+};

package/dist/distribution/fingerprint.d.ts

@@ -0,0 +1,2 @@
+import type { DistributionReport } from "./types.js";
+export declare const createDistributionFingerprint: (report: Omit<DistributionReport, "compile_fingerprint" | "generated_at">) => string;

package/dist/distribution/fingerprint.js

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+const stableStringify = (value) => {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+};
+export const createDistributionFingerprint = (report) => `sf1:${createHash("sha1").update(stableStringify(report)).digest("hex").slice(0, 12)}`;

package/dist/distribution/imageRef.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedImageReference {
+    digest: string | null;
+    name: string;
+    registry: string | null;
+    tag: string | null;
+}
+export declare const parseImageReference: (value: string) => ParsedImageReference | null;
+export declare const parseImplicitImageReference: (value: string) => ParsedImageReference | null;
+export declare const hasRegistryComponent: (value: string) => boolean;

package/dist/distribution/imageRef.js

@@ -0,0 +1,65 @@
+const NAME_COMPONENT = /^[a-z0-9]+(?:(?:[._]|__|[-]+)[a-z0-9]+)*$/;
+const TAG_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9._-]{0,127}$/;
+const DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/;
+const REGISTRY_HOST_PATTERN = /^[a-zA-Z0-9.-]+(?::\d{1,5})?$/;
+const isRegistryComponent = (component) => (component.includes(".") || component.includes(":") || component === "localhost")
+    && REGISTRY_HOST_PATTERN.test(component);
+const splitDigest = (value) => {
+    const index = value.indexOf("@");
+    if (index === -1) {
+        return { digest: null, rest: value };
+    }
+    return { digest: value.slice(index + 1), rest: value.slice(0, index) };
+};
+const splitTag = (value) => {
+    const slashIndex = value.lastIndexOf("/");
+    const colonIndex = value.lastIndexOf(":");
+    if (colonIndex === -1 || colonIndex < slashIndex) {
+        return { rest: value, tag: null };
+    }
+    return { rest: value.slice(0, colonIndex), tag: value.slice(colonIndex + 1) };
+};
+export const parseImageReference = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed || /\s/.test(trimmed)) {
+        return null;
+    }
+    const { digest, rest: withoutDigest } = splitDigest(trimmed);
+    if (digest !== null && !DIGEST_PATTERN.test(digest)) {
+        return null;
+    }
+    const { rest: repository, tag } = splitTag(withoutDigest);
+    if (tag !== null && !TAG_PATTERN.test(tag)) {
+        return null;
+    }
+    if (!repository) {
+        return null;
+    }
+    const components = repository.split("/");
+    let registry = null;
+    let nameComponents = components;
+    if (components.length > 1 && isRegistryComponent(components[0])) {
+        registry = components[0];
+        nameComponents = components.slice(1);
+    }
+    if (nameComponents.length === 0 || nameComponents.some((component) => !NAME_COMPONENT.test(component))) {
+        return null;
+    }
+    return {
+        digest,
+        name: nameComponents.join("/"),
+        registry,
+        tag
+    };
+};
+export const parseImplicitImageReference = (value) => {
+    const parsed = parseImageReference(value);
+    if (!parsed) {
+        return null;
+    }
+    if (parsed.digest === null && parsed.tag === null && parsed.registry === null) {
+        return null;
+    }
+    return parsed;
+};
+export const hasRegistryComponent = (value) => parseImageReference(value)?.registry !== null;

package/dist/distribution/imageRuntimeAuth.d.ts

@@ -0,0 +1,19 @@
+import type { ResolvedAuthProfile } from "../auth/index.js";
+import type { DistributionReport } from "./types.js";
+export interface ImageRuntimeAuthInput {
+    authProfile: ResolvedAuthProfile;
+    report: DistributionReport;
+    tempRoot: string;
+}
+export interface ImageRuntimeAuthResult {
+    coveredModelSecrets: Set<string>;
+    mountArgs: string[];
+}
+/**
+ * Builds the credential mounts for a sourceless image deployment that uses
+ * import-based model auth. The OAuth-mode config is already baked into the
+ * image, so this only mounts the consumer's credential tokens (per-adapter) and
+ * their raw import directories into each runtime home — the same material a
+ * project deployment provides, without needing the project source.
+ */
+export declare const prepareImageRuntimeAuthMounts: (input: ImageRuntimeAuthInput) => Promise<ImageRuntimeAuthResult>;

package/dist/distribution/imageRuntimeAuth.js

@@ -0,0 +1,71 @@
+import path from "node:path";
+import { loadImportedClaudeCodeCredential, loadImportedCodexCredential } from "../auth/index.js";
+import { fileExists } from "../filesystem/index.js";
+import { getRuntimeAdapter } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+const importMountTargetName = (kind) => kind === "claude-code" ? ".claude" : ".codex";
+/**
+ * Builds the credential mounts for a sourceless image deployment that uses
+ * import-based model auth. The OAuth-mode config is already baked into the
+ * image, so this only mounts the consumer's credential tokens (per-adapter) and
+ * their raw import directories into each runtime home — the same material a
+ * project deployment provides, without needing the project source.
+ */
+export const prepareImageRuntimeAuthMounts = async (input) => {
+    const coveredModelSecrets = new Set();
+    const mountArgs = [];
+    const runtimeHomes = new Set();
+    for (const instance of input.report.runtime_instances) {
+        if (instance.home_path) {
+            runtimeHomes.add(instance.home_path);
+        }
+        const adapter = getRuntimeAdapter(instance.runtime);
+        if (!adapter.prepareRuntimeAuth) {
+            continue;
+        }
+        const prepared = await adapter.prepareRuntimeAuth({
+            authProfile: input.authProfile,
+            env: {},
+            instance: {
+                config_path: instance.config_path,
+                home_path: instance.home_path,
+                id: instance.id,
+                model_auth_methods: instance.model_auth_methods,
+                model_secrets_required: instance.model_secrets_required,
+                runtime: instance.runtime
+            },
+            outputDirectory: "",
+            tempRoot: input.tempRoot
+        });
+        for (const secret of prepared.coveredModelSecrets) {
+            coveredModelSecrets.add(secret);
+        }
+        mountArgs.push(...prepared.mountArgs);
+    }
+    // Mount the raw credential import directories into each runtime home so the
+    // runtime's OAuth client can read them (e.g. ~/.claude, ~/.codex).
+    for (const kind of ["claude-code", "codex"]) {
+        const entry = input.authProfile.imports[kind];
+        if (!entry) {
+            continue;
+        }
+        if (!(await fileExists(entry.path))) {
+            throw new SpawnfileError("validation_error", `Imported auth path for ${kind} does not exist: ${entry.path}`);
+        }
+        // The directory existing is not enough: a registered import whose credential
+        // file is missing, expired, or malformed would mount cleanly but produce a
+        // container that cannot authenticate. Load it now so the failure surfaces
+        // before the container starts, mirroring the project-deployment path.
+        const credential = kind === "claude-code"
+            ? await loadImportedClaudeCodeCredential(entry.path)
+            : await loadImportedCodexCredential(entry.path);
+        if (!credential) {
+            throw new SpawnfileError("validation_error", `Imported ${kind} auth at ${entry.path} has no usable credential. ` +
+                `Re-run the ${kind} login (or re-import) before deploying this image.`);
+        }
+        for (const home of runtimeHomes) {
+            mountArgs.push("-v", `${entry.path}:${path.posix.join(home, importMountTargetName(kind))}`);
+        }
+    }
+    return { coveredModelSecrets, mountArgs };
+};

package/dist/distribution/index.d.ts

@@ -0,0 +1,24 @@
+export { buildDistributionReport, createDistributionImageLabels } from "./buildDistributionReport.js";
+export type { BuildDistributionReportInput, DistributionEnvVariableInput } from "./buildDistributionReport.js";
+export { createDistributionFingerprint } from "./fingerprint.js";
+export { extractImageReport, resolveDockerBaseArgs } from "./extractImage.js";
+export type { DockerCommandRunner, ExtractImageOptions, ImageInspection } from "./extractImage.js";
+export { parseDistributionReport } from "./distributionReportSchema.js";
+export { consumeImageUp } from "./consumeImage.js";
+export type { ConsumeImageUpOptions, ConsumeImageUpResult } from "./consumeImage.js";
+export { deriveDeploymentName, deriveVolumeName, renderEnvFileContent, resolveImageEnvironment } from "./consumeImageSupport.js";
+export { createConsumerDockerRunner } from "./dockerRunner.js";
+export { prepareImageRuntimeAuthMounts } from "./imageRuntimeAuth.js";
+export { runImagePreflight } from "./preflight.js";
+export { verifyDistributionReport } from "./verifyDistributionReport.js";
+export type { VerifyDistributionReportInput } from "./verifyDistributionReport.js";
+export { projectImageOrganizationView } from "./projectImageView.js";
+export { buildImageInterfaceSummary, renderImageInterface } from "./renderImageInterface.js";
+export type { ImageInterfaceSummary, RenderImageInterfaceOptions } from "./renderImageInterface.js";
+export type { PreflightInput, PreflightResult } from "./preflight.js";
+export { extractSingleFileFromTar } from "./tarReader.js";
+export { hasRegistryComponent, parseImageReference, parseImplicitImageReference } from "./imageRef.js";
+export type { ParsedImageReference } from "./imageRef.js";
+export { normalizeProjectLabelSlug } from "./projectName.js";
+export { DISTRIBUTION_REPORT_IMAGE_PATH, DISTRIBUTION_REPORT_OUTPUT_FILE, DISTRIBUTION_REPORT_VERSION, IMAGE_CONTRACT_VERSION } from "./types.js";
+export type { DistributionAgentSummary, DistributionImageLabels, DistributionMoltnetNetwork, DistributionOrganizationSummary, DistributionPersistentMount, DistributionPortMapping, DistributionReport, DistributionRuntimeInstance, DistributionSecretCategory, DistributionSecretEntry, DistributionTeamSummary, DistributionWorkspaceResource } from "./types.js";

package/dist/distribution/index.js

@@ -0,0 +1,16 @@
+export { buildDistributionReport, createDistributionImageLabels } from "./buildDistributionReport.js";
+export { createDistributionFingerprint } from "./fingerprint.js";
+export { extractImageReport, resolveDockerBaseArgs } from "./extractImage.js";
+export { parseDistributionReport } from "./distributionReportSchema.js";
+export { consumeImageUp } from "./consumeImage.js";
+export { deriveDeploymentName, deriveVolumeName, renderEnvFileContent, resolveImageEnvironment } from "./consumeImageSupport.js";
+export { createConsumerDockerRunner } from "./dockerRunner.js";
+export { prepareImageRuntimeAuthMounts } from "./imageRuntimeAuth.js";
+export { runImagePreflight } from "./preflight.js";
+export { verifyDistributionReport } from "./verifyDistributionReport.js";
+export { projectImageOrganizationView } from "./projectImageView.js";
+export { buildImageInterfaceSummary, renderImageInterface } from "./renderImageInterface.js";
+export { extractSingleFileFromTar } from "./tarReader.js";
+export { hasRegistryComponent, parseImageReference, parseImplicitImageReference } from "./imageRef.js";
+export { normalizeProjectLabelSlug } from "./projectName.js";
+export { DISTRIBUTION_REPORT_IMAGE_PATH, DISTRIBUTION_REPORT_OUTPUT_FILE, DISTRIBUTION_REPORT_VERSION, IMAGE_CONTRACT_VERSION } from "./types.js";

package/dist/distribution/preflight.d.ts

@@ -0,0 +1,11 @@
+import type { DistributionReport } from "./types.js";
+export interface PreflightInput {
+    authValues: Record<string, string>;
+    availableImports?: string[];
+    report: DistributionReport;
+}
+export interface PreflightResult {
+    generatedSecrets: string[];
+    requiredSecrets: string[];
+}
+export declare const runImagePreflight: (input: PreflightInput) => PreflightResult;