spawnfile 0.1.11 → 0.1.13

package/dist/deployment/homeStore.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+import { open, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { resolveSpawnfileHome } from "../auth/index.js";
+import { ensureDirectory, readUtf8File } from "../filesystem/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { normalizeDeploymentName } from "./names.js";
+import { parseDeploymentRecord } from "./record.js";
+export const resolveHomeDeploymentsDirectory = () => path.join(resolveSpawnfileHome(), "deployments");
+export const resolveHomeDeploymentDirectory = (deploymentName) => path.join(resolveHomeDeploymentsDirectory(), normalizeDeploymentName(deploymentName));
+export const resolveHomeRecordPath = (deploymentName) => path.join(resolveHomeDeploymentDirectory(deploymentName), "record.json");
+export const resolveHomeReportPath = (deploymentName) => path.join(resolveHomeDeploymentDirectory(deploymentName), "spawnfile-report.json");
+/**
+ * Acquires an exclusive lock for a home deployment so concurrent `up`
+ * invocations cannot race on the same record (and orphan each other's
+ * containers). Returns a release function. Throws if the deployment is already
+ * locked by another in-flight operation.
+ */
+const isProcessAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // ESRCH means no such process (stale); EPERM means it exists but is ours to
+        // not signal — treat as alive to stay safe.
+        return error.code === "EPERM";
+    }
+};
+export const acquireHomeDeploymentLock = async (deploymentName) => {
+    const directory = resolveHomeDeploymentDirectory(deploymentName);
+    await ensureDirectory(directory);
+    const lockPath = path.join(directory, ".lock");
+    const write = async () => {
+        const handle = await open(lockPath, "wx");
+        try {
+            await handle.write(JSON.stringify({ pid: process.pid }));
+        }
+        finally {
+            await handle.close();
+        }
+    };
+    try {
+        await write();
+    }
+    catch (error) {
+        if (error.code !== "EEXIST") {
+            throw error;
+        }
+        // A lock exists. Reclaim it only if the owning process is gone (a crashed
+        // deploy must not lock the deployment forever); otherwise it is genuinely busy.
+        let ownerPid = null;
+        try {
+            ownerPid = JSON.parse(await readUtf8File(lockPath)).pid ?? null;
+        }
+        catch {
+            ownerPid = null;
+        }
+        if (ownerPid !== null && isProcessAlive(ownerPid)) {
+            throw new SpawnfileError("runtime_error", `Deployment "${normalizeDeploymentName(deploymentName)}" is already being modified by another operation`);
+        }
+        await rm(lockPath, { force: true });
+        await write();
+    }
+    return async () => {
+        await rm(lockPath, { force: true });
+    };
+};
+const writeAtomic = async (filePath, content) => {
+    const temporaryPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+    await writeFile(temporaryPath, content, "utf8");
+    await rename(temporaryPath, filePath);
+};
+/** Writes the record and the cached distribution report together, record last. */
+export const writeHomeDeployment = async (record, report) => {
+    const parsed = parseDeploymentRecord(record);
+    const directory = resolveHomeDeploymentDirectory(parsed.name);
+    await ensureDirectory(directory);
+    const reportPath = resolveHomeReportPath(parsed.name);
+    const recordPath = resolveHomeRecordPath(parsed.name);
+    await writeAtomic(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+    await writeAtomic(recordPath, `${JSON.stringify(parsed, null, 2)}\n`);
+    return { recordPath, reportPath };
+};
+export const readHomeDeploymentRecord = async (deploymentName) => {
+    const recordPath = resolveHomeRecordPath(deploymentName);
+    let parsed;
+    try {
+        parsed = JSON.parse(await readUtf8File(recordPath));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("validation_error", `Unable to read home deployment record ${recordPath}: ${reason}`);
+    }
+    return parseDeploymentRecord(parsed, recordPath);
+};
+export const readHomeDeploymentReport = async (deploymentName) => readUtf8File(resolveHomeReportPath(deploymentName));
+export const homeDeploymentExists = async (deploymentName) => {
+    const records = await listHomeDeploymentRecords();
+    const target = normalizeDeploymentName(deploymentName);
+    return records.some((entry) => entry.record.name === target);
+};
+export const listHomeDeploymentRecords = async () => {
+    const directory = resolveHomeDeploymentsDirectory();
+    let entries;
+    try {
+        entries = await readdir(directory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("validation_error", `Unable to read home deployments directory ${directory}: ${reason}`);
+    }
+    const records = await Promise.all(entries
+        .sort()
+        .map(async (entry) => {
+        const recordPath = path.join(directory, entry, "record.json");
+        try {
+            const parsed = JSON.parse(await readUtf8File(recordPath));
+            return { path: recordPath, record: parseDeploymentRecord(parsed, recordPath) };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return records
+        .filter((entry) => entry !== null)
+        .sort((left, right) => left.record.name.localeCompare(right.record.name));
+};

package/dist/deployment/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./dockerLabels.js";
+export * from "./dockerInspect.js";
+export * from "./dockerLogs.js";
+export * from "./dockerManager.js";
+export * from "./dockerProbeGateway.js";
+export * from "./dockerRecover.js";
+export * from "./homeStore.js";
+export * from "./names.js";
+export * from "./record.js";
+export * from "./target.js";

package/dist/deployment/index.js

@@ -0,0 +1,10 @@
+export * from "./dockerLabels.js";
+export * from "./dockerInspect.js";
+export * from "./dockerLogs.js";
+export * from "./dockerManager.js";
+export * from "./dockerProbeGateway.js";
+export * from "./dockerRecover.js";
+export * from "./homeStore.js";
+export * from "./names.js";
+export * from "./record.js";
+export * from "./target.js";

package/dist/deployment/names.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeDeploymentName: (name: string | undefined) => string;
+export declare const resolveDeploymentRecordsDirectory: (outputDirectory: string) => string;
+export declare const resolveDeploymentRecordPath: (outputDirectory: string, deploymentName: string) => string;

package/dist/deployment/names.js

@@ -0,0 +1,12 @@
+import path from "node:path";
+import { SpawnfileError } from "../shared/index.js";
+const deploymentNamePattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export const normalizeDeploymentName = (name) => {
+    const normalized = (name ?? "default").trim();
+    if (!deploymentNamePattern.test(normalized)) {
+        throw new SpawnfileError("validation_error", `Deployment name must be kebab-case: ${name ?? ""}`);
+    }
+    return normalized;
+};
+export const resolveDeploymentRecordsDirectory = (outputDirectory) => path.join(outputDirectory, "deployments");
+export const resolveDeploymentRecordPath = (outputDirectory, deploymentName) => path.join(resolveDeploymentRecordsDirectory(outputDirectory), `${normalizeDeploymentName(deploymentName)}.json`);

package/dist/deployment/record.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+declare const recordSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"project">;
+    root: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    digest: z.ZodNullable<z.ZodString>;
+    kind: z.ZodLiteral<"image">;
+    ref: z.ZodString;
+}, z.core.$strict>]>;
+export type DeploymentRecordSource = z.infer<typeof recordSourceSchema>;
+export declare const deploymentRecordSchema: z.ZodObject<{
+    auth_profile: z.ZodNullable<z.ZodString>;
+    compile_fingerprint: z.ZodString;
+    created_at: z.ZodString;
+    env_file: z.ZodOptional<z.ZodString>;
+    manager: z.ZodString;
+    name: z.ZodString;
+    output_directory: z.ZodNullable<z.ZodString>;
+    source: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        root: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        digest: z.ZodNullable<z.ZodString>;
+        kind: z.ZodLiteral<"image">;
+        ref: z.ZodString;
+    }, z.core.$strict>]>;
+    target: z.ZodUnion<readonly [z.ZodObject<{
+        endpoint_fingerprint: z.ZodString;
+        kind: z.ZodLiteral<"context">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        context: z.ZodString;
+        endpoint_fingerprint: z.ZodString;
+        kind: z.ZodLiteral<"docker-context">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"host">;
+        value: z.ZodString;
+    }, z.core.$strict>]>;
+    units: z.ZodArray<z.ZodObject<{
+        container_id: z.ZodNullable<z.ZodString>;
+        container_name: z.ZodNullable<z.ZodString>;
+        contains: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodUnion<readonly [z.ZodLiteral<"agent">, z.ZodLiteral<"network">, z.ZodLiteral<"team">]>;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        image_id: z.ZodNullable<z.ZodString>;
+        image_tag: z.ZodString;
+        kind: z.ZodLiteral<"container">;
+        manager: z.ZodOptional<z.ZodString>;
+        runtime_instances: z.ZodArray<z.ZodString>;
+        target: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            endpoint_fingerprint: z.ZodString;
+            kind: z.ZodLiteral<"context">;
+            name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            context: z.ZodString;
+            endpoint_fingerprint: z.ZodString;
+            kind: z.ZodLiteral<"docker-context">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"host">;
+            value: z.ZodString;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    version: z.ZodLiteral<"spawnfile.deployment.v2">;
+}, z.core.$strict>;
+export type DeploymentRecord = z.infer<typeof deploymentRecordSchema>;
+export declare const parseDeploymentRecord: (source: unknown, sourceLabel?: string) => DeploymentRecord;
+export declare const readDeploymentRecord: (recordPath: string) => Promise<DeploymentRecord>;
+export declare const readDeploymentRecordFromOutput: (outputDirectory: string, deploymentName: string) => Promise<DeploymentRecord>;
+export declare const listDeploymentRecords: (outputDirectory: string) => Promise<Array<{
+    path: string;
+    record: DeploymentRecord;
+}>>;
+export declare const writeDeploymentRecord: (outputDirectory: string, record: DeploymentRecord) => Promise<string>;
+export {};

package/dist/deployment/record.js

@@ -0,0 +1,174 @@
+import path from "node:path";
+import { readdir, rename, writeFile } from "node:fs/promises";
+import { z } from "zod";
+import { ensureDirectory, readUtf8File } from "../filesystem/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { normalizeDeploymentName, resolveDeploymentRecordPath, resolveDeploymentRecordsDirectory } from "./names.js";
+const contextTargetSchema = z.object({
+    endpoint_fingerprint: z.string().regex(/^sha256:[a-f0-9]{32}$/),
+    kind: z.literal("context"),
+    name: z.string().min(1)
+}).strict();
+const legacyContextTargetSchema = z.object({
+    context: z.string().min(1),
+    endpoint_fingerprint: z.string().regex(/^sha256:[a-f0-9]{32}$/),
+    kind: z.literal("docker-context")
+}).strict();
+const hostTargetSchema = z.object({
+    kind: z.literal("host"),
+    value: z.string().min(1)
+}).strict();
+const targetSchema = z.union([
+    contextTargetSchema,
+    legacyContextTargetSchema,
+    hostTargetSchema
+]);
+const unitV1Schema = z.object({
+    container_id: z.string().min(1).nullable(),
+    container_name: z.string().min(1).nullable(),
+    contains: z.array(z.object({
+        id: z.string().min(1),
+        kind: z.union([z.literal("agent"), z.literal("team")])
+    }).strict()),
+    id: z.string().min(1),
+    image_id: z.string().min(1).nullable(),
+    image_tag: z.string().min(1),
+    kind: z.literal("container"),
+    runtime_instances: z.array(z.string().min(1))
+}).strict();
+const unitSchema = z.object({
+    container_id: z.string().min(1).nullable(),
+    container_name: z.string().min(1).nullable(),
+    contains: z.array(z.object({
+        id: z.string().min(1),
+        kind: z.union([z.literal("agent"), z.literal("network"), z.literal("team")])
+    }).strict()),
+    id: z.string().min(1),
+    image_id: z.string().min(1).nullable(),
+    image_tag: z.string().min(1),
+    kind: z.literal("container"),
+    manager: z.string().min(1).optional(),
+    runtime_instances: z.array(z.string().min(1)),
+    target: targetSchema.optional()
+}).strict();
+const recordSourceSchema = z.union([
+    z.object({
+        kind: z.literal("project"),
+        root: z.string().min(1)
+    }).strict(),
+    z.object({
+        digest: z.string().min(1).nullable(),
+        kind: z.literal("image"),
+        ref: z.string().min(1)
+    }).strict()
+]);
+const deploymentRecordV1Schema = z.object({
+    auth_profile: z.string().min(1).nullable(),
+    compile_fingerprint: z.string().min(1),
+    created_at: z.string().min(1),
+    env_file: z.string().min(1).optional(),
+    manager: z.literal("docker"),
+    name: z.string().min(1),
+    output_directory: z.string().min(1),
+    project_root: z.string().min(1),
+    target: targetSchema,
+    units: z.array(unitV1Schema).min(1),
+    version: z.literal("spawnfile.deployment.v1")
+}).strict();
+export const deploymentRecordSchema = z.object({
+    auth_profile: z.string().min(1).nullable(),
+    compile_fingerprint: z.string().min(1),
+    created_at: z.string().min(1),
+    env_file: z.string().min(1).optional(),
+    manager: z.string().min(1),
+    name: z.string().min(1),
+    output_directory: z.string().min(1).nullable(),
+    source: recordSourceSchema,
+    target: targetSchema,
+    units: z.array(unitSchema).min(1),
+    version: z.literal("spawnfile.deployment.v2")
+}).strict();
+const upgradeV1Record = (record) => ({
+    auth_profile: record.auth_profile,
+    compile_fingerprint: record.compile_fingerprint,
+    created_at: record.created_at,
+    ...(record.env_file ? { env_file: record.env_file } : {}),
+    manager: record.manager,
+    name: record.name,
+    output_directory: record.output_directory,
+    source: { kind: "project", root: record.project_root },
+    target: record.target,
+    units: record.units,
+    version: "spawnfile.deployment.v2"
+});
+const hasVersion = (source, version) => typeof source === "object"
+    && source !== null
+    && source.version === version;
+export const parseDeploymentRecord = (source, sourceLabel = "deployment record") => {
+    let record;
+    if (hasVersion(source, "spawnfile.deployment.v1")) {
+        const parsed = deploymentRecordV1Schema.safeParse(source);
+        if (!parsed.success) {
+            throw new SpawnfileError("validation_error", `Invalid ${sourceLabel}: ${z.prettifyError(parsed.error)}`);
+        }
+        record = upgradeV1Record(parsed.data);
+    }
+    else {
+        const parsed = deploymentRecordSchema.safeParse(source);
+        if (!parsed.success) {
+            throw new SpawnfileError("validation_error", `Invalid ${sourceLabel}: ${z.prettifyError(parsed.error)}`);
+        }
+        record = parsed.data;
+    }
+    const normalizedName = normalizeDeploymentName(record.name);
+    if (normalizedName !== record.name) {
+        throw new SpawnfileError("validation_error", `Invalid ${sourceLabel}: deployment name must be normalized`);
+    }
+    return record;
+};
+export const readDeploymentRecord = async (recordPath) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readUtf8File(recordPath));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("validation_error", `Unable to read deployment record ${recordPath}: ${reason}`);
+    }
+    return parseDeploymentRecord(parsed, recordPath);
+};
+export const readDeploymentRecordFromOutput = async (outputDirectory, deploymentName) => readDeploymentRecord(resolveDeploymentRecordPath(outputDirectory, deploymentName));
+export const listDeploymentRecords = async (outputDirectory) => {
+    const recordsDirectory = resolveDeploymentRecordsDirectory(outputDirectory);
+    let entries;
+    try {
+        entries = await readdir(recordsDirectory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("validation_error", `Unable to read deployment records directory ${recordsDirectory}: ${reason}`);
+    }
+    const records = await Promise.all(entries
+        .filter((entry) => entry.endsWith(".json"))
+        .sort()
+        .map(async (entry) => {
+        const recordPath = path.join(recordsDirectory, entry);
+        return {
+            path: recordPath,
+            record: await readDeploymentRecord(recordPath)
+        };
+    }));
+    return records.sort((left, right) => left.record.name.localeCompare(right.record.name));
+};
+export const writeDeploymentRecord = async (outputDirectory, record) => {
+    const parsed = parseDeploymentRecord(record);
+    const recordPath = resolveDeploymentRecordPath(outputDirectory, parsed.name);
+    await ensureDirectory(path.dirname(recordPath));
+    const temporaryPath = path.join(path.dirname(recordPath), `.${path.basename(recordPath)}.${process.pid}.${Date.now()}.tmp`);
+    await writeFile(temporaryPath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
+    await rename(temporaryPath, recordPath);
+    return recordPath;
+};

package/dist/deployment/target.d.ts

@@ -0,0 +1,35 @@
+export type DockerDeploymentTarget = {
+    endpoint_fingerprint: string;
+    kind: "context";
+    name: string;
+} | {
+    endpoint_fingerprint: string;
+    kind: "docker-context";
+    context: string;
+} | {
+    kind: "host";
+    value: string;
+};
+export type DockerTargetExecFile = (file: string, args: string[], options: {
+    timeout: number;
+}) => Promise<{
+    stderr: string;
+    stdout: string;
+}>;
+export interface ResolveDockerDeploymentTargetOptions {
+    context?: string | null;
+    dockerCommand?: string;
+    dockerHost?: string | null;
+    execFile?: DockerTargetExecFile;
+    timeoutMs?: number;
+}
+export declare const createEndpointFingerprint: (endpoint: string) => string;
+export declare const createDockerDeploymentTarget: (input: {
+    context?: string;
+    endpoint?: string;
+    host?: string;
+}) => DockerDeploymentTarget;
+export declare const dockerContextNameForTarget: (target: DockerDeploymentTarget) => string | null;
+export declare const dockerHostValueForTarget: (target: DockerDeploymentTarget) => string | null;
+export declare const resolveDockerDeploymentTarget: (input?: ResolveDockerDeploymentTargetOptions) => Promise<DockerDeploymentTarget>;
+export declare const verifyDockerDeploymentTarget: (target: DockerDeploymentTarget, options?: Omit<ResolveDockerDeploymentTargetOptions, "context" | "dockerHost">) => Promise<string | null>;

package/dist/deployment/target.js

@@ -0,0 +1,96 @@
+import { createHash } from "node:crypto";
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import { SpawnfileError } from "../shared/index.js";
+const execFile = promisify(execFileCallback);
+export const createEndpointFingerprint = (endpoint) => {
+    const normalized = endpoint.trim();
+    if (normalized.length === 0) {
+        throw new SpawnfileError("validation_error", "Deployment target endpoint must not be empty");
+    }
+    return `sha256:${createHash("sha256").update(normalized).digest("hex").slice(0, 32)}`;
+};
+const parseDockerEndpoint = (stdout) => {
+    const trimmed = stdout.trim();
+    if (trimmed.length === 0) {
+        throw new SpawnfileError("runtime_error", "Docker context endpoint was empty");
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "string" && parsed.trim().length > 0) {
+            return parsed.trim();
+        }
+    }
+    catch {
+        // Docker/podman variants may return a plain string instead of JSON.
+    }
+    return trimmed;
+};
+const resolveDockerContextEndpoint = async (context, options) => {
+    try {
+        const { stdout } = await options.execFile(options.dockerCommand, ["context", "inspect", context, "--format", "{{json .Endpoints.docker.Host}}"], { timeout: options.timeoutMs });
+        return parseDockerEndpoint(stdout);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("runtime_error", `Unable to resolve Docker context "${context}": ${reason}`);
+    }
+};
+export const createDockerDeploymentTarget = (input) => {
+    const host = input.host?.trim();
+    if (host) {
+        return {
+            kind: "host",
+            value: host
+        };
+    }
+    const context = input.context?.trim();
+    const endpoint = input.endpoint?.trim();
+    if (!context || !endpoint) {
+        throw new SpawnfileError("validation_error", "Docker context deployment targets require both context and endpoint");
+    }
+    return {
+        name: context,
+        endpoint_fingerprint: createEndpointFingerprint(endpoint),
+        kind: "context"
+    };
+};
+export const dockerContextNameForTarget = (target) => target.kind === "context"
+    ? target.name
+    : target.kind === "docker-context"
+        ? target.context
+        : null;
+export const dockerHostValueForTarget = (target) => target.kind === "host" ? target.value : null;
+export const resolveDockerDeploymentTarget = async (input = {}) => {
+    const explicitContext = input.context?.trim();
+    const host = explicitContext ? undefined : input.dockerHost?.trim() ?? process.env.DOCKER_HOST?.trim();
+    if (host) {
+        return createDockerDeploymentTarget({ host });
+    }
+    const resolvedOptions = {
+        dockerCommand: input.dockerCommand ?? "docker",
+        execFile: input.execFile ?? execFile,
+        timeoutMs: input.timeoutMs ?? 10_000
+    };
+    const context = explicitContext || "default";
+    const endpoint = await resolveDockerContextEndpoint(context, resolvedOptions);
+    return createDockerDeploymentTarget({ context, endpoint });
+};
+export const verifyDockerDeploymentTarget = async (target, options = {}) => {
+    if (target.kind === "host") {
+        return null;
+    }
+    const context = dockerContextNameForTarget(target);
+    if (!context) {
+        return null;
+    }
+    const current = await resolveDockerDeploymentTarget({
+        ...options,
+        context
+    });
+    const currentFingerprint = current.kind === "host" ? null : current.endpoint_fingerprint;
+    if (currentFingerprint !== target.endpoint_fingerprint) {
+        throw new SpawnfileError("runtime_error", `Docker context "${context}" endpoint changed since deployment`);
+    }
+    return context;
+};

package/dist/dev/activity.d.ts

@@ -0,0 +1,14 @@
+import { type DevExecFile } from "./docker.js";
+import { type DevProjectOptions } from "./project.js";
+export interface DevActivityProjectOptions extends DevProjectOptions {
+    agent?: string;
+    execFile?: DevExecFile;
+    tail?: number;
+}
+export interface DevActivityProjectResult {
+    containerName: string;
+    deploymentName: string;
+    events: unknown[];
+    outputDirectory: string;
+}
+export declare const devActivityProject: (inputPath: string, options?: DevActivityProjectOptions) => Promise<DevActivityProjectResult>;

package/dist/dev/activity.js

@@ -0,0 +1,48 @@
+import { defaultExecFile, dockerArgsForRecord, firstContainerName, runDocker } from "./docker.js";
+import { PI_CONTROL_URL, resolveDevOutputDirectory, selectDeploymentRecord } from "./project.js";
+import { SpawnfileError } from "../shared/index.js";
+const activityPath = (options) => {
+    const params = new URLSearchParams();
+    if (options.agent) {
+        params.set("agent", options.agent);
+    }
+    if (typeof options.tail === "number" && Number.isInteger(options.tail) && options.tail > 0) {
+        params.set("tail", String(options.tail));
+    }
+    const query = params.toString();
+    return `${PI_CONTROL_URL}/spawnfile/activity${query ? `?${query}` : ""}`;
+};
+const parseActivityEvents = (stdout) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        throw new SpawnfileError("runtime_error", "Pi activity endpoint returned invalid JSON");
+    }
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        !Array.isArray(parsed.events)) {
+        throw new SpawnfileError("runtime_error", "Pi activity endpoint response did not include an events array");
+    }
+    return parsed.events;
+};
+export const devActivityProject = async (inputPath, options = {}) => {
+    const outputDirectory = await resolveDevOutputDirectory(inputPath, options.outputDirectory);
+    const record = await selectDeploymentRecord(outputDirectory, options.deploymentName);
+    const containerName = firstContainerName(record);
+    const stdout = await runDocker(options.dockerCommand ?? "docker", [
+        ...dockerArgsForRecord(record),
+        "exec",
+        containerName,
+        "curl",
+        "-fsS",
+        activityPath(options)
+    ], options.execFile ?? defaultExecFile);
+    return {
+        containerName,
+        deploymentName: record.name,
+        events: parseActivityEvents(stdout),
+        outputDirectory
+    };
+};

package/dist/dev/docker.d.ts

@@ -0,0 +1,16 @@
+import { type CompileProjectResult } from "../compiler/index.js";
+import { type DeploymentRecord } from "../deployment/index.js";
+export type DevExecFile = (file: string, args: string[], options: {
+    timeout: number;
+}) => Promise<{
+    stderr: string;
+    stdout: string;
+}>;
+export declare const defaultExecFile: DevExecFile;
+export declare const dockerArgsForRecord: (record: DeploymentRecord) => string[];
+export declare const firstContainerName: (record: DeploymentRecord) => string;
+export declare const compileForDevApply: (inputPath: string, outputDirectory: string, record: DeploymentRecord, dockerCommand: string, execFileImpl: DevExecFile) => Promise<CompileProjectResult>;
+export declare const runDocker: (command: string, args: string[], execFileImpl: DevExecFile, timeout?: number) => Promise<string>;
+export declare const copyIntoContainer: (dockerCommand: string, dockerPrefix: string[], source: string, destination: string, execFileImpl: DevExecFile) => Promise<void>;
+export declare const ensureContainerDirectories: (dockerCommand: string, dockerPrefix: string[], containerName: string, paths: string[], execFileImpl: DevExecFile) => Promise<void>;
+export declare const chownContainerPaths: (dockerCommand: string, dockerPrefix: string[], containerName: string, paths: string[], execFileImpl: DevExecFile) => Promise<void>;