@nodeint/migent 0.0.0-stage → 0.1.0

package/dist/commands/watch.js

@@ -0,0 +1,169 @@
+import { openSync, readSync, closeSync, statSync } from "node:fs";
+import path from "node:path";
+import { CancellationRequested, ConfigurationError, SessionStore, log, raiseCancellation, readExecutionFile, watchSnapshot, } from "@nodeint/migent-kernel";
+import { printNotice, printWatchEvent, printWatchSnapshot } from "../display.js";
+const TERMINAL_EXECUTION_STATUSES = new Set(["completed", "failed", "cancelled"]);
+export async function watchSession(workspace, sessionId, options = {}) {
+    const once = options.once ?? false;
+    const untilTerminal = options.untilTerminal ?? false;
+    const jsonLines = options.jsonLines ?? false;
+    const executionId = options.executionId ?? null;
+    const cursor = options.cursor === undefined ? null : options.cursor;
+    if (once && untilTerminal)
+        throw new ConfigurationError("--once cannot be combined with --until.");
+    if (once && cursor !== null)
+        throw new ConfigurationError("--once cannot be combined with --cursor.");
+    if (untilTerminal && !executionId)
+        throw new ConfigurationError("--until requires --execution.");
+    if (cursor !== null && cursor < 0)
+        throw new ConfigurationError("--cursor must be >= 0.");
+    const sessionDirectory = path.join(workspace, ".migent", "sessions", sessionId);
+    const eventsPath = path.join(sessionDirectory, "events.jsonl");
+    if (!isFile(eventsPath))
+        throw new ConfigurationError(`No events found for session: ${sessionId}`);
+    new SessionStore(workspace).reapOrphanedExecutions(sessionId, "ignore");
+    let executionPath = null;
+    if (executionId !== null) {
+        const resolved = path.join(sessionDirectory, "executions", executionId, "execution.json");
+        executionPath = resolved;
+        if (!isFile(resolved))
+            throw new ConfigurationError(`No execution found: ${executionId}`);
+    }
+    if (once) {
+        printSnapshot(sessionDirectory, executionId, jsonLines);
+        return 0;
+    }
+    let followCursor = cursor;
+    if (followCursor === null) {
+        const snapshot = printSnapshot(sessionDirectory, executionId, jsonLines);
+        followCursor = Number(snapshot.events_cursor ?? 0);
+    }
+    printNotice(`Watching session ${sessionId}.`);
+    const onSigint = () => {
+        try {
+            raiseCancellation(2);
+        }
+        catch {
+            // The command loop observes the pending cancellation.
+        }
+    };
+    const onSigterm = () => {
+        try {
+            raiseCancellation(15);
+        }
+        catch {
+            // The command loop observes the pending cancellation.
+        }
+    };
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    const fd = openSync(eventsPath, "r");
+    try {
+        let position = followCursor;
+        let pending = "";
+        for (;;) {
+            const read = readCompleteLines(fd, position, pending);
+            position = read.position;
+            pending = read.pending;
+            for (const line of read.lines)
+                emitWatchEvent(line, executionId, jsonLines);
+            if (read.lines.length > 0)
+                continue;
+            if (untilTerminal) {
+                if (executionPath === null)
+                    throw new ConfigurationError("--until requires --execution.");
+                const record = readExecutionFile(executionPath);
+                if (record !== null && TERMINAL_EXECUTION_STATUSES.has(String(record.status))) {
+                    const drained = readCompleteLines(fd, position, pending);
+                    for (const line of drained.lines)
+                        emitWatchEvent(line, executionId, jsonLines);
+                    return untilTerminalExitCode(record);
+                }
+            }
+            await delay(250);
+        }
+    }
+    catch (error) {
+        if (error instanceof CancellationRequested) {
+            log(error.message);
+            return 130;
+        }
+        throw error;
+    }
+    finally {
+        closeSync(fd);
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+    }
+}
+function printSnapshot(sessionDirectory, executionId, jsonLines) {
+    const snapshot = watchSnapshot(sessionDirectory, executionId);
+    if (jsonLines)
+        process.stdout.write(`${JSON.stringify(snapshot)}\n`);
+    else
+        printWatchSnapshot(snapshot);
+    return snapshot;
+}
+function emitWatchEvent(line, executionId, jsonLines) {
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch {
+        return;
+    }
+    if (!isRecord(event))
+        return;
+    if (executionId !== null && event.execution_id !== executionId)
+        return;
+    if (jsonLines) {
+        process.stdout.write(`${JSON.stringify(event)}\n`);
+        return;
+    }
+    printWatchEvent(event);
+}
+function untilTerminalExitCode(record) {
+    if (record.status === "completed") {
+        const outcome = record.outcome;
+        if (isRecord(outcome) && outcome.status === "complete")
+            return 0;
+        return 1;
+    }
+    if (record.status === "failed" || record.status === "cancelled")
+        return 1;
+    return 1;
+}
+function readCompleteLines(fd, position, pending) {
+    const chunks = [];
+    const buffer = Buffer.alloc(64 * 1024);
+    let offset = position;
+    for (;;) {
+        const count = readSync(fd, buffer, 0, buffer.length, offset);
+        if (count <= 0)
+            break;
+        chunks.push(Buffer.from(buffer.subarray(0, count)));
+        offset += count;
+    }
+    if (chunks.length === 0)
+        return { lines: [], pending, position };
+    pending += Buffer.concat(chunks).toString("utf8");
+    const pieces = pending.split("\n");
+    const rest = pieces.pop() ?? "";
+    return { lines: pieces, pending: rest, position: offset };
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function isFile(filePath) {
+    try {
+        return statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/commands/workspace-registry.d.ts

@@ -0,0 +1,8 @@
+import { callService, startDetached } from "@nodeint/migent-registry";
+export declare const workspaceApi: {
+    startDetached: typeof startDetached;
+    callService: typeof callService;
+};
+export declare function runRegister(workspacePath: string | null, name: string | null): Promise<number>;
+export declare function runWorkspaceList(asJson: boolean): Promise<number>;
+export declare function runRemove(workspaceId: string): Promise<number>;

package/dist/commands/workspace-registry.js

@@ -0,0 +1,106 @@
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { ServiceError, callService, endpointFromHome, ensureRegistryHome, startDetached } from "@nodeint/migent-registry";
+import { printError } from "../display.js";
+import { findWorkspace, invocationCwdPath } from "../workspace.js";
+export const workspaceApi = {
+    startDetached,
+    callService,
+};
+export async function runRegister(workspacePath, name) {
+    const root = workspaceRoot(workspacePath);
+    if (!path.isAbsolute(root)) {
+        printError("Workspace path is not absolute.");
+        return 2;
+    }
+    process.stderr.write(`Registering ${root}\n`);
+    let endpoint;
+    try {
+        endpoint = await workspaceApi.startDetached(ensureRegistryHome());
+    }
+    catch (error) {
+        if (error instanceof ServiceError) {
+            printError(error.message);
+            return 1;
+        }
+        throw error;
+    }
+    const body = { path: root, tool: { name: "migent", version: "0.1.0" } };
+    if (name !== null)
+        body.name = name;
+    if (!path.isAbsolute(String(body.path))) {
+        printError("Workspace path is not absolute.");
+        return 2;
+    }
+    return finish("POST", "/v1/workspaces", endpoint, body);
+}
+export async function runWorkspaceList(asJson) {
+    const endpoint = endpointFromHome(ensureRegistryHome());
+    if (endpoint === null) {
+        printError("Registry service is not running.");
+        return 1;
+    }
+    let status;
+    let payload;
+    try {
+        [status, payload] = await workspaceApi.callService(endpoint.host, endpoint.port, endpoint.token, "GET", "/v1/workspaces");
+    }
+    catch (error) {
+        printError(`Registry request failed: ${errorText(error)}`);
+        return 1;
+    }
+    if (status !== 200)
+        return statusExit(status, payload);
+    const rows = payload.workspaces;
+    if (!Array.isArray(rows)) {
+        printError("Registry response was invalid.");
+        return 1;
+    }
+    if (asJson) {
+        process.stdout.write(`${JSON.stringify({ workspaces: rows })}\n`);
+    }
+    else {
+        for (const row of rows) {
+            const record = row && typeof row === "object" ? row : {};
+            const available = record.available ? "true" : "false";
+            process.stdout.write(`${String(record.id)}  ${String(record.name)}  ${String(record.path)}  ${available}\n`);
+        }
+    }
+    return 0;
+}
+export async function runRemove(workspaceId) {
+    const endpoint = endpointFromHome(ensureRegistryHome());
+    if (endpoint === null) {
+        printError("Registry service is not running.");
+        return 1;
+    }
+    return finish("DELETE", `/v1/workspaces/${workspaceId}`, endpoint, null);
+}
+async function finish(method, requestPath, endpoint, body) {
+    let status;
+    let payload;
+    try {
+        [status, payload] = await workspaceApi.callService(endpoint.host, endpoint.port, endpoint.token, method, requestPath, body);
+    }
+    catch (error) {
+        printError(`Registry request failed: ${errorText(error)}`);
+        return 1;
+    }
+    if (status === 200 || status === 201) {
+        process.stdout.write(`${JSON.stringify(payload)}\n`);
+        return 0;
+    }
+    return statusExit(status, payload);
+}
+function statusExit(status, payload) {
+    const message = payload.message;
+    printError(typeof message === "string" && message ? message : "Registry request failed.");
+    return status === 404 ? 2 : 1;
+}
+function workspaceRoot(workspacePath) {
+    const start = workspacePath === null ? invocationCwdPath() : path.resolve(invocationCwdPath(), workspacePath);
+    return realpathSync(findWorkspace(start));
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/display.d.ts

@@ -0,0 +1,12 @@
+import type { Check } from "@nodeint/migent-kernel";
+export declare function printError(message: string): void;
+export declare function printNotice(message: string): void;
+export declare function printCreated(paths: readonly string[], nextCommand: string): void;
+export declare function printAlreadyInitialized(): void;
+export declare function printInitConflicts(paths: readonly string[]): void;
+export declare function printDoctor(checks: readonly Check[]): void;
+export declare function printSessions(rows: readonly string[][]): void;
+export declare function printAgent(result: Record<string, unknown>, role: string, provider: string, model: string): void;
+export declare function printWatchSnapshot(snapshot: Record<string, unknown>): void;
+export declare function printWatchEvent(event: Record<string, unknown>): void;
+export declare function formatWatchTimestamp(timestamp: unknown): string;

package/dist/display.js

@@ -0,0 +1,123 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const pc = require("picocolors");
+export function printError(message) {
+    const tty = Boolean(process.stderr.isTTY);
+    const prefix = tty ? pc.red(pc.bold("migent: ")) : "migent: ";
+    process.stderr.write(`${prefix}${message}\n`);
+}
+export function printNotice(message) {
+    const tty = Boolean(process.stderr.isTTY);
+    const prefix = tty ? pc.cyan(pc.bold("[migent] ")) : "[migent] ";
+    process.stderr.write(`${prefix}${message}\n`);
+}
+export function printCreated(paths, nextCommand) {
+    process.stdout.write("Created:\n");
+    for (const filePath of paths)
+        process.stdout.write(`  ${filePath}\n`);
+    process.stdout.write("Next:\n");
+    process.stdout.write(`  ${nextCommand}\n`);
+}
+export function printAlreadyInitialized() {
+    process.stdout.write("Already initialized.\n");
+}
+export function printInitConflicts(paths) {
+    printError("existing files block init.");
+    for (const filePath of paths)
+        process.stderr.write(`  ${filePath}\n`);
+}
+export function printDoctor(checks) {
+    const tty = Boolean(process.stdout.isTTY);
+    for (const check of checks) {
+        const status = check.ok ? (tty ? pc.green("ok") : "ok") : tty ? pc.red("failed") : "failed";
+        process.stdout.write(`${check.name.padEnd(12)}${status}\n`);
+        for (const item of check.items) {
+            const line = `  ${item}`;
+            process.stdout.write(`${tty ? pc.dim(line) : line}\n`);
+        }
+        for (const problem of check.problems)
+            process.stdout.write(`  ${problem}\n`);
+    }
+}
+export function printSessions(rows) {
+    if (rows.length === 0) {
+        process.stdout.write("No sessions.\n");
+        return;
+    }
+    for (const row of rows) {
+        const [, sessionId, workflowId, status, executionId, decision, outputs, task] = row;
+        process.stdout.write(`${sessionId ?? ""}  ${workflowId ?? ""}  ${status ?? ""}  ${executionId ?? ""}  ${decision ?? ""}  ${outputs ?? ""}  ${task ?? ""}\n`);
+    }
+}
+export function printAgent(result, role, provider, model) {
+    const decision = String(result.outcome_decision ?? "");
+    let outcome = String(result.outcome_status ?? "failed");
+    if (decision)
+        outcome = `${outcome} ${decision}`;
+    const rows = [
+        ["role", role],
+        ["model", `${provider}/${model}`],
+        ["outcome", outcome],
+        ["session", String(result.session_id ?? "")],
+        ["execution", String(result.execution_id ?? "")],
+    ];
+    for (const [label, value] of rows)
+        process.stdout.write(`${label}  ${value}\n`);
+}
+export function printWatchSnapshot(snapshot) {
+    const lines = [
+        ["session_id", String(snapshot.session_id ?? "--")],
+        ["status", String(snapshot.status ?? "unknown")],
+    ];
+    if (typeof snapshot.workflow_id === "string" && snapshot.workflow_id) {
+        lines.push(["workflow", snapshot.workflow_id]);
+    }
+    if (typeof snapshot.task === "string" && snapshot.task)
+        lines.push(["task", snapshot.task]);
+    const executionId = snapshot.execution_id;
+    const executionStatus = snapshot.execution_status ?? snapshot.latest_execution_status;
+    if (typeof executionId === "string" && executionId) {
+        const value = typeof executionStatus === "string" && executionStatus
+            ? `${executionId} · ${executionStatus}`
+            : executionId;
+        lines.push(["execution", value]);
+    }
+    const outcome = snapshot.outcome;
+    if (isRecord(outcome) && typeof outcome.status === "string") {
+        lines.push(["outcome", outcome.status]);
+        if (typeof outcome.decision === "string" && outcome.decision)
+            lines.push(["decision", outcome.decision]);
+    }
+    lines.push(["updated_at", formatWatchTimestamp(snapshot.updated_at)]);
+    const outputs = snapshot.outputs;
+    if (isRecord(outputs) && Object.keys(outputs).length > 0)
+        lines.push(["outputs", Object.keys(outputs).join(", ")]);
+    else
+        lines.push(["outputs", "none"]);
+    lines.push(["events_cursor", String(snapshot.events_cursor ?? 0)]);
+    for (const [label, value] of lines)
+        process.stdout.write(`${label}  ${value}\n`);
+}
+export function printWatchEvent(event) {
+    const eventName = event.event;
+    const stageId = event.stage_id;
+    if (typeof eventName !== "string" || typeof stageId !== "string")
+        return;
+    const summary = typeof event.summary === "string" && event.summary ? ` · ${event.summary}` : "";
+    const label = eventName.replace(/^provider\./, "").replaceAll("_", " ");
+    process.stdout.write(`${formatWatchTimestamp(event.timestamp)} ${stageId} ${label}${summary}\n`);
+}
+export function formatWatchTimestamp(timestamp) {
+    if (typeof timestamp !== "string" || timestamp.trim() === "")
+        return "--";
+    let text = timestamp.trim();
+    if (text.endsWith("Z"))
+        text = `${text.slice(0, -1)}+00:00`;
+    const parsed = new Date(text);
+    if (Number.isNaN(parsed.getTime()))
+        return timestamp.trim();
+    return parsed.toISOString().replace("T", " ").replace(/\.\d+Z$/, "+00:00").replace("Z", "+00:00");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/hooks.d.ts

@@ -0,0 +1,6 @@
+import type { AgentToolRunner } from "@nodeint/migent-kernel";
+/** Test seams. Production leaves both null. */
+export declare const cliHooks: {
+    which: ((command: string) => string | null) | null;
+    runner: AgentToolRunner | null;
+};

package/dist/hooks.js

@@ -0,0 +1,5 @@
+/** Test seams. Production leaves both null. */
+export const cliHooks = {
+    which: null,
+    runner: null,
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[], cwd?: string): Promise<number>;

package/dist/index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { CommanderError } from "commander";
+import { ConfigurationError } from "@nodeint/migent-kernel";
+import { printError } from "./display.js";
+import { cliHooks } from "./hooks.js";
+import { createProgram } from "./program.js";
+import { setInvocationCwd } from "./workspace.js";
+export async function main(argv = process.argv.slice(2), cwd) {
+    setInvocationCwd(cwd);
+    const status = { code: 0, handled: false };
+    try {
+        const program = createProgram(status);
+        await program.parseAsync(argv, { from: "user" });
+        if (!status.handled) {
+            program.outputHelp();
+            return 2;
+        }
+        return status.code;
+    }
+    catch (error) {
+        if (error instanceof ConfigurationError) {
+            printError(error.message);
+            return 2;
+        }
+        if (error instanceof CommanderError)
+            return error.exitCode === 0 ? 0 : 2;
+        throw error;
+    }
+    finally {
+        setInvocationCwd(undefined);
+        cliHooks.which = null;
+        cliHooks.runner = null;
+    }
+}
+function isDirectRun() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (isDirectRun()) {
+    main()
+        .then((code) => {
+        process.exit(code);
+    })
+        .catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/migrate.d.ts

@@ -0,0 +1,8 @@
+import { type MigrationAdapter } from "@nodeint/migent-kernel";
+export declare function requireCurrentSchema(workspace: string): void;
+export declare function runMigrate(workspace: string, options?: {
+    assumeYes?: boolean;
+    confirm?: ((message: string) => boolean | Promise<boolean>) | null;
+    adapters?: Record<string, MigrationAdapter> | null;
+}): Promise<number>;
+export declare function migrationAdapters(adapters?: Record<string, unknown>): Record<string, MigrationAdapter>;