openmerit 0.1.4 → 0.1.6-preview.0

package/dist/pi/src/scheduler.d.ts

@@ -0,0 +1,11 @@
+export interface PiWakeupOptions {
+    readonly projectRoot: string;
+    readonly extensionPath: string;
+    readonly provider: string;
+    readonly modelId: string;
+}
+export declare function piWakeupLabel(projectRoot: string): string;
+export declare function piWakeupPlistPath(projectRoot: string): string;
+export declare function renderPiWakeupPlist(options: PiWakeupOptions, piPath: string, runnerPath: string): string;
+export declare function provisionPiWakeup(options: PiWakeupOptions): Promise<string>;
+export declare function removePiWakeup(projectRoot: string): Promise<boolean>;

package/dist/pi/src/scheduler.js

@@ -0,0 +1,137 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const POLL_SECONDS = 300;
+function projectHash(projectRoot) {
+    return createHash("sha256").update(resolve(projectRoot)).digest("hex").slice(0, 16);
+}
+export function piWakeupLabel(projectRoot) {
+    return `com.openmerit.pi.${projectHash(projectRoot)}`;
+}
+export function piWakeupPlistPath(projectRoot) {
+    return join(homedir(), "Library", "LaunchAgents", `${piWakeupLabel(projectRoot)}.plist`);
+}
+function managedMarker(projectRoot) {
+    return `<!-- openmerit-managed:${projectHash(projectRoot)} -->`;
+}
+function xml(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+async function executable(name) {
+    for (const directory of (process.env.PATH ?? "").split(":")) {
+        if (!directory)
+            continue;
+        const path = join(directory, name);
+        try {
+            await access(path, constants.X_OK);
+            return path;
+        }
+        catch { /* try the next PATH entry */ }
+    }
+    throw new Error(`${name} is not on PATH`);
+}
+export function renderPiWakeupPlist(options, piPath, runnerPath) {
+    const args = [process.execPath, runnerPath, resolve(options.projectRoot), piPath,
+        resolve(options.extensionPath), options.provider, options.modelId];
+    const argumentsXml = args.map((argument) => `      <string>${xml(argument)}</string>`).join("\n");
+    const path = [dirname(process.execPath), dirname(piPath), "/usr/bin", "/bin", "/usr/sbin", "/sbin"].join(":");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+${managedMarker(options.projectRoot)}
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${xml(piWakeupLabel(options.projectRoot))}</string>
+  <key>ProgramArguments</key><array>
+${argumentsXml}
+  </array>
+  <key>WorkingDirectory</key><string>${xml(resolve(options.projectRoot))}</string>
+  <key>EnvironmentVariables</key><dict>
+    <key>PATH</key><string>${xml(path)}</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>StartInterval</key><integer>${POLL_SECONDS}</integer>
+</dict>
+</plist>
+`;
+}
+async function loaded(label) {
+    try {
+        await execFileAsync("launchctl", ["print", `gui/${process.getuid?.()}/${label}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function provisionPiWakeup(options) {
+    if (process.platform !== "darwin" || process.getuid === undefined) {
+        throw new Error("Persistent Pi wakeups require a macOS user LaunchAgent.");
+    }
+    if (!options.provider || !options.modelId)
+        throw new Error("Select an authenticated Pi model before scheduling.");
+    const piPath = await executable("pi");
+    const auth = await execFileAsync(piPath, ["auth", "check", "--model", `${options.provider}/${options.modelId}`], {
+        env: {
+            HOME: homedir(),
+            PATH: [dirname(process.execPath), dirname(piPath), "/usr/bin", "/bin", "/usr/sbin", "/sbin"].join(":"),
+        },
+    });
+    if (auth.stdout.trim() !== "ready") {
+        throw new Error(`Pi authentication is not ready for ${options.provider}/${options.modelId} in the background environment.`);
+    }
+    const extensionPath = resolve(options.extensionPath);
+    const runnerPath = join(dirname(extensionPath), `wakeup${extname(extensionPath)}`);
+    await access(runnerPath, constants.R_OK);
+    const path = piWakeupPlistPath(options.projectRoot);
+    const content = renderPiWakeupPlist({ ...options, extensionPath }, piPath, runnerPath);
+    let prior;
+    try {
+        prior = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (prior && !prior.includes(managedMarker(options.projectRoot))) {
+        throw new Error(`Refusing to replace unmanaged LaunchAgent ${basename(path)}.`);
+    }
+    const label = piWakeupLabel(options.projectRoot);
+    if (prior === content && await loaded(label))
+        return path;
+    if (await loaded(label))
+        await execFileAsync("launchctl", ["bootout", `gui/${process.getuid()}/${label}`]);
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, content, { mode: 0o600 });
+    await rename(temporary, path);
+    await execFileAsync("launchctl", ["bootstrap", `gui/${process.getuid()}`, path]);
+    return path;
+}
+export async function removePiWakeup(projectRoot) {
+    if (process.platform !== "darwin" || process.getuid === undefined)
+        return false;
+    const path = piWakeupPlistPath(projectRoot);
+    let content;
+    try {
+        content = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+    if (!content.includes(managedMarker(projectRoot))) {
+        throw new Error(`Refusing to remove unmanaged LaunchAgent ${basename(path)}.`);
+    }
+    const label = piWakeupLabel(projectRoot);
+    if (await loaded(label))
+        await execFileAsync("launchctl", ["bootout", `gui/${process.getuid()}/${label}`]);
+    await unlink(path);
+    return true;
+}

package/dist/pi/src/wakeup.d.ts

@@ -0,0 +1,2 @@
+import type { OpenMeritProjectState } from "../../protocol/src/index.ts";
+export declare function isPiWakeupDue(state: OpenMeritProjectState, now?: string): boolean;

package/dist/pi/src/wakeup.js

@@ -0,0 +1,108 @@
+import { spawn } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildAutomationPlan, OpenMeritCoordinator, ProjectStore } from "../../core/src/index.js";
+const wakeupDescriptor = {
+    id: "pi-launchagent", name: "Pi LaunchAgent", version: "0.87", protocolVersions: ["0.1"],
+    capabilities: [], executionModes: ["non_interactive"],
+    structuredOutput: { schemaDialect: "https://json-schema.org/draft/2020-12/schema", presentation: "adapter_validation", enforcement: "adapter" },
+    automation: {
+        supportedSignals: ["product_task_completed", "metric_window_available", "scheduled_tick", "model_catalog_changed", "verification_window_completed"],
+        persistentScheduling: true, backgroundExecution: true, wakeupProvisioning: "infrastructure_change",
+    },
+};
+export function isPiWakeupDue(state, now = new Date().toISOString()) {
+    const execution = state.cycle.policy?.checkPolicy.execution;
+    if (execution?.mode !== "persistent" || !execution.infrastructureChangesAllowed || state.activeIntent || state.automation.paused)
+        return false;
+    if (state.automation.pendingIntentKind)
+        return true;
+    const at = buildAutomationPlan(state, wakeupDescriptor).nextWakeupAt;
+    return at !== undefined && Date.parse(at) <= Date.parse(now);
+}
+async function run() {
+    const [projectRoot, piPath, extensionPath, provider, modelId] = process.argv.slice(2);
+    if (!projectRoot || !piPath || !extensionPath || !provider || !modelId)
+        process.exitCode = 2;
+    if (process.exitCode)
+        return;
+    const store = new ProjectStore(projectRoot);
+    const state = await store.readState();
+    if (!state || !isPiWakeupDue(state))
+        return;
+    const startedAt = new Date().toISOString();
+    const coordinator = new OpenMeritCoordinator(store, {
+        descriptor: wakeupDescriptor,
+        async dispatch() { return { accepted: false, reason: "The wakeup runner does not dispatch harness work directly." }; },
+    });
+    const check = state.automation.pendingIntentKind === "run_assessment"
+        ? await coordinator.assessBaseline(startedAt)
+        : state.automation.pendingIntentKind
+            ? undefined
+            : await coordinator.recordAutomationSignal({
+                protocolVersion: "0.1", id: `wakeup-${crypto.randomUUID()}`,
+                type: "scheduled_tick", occurredAt: startedAt, targetId: state.cycle.targetId,
+            });
+    if (check && check.decision.action !== "issue_intent") {
+        await writeFile(join(store.directory, "scheduler-status.json"), JSON.stringify({
+            schemaVersion: 1, startedAt, completedAt: new Date().toISOString(), exitCode: 0,
+            decision: check.decision.reason,
+        }, null, 2) + "\n", { mode: 0o600 });
+        return;
+    }
+    const configuredTimeout = Number(process.env.OPENMERIT_WAKEUP_TIMEOUT_MS);
+    const runLimitMs = Number.isFinite(configuredTimeout) && configuredTimeout >= 5_000
+        ? Math.min(configuredTimeout, 15 * 60_000)
+        : 15 * 60_000;
+    const deadline = Date.now() + runLimitMs;
+    const invokePi = async (prompt) => {
+        const child = spawn(piPath, [
+            "--no-extensions", "--extension", extensionPath, "--provider", provider, "--model", modelId,
+            ...(process.env.OPENMERIT_WAKEUP_DEBUG === "1" ? ["--mode", "json"] : []),
+            "--no-session", "--print", prompt,
+        ], { cwd: projectRoot, stdio: process.env.OPENMERIT_WAKEUP_DEBUG === "1" ? "inherit" : "ignore", env: process.env });
+        return new Promise((resolve, reject) => {
+            let timedOut = false;
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+                setTimeout(() => child.kill("SIGKILL"), 5_000).unref();
+            }, Math.max(1, deadline - Date.now()));
+            child.once("error", (error) => { clearTimeout(timeout); reject(error); });
+            child.once("exit", (code) => { clearTimeout(timeout); resolve(timedOut ? 124 : code ?? 1); });
+        });
+    };
+    let exitCode = await invokePi("Run the due OpenMerit scheduled check for this configured project. " +
+        "On startup, OpenMerit may create an active intent in .openmerit/state.json. Read that intent and .openmerit/config.json, " +
+        "perform only its authorized work, and call openmerit_complete_intent exactly once with verified evidence. " +
+        "For baseline assessment, if no application metric windows exist, report insufficiency promptly; do not wait for new data or invent samples. " +
+        "If evidence is unavailable, report failure honestly. Never change Pi's model or an unauthorized application route.");
+    const issued = await store.readState();
+    if (exitCode === 0 && issued?.activeIntent && !state.activeIntent && Date.now() < deadline) {
+        const intent = issued.activeIntent;
+        exitCode = await invokePi(`Complete the already active OpenMerit ${intent.kind} intent ${intent.id}. ` +
+            "Read .openmerit/config.json and the project evidence. Follow the requested outcome and constraints below. " +
+            "Use the registered openmerit_complete_intent tool exactly once, with verified evidence; if evidence is unavailable, report failure honestly. " +
+            "Never change Pi's model or the application model unless this intent explicitly authorizes that target-bound change.\n\n" +
+            JSON.stringify(intent));
+        if ((await store.readState())?.activeIntent?.id === intent.id)
+            exitCode = 1;
+    }
+    const finalState = await store.readState();
+    if (finalState?.activeIntent && exitCode === 0)
+        exitCode = 1;
+    if (finalState?.automation.pendingIntentKind && exitCode === 0)
+        exitCode = 1;
+    await writeFile(join(store.directory, "scheduler-status.json"), JSON.stringify({
+        schemaVersion: 1, startedAt, completedAt: new Date().toISOString(), exitCode,
+        ...(finalState?.activeIntent ? { activeIntentId: finalState.activeIntent.id } : {}),
+    }, null, 2) + "\n", { mode: 0o600 });
+    process.exitCode = exitCode;
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
+    run().catch((error) => {
+        process.stderr.write(`OpenMerit Pi wakeup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}