spawnfile 0.1.10 → 0.1.12

package/dist/status/compileReport.js

@@ -0,0 +1,230 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { REPORT_FILENAME } from "../shared/index.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const toStringOrNull = (value) => typeof value === "string" ? value : null;
+const toStringArray = (value) => Array.isArray(value)
+    ? value.filter((entry) => typeof entry === "string")
+    : [];
+const toNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+const toBooleanOrNull = (value) => typeof value === "boolean" ? value : null;
+const toNumberArray = (value) => Array.isArray(value)
+    ? value.filter((entry) => typeof entry === "number" && Number.isFinite(entry))
+    : [];
+const normalizeCapability = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const key = toStringOrNull(value.key);
+    const message = toStringOrNull(value.message);
+    const outcome = toStringOrNull(value.outcome);
+    if (!key || !message || !["degraded", "supported", "unsupported"].includes(outcome ?? "")) {
+        return null;
+    }
+    return { key, message, outcome: outcome };
+};
+const normalizeDiagnostic = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const level = toStringOrNull(value.level);
+    const message = toStringOrNull(value.message);
+    if (!message || !["error", "info", "warn"].includes(level ?? "")) {
+        return null;
+    }
+    return { level: level, message };
+};
+const normalizeNode = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const id = toStringOrNull(value.id);
+    const kind = toStringOrNull(value.kind);
+    if (!id || !["agent", "team"].includes(kind ?? "")) {
+        return null;
+    }
+    return {
+        capabilities: (Array.isArray(value.capabilities) ? value.capabilities : [])
+            .map(normalizeCapability)
+            .filter((entry) => entry !== null),
+        diagnostics: (Array.isArray(value.diagnostics) ? value.diagnostics : [])
+            .map(normalizeDiagnostic)
+            .filter((entry) => entry !== null),
+        id,
+        kind: kind,
+        outputDir: toStringOrNull(value.output_dir),
+        runtime: toStringOrNull(value.runtime)
+    };
+};
+const normalizeRuntimeInstance = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const id = toStringOrNull(value.id);
+    const runtime = toStringOrNull(value.runtime);
+    if (!id || !runtime) {
+        return null;
+    }
+    return {
+        configPath: toStringOrNull(value.config_path),
+        homePath: toStringOrNull(value.home_path),
+        id,
+        internalPort: toNumberOrNull(value.internal_port),
+        nodeIds: toStringArray(value.node_ids),
+        publishedPort: toNumberOrNull(value.published_port),
+        runtime,
+        workspacePath: toStringOrNull(value.workspace_path)
+    };
+};
+const normalizeMoltnetRoom = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const id = toStringOrNull(value.id);
+    if (!id) {
+        return null;
+    }
+    return {
+        id,
+        members: toStringArray(value.members),
+        visibility: toStringOrNull(value.visibility),
+        writePolicy: toStringOrNull(value.write_policy)
+    };
+};
+const normalizeMoltnetServer = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const id = toStringOrNull(value.id);
+    const mode = toStringOrNull(value.mode);
+    const networkId = toStringOrNull(value.network_id);
+    const baseUrl = toStringOrNull(value.base_url);
+    if (!id || !baseUrl || !networkId || (mode !== "managed" && mode !== "external")) {
+        return null;
+    }
+    return {
+        authMode: toStringOrNull(value.auth_mode),
+        baseUrl,
+        directMessages: toBooleanOrNull(value.direct_messages),
+        id,
+        mode,
+        networkId,
+        operatorTokenSecret: toStringOrNull(value.operator_token_secret),
+        port: toNumberOrNull(value.port),
+        publicRead: toBooleanOrNull(value.public_read),
+        rooms: (Array.isArray(value.rooms) ? value.rooms : [])
+            .map(normalizeMoltnetRoom)
+            .filter((entry) => entry !== null),
+        storeKind: toStringOrNull(value.store_kind)
+    };
+};
+const normalizePortMapping = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const internalPort = toNumberOrNull(value.internal_port);
+    const publishedPort = toNumberOrNull(value.published_port);
+    return internalPort && publishedPort ? { internalPort, publishedPort } : null;
+};
+const normalizePersistentMount = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const id = toStringOrNull(value.id);
+    const mountPath = toStringOrNull(value.mount_path);
+    const reason = toStringOrNull(value.reason);
+    const volumeName = toStringOrNull(value.volume_name);
+    return id && mountPath && reason && volumeName
+        ? { id, mountPath, reason, volumeName }
+        : null;
+};
+const normalizeWorkspaceResource = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const backingPath = toStringOrNull(value.backing_path);
+    const id = toStringOrNull(value.id);
+    const kind = toStringOrNull(value.kind);
+    const linkPath = toStringOrNull(value.link_path);
+    const mode = toStringOrNull(value.mode);
+    const mount = toStringOrNull(value.mount);
+    const sharing = toStringOrNull(value.sharing);
+    return backingPath && id && kind && linkPath && mode && mount && sharing
+        ? { backingPath, id, kind, linkPath, mode, mount, sharing }
+        : null;
+};
+const normalizeReport = (value, reportPath) => {
+    if (!isRecord(value) || !Array.isArray(value.nodes)) {
+        return null;
+    }
+    const container = isRecord(value.container) ? value.container : {};
+    const runtimeInstances = Array.isArray(container.runtime_instances)
+        ? container.runtime_instances
+        : [];
+    const moltnet = isRecord(container.moltnet) ? container.moltnet : {};
+    const moltnetServers = Array.isArray(moltnet.server_plans) ? moltnet.server_plans : [];
+    return {
+        compileFingerprint: toStringOrNull(value.compile_fingerprint),
+        generatedAt: toStringOrNull(value.generated_at),
+        internalPorts: toNumberArray(container.internal_ports),
+        moltnetServers: moltnetServers
+            .map(normalizeMoltnetServer)
+            .filter((entry) => entry !== null),
+        nodes: value.nodes
+            .map(normalizeNode)
+            .filter((entry) => entry !== null),
+        outputDirectory: toStringOrNull(value.output_directory),
+        persistentMounts: (Array.isArray(container.persistent_mounts) ? container.persistent_mounts : [])
+            .map(normalizePersistentMount)
+            .filter((entry) => entry !== null),
+        portMappings: (Array.isArray(container.port_mappings) ? container.port_mappings : [])
+            .map(normalizePortMapping)
+            .filter((entry) => entry !== null),
+        publishedPorts: toNumberArray(container.published_ports ?? container.ports),
+        reportPath,
+        root: toStringOrNull(value.root),
+        runtimeInstances: runtimeInstances
+            .map(normalizeRuntimeInstance)
+            .filter((entry) => entry !== null),
+        secretsRequired: toStringArray(container.secrets_required),
+        workspaceResources: (Array.isArray(container.workspace_resources) ? container.workspace_resources : [])
+            .map(normalizeWorkspaceResource)
+            .filter((entry) => entry !== null)
+    };
+};
+export const resolveCompileReportPath = (outputDirectory) => path.join(outputDirectory, REPORT_FILENAME);
+export const loadCompileReport = async (outputDirectory) => {
+    const reportPath = resolveCompileReportPath(outputDirectory);
+    try {
+        await stat(reportPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { kind: "missing", reportPath };
+        }
+        return {
+            failure: { exitCode: 2, message: `Unable to stat compile report ${reportPath}` },
+            kind: "failure",
+            reportPath
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(reportPath, "utf8"));
+    }
+    catch {
+        return {
+            failure: { exitCode: 2, message: `Unable to read compile report ${reportPath}` },
+            kind: "failure",
+            reportPath
+        };
+    }
+    const report = normalizeReport(parsed, reportPath);
+    return report
+        ? { kind: "loaded", report, reportPath }
+        : {
+            failure: { exitCode: 2, message: `Malformed compile report ${reportPath}` },
+            kind: "failure",
+            reportPath
+        };
+};

package/dist/status/compiledContainerObservations.d.ts

@@ -0,0 +1,5 @@
+import type { LoadedCompileReport } from "./compileReport.js";
+import type { StatusObservation } from "./types.js";
+export declare const createCompiledContainerObservations: (loaded: Extract<LoadedCompileReport, {
+    kind: "loaded";
+}>) => StatusObservation[];

package/dist/status/compiledContainerObservations.js

@@ -0,0 +1,63 @@
+const createObservation = (input) => ({
+    ...input,
+    label: `${input.severity.toUpperCase()} ${input.key}`
+});
+export const createCompiledContainerObservations = (loaded) => {
+    const observations = [];
+    const report = loaded.report;
+    for (const instance of report.runtimeInstances) {
+        observations.push(createObservation({
+            key: "runtime.instance",
+            message: `${instance.id} emits ${instance.runtime} workspace ${instance.workspacePath ?? "unknown"}`,
+            severity: "ok",
+            source: "compile_report",
+            subject: `runtime-instance:${instance.id}`
+        }));
+    }
+    for (const server of report.moltnetServers ?? []) {
+        observations.push(createObservation({
+            key: "network.compiled",
+            message: `${server.networkId} Moltnet ${server.mode} server at ${server.baseUrl}`,
+            severity: "ok",
+            source: "compile_report",
+            subject: `network:${server.networkId}`
+        }));
+        for (const room of server.rooms) {
+            observations.push(createObservation({
+                key: "network.room.compiled",
+                message: `${server.networkId}/${room.id} expects ${room.members.length} member(s)`,
+                severity: "ok",
+                source: "compile_report",
+                subject: `room:${server.networkId}:${room.id}`
+            }));
+        }
+    }
+    for (const mount of report.persistentMounts ?? []) {
+        observations.push(createObservation({
+            key: "container.mount",
+            message: `${mount.id} mounted at ${mount.mountPath} using volume ${mount.volumeName}`,
+            severity: "ok",
+            source: "compile_report",
+            subject: "compile"
+        }));
+    }
+    for (const resource of report.workspaceResources ?? []) {
+        observations.push(createObservation({
+            key: "workspace.resource",
+            message: `${resource.id} linked at ${resource.linkPath} from ${resource.backingPath}`,
+            severity: "ok",
+            source: "compile_report",
+            subject: "compile"
+        }));
+    }
+    if ((report.internalPorts?.length ?? 0) > 0 || (report.publishedPorts?.length ?? 0) > 0) {
+        observations.push(createObservation({
+            key: "container.ports",
+            message: `internal ports: ${(report.internalPorts ?? []).join(", ") || "none"}; published ports: ${(report.publishedPorts ?? []).join(", ") || "none"}`,
+            severity: "ok",
+            source: "compile_report",
+            subject: "compile"
+        }));
+    }
+    return observations;
+};

package/dist/status/deploymentLogs.d.ts

@@ -0,0 +1,12 @@
+import { type DeploymentRecord, type DockerLogsExecFile } from "../deployment/index.js";
+import type { LoadedCompileReport } from "./compileReport.js";
+import type { StatusObservation } from "./types.js";
+export interface CollectDeploymentLogOptions {
+    deployments: DeploymentRecord[];
+    dockerCommand?: string;
+    execFile?: DockerLogsExecFile;
+    loadedReport: LoadedCompileReport;
+    tail?: number;
+    timeoutMs?: number;
+}
+export declare const collectDeploymentLogObservations: (options: CollectDeploymentLogOptions) => Promise<StatusObservation[]>;

package/dist/status/deploymentLogs.js

@@ -0,0 +1,45 @@
+import { readDockerDeploymentLogs } from "../deployment/index.js";
+const createObservation = (input) => ({
+    ...input,
+    label: `${input.severity.toUpperCase()} ${input.key}`,
+    source: "deployment"
+});
+const secretValuesFor = (loadedReport) => {
+    if (loadedReport.kind !== "loaded") {
+        return [];
+    }
+    return (loadedReport.report.secretsRequired ?? [])
+        .map((secretName) => process.env[secretName])
+        .filter((value) => typeof value === "string" && value.length > 0);
+};
+const normalizeFailureSeverity = (severity) => severity === "error" ? "unknown" : severity;
+export const collectDeploymentLogObservations = async (options) => {
+    const secretValues = secretValuesFor(options.loadedReport);
+    const observations = [];
+    for (const deployment of options.deployments) {
+        const logs = await readDockerDeploymentLogs(deployment, {
+            dockerCommand: options.dockerCommand,
+            execFile: options.execFile,
+            secretValues,
+            tail: options.tail,
+            timeoutMs: options.timeoutMs
+        });
+        for (const unit of deployment.units) {
+            const unitLogs = logs.get(unit.id);
+            if (!unitLogs) {
+                continue;
+            }
+            observations.push(createObservation({
+                details: {
+                    container_ref: unitLogs.containerRef,
+                    log_tail: unitLogs.text
+                },
+                key: "deployment.logs",
+                message: `${deployment.name}/${unit.id}: ${unitLogs.message}`,
+                severity: normalizeFailureSeverity(unitLogs.severity),
+                subject: `deployment-unit:${deployment.name}:${unit.id}`
+            }));
+        }
+    }
+    return observations;
+};

package/dist/status/deployments.d.ts

@@ -0,0 +1,14 @@
+import type { DeploymentRecord, DockerInspectionResult } from "../deployment/index.js";
+import type { StatusDeploymentSummary, StatusObservation } from "./types.js";
+export interface LoadedDeploymentRecord {
+    path: string;
+    record: DeploymentRecord;
+}
+export type StatusDeploymentInspections = Map<string, DockerInspectionResult>;
+export declare const createDeploymentSummaries: (records: LoadedDeploymentRecord[], inspections?: StatusDeploymentInspections) => StatusDeploymentSummary[];
+export declare const createDeploymentObservations: (deployments: StatusDeploymentSummary[], options: {
+    compileFingerprint: string | null;
+    liveRequested: boolean;
+    outputDirectory: string;
+    recover: boolean;
+}) => StatusObservation[];

package/dist/status/deployments.js

@@ -0,0 +1,128 @@
+const createObservation = (input) => ({
+    ...input,
+    label: `${input.severity.toUpperCase()} ${input.key}`
+});
+const targetLabelFor = (record) => record.target.kind === "context"
+    ? `docker context ${record.target.name}`
+    : record.target.kind === "docker-context"
+        ? `docker context ${record.target.context}`
+        : "docker host";
+const liveForInspection = (inspection) => {
+    if (!inspection) {
+        return null;
+    }
+    return {
+        checked: true,
+        containerId: inspection.containerId,
+        drift: [...inspection.drift],
+        exists: inspection.exists,
+        exitCode: inspection.exitCode,
+        finishedAt: inspection.finishedAt,
+        imageId: inspection.imageId,
+        message: inspection.message,
+        restartCount: inspection.restartCount,
+        running: inspection.running,
+        severity: inspection.severity,
+        startedAt: inspection.startedAt,
+        status: inspection.status
+    };
+};
+const unitSeverity = (live) => {
+    if (!live) {
+        return "ok";
+    }
+    if (live.severity !== "ok") {
+        return live.severity;
+    }
+    if (live.running === true) {
+        return "ok";
+    }
+    if (live.exists === false) {
+        return "warn";
+    }
+    if (live.running === false) {
+        return "error";
+    }
+    return "unknown";
+};
+const summarizeUnit = (unit, live) => ({
+    containerId: unit.container_id,
+    containerName: unit.container_name,
+    contains: unit.contains.map((entry) => ({ id: entry.id, kind: entry.kind })),
+    id: unit.id,
+    imageId: unit.image_id,
+    imageTag: unit.image_tag,
+    kind: unit.kind,
+    live,
+    runtimeInstances: [...unit.runtime_instances]
+});
+export const createDeploymentSummaries = (records, inspections = new Map()) => records.map(({ path, record }) => ({
+    authProfile: record.auth_profile,
+    compileFingerprint: record.compile_fingerprint,
+    createdAt: record.created_at,
+    manager: record.manager,
+    name: record.name,
+    recordPath: path,
+    target: targetLabelFor(record),
+    units: record.units.map((unit) => summarizeUnit(unit, liveForInspection(inspections.get(record.name)?.get(unit.id))))
+}));
+export const createDeploymentObservations = (deployments, options) => {
+    const observations = [];
+    if (deployments.length === 0 && options.liveRequested && !options.recover) {
+        observations.push(createObservation({
+            key: "deployment.record",
+            message: `No deployment records found under ${options.outputDirectory}`,
+            severity: "warn",
+            source: "deployment",
+            subject: "deployment"
+        }));
+    }
+    if (options.recover) {
+        observations.push(createObservation({
+            key: "deployment.recover",
+            message: "Label recovery is not implemented yet; use record-backed status for live checks",
+            severity: "unknown",
+            source: "deployment",
+            subject: "deployment"
+        }));
+    }
+    for (const deployment of deployments) {
+        observations.push(createObservation({
+            key: "deployment.record",
+            message: `${deployment.name} record exists at ${deployment.recordPath}`,
+            severity: "ok",
+            source: "deployment",
+            subject: `deployment:${deployment.name}`
+        }));
+        if (options.compileFingerprint && deployment.compileFingerprint !== options.compileFingerprint) {
+            observations.push(createObservation({
+                key: "deployment.compile_fingerprint",
+                message: `${deployment.name} was deployed from ${deployment.compileFingerprint}, current compile is ${options.compileFingerprint}`,
+                severity: "warn",
+                source: "deployment",
+                subject: `deployment:${deployment.name}`
+            }));
+        }
+        for (const unit of deployment.units) {
+            const severity = unitSeverity(unit.live);
+            const unitSubject = `deployment-unit:${deployment.name}:${unit.id}`;
+            observations.push(createObservation({
+                key: "deployment.unit",
+                message: unit.live?.message ?? `${unit.id} recorded for ${deployment.target}`,
+                severity,
+                source: "deployment",
+                subject: unitSubject
+            }));
+            for (const entry of unit.contains) {
+                observations.push(createObservation({
+                    key: "deployment.hosting",
+                    message: `${entry.id} is hosted by ${deployment.name}/${unit.id}`,
+                    severity,
+                    source: "deployment",
+                    subject: entry.id
+                }));
+            }
+        }
+    }
+    return observations;
+};

package/dist/status/imageStatusReport.d.ts

@@ -0,0 +1,10 @@
+import type { DistributionReport } from "../distribution/index.js";
+import type { LoadedCompileReport, StatusReport } from "./compileReport.js";
+/**
+ * Maps a cached distribution report (from a sourceless image deployment) into
+ * the StatusReport shape so live status can render the compiled, deployment,
+ * and runtime layers without project source. Moltnet server plans are not part
+ * of the distribution report, so the network layer falls back to `unknown`.
+ */
+export declare const distributionReportToStatusReport: (report: DistributionReport, reportPath: string) => StatusReport;
+export declare const loadedImageCompileReport: (report: DistributionReport, reportPath: string) => LoadedCompileReport;

package/dist/status/imageStatusReport.js

@@ -0,0 +1,73 @@
+/**
+ * Maps a cached distribution report (from a sourceless image deployment) into
+ * the StatusReport shape so live status can render the compiled, deployment,
+ * and runtime layers without project source. Moltnet server plans are not part
+ * of the distribution report, so the network layer falls back to `unknown`.
+ */
+export const distributionReportToStatusReport = (report, reportPath) => ({
+    compileFingerprint: report.compile_fingerprint,
+    generatedAt: report.generated_at,
+    internalPorts: report.internal_ports,
+    moltnetServers: [],
+    nodes: [
+        ...report.organization.agents.map((agent) => ({
+            capabilities: [],
+            diagnostics: [],
+            id: agent.id,
+            kind: "agent",
+            outputDir: null,
+            runtime: agent.runtime
+        })),
+        ...report.organization.teams.map((team) => ({
+            capabilities: [],
+            diagnostics: [],
+            id: team.id,
+            kind: "team",
+            outputDir: null,
+            runtime: null
+        }))
+    ],
+    outputDirectory: null,
+    persistentMounts: report.persistent_mounts.map((mount) => ({
+        id: mount.id,
+        mountPath: mount.target,
+        reason: "image persistent mount",
+        volumeName: ""
+    })),
+    portMappings: report.port_mappings.map((mapping) => ({
+        internalPort: mapping.internal_port,
+        publishedPort: mapping.published_port
+    })),
+    publishedPorts: report.ports,
+    reportPath,
+    root: null,
+    runtimeInstances: report.runtime_instances.map((instance) => ({
+        configPath: instance.config_path,
+        homePath: instance.home_path,
+        id: instance.id,
+        internalPort: instance.internal_port,
+        nodeIds: instance.node_ids,
+        publishedPort: instance.published_port,
+        runtime: instance.runtime,
+        workspacePath: instance.workspace_path
+    })),
+    secretsRequired: [
+        ...new Set(["model", "project", "runtime", "surface"].flatMap((category) => report.secrets[category]
+            .filter((entry) => entry.required && !entry.generated)
+            .map((entry) => entry.name)))
+    ].sort(),
+    workspaceResources: report.resources.map((resource) => ({
+        backingPath: "",
+        id: resource.id,
+        kind: resource.kind,
+        linkPath: resource.link_path,
+        mode: resource.mode,
+        mount: resource.mount,
+        sharing: resource.sharing
+    }))
+});
+export const loadedImageCompileReport = (report, reportPath) => ({
+    kind: "loaded",
+    report: distributionReportToStatusReport(report, reportPath),
+    reportPath
+});

package/dist/status/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./buildStatus.js";
+export * from "./compiledContainerObservations.js";
+export * from "./compileReport.js";
+export * from "./deploymentLogs.js";
+export * from "./deployments.js";
+export * from "./moltnetProbes.js";
+export * from "./renderStatus.js";
+export * from "./runtimeProbes.js";
+export * from "./selectionSubjects.js";
+export * from "./selectors.js";
+export * from "./traversal.js";
+export * from "./types.js";
+export * from "./imageStatusReport.js";
+export * from "./registryDrift.js";

package/dist/status/index.js

@@ -0,0 +1,14 @@
+export * from "./buildStatus.js";
+export * from "./compiledContainerObservations.js";
+export * from "./compileReport.js";
+export * from "./deploymentLogs.js";
+export * from "./deployments.js";
+export * from "./moltnetProbes.js";
+export * from "./renderStatus.js";
+export * from "./runtimeProbes.js";
+export * from "./selectionSubjects.js";
+export * from "./selectors.js";
+export * from "./traversal.js";
+export * from "./types.js";
+export * from "./imageStatusReport.js";
+export * from "./registryDrift.js";

package/dist/status/moltnetProbes.d.ts

@@ -0,0 +1,21 @@
+import type { DeploymentRecord, DockerInspectionResult, DockerProbeExecFile } from "../deployment/index.js";
+import type { LoadedCompileReport } from "./compileReport.js";
+import type { StatusObservation } from "./types.js";
+export type StatusNetworkInspections = Map<string, DockerInspectionResult>;
+export interface CollectMoltnetProbeOptions {
+    authValues?: Record<string, string>;
+    deployments: DeploymentRecord[];
+    execFile?: DockerProbeExecFile;
+    fetchJson?: MoltnetFetchJson;
+    inspections: StatusNetworkInspections;
+    loadedReport: LoadedCompileReport;
+    timeoutMs?: number;
+}
+export type MoltnetFetchJson = (url: string, headers: Record<string, string>, timeoutMs: number) => Promise<MoltnetProbeResponse>;
+interface MoltnetProbeResponse {
+    error?: string;
+    json: unknown;
+    ok: boolean;
+}
+export declare const collectMoltnetProbeObservations: (options: CollectMoltnetProbeOptions) => Promise<StatusObservation[]>;
+export {};