@awak-app/simy-cli 0.5.8 → 0.5.11

package/src/codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+// Record/observation checks, not authentication of the collector or host completion.
+import { lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
+import {
+  checkAcceptance,
+  contextDigest,
+  readEvidenceArtifact,
+  sha256,
+} from "./check-acceptance.mjs";
+
+const text = (value) => typeof value === "string" && value.trim().length > 0;
+const object = (value) =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+export const MINIMUM_COMPLETION_VERSION = 1;
+
+export function minimumCharter(charter) {
+  if (
+    charter?.completion_contract?.version !== 2 ||
+    !text(charter.id) ||
+    !text(charter.requirement) ||
+    !Array.isArray(charter.acceptance_criteria) ||
+    !charter.acceptance_criteria.length ||
+    !charter.acceptance_criteria.every(text)
+  ) {
+    throw new Error("Current completion charter required");
+  }
+  const source = {
+    original_request:
+      charter.thread_state?.original_request || charter.requirement,
+    requirement: charter.requirement,
+    minimum_scope:
+      charter.completion_contract.minimum_scope || charter.acceptance_criteria,
+    non_goals: charter.completion_contract.non_goals || [],
+  };
+  return {
+    schema_version: 1,
+    minimum_completion_version: MINIMUM_COMPLETION_VERSION,
+    run_id: charter.id,
+    source,
+    criteria: charter.acceptance_criteria.map((outcome, index) => ({
+      id: `AC-${index + 1}`,
+      outcome,
+      acceptance_source: `request:${contextDigest(source)}`,
+      layers: {
+        user: {
+          applicability: "required",
+          method:
+            "Exercise the actual operation and observe its result; reopen/reload when persistence is required.",
+        },
+        system: {
+          applicability: "required",
+          method:
+            "Independently inspect the final postcondition and necessary integration; persisted values and ownership when saving.",
+        },
+      },
+    })),
+  };
+}
+
+export function minimumContext(charter, headSha) {
+  const frozen = minimumCharter(charter);
+  return {
+    run_id: charter.id,
+    stage: "locally_verified",
+    environment: "local",
+    fixture_id: charter.id,
+    input_sha256: contextDigest(frozen.source),
+    source_revisions: { [charter.repository]: headSha },
+  };
+}
+
+export async function loadMinimumJson(file) {
+  const stat = await lstat(file);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
+    throw new Error("Invalid minimum evidence input");
+  return JSON.parse(await readFile(file, "utf8"));
+}
+
+export async function checkMinimumCompletion({
+  charter,
+  matrix,
+  context,
+  evidenceRoot,
+}) {
+  const frozen = minimumCharter(charter);
+  const charterBytes = Buffer.from(JSON.stringify(frozen));
+  const charterSha = sha256(charterBytes);
+  const contextSha = contextDigest(context);
+  const report = await checkAcceptance({
+    charterBytes,
+    matrix,
+    expectedCharterSha256: charterSha,
+    expectedContextSha256: contextSha,
+    evidenceRoot,
+  });
+  report.minimum_completion_version = MINIMUM_COMPLETION_VERSION;
+  report.charter_sha256 = charterSha;
+  report.context_sha256 = contextSha;
+  report.matrix_sha256 = contextDigest(matrix);
+  report.head_sha = context.source_revisions[charter.repository];
+  const fail = (id, reason) => report.errors.push(`${id}: ${reason}`);
+  for (const criterion of frozen.criteria) {
+    const row = matrix.results.find((result) => result.id === criterion.id);
+    if (
+      !Array.isArray(row?.implementation_refs) ||
+      !row.implementation_refs.length ||
+      !row.implementation_refs.every(
+        (ref) =>
+          text(ref) &&
+          !path.isAbsolute(ref) &&
+          !ref.includes("\\") &&
+          ref
+            .split("/")
+            .every(
+              (segment) =>
+                segment &&
+                segment !== ".." &&
+                segment !== "." &&
+                !segment.includes(":"),
+            ),
+      )
+    ) {
+      fail(
+        criterion.id,
+        "Missing or unsafe requirement-to-implementation mapping",
+      );
+    }
+    for (const [layer, names] of Object.entries({
+      user: ["operation", "result"],
+      system: ["postcondition", "integration"],
+    })) {
+      const cell = row?.layers?.[layer];
+      if (cell?.status !== "passed") continue;
+      try {
+        // The first artifact is a structured observation; further artifacts may be images/logs.
+        const observation = JSON.parse(
+          (
+            await readEvidenceArtifact(
+              await realpath(evidenceRoot),
+              cell.evidence[0],
+            )
+          ).toString(),
+        );
+        if (
+          observation.criterion_id !== criterion.id ||
+          observation.context_sha256 !== contextSha ||
+          !object(observation.checks)
+        )
+          throw new Error("Wrong observation context");
+        for (const name of names) {
+          const check = observation.checks[name];
+          if (
+            !object(check) ||
+            !text(check.subject) ||
+            check.expected === null ||
+            check.expected === undefined ||
+            (name === "operation" && check.expected !== true) ||
+            !isDeepStrictEqual(check.expected, check.actual)
+          ) {
+            fail(
+              `${criterion.id}/${layer}/${name}`,
+              "Missing observation or expected/actual mismatch",
+            );
+          }
+        }
+      } catch {
+        fail(
+          `${criterion.id}/${layer}`,
+          "Missing, altered or invalid structured observation",
+        );
+      }
+    }
+  }
+  report.status = report.errors.length
+    ? "evidence_incomplete"
+    : "evidence_complete";
+  // Additional floor failures must be visible in the human-readable record too.
+  report.markdown += `\nMinimum completion: ${report.status}\n${report.errors.map((error) => `- ${error}`).join("\n")}\n`;
+  return report;
+}
+
+const entry = process.argv[1]
+  ? await realpath(process.argv[1]).catch(() => null)
+  : null;
+if (entry === fileURLToPath(import.meta.url)) {
+  try {
+    const [
+      charterPath,
+      matrixPath,
+      contextPath,
+      expectedCharter,
+      expectedContext,
+      ...extra
+    ] = process.argv.slice(2);
+    if (!expectedContext || extra.length) throw new Error("Invalid arguments");
+    const charter = await loadMinimumJson(charterPath);
+    const context = await loadMinimumJson(contextPath);
+    if (
+      sha256(Buffer.from(JSON.stringify(minimumCharter(charter)))) !==
+        expectedCharter ||
+      contextDigest(context) !== expectedContext
+    )
+      throw new Error("Trusted digest mismatch");
+    const report = await checkMinimumCompletion({
+      charter,
+      context,
+      matrix: await loadMinimumJson(matrixPath),
+      evidenceRoot: path.dirname(path.resolve(matrixPath)),
+    });
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    process.exitCode = report.status === "evidence_complete" ? 0 : 1;
+  } catch {
+    process.stderr.write(
+      "Minimum completion unavailable. Supply charter.json matrix.json context.json trusted-charter-sha256 trusted-context-sha256.\n",
+    );
+    process.exitCode = 2;
+  }
+}

package/src/console/app.js

@@ -137,6 +137,23 @@ export function AgenticLoopConsole({ agent, onQuit = () => {} }) {
       }
       return;
     }
+    if (command.type === "update") {
+      setBusy(true);
+      try {
+        const result = await agent.updates?.performAction?.();
+        setNotice(
+          result?.opened
+            ? "Opened the SIMY Apple Silicon installer download page."
+            : `Open the installer download manually: ${cliUpdate?.action?.url || agent.webOrigin}`,
+        );
+      } catch (error) {
+        setNotice(error instanceof Error ? error.message : String(error));
+      } finally {
+        setBusy(false);
+        if (!selectedRun) setInputMode(true);
+      }
+      return;
+    }
     if (command.type === "configure") {
       setDraft((current) => updateDraft(current, command));
       setNotice(configurationNotice(command));
@@ -897,10 +914,12 @@ function ActionBar({
                 wrap: "wrap",
                 children: `UPDATE  ${cliUpdate.message || "SIMY CLI update status changed."}`,
               }),
-              cliUpdate.action?.command
+              cliUpdate.action?.command || cliUpdate.action?.url
                 ? jsx(Text, {
                     wrap: "wrap",
-                    children: `Next  ${cliUpdate.action.command}`,
+                    children: cliUpdate.action?.url
+                      ? `Next  /update or open ${cliUpdate.action.url}`
+                      : `Next  ${cliUpdate.action.command}`,
                   })
                 : null,
             ],

package/src/console/commands.js

@@ -15,6 +15,7 @@ const HELP_LINES = [
   "/pause                Pause the active executor process",
   "/resume               Resume a paused executor process",
   "/stop                 Stop the selected run",
+  "/update               Open the available installer download",
 ];
 
 export function parseConsoleCommand(value) {
@@ -66,6 +67,8 @@ export function parseConsoleCommand(value) {
       return { type: "resume" };
     case "/stop":
       return { type: "stop" };
+    case "/update":
+      return { type: "update" };
     case "/help":
       return { type: "help" };
     default:

package/src/desktop-host.js

@@ -0,0 +1,220 @@
+import { spawn, execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { startAgent } from "./agent.js";
+import { createCliAutoUpdater, readCliPackageInfo } from "./auto-update.js";
+import { createAgentShutdown } from "./shutdown.js";
+import { resolveWebOrigin } from "./web-origin.js";
+import { openAuthorizationUrl } from "./browser.js";
+import { inspectBackendExecutable } from "./backend-executable.js";
+import { startWorkflowUpdates } from "./sqm/workflow-update.js";
+import {
+  acquireDesktopProcessLock,
+  assertNoLegacyCliDaemon,
+  PROCESS_CONFLICT_CODE,
+  PROCESS_CONFLICT_MESSAGE,
+  validateDesktopSupervisor,
+} from "./desktop-process-lock.js";
+
+const silentLogger = { log() {}, error() {} };
+
+export async function startDesktopHost({ input = process.stdin, output = process.stdout, env = process.env,
+  dependencies = {}, exit = (code) => { process.exitCode = code; } } = {}) {
+  const emit = (event) => output.write(`${JSON.stringify(event)}\n`);
+  const root = env.SIMY_HOME?.trim() || join(homedir(), ".simy");
+  const webOrigin = resolveWebOrigin(null, env);
+  const candidate = Boolean(env.SIMY_DESKTOP_SUPERVISOR_TOKEN);
+  if (candidate && !await validateDesktopSupervisor(root, env.SIMY_DESKTOP_SUPERVISOR_TOKEN)) {
+    throw new Error("Desktop update supervisor is no longer running.");
+  }
+  const lock = candidate ? null : await acquireDesktopProcessLock(root, { webOrigin });
+  const supervisorToken = lock?.nonce || env.SIMY_DESKTOP_SUPERVISOR_TOKEN;
+  let agent, updater, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null;
+  let shuttingDown = null;
+  let commands;
+  const packageInfo = dependencies.packageInfo || await readCliPackageInfo();
+  const publish = () => {
+    if (closed || relay || !agent) return Promise.resolve();
+    if (publishing) return publishing;
+    publishing = Promise.resolve(agent.getDesktopStatus()).then((status) => {
+      if (!closed && !relay) emit({ type: "status", status });
+    }).finally(() => { publishing = null; });
+    return publishing;
+  };
+  const stopAgent = async () => {
+    clearInterval(timer);
+    await stopWorkflows();
+    if (agent) await createAgentShutdown(agent)();
+  };
+  const close = () => shuttingDown ||= (async () => {
+    closed = true;
+    commands?.close();
+    input.pause?.();
+    if (relay) {
+      relay.stdin.end();
+      await new Promise((done) => {
+        const limit = setTimeout(() => { relay.kill("SIGTERM"); done(); }, 10_000);
+        relay.once("exit", () => { clearTimeout(limit); done(); });
+        if (relay.exitCode !== null) { clearTimeout(limit); done(); }
+      });
+    } else await stopAgent();
+    await lock?.release();
+  })();
+
+  try {
+    if (!candidate) {
+      await (dependencies.assertNoLegacyDaemon || assertNoLegacyCliDaemon)(webOrigin);
+    }
+    updater = await (dependencies.createUpdater || createCliAutoUpdater)({
+      daemon: true, interactive: true, webOrigin,
+      disabled: env.SIMY_AUTO_UPDATE === "0",
+      dependencies: { packageInfo, logger() {} },
+    });
+    agent = await (dependencies.startAgent || startAgent)({
+      daemon: true, webOrigin, sessionRoot: root, quiet: true, updateManager: updater,
+    });
+    stopWorkflows = (dependencies.startWorkflowUpdates || startWorkflowUpdates)({ enabled: env.SIMY_AUTO_UPDATE !== "0" });
+    updater.on?.("change", () => { void publish().catch(() => {}); });
+    updater.start({ registry: agent.registry, restartDaemon: async (targetVersion, installation) => {
+      if (!installation?.entryPath || !installation?.executablePath) throw new Error("Signed update runtime is unavailable.");
+      const child = (dependencies.spawn || spawn)(installation.executablePath,
+        [join(dirname(installation.entryPath), "desktop-host.js")], {
+          stdio: ["pipe", "pipe", "ignore"],
+          env: { ...env, SIMY_DESKTOP_SUPERVISOR_TOKEN: supervisorToken },
+        });
+      const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+      let accepted = false;
+      child.stdin.on("error", () => {
+        if (relay === child && !closed) {
+          emit({ type: "error", message: "SIMY update connection ended. Reconnect to start the service again." });
+          void close().then(() => exit(1));
+        }
+      });
+      child.on("exit", () => {
+        if (relay === child && !closed) {
+          emit({ type: "error", message: "SIMY stopped. Reconnect to start it again." });
+          void close().then(() => exit(1));
+        }
+      });
+      try {
+        const first = await new Promise((accept, reject) => {
+          const limit = setTimeout(() => reject(new Error("Updated desktop runtime did not start in time.")), 30_000);
+          const finish = (fn, value) => { clearTimeout(limit); fn(value); };
+          child.once("error", () => finish(reject, new Error("Updated desktop runtime could not start.")));
+          child.once("exit", () => { if (!accepted) finish(reject, new Error("Updated desktop runtime exited before verification.")); });
+          lines.on("line", (line) => {
+            if (line.length > 131072) return;
+            let event; try { event = JSON.parse(line); } catch { return; }
+            if (accepted) { emit(event); return; }
+            if (event.type === "status") {
+              if (!validCandidateStatus(event.status, targetVersion, webOrigin)) {
+                finish(reject, new Error("Updated desktop runtime identity mismatch."));
+              } else { accepted = true; finish(accept, event); }
+            }
+          });
+        });
+        relay = child;
+        await stopAgent();
+        if (child.exitCode !== null || closed) throw new Error("Updated runtime stopped during handoff.");
+        emit(first);
+      } catch (error) {
+        lines.close(); child.kill("SIGTERM"); throw error;
+      }
+    } });
+    await publish();
+    timer = setInterval(() => { void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." })); }, 3_000);
+  } catch (error) { await close(); throw error; }
+
+  let queue = Promise.resolve();
+  commands = createInterface({ input, crlfDelay: Infinity });
+  commands.on("line", (line) => {
+    if (closed) return;
+    if (line.length > 4096) return;
+    let command; try { command = JSON.parse(line); } catch { return; }
+    if (typeof command.id !== "string" || command.id.length > 128) return;
+    if (relay) {
+      if (!relay.stdin.destroyed && relay.exitCode === null) relay.stdin.write(`${JSON.stringify(command)}\n`);
+      return;
+    }
+    queue = queue.then(async () => {
+      try {
+        const action = command.action;
+        if (action === "refresh" || action === "reconnect") {
+          await agent.refreshCodexStatus?.();
+          await agent.refreshDesktopStatus();
+        }
+        else if (action === "login") {
+          const url = await agent.requestDesktopLogin();
+          if (url) {
+            if (new URL(url).origin !== webOrigin) throw new Error("Invalid login origin.");
+            const result = await (dependencies.openLogin || openAuthorizationUrl)(url, { logger: silentLogger });
+            if (!result.opened) throw new Error("Could not open the login page.");
+          }
+        } else if (action === "check_update") await updater.checkNow();
+        else if (action === "update") {
+          if (updater.snapshot().state === "waiting_for_idle") await updater.maybeApply();
+          else await updater.performAction();
+        } else if (action === "codex_login") await (dependencies.codexLogin || openCodexLogin)(root);
+        else if (action === "quit") {
+          const status = await agent.getDesktopStatus();
+          if (status.tasks.activeCount > 0 && command.force !== true) throw new Error("Tasks are still running. Confirm before quitting.");
+          emit({ type: "result", id: command.id, ok: true });
+          await close(); exit(0); return;
+        } else throw new Error("Unsupported desktop action.");
+        emit({ type: "result", id: command.id, ok: true });
+        await publish();
+      } catch {
+        emit({ type: "result", id: command.id, ok: false, message: "Action could not finish. Refresh the status and try again; active tasks must finish before quitting." });
+      }
+    }).catch(() => {});
+  });
+  commands.on("close", () => { if (!closed) void close().then(() => exit(0)); });
+  return { close, publish, agent };
+}
+
+function validCandidateStatus(status, version, webOrigin) {
+  return status?.schemaVersion === 1 && status.version === version && status.webOrigin === webOrigin
+    && ["signed_out", "signed_in", "expired"].includes(status.auth?.state)
+    && ["connecting", "online", "offline", "unauthorized", "unknown"].includes(status.connection?.state)
+    && Number.isSafeInteger(status.tasks?.activeCount) && status.tasks.activeCount >= 0
+    && Array.isArray(status.tasks.items) && typeof status.codex?.state === "string";
+}
+
+async function openCodexLogin(root) {
+  const codex = await inspectBackendExecutable("codex");
+  if (!codex.available || !codex.executable) throw new Error("Codex is not installed.");
+  const directory = await mkdtemp(join(root, "codex-login-"));
+  const script = join(directory, "Sign in to Codex.command");
+  const quote = (s) => `'${s.replaceAll("'", "'\\''")}'`;
+  await writeFile(script, `#!/bin/bash\nexport PATH="/opt/homebrew/bin:/usr/local/bin:$HOME/.local/bin:$PATH"\n${quote(codex.executable)} login\nresult=$?\nrm -f -- ${quote(script)}\nrmdir -- ${quote(directory)}\nexit "$result"\n`, { mode: 0o700 });
+  await chmod(script, 0o700);
+  try { await promisify(execFile)("/usr/bin/open", ["-a", "Terminal", script], { timeout: 10_000 }); }
+  catch (error) { await rm(directory, { recursive: true, force: true }); throw error; }
+}
+
+export function isDesktopHostEntry(entry = process.argv[1]) {
+  try { return Boolean(entry) && realpathSync(entry) === fileURLToPath(import.meta.url); }
+  catch { return false; }
+}
+
+if (isDesktopHostEntry()) {
+  let host;
+  const stop = () => { void host?.close().finally(() => process.exit(0)); };
+  process.once("SIGTERM", stop); process.once("SIGINT", stop);
+  startDesktopHost().then((value) => { host = value; }).catch((error) => {
+    const conflict = error?.code === PROCESS_CONFLICT_CODE;
+    process.stdout.write(`${JSON.stringify({
+      type: "error",
+      ...(conflict ? { code: PROCESS_CONFLICT_CODE } : {}),
+      message: conflict
+        ? PROCESS_CONFLICT_MESSAGE
+        : "SIMY could not start. Check whether another SIMY window is already running, then reconnect.",
+    })}\n`);
+    process.exitCode = 1;
+  });
+}