@nikelyh/offscript 0.0.0-stage → 1.1.0

package/dist/scripts/server/access-file.js

@@ -0,0 +1,21 @@
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+export function createHostAccessFile(directory, access) {
+    const path = join(directory, `.offscript-host-${process.pid}-${randomUUID()}.json`);
+    const content = JSON.stringify({ origin: access.origin, token: access.token }, null, 2) + "\n";
+    writeFileSync(path, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
+    return Object.freeze({ path,
+        remove() {
+            try {
+                if (readFileSync(path, "utf8") !== content)
+                    throw new Error("Host access file was modified; it was preserved.");
+                unlinkSync(path);
+            }
+            catch (error) {
+                if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                    throw error;
+            }
+        },
+    });
+}

package/dist/scripts/server/cli-results.js

@@ -0,0 +1,126 @@
+import { simulationId } from "../../packages/domain/index.js";
+import { openPersistence } from "../../packages/persistence/index.js";
+import { evaluateFindingAssessment } from "../../packages/contracts/index.js";
+import { executeRecoverSimulation } from "../../packages/application/index.js";
+export async function executeListCommand(options) {
+    const persistence = openPersistence({
+        projectRoot: options.projectRoot,
+        ...(options.dataDirectory !== undefined ? { dataDirectory: options.dataDirectory } : {}),
+    });
+    try {
+        persistence.migrate();
+        const list = await persistence.configurations.listConfigurations();
+        if (list.length === 0) {
+            console.log("No saved simulations found in this project.");
+            return;
+        }
+        console.log(`Saved simulations (${list.length}):\n`);
+        for (const sim of list) {
+            console.log(`• ${sim.name} (${sim.simulationId})`);
+            console.log(`  Target: ${sim.targetUrl}`);
+            console.log(`  Goal:   ${sim.goal.split("\n")[0]}`);
+            console.log(`  Users:  ${sim.userProfileIds.join(", ")}`);
+            console.log("");
+        }
+    }
+    finally {
+        persistence.close();
+    }
+}
+export async function executeResultsCommand(options) {
+    const persistence = openPersistence({
+        projectRoot: options.projectRoot,
+        ...(options.dataDirectory !== undefined ? { dataDirectory: options.dataDirectory } : {}),
+    });
+    try {
+        persistence.migrate();
+        const simId = simulationId(options.simulationId);
+        const configuration = await persistence.configurations.findConfiguration(simId);
+        if (!configuration) {
+            console.error(`OFFSCRIPT: Simulation not found: ${options.simulationId}`);
+            process.exitCode = 1;
+            return;
+        }
+        const observations = await persistence.observations.listObservations(simId);
+        const investigations = await persistence.investigations.listInvestigations(simId);
+        const completed = investigations.filter((inv) => inv.lifecycle.status === "completed");
+        const findings = completed.map((inv) => evaluateFindingAssessment(inv, observations));
+        console.log(`Simulation: ${configuration.name} (${configuration.simulationId})`);
+        console.log(`Target:     ${configuration.targetUrl}`);
+        console.log(`Goal:       ${configuration.goal}\n`);
+        console.log(`--- Findings (${findings.length}) ---`);
+        if (findings.length === 0) {
+            console.log("  No completed findings recorded.");
+        }
+        else {
+            for (const finding of findings) {
+                const badge = finding.isConfirmedFinding
+                    ? "[CONFIRMED FINDING]"
+                    : finding.confidence === "provisional"
+                        ? "[PROVISIONAL]"
+                        : finding.confidence === "refuted"
+                            ? "[REFUTED]"
+                            : "[INCONCLUSIVE]";
+                console.log(`  ${badge} ${finding.hypothesis}`);
+                console.log(`    Outcome:      ${finding.outcome} (${finding.confidence})`);
+                console.log(`    Explanation:  ${finding.explanation}`);
+                if (finding.uncertaintyReason) {
+                    console.log(`    Uncertainty:  ${finding.uncertaintyReason}`);
+                }
+                console.log(`    Participants: ${finding.participatingAgents.join(", ")}`);
+                if (finding.evidenceIds.length > 0) {
+                    console.log(`    Evidence:     ${finding.evidenceIds.join(", ")}`);
+                }
+                console.log("");
+            }
+        }
+        console.log(`--- Observations (${observations.length}) ---`);
+        if (observations.length === 0) {
+            console.log("  No observations recorded.");
+        }
+        else {
+            for (const obs of observations) {
+                console.log(`  • [${obs.id}] by ${obs.agentId} at ${obs.context.location}`);
+                console.log(`    ${obs.description}`);
+                if (obs.evidenceIds.length > 0) {
+                    console.log(`    Evidence: ${obs.evidenceIds.join(", ")}`);
+                }
+            }
+            console.log("");
+        }
+        console.log(`--- Investigations (${investigations.length}) ---`);
+        if (investigations.length === 0) {
+            console.log("  No investigations requested.");
+        }
+        else {
+            for (const inv of investigations) {
+                const status = inv.lifecycle.status;
+                console.log(`  • [${inv.id}] (${status}) "${inv.hypothesis}"`);
+                console.log(`    Requested by: ${inv.requestedBy}`);
+                if (status !== "requested") {
+                    console.log(`    Assigned:     ${inv.lifecycle.agentIds.join(", ")}`);
+                }
+            }
+            console.log("");
+        }
+    }
+    finally {
+        persistence.close();
+    }
+}
+export async function executeRecoverCommand(options) {
+    const persistence = openPersistence({
+        projectRoot: options.projectRoot,
+        ...(options.dataDirectory !== undefined ? { dataDirectory: options.dataDirectory } : {}),
+    });
+    try {
+        persistence.migrate();
+        const simId = simulationId(options.simulationId);
+        const action = options.cancel ? "cancel" : "fail";
+        const result = await executeRecoverSimulation({ simulationId: simId, action, reason: "INTERRUPTED_BY_HOST_RESTART" }, persistence.simulations);
+        console.log(`Simulation ${options.simulationId} recovered to ${result.simulation.lifecycle.status}.`);
+    }
+    finally {
+        persistence.close();
+    }
+}

package/dist/scripts/server/open-browser.js

@@ -0,0 +1,13 @@
+import { spawn } from "node:child_process";
+import { pathToFileURL } from "node:url";
+/** Launch a local entry without interpreting paths as shell commands. */
+export function openBrowser(path, platform = process.platform, launch = spawn) {
+    const url = pathToFileURL(path).href;
+    const command = platform === "win32" ? "rundll32.exe" : platform === "darwin" ? "open" : "xdg-open";
+    const args = platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+    return new Promise((resolve, reject) => {
+        const child = launch(command, args, { shell: false, windowsHide: true, stdio: "ignore" });
+        child.once("error", reject);
+        child.once("exit", code => code === 0 ? resolve() : reject(new Error("Browser launcher failed.")));
+    });
+}

package/dist/scripts/server/run.js

@@ -0,0 +1,76 @@
+import { createLocalHost } from "../../packages/runtime/host.js";
+import { createMultiModeSessionFactory } from "../../packages/orchestration/index.js";
+import { createHostAccessFile } from "./access-file.js";
+import { createStudioEntryFile } from "./studio-entry-file.js";
+import { openBrowser } from "./open-browser.js";
+import { startupError } from "./startup-error.js";
+process.env.MOZAIK_API_KEY ??= "";
+let requestStop = () => { };
+const stopping = new Promise(resolve => { requestStop = resolve; });
+let interrupted = false;
+function stop() { interrupted = true; requestStop(); }
+process.once("SIGINT", stop);
+process.once("SIGTERM", stop);
+let host;
+let access;
+let studioEntry;
+try {
+    const portText = process.env.OFFSCRIPT_PORT;
+    if (portText !== undefined && !/^\d+$/.test(portText))
+        throw new Error("Invalid port configuration.");
+    host = createLocalHost({ projectRoot: process.env.OFFSCRIPT_PROJECT_ROOT ?? process.cwd(),
+        sessionFactory: createMultiModeSessionFactory(),
+        ...(process.env.OFFSCRIPT_STUDIO_DIRECTORY ? { studioDirectory: process.env.OFFSCRIPT_STUDIO_DIRECTORY } : {}),
+        ...(process.env.OFFSCRIPT_DATA_DIRECTORY === undefined ? {} : { dataDirectory: process.env.OFFSCRIPT_DATA_DIRECTORY }),
+        ...(portText === undefined ? {} : { port: Number(portText) }),
+        onDiagnostic(code) { console.error(code); process.exitCode = 1; stop(); },
+    });
+    const origin = await host.start();
+    if (!interrupted) {
+        access = createHostAccessFile(host.config.dataDirectory, host.credentials());
+        console.log(`OFFSCRIPT host: ${origin}`);
+        console.log(`Local access credentials: ${access.path}`);
+        if (process.env.OFFSCRIPT_STUDIO_DIRECTORY) {
+            studioEntry = createStudioEntryFile(host.config.dataDirectory, host.studioEntry());
+            console.log(`Open this local file in your browser to enter Studio: ${studioEntry.path}`);
+            console.log("The entry is single-use and expires in five minutes. Refreshing Studio keeps the browser session.");
+            if (process.env.OFFSCRIPT_OPEN_BROWSER === "1") {
+                void openBrowser(studioEntry.path).catch(() => {
+                    if (!interrupted)
+                        console.error("Could not open a browser. Open the printed local HTML entry manually; the host is still running.");
+                });
+            }
+        }
+        console.log("Press Ctrl+C to stop. No exploration starts automatically.");
+        await stopping;
+    }
+}
+catch (error) {
+    console.error(`OFFSCRIPT: ${startupError(error)}`);
+    process.exitCode = 1;
+}
+finally {
+    try {
+        await host?.close();
+    }
+    catch {
+        console.error("OFFSCRIPT host shutdown did not complete cleanly.");
+        process.exitCode = 1;
+    }
+    try {
+        access?.remove();
+    }
+    catch {
+        console.error("OFFSCRIPT host access file could not be removed.");
+        process.exitCode = 1;
+    }
+    try {
+        studioEntry?.remove();
+    }
+    catch {
+        console.error("Studio entry file could not be removed.");
+        process.exitCode = 1;
+    }
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+}

package/dist/scripts/server/startup-error.js

@@ -0,0 +1,17 @@
+/** Report actionable categories without exposing credentials or exception contents. */
+export function startupError(error) {
+    const seen = new Set();
+    let current = error;
+    while (current instanceof Error && !seen.has(current)) {
+        seen.add(current);
+        const code = "code" in current ? current.code : undefined;
+        if (code === "EADDRINUSE")
+            return "Port is already in use. Choose --port 0 or another port.";
+        if (code === "EACCES" || code === "EPERM")
+            return "Access denied. Check project/storage permissions and the selected port.";
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return "Project, storage, or distribution path is unavailable. Check the selected directories.";
+        current = current.cause;
+    }
+    return "Host could not start. Check project, port, storage, and installed distribution compatibility.";
+}

package/dist/scripts/server/studio-entry-file.js

@@ -0,0 +1,22 @@
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+export function createStudioEntryFile(directory, access) {
+    const path = join(directory, `.offscript-studio-${process.pid}-${randomUUID()}.html`);
+    const escape = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+    const content = `<!doctype html><html lang="en"><meta charset="utf-8"><meta name="referrer" content="no-referrer"><title>Open OFFSCRIPT Studio</title>
+<form method="post" action="${escape(access.origin)}/studio/session"><input type="hidden" name="entry" value="${escape(access.entry)}"><button>Open OFFSCRIPT Studio</button></form>
+<script>document.querySelector('form').submit()</script></html>`;
+    writeFileSync(path, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
+    return Object.freeze({ path, remove() {
+            try {
+                if (readFileSync(path, "utf8") !== content)
+                    throw new Error("Studio entry file changed; it was preserved.");
+                unlinkSync(path);
+            }
+            catch (error) {
+                if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                    throw error;
+            }
+        } });
+}