voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/commands/interactive/lifecycle.js

@@ -0,0 +1,141 @@
+import { runTeardown } from "../../competition/shared/teardown.js";
+import { disposeInteractiveSessionBuffer, getInteractiveSessionRecordSnapshot, rewriteInteractiveSessionRecord, } from "../../domain/interactive/persistence/adapter.js";
+import { toErrorMessage } from "../../utils/errors.js";
+const INTERACTIVE_TERMINATION_WAIT_MS = 1_000;
+let activeInteractive;
+let terminationInFlight = false;
+export function registerActiveInteractive(context) {
+    activeInteractive = context;
+}
+export function clearActiveInteractive(sessionId) {
+    if (activeInteractive?.sessionId !== sessionId) {
+        return;
+    }
+    if (!terminationInFlight) {
+        activeInteractive = undefined;
+    }
+}
+export async function terminateActiveInteractive(status, reason) {
+    if (!activeInteractive || terminationInFlight) {
+        return;
+    }
+    terminationInFlight = true;
+    const context = activeInteractive;
+    let persistenceError;
+    try {
+        terminateInteractiveProcess(context.process);
+        await waitForInteractiveCompletion(context.completion);
+        const existingRecord = await getInteractiveSessionRecordSnapshot({
+            root: context.root,
+            sessionId: context.sessionId,
+        });
+        if (!existingRecord) {
+            return;
+        }
+        if (existingRecord.status === "running") {
+            await rewriteInteractiveSessionRecord({
+                root: context.root,
+                sessionId: context.sessionId,
+                mutate: (record) => record.status === "running"
+                    ? buildTerminatedRecord(record, status, reason)
+                    : record,
+                forceFlush: true,
+            });
+        }
+        await disposeInteractiveSessionBuffer({
+            root: context.root,
+            sessionId: context.sessionId,
+        });
+    }
+    catch (error) {
+        persistenceError =
+            error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to finalize interactive session ${context.sessionId}: ${toErrorMessage(error)}`);
+    }
+    finally {
+        try {
+            await runTeardown(context.teardown);
+        }
+        finally {
+            terminationInFlight = false;
+            activeInteractive = undefined;
+        }
+    }
+    if (persistenceError) {
+        throw persistenceError;
+    }
+}
+export async function finalizeActiveInteractive(sessionId) {
+    if (!activeInteractive || activeInteractive.sessionId !== sessionId) {
+        clearActiveInteractive(sessionId);
+        return;
+    }
+    if (terminationInFlight) {
+        return;
+    }
+    try {
+        await disposeInteractiveSessionBuffer({
+            root: activeInteractive.root,
+            sessionId,
+        });
+    }
+    finally {
+        try {
+            await runTeardown(activeInteractive.teardown);
+        }
+        finally {
+            clearActiveInteractive(sessionId);
+        }
+    }
+}
+function terminateInteractiveProcess(process) {
+    if (!process) {
+        return;
+    }
+    if (process.exitCode !== null || process.signalCode !== null) {
+        return;
+    }
+    try {
+        process.kill("SIGTERM");
+    }
+    catch {
+        // Ignore teardown kill failures; record finalization still proceeds.
+    }
+}
+async function waitForInteractiveCompletion(completion) {
+    if (!completion) {
+        return;
+    }
+    await Promise.race([
+        completion.then(() => undefined, () => undefined),
+        new Promise((resolve) => {
+            setTimeout(resolve, INTERACTIVE_TERMINATION_WAIT_MS);
+        }),
+    ]);
+}
+function buildTerminatedRecord(record, status, reason) {
+    if (status === "aborted") {
+        return {
+            ...record,
+            status: "succeeded",
+        };
+    }
+    return {
+        ...record,
+        status: "failed",
+        error: {
+            code: "provider_launch_failed",
+            message: buildTerminationMessage(status, reason),
+        },
+    };
+}
+function buildTerminationMessage(status, reason) {
+    if (status === "aborted") {
+        return reason
+            ? `Interactive session aborted after ${reason}.`
+            : "Interactive session aborted before completion.";
+    }
+    return reason
+        ? `Interactive session failed after ${reason}.`
+        : "Interactive session failed before completion.";
+}

package/dist/commands/list/command.d.ts

@@ -1,13 +1,20 @@
+import type { ListJsonOutput, ListMode, ListOperator } from "../../contracts/list.js";
 export interface ListCommandInput {
     root: string;
+    specsFilePath: string;
     runsFilePath: string;
+    reductionsFilePath: string;
+    messagesFilePath: string;
+    verificationsFilePath: string;
+    operator: ListOperator;
+    sessionId?: string;
     limit?: number;
-    specPath?: string;
-    runId?: string;
-    includePruned?: boolean;
+    verbose?: boolean;
 }
 export interface ListCommandResult {
     warnings: string[];
     output?: string;
+    mode: ListMode;
+    json: ListJsonOutput;
 }
 export declare function executeListCommand(input: ListCommandInput): Promise<ListCommandResult>;