@interf/compiler 0.9.4 → 0.13.0

package/dist/cli/commands/prep.d.ts

@@ -0,0 +1,2 @@
+import type { CommandModule } from "yargs";
+export declare const prepCommand: CommandModule;

package/dist/cli/commands/prep.js

@@ -0,0 +1,134 @@
+/**
+ * `interf prep` — preparation CRUD against a connected instance.
+ *
+ *   interf prep ls
+ *   interf prep create <id> --source <path> --method <id> [--about <text>]
+ *   interf prep show <id>
+ *   interf prep rm <id>
+ *
+ * Every subcommand requires an active connection. If `~/.interf/connection.json`
+ * is missing or unreachable, the command exits non-zero with the
+ * connect-or-error hint.
+ */
+import { resolve } from "node:path";
+import chalk from "chalk";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection, } from "../../packages/local-service/connection-config.js";
+import { preparationResourcePath } from "../../packages/local-service/routes.js";
+function requireConnection(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
+    });
+    if (!conn) {
+        console.error(CONNECT_OR_ERROR_HINT);
+        process.exit(1);
+    }
+    return { url: conn.url.replace(/\/+$/, ""), token: conn.auth_token };
+}
+async function callJson(url, token, init = {}) {
+    const headers = new Headers(init.headers ?? {});
+    if (token)
+        headers.set("authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+    }
+    const response = await fetch(url, { ...init, headers });
+    const raw = await response.text();
+    let body = null;
+    if (raw.length > 0) {
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            body = null;
+        }
+    }
+    return { status: response.status, body, raw };
+}
+export const prepCommand = {
+    command: "prep <subcommand>",
+    describe: "Manage preparations on the connected instance",
+    builder: (yargs) => yargs
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" })
+        .command("ls", "List preparations", (y) => y, async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, body, raw } = await callJson(`${url}/v1/preparations`, token);
+        if (status !== 200 || !body) {
+            console.error(chalk.red(`Failed to list preparations (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const preparations = body.preparations ?? [];
+        if (preparations.length === 0) {
+            console.log(chalk.dim("  No preparations yet. Create one with `interf prep create <id> --source <path> --method <method-id>`."));
+            return;
+        }
+        console.log();
+        console.log(chalk.bold("  Preparations"));
+        console.log();
+        for (const prep of preparations) {
+            const sourceLabel = prep.source?.locator ?? prep.source_path ?? "(no source)";
+            const method = prep.method_id ?? "(no method)";
+            const readiness = prep.readiness?.status ?? "—";
+            console.log(`  ${prep.id}`);
+            console.log(chalk.dim(`    source: ${sourceLabel}`));
+            console.log(chalk.dim(`    method: ${method}`));
+            console.log(chalk.dim(`    readiness: ${readiness}`));
+        }
+    })
+        .command("create <prep-id>", "Create a preparation", (y) => y
+        .positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id (lowercase, dash-separated)" })
+        .option("source", { type: "string", demandOption: true, describe: "Path to the Source Folder" })
+        .option("method", { type: "string", demandOption: true, describe: "Method id (e.g. interf-default)" })
+        .option("about", { type: "string", describe: "One-line description of the agent work" }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const sourceAbs = resolve(process.cwd(), args.source);
+        const requestBody = {
+            id: args.prepId,
+            source: { kind: "local-folder", locator: sourceAbs },
+            method_id: args.method,
+            about: args.about,
+            checks: [],
+        };
+        const { status, body, raw } = await callJson(`${url}/v1/preparations`, token, { method: "POST", body: JSON.stringify(requestBody) });
+        if (status !== 201 && status !== 200) {
+            console.error(chalk.red(`Failed to create preparation (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Created preparation ${chalk.bold(args.prepId)}.`));
+        if (body?.portable_context?.value) {
+            console.log(chalk.dim(`  portable context (locator): ${body.portable_context.value}`));
+        }
+    })
+        .command("show <prep-id>", "Show a preparation's full record", (y) => y.positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, body, raw } = await callJson(`${url}${preparationResourcePath(args.prepId)}`, token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to read preparation ${args.prepId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(JSON.stringify(body, null, 2));
+    })
+        .command("rm <prep-id>", "Delete a preparation", (y) => y.positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, raw } = await callJson(`${url}${preparationResourcePath(args.prepId)}`, token, { method: "DELETE" });
+        if (status !== 200 && status !== 204) {
+            console.error(chalk.red(`Failed to delete preparation ${args.prepId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Deleted preparation ${chalk.bold(args.prepId)}.`));
+    })
+        .demandCommand(1)
+        .strict(),
+    handler: () => {
+        /* yargs subcommand handlers do the work */
+    },
+};

package/dist/cli/commands/reset.d.ts

@@ -1,2 +1,9 @@
 import type { CommandModule } from "yargs";
-export declare const resetCommand: CommandModule;
+interface ResetArgs {
+    prepId: string;
+    mode?: "compile" | "all";
+    url?: string;
+    token?: string;
+}
+export declare const resetCommand: CommandModule<unknown, ResetArgs>;
+export {};

package/dist/cli/commands/reset.js

@@ -1,22 +1,54 @@
+/**
+ * `interf reset <prep-id>` — reset a preparation's compile output (or all state).
+ *
+ *   interf reset bristol             # default mode = compile
+ *   interf reset bristol --mode all  # also clear method draft / runs
+ */
 import chalk from "chalk";
-import { detectInterf } from "../../packages/project-model/interf.js";
-import { resetCompiledGeneratedState } from "../../packages/compiler/reset.js";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/local-service/connection-config.js";
+function resolveConnection(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
+    });
+    if (!conn) {
+        console.error(CONNECT_OR_ERROR_HINT);
+        process.exit(1);
+    }
+    return { url: conn.url.replace(/\/+$/, ""), token: conn.auth_token };
+}
+async function callJson(url, token, init = {}) {
+    const headers = new Headers(init.headers ?? {});
+    if (token)
+        headers.set("authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("content-type"))
+        headers.set("content-type", "application/json");
+    const response = await fetch(url, { ...init, headers });
+    const raw = await response.text();
+    return { status: response.status, raw };
+}
 export const resetCommand = {
-    command: "reset <scope>",
-    describe: "Reset generated Portable Context state while keeping source files and the local Method package",
-    builder: (yargs) => yargs.positional("scope", {
+    command: "reset <prep-id>",
+    describe: "Reset a preparation's compile output",
+    builder: (yargs) => yargs
+        .positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" })
+        .option("mode", {
         type: "string",
         choices: ["compile", "all"],
-    }),
-    handler: async (argv) => {
-        const detected = detectInterf(process.cwd());
-        if (!detected) {
-            process.exitCode = 1;
-            console.log(chalk.red("Run this from inside a Portable Context."));
-            return;
+        default: "compile",
+        describe: "Scope of the reset",
+    })
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }),
+    handler: async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, raw } = await callJson(`${url}/v1/preparations/${encodeURIComponent(args.prepId)}/reset`, token, { method: "POST", body: JSON.stringify({ scope: args.mode }) });
+        if (status !== 200 && status !== 204) {
+            console.error(chalk.red(`Failed to reset ${args.prepId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
         }
-        const compiledPath = detected.path;
-        resetCompiledGeneratedState(compiledPath, argv.scope);
-        console.log(chalk.green("  Portable Context reset complete."));
+        console.log(chalk.green(`Reset ${chalk.bold(args.prepId)} (${args.mode}).`));
     },
 };

package/dist/cli/commands/runs.d.ts

@@ -0,0 +1,2 @@
+import type { CommandModule } from "yargs";
+export declare const runsCommand: CommandModule;

package/dist/cli/commands/runs.js

@@ -0,0 +1,120 @@
+/**
+ * `interf runs` — observe / cancel / fetch run records on the connected instance.
+ *
+ *   interf runs ls [--prep <id>]
+ *   interf runs status <run-id>
+ *   interf runs cancel <run-id>
+ *   interf runs fetch <run-id> --to <path>
+ */
+import chalk from "chalk";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/local-service/connection-config.js";
+function resolveConnection(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
+    });
+    if (!conn) {
+        console.error(CONNECT_OR_ERROR_HINT);
+        process.exit(1);
+    }
+    return { url: conn.url.replace(/\/+$/, ""), token: conn.auth_token };
+}
+async function callJson(url, token, init = {}) {
+    const headers = new Headers(init.headers ?? {});
+    if (token)
+        headers.set("authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("content-type"))
+        headers.set("content-type", "application/json");
+    const response = await fetch(url, { ...init, headers });
+    const raw = await response.text();
+    let body = null;
+    if (raw) {
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            body = null;
+        }
+    }
+    return { status: response.status, body, raw };
+}
+export const runsCommand = {
+    command: "runs <subcommand>",
+    describe: "Inspect runs on the connected instance",
+    builder: (yargs) => yargs
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" })
+        .command("ls", "List runs (optionally filtered by preparation)", (y) => y.option("prep", { type: "string", describe: "Filter by preparation id" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const path = args.prep
+            ? `/v1/preparations/${encodeURIComponent(args.prep)}/runs`
+            : "/v1/runs";
+        const { status, body, raw } = await callJson(`${url}${path}`, token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to list runs (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const runs = body?.runs
+            ?? (body?.compile_runs ?? []).map((r) => r.run).filter(Boolean);
+        if (runs.length === 0) {
+            console.log(chalk.dim("  No runs."));
+            return;
+        }
+        console.log();
+        for (const run of runs) {
+            console.log(`  ${chalk.bold(run.run_id)} ${chalk.dim(`(${run.status ?? "?"})`)}`);
+            if (run.preparation)
+                console.log(chalk.dim(`    prep: ${run.preparation}`));
+            if (run.started_at)
+                console.log(chalk.dim(`    started: ${run.started_at}`));
+        }
+        console.log();
+    })
+        .command("status <run-id>", "Show full record for a run", (y) => y.positional("run-id", { type: "string", demandOption: true, describe: "Run id" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, raw } = await callJson(`${url}/v1/runs/${encodeURIComponent(args.runId)}`, token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to read run ${args.runId} (HTTP ${status}).`));
+            process.exit(1);
+        }
+        console.log(raw);
+    })
+        .command("cancel <run-id>", "Cancel a running run", (y) => y.positional("run-id", { type: "string", demandOption: true, describe: "Run id" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, raw } = await callJson(`${url}/v1/runs/${encodeURIComponent(args.runId)}/cancel`, token, { method: "POST", body: JSON.stringify({}) });
+        if (status !== 200 && status !== 202 && status !== 204) {
+            console.error(chalk.red(`Failed to cancel ${args.runId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Cancelled ${chalk.bold(args.runId)}.`));
+    })
+        .command("fetch <run-id>", "Download a run's portable context", (y) => y
+        .positional("run-id", { type: "string", demandOption: true, describe: "Run id" })
+        .option("to", { type: "string", demandOption: true, describe: "Target path" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const headers = new Headers();
+        if (token)
+            headers.set("authorization", `Bearer ${token}`);
+        const response = await fetch(`${url}/v1/runs/${encodeURIComponent(args.runId)}/artifacts/portable-context`, { headers });
+        if (response.status !== 200) {
+            console.error(chalk.red(`Failed to fetch artifact (HTTP ${response.status}).`));
+            process.exit(1);
+        }
+        const target = isAbsolute(args.to) ? args.to : resolve(process.cwd(), args.to);
+        mkdirSync(dirname(target), { recursive: true });
+        const buffer = Buffer.from(await response.arrayBuffer());
+        writeFileSync(target, buffer);
+        console.log(chalk.green(`Wrote ${target} (${buffer.length} bytes).`));
+    })
+        .demandCommand(1)
+        .strict(),
+    handler: () => {
+        /* yargs subcommand handlers do the work */
+    },
+};

package/dist/cli/commands/status.d.ts

@@ -1,2 +1,7 @@
 import type { CommandModule } from "yargs";
-export declare const statusCommand: CommandModule;
+interface StatusArgs {
+    url?: string;
+    token?: string;
+}
+export declare const statusCommand: CommandModule<unknown, StatusArgs>;
+export {};

package/dist/cli/commands/status.js

@@ -1,237 +1,78 @@
+/**
+ * `interf status` — print connection state + preparation summary.
+ */
 import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { detectInterf, listPortableContextsForSourceFolder, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { computeCompiledHealth } from "../../packages/compiler/state.js";
-import { sourcePreparationConfigFromInterfConfig, loadCompiledPreparationConfig, } from "../../packages/project-model/source-config.js";
-import { printSavedTestComparisonState, readCurrentSavedTestComparison } from "./test-flow.js";
-import { findLocalService, readLocalServiceRunSnapshot, } from "../../packages/local-service/index.js";
-import { resolveCommandControlPath } from "./control-path.js";
-function statusColor(status) {
-    switch (status) {
-        case "compiled":
-            return chalk.green;
-        case "running":
-            return chalk.yellow;
-        case "failed":
-            return chalk.red;
-        default:
-            return chalk.dim;
-    }
-}
-function publicReadinessStatus(status) {
-    return status === "compiled" ? "ready" : "not ready";
-}
-function publicPrepareState(status) {
-    if (status === "compiled")
-        return "prepared";
-    if (status === "idle")
-        return "not prepared";
-    return status;
-}
-function publicHealthSummary(health) {
-    const completedStages = health.metrics.completed_stages;
-    const stageTotal = health.metrics.stage_total;
-    if (typeof completedStages === "number" && typeof stageTotal === "number") {
-        if (health.status === "compiled") {
-            return `Portable Context ready — ${completedStages}/${stageTotal} Method stages satisfied.`;
-        }
-        if (health.status === "stale") {
-            return `Portable Context not ready — ${completedStages}/${stageTotal} Method stages satisfied.`;
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/local-service/connection-config.js";
+async function callJson(url, token) {
+    const headers = new Headers();
+    if (token)
+        headers.set("authorization", `Bearer ${token}`);
+    try {
+        const response = await fetch(url, { headers });
+        const raw = await response.text();
+        let body = null;
+        if (raw) {
+            try {
+                body = JSON.parse(raw);
+            }
+            catch {
+                body = null;
+            }
         }
+        return { status: response.status, body };
+    }
+    catch {
+        return { status: 0, body: null };
     }
-    return health.summary
-        .replace(/\bCompiled\b/g, "Prepared")
-        .replace(/\bcompiled\b/g, "prepared")
-        .replace(/\bmethod stages\b/g, "Method stages")
-        .replace(/\bmethod stage\b/g, "Method stage");
 }
 export const statusCommand = {
     command: "status",
-    describe: "Show deterministic health for the Portable Context agents use",
-    builder: (yargs) => yargs.option("watch", {
-        type: "boolean",
-        default: false,
-        describe: "Poll the local Interf service for live run status",
-    }),
-    handler: async (argv) => {
-        let compiledPath = null;
-        const detected = detectInterf(process.cwd());
-        const serviceProjectPath = detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath();
-        const service = await findLocalService({
-            projectPath: serviceProjectPath,
-            timeoutMs: 200,
+    describe: "Show connection + preparation summary",
+    builder: (yargs) => yargs
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }),
+    handler: async (args) => {
+        const conn = readActiveConnection({
+            urlOverride: args.url,
+            authTokenOverride: args.token,
         });
-        if (service) {
-            await printLocalServiceStatus(service.serviceUrl);
-            if (argv.watch === true) {
-                await watchLocalServiceStatus(service.serviceUrl);
-            }
-            return;
+        if (!conn) {
+            console.error(CONNECT_OR_ERROR_HINT);
+            process.exit(1);
         }
-        if (detected) {
-            compiledPath = detected.path;
+        const url = conn.url.replace(/\/+$/, "");
+        const token = conn.auth_token;
+        const instance = await callJson(`${url}/v1/instance`, token);
+        if (instance.status === 0) {
+            console.error(chalk.red(`Connection ${url} is unreachable.`));
+            console.error(CONNECT_OR_ERROR_HINT);
+            process.exit(1);
         }
-        else {
-            const sourcePath = resolveCommandControlPath();
-            const local = listPortableContextsForSourceFolder(sourcePath).map(({ path, config }) => ({
-                path,
-                name: config.name,
-            }));
-            if (local.length === 0) {
-                process.exitCode = 1;
-                console.log(chalk.red("  No Portable Context found."));
-                console.log(chalk.dim("  Run `interf`, save readiness checks, and compile Portable Context agents can use first."));
-                return;
-            }
-            if (local.length === 1) {
-                compiledPath = local[0].path;
-            }
-            else {
-                const selected = await p.select({
-                    message: "Which Portable Context?",
-                    options: local.map((entry) => ({ value: entry.path, label: entry.name })),
-                });
-                if (p.isCancel(selected))
-                    return;
-                compiledPath = selected;
-            }
+        console.log();
+        console.log(chalk.bold("  Interf engine"));
+        console.log(`  URL:      ${url}`);
+        if (instance.body?.pid)
+            console.log(`  PID:      ${instance.body.pid}`);
+        if (instance.body?.package_version)
+            console.log(`  Version:  ${instance.body.package_version}`);
+        if (instance.body?.uptime_seconds !== undefined) {
+            console.log(`  Uptime:   ${instance.body.uptime_seconds}s`);
         }
-        const health = computeCompiledHealth(compiledPath);
-        const color = statusColor(health.status);
+        console.log(`  Auth:     ${instance.body?.auth_required ? "required (token in connection.json)" : "open (loopback)"}`);
+        const preps = await callJson(`${url}/v1/preparations`, token);
+        const list = preps.body?.preparations ?? [];
         console.log();
-        console.log(color(`  ${health.target_name}`));
-        console.log(chalk.dim(`  readiness: ${publicReadinessStatus(health.status)}`));
-        console.log(chalk.dim(`  prepare state: ${publicPrepareState(health.status)}`));
-        console.log(chalk.dim(`  ${publicHealthSummary(health)}`));
-        const compiledConfig = readInterfConfig(compiledPath);
-        const sourcePath = resolveSourceControlPath(compiledPath);
-        const latestComparisonState = compiledConfig
-            ? readCurrentSavedTestComparison({
-                projectPath: sourcePath,
-                preparationName: compiledConfig.name,
-                checks: (loadCompiledPreparationConfig(compiledPath)
-                    ?? sourcePreparationConfigFromInterfConfig(compiledConfig)).checks,
-            })
-            : { comparison: null, stale: false };
-        const latestComparison = latestComparisonState.comparison;
-        if (latestComparison) {
-            printSavedTestComparisonState(latestComparison);
+        console.log(chalk.bold(`  Preparations (${list.length})`));
+        if (list.length === 0) {
+            console.log(chalk.dim("  No preparations yet. `interf prep create <id> --source <path> --method <id>`."));
         }
         else {
-            console.log();
-            console.log(chalk.dim(latestComparisonState.stale
-                ? "  Saved readiness results are stale for the current checks. Run `interf test` again."
-                : "  No saved readiness check run yet. Run `interf test` to check source files and Portable Context."));
+            for (const prep of list) {
+                const readiness = prep.readiness?.status ?? "—";
+                console.log(`  ${chalk.bold(prep.id)} ${chalk.dim(`(${prep.method_id} · ${readiness})`)}`);
+                console.log(chalk.dim(`    source: ${prep.source.locator}`));
+            }
         }
         console.log();
-        const metricOrder = [
-            "source_total",
-            "stage_total",
-            "completed_stages",
-            "warnings",
-            "errors",
-        ];
-        const printed = new Set();
-        for (const key of metricOrder) {
-            const value = health.metrics[key];
-            if (typeof value !== "number")
-                continue;
-            printed.add(key);
-            console.log(chalk.dim(`  ${key}: ${value}`));
-        }
-        for (const [key, value] of Object.entries(health.metrics)) {
-            if (printed.has(key))
-                continue;
-            console.log(chalk.dim(`  ${key}: ${value}`));
-        }
     },
 };
-function formatEventTime(value) {
-    const date = new Date(value);
-    if (Number.isNaN(date.valueOf()))
-        return value;
-    return date.toLocaleTimeString([], {
-        hour: "2-digit",
-        minute: "2-digit",
-        second: "2-digit",
-    });
-}
-function testScore(run) {
-    const compiled = run.comparison?.compiled;
-    const raw = run.comparison?.raw;
-    if (compiled)
-        return `${compiled.passed_cases}/${compiled.total_cases}`;
-    if (raw)
-        return `${raw.passed_cases}/${raw.total_cases}`;
-    return "pending";
-}
-function compileRunEventDetail(event) {
-    if ("message" in event && typeof event.message === "string")
-        return event.message;
-    if ("summary" in event && typeof event.summary === "string")
-        return event.summary;
-    if ("error" in event && typeof event.error === "string")
-        return event.error;
-    if ("stage_id" in event && typeof event.stage_id === "string")
-        return event.stage_id;
-    return "recorded";
-}
-async function printLocalServiceStatus(serviceUrl) {
-    const { jobs, compileRuns, testRuns } = await readLocalServiceRunSnapshot({ serviceUrl });
-    const latestJob = jobs[0] ?? null;
-    const latestCompile = compileRuns[0]?.run ?? null;
-    const latestTest = testRuns[0] ?? null;
-    console.log();
-    console.log(chalk.green("  Interf local service is running"));
-    console.log(chalk.dim(`  Interf: ${serviceUrl}/`));
-    if (latestJob) {
-        console.log();
-        console.log(chalk.bold(`  Latest local job: ${latestJob.title}`));
-        console.log(chalk.dim(`  run: ${latestJob.run_id}`));
-        console.log(chalk.dim(`  type: ${latestJob.job_type}`));
-        console.log(chalk.dim(`  status: ${latestJob.status}`));
-        const stepSummary = latestJob.steps
-            .map((step) => `${step.id}:${step.status}`)
-            .join(", ");
-        if (stepSummary)
-            console.log(chalk.dim(`  steps: ${stepSummary}`));
-        for (const event of latestJob.events.slice(-4)) {
-            const detail = event.message ?? event.step_id ?? "recorded";
-            console.log(chalk.dim(`  ${formatEventTime(event.timestamp)} ${event.type} ${detail}`));
-        }
-    }
-    if (latestCompile) {
-        console.log();
-        console.log(chalk.bold(`  Latest prepare run: ${latestCompile.preparation}`));
-        console.log(chalk.dim(`  run: ${latestCompile.run_id}`));
-        console.log(chalk.dim(`  status: ${latestCompile.status}`));
-        console.log(chalk.dim(`  Method: ${latestCompile.method}`));
-        const stageSummary = latestCompile.stages
-            .map((stage) => `${stage.stage_id}:${stage.status}`)
-            .join(", ");
-        if (stageSummary)
-            console.log(chalk.dim(`  stages: ${stageSummary}`));
-        const events = latestCompile.events.slice(-6);
-        for (const event of events) {
-            const detail = compileRunEventDetail(event);
-            console.log(chalk.dim(`  ${formatEventTime(event.timestamp)} ${event.type} ${detail}`));
-        }
-    }
-    else {
-        console.log(chalk.dim("  No prepare runs recorded by the local service yet."));
-    }
-    if (latestTest) {
-        console.log();
-        console.log(chalk.bold(`  Latest readiness check run: ${latestTest.preparation}`));
-        console.log(chalk.dim(`  status: ${latestTest.status}`));
-        console.log(chalk.dim(`  mode: ${latestTest.mode}`));
-        console.log(chalk.dim(`  readiness checks: ${testScore(latestTest)}`));
-    }
-}
-async function watchLocalServiceStatus(serviceUrl) {
-    while (true) {
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-        console.clear();
-        await printLocalServiceStatus(serviceUrl);
-    }
-}