@awak-app/simy-cli 0.4.0 → 0.5.1

package/src/sqm/bundle-store.js

@@ -9,6 +9,18 @@ import { validateKnowledgeBundle } from "./validation.js";
 const DEFAULT_TTL_MS = 5 * 60 * 1000;
 export const SQM_BUNDLE_FETCH_TIMEOUT_MS = 15_000;
 
+export class SqmIncompatibleCliError extends Error {
+  constructor(message, { currentVersion, minimumVersion, modules = [] } = {}) {
+    super(message);
+    this.name = "SqmIncompatibleCliError";
+    this.code = "incompatible_cli";
+    this.currentVersion = currentVersion || null;
+    this.minimumVersion = minimumVersion || null;
+    this.modules = modules;
+    this.fallbackAllowed = false;
+  }
+}
+
 export async function loadKnowledgeBundle({
   repository,
   cliVersion,
@@ -68,6 +80,7 @@ export async function loadKnowledgeBundle({
       });
       return result(bundle, [], "cloud");
     } catch (error) {
+      if (error?.code === "incompatible_cli") throw error;
       if (error?.fallbackAllowed !== false && cached && Date.parse(cached.bundle.expires_at) > now) return result(cached.bundle, [`SQM Cloud unavailable; using last verified bundle: ${message(error)}`], "stale_cache");
       return result(null, [`SQM knowledge could not be used; shadow checks were skipped: ${message(error)}`], "unavailable");
     }
@@ -169,6 +182,18 @@ async function fetchBundle({ endpoint, repository, cliVersion, token, organizati
   }
   if (!response.ok) {
     const body = await response.text().catch(() => "");
+    const parsed = parseErrorBody(body);
+    if (response.status === 409 && parsed?.error?.code === "incompatible_cli") {
+      const modules = Array.isArray(parsed.error.modules) ? parsed.error.modules : [];
+      const minimumVersion = modules
+        .map((module) => String(module?.min_cli_version || ""))
+        .filter(Boolean)
+        .sort(compareSemverDescending)[0] || null;
+      throw new SqmIncompatibleCliError(
+        parsed.error.message || "The selected knowledge bundle requires a newer SIMY CLI.",
+        { currentVersion: parsed.error.cli_version || cliVersion, minimumVersion, modules },
+      );
+    }
     const error = new Error(`SQM Cloud returned HTTP ${response.status}${body ? `: ${body.slice(0, 300)}` : ""}.`);
     error.fallbackAllowed = response.status >= 500 && response.status <= 599;
     throw error;
@@ -186,6 +211,23 @@ async function fetchBundle({ endpoint, repository, cliVersion, token, organizati
   }
 }
 
+function parseErrorBody(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+
+function compareSemverDescending(left, right) {
+  const a = left.split(".").map(Number);
+  const b = right.split(".").map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    if ((a[index] || 0) !== (b[index] || 0)) return (b[index] || 0) - (a[index] || 0);
+  }
+  return 0;
+}
+
 async function readVerifiedCache(location, options, identity) {
   try {
     const [bundleRaw, metadataRaw] = await Promise.all([readFile(location.bundle, "utf8"), readFile(location.metadata, "utf8")]);

package/src/sqm/review-worker.js

@@ -0,0 +1,278 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { inspectDesktopExecutor } from "../desktop-executor.js";
+import {
+  webApiErrorMessage,
+  webApiHeaders,
+  webApiUrl,
+} from "../web-api.js";
+
+const DEFAULT_LEASE_SECONDS = 300;
+const DEFAULT_REQUEST_TIMEOUT_MS = 20_000;
+const DEFAULT_EXECUTION_TIMEOUT_MS = 240_000;
+
+export class SqmLocalReviewError extends Error {
+  constructor(message, { status = null, code = "sqm_local_review_error" } = {}) {
+    super(message);
+    this.name = "SqmLocalReviewError";
+    this.status = status;
+    this.code = code;
+  }
+}
+
+export function createSqmLocalReviewApi({
+  getConnection,
+  fetchImpl = globalThis.fetch,
+  requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+} = {}) {
+  if (typeof getConnection !== "function") throw new TypeError("getConnection is required");
+  if (typeof fetchImpl !== "function") throw new TypeError("fetchImpl is required");
+
+  return {
+    async request(body) {
+      const connection = getConnection();
+      if (!connection?.apiOrigin || !connection?.token) {
+        throw new SqmLocalReviewError("The SIMY CLI session is not connected.", {
+          code: "local_cli_session_unavailable",
+        });
+      }
+      let response;
+      try {
+        response = await fetchImpl(
+          webApiUrl("sqm/reviews", {
+            webOrigin: connection.apiOrigin,
+            apiBaseUrl: connection.apiBaseUrl,
+          }),
+          {
+            method: "POST",
+            headers: webApiHeaders(
+              { token: connection.token },
+              { "Content-Type": "application/json" },
+            ),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(requestTimeoutMs),
+          },
+        );
+      } catch (error) {
+        throw new SqmLocalReviewError(`SIMY Web could not be reached: ${errorMessage(error)}`, {
+          code: "sqm_local_review_gateway_unavailable",
+        });
+      }
+      const payload = await response.json().catch(() => null);
+      if (!response.ok) {
+        throw new SqmLocalReviewError(webApiErrorMessage(payload, response.status), {
+          status: response.status,
+          code: machineCode(payload?.code || payload?.detail?.code),
+        });
+      }
+      return payload;
+    },
+  };
+}
+
+export function createSqmLocalReviewWorker({
+  api,
+  workerId = "sqm-local-review",
+  leaseSeconds = DEFAULT_LEASE_SECONDS,
+  heartbeatIntervalMs = Math.max(10_000, Math.floor(leaseSeconds * 500)),
+  runReview = runStructuredCodexReview,
+  beginWork = () => () => {},
+  onError = () => {},
+} = {}) {
+  if (!api || typeof api.request !== "function") throw new TypeError("api.request is required");
+  let activeJobId = null;
+  let pollPromise = null;
+  let closed = false;
+
+  const leaseBody = (claim) => ({
+    worker_id: workerId,
+    lease_seconds: leaseSeconds,
+    job_id: claim.job_id,
+    lease_token: claim.lease_token,
+  });
+
+  const processClaim = async (claim) => {
+    activeJobId = claim.job_id;
+    let heartbeatTimer = null;
+    const heartbeat = () => {
+      void api.request({ action: "heartbeat", ...leaseBody(claim) }).catch(onError);
+    };
+    heartbeatTimer = setInterval(heartbeat, heartbeatIntervalMs);
+    heartbeatTimer.unref?.();
+    try {
+      const analysis = await runReview(claim.request);
+      const advanced = await api.request({
+        action: "advance",
+        ...leaseBody(claim),
+        analysis_output: analysis.output,
+        executor_model: analysis.model,
+      });
+      if (advanced.completed) return advanced;
+      const adjudication = await runReview(advanced.request);
+      return api.request({
+        action: "complete",
+        ...leaseBody(claim),
+        analysis_output: analysis.output,
+        adjudication_output: adjudication.output,
+        executor_model: adjudication.model || analysis.model,
+      });
+    } finally {
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
+      activeJobId = null;
+    }
+  };
+
+  return {
+    snapshot() {
+      return { active_job_id: activeJobId, closed };
+    },
+    poll() {
+      if (closed || pollPromise) return pollPromise || Promise.resolve(null);
+      const releaseWork = beginWork?.();
+      if (!releaseWork) return Promise.resolve(null);
+      pollPromise = (async () => {
+        const claim = await api.request({
+          action: "claim",
+          worker_id: workerId,
+          lease_seconds: leaseSeconds,
+        });
+        if (!claim?.claimed) return null;
+        return processClaim(claim);
+      })()
+        .catch((error) => {
+          onError(error);
+          return null;
+        })
+        .finally(() => {
+          pollPromise = null;
+          releaseWork();
+        });
+      return pollPromise;
+    },
+    async close() {
+      closed = true;
+      await pollPromise;
+    },
+  };
+}
+
+export async function runStructuredCodexReview(
+  request,
+  {
+    spawnImpl = spawn,
+    inspectExecutor = inspectDesktopExecutor,
+    executionTimeoutMs = DEFAULT_EXECUTION_TIMEOUT_MS,
+  } = {},
+) {
+  assertStructuredRequest(request);
+  const inspection = await inspectExecutor("codex");
+  if (!inspection?.compatible || !inspection.executable) {
+    throw new SqmLocalReviewError("A compatible local Codex executable is required.", {
+      code: "codex_local_unavailable",
+    });
+  }
+  const workDir = await mkdtemp(join(tmpdir(), "simy-sqm-review-"));
+  const schemaPath = join(workDir, "output-schema.json");
+  const outputPath = join(workDir, "output.json");
+  try {
+    await writeFile(schemaPath, JSON.stringify(request.output_schema), { mode: 0o600 });
+    const prompt = [
+      request.system,
+      "Return only JSON that strictly matches the provided output schema.",
+      request.prompt,
+    ].join("\n\n");
+    await spawnCodex(
+      inspection.executable,
+      [
+        "exec",
+        "--skip-git-repo-check",
+        "--sandbox",
+        "read-only",
+        "--ephemeral",
+        "--ignore-user-config",
+        "--ignore-rules",
+        "--output-schema",
+        schemaPath,
+        "--output-last-message",
+        outputPath,
+        "-",
+      ],
+      prompt,
+      { spawnImpl, executionTimeoutMs },
+    );
+    const output = JSON.parse(await readFile(outputPath, "utf8"));
+    if (!output || Array.isArray(output) || typeof output !== "object") {
+      throw new Error("Codex returned a non-object JSON value");
+    }
+    return {
+      output,
+      model: `codex-local/${inspection.installed_version || "unknown"}`,
+    };
+  } catch (error) {
+    if (error instanceof SqmLocalReviewError) throw error;
+    throw new SqmLocalReviewError(`Local Codex review failed: ${errorMessage(error)}`, {
+      code: "codex_local_review_failed",
+    });
+  } finally {
+    await rm(workDir, { recursive: true, force: true });
+  }
+}
+
+function spawnCodex(command, args, prompt, { spawnImpl, executionTimeoutMs }) {
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl(command, args, {
+      env: safeCodexEnvironment(process.env),
+      stdio: ["pipe", "ignore", "pipe"],
+    });
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      child.kill?.("SIGTERM");
+      finish(new Error(`Codex timed out after ${executionTimeoutMs}ms`));
+    }, executionTimeoutMs);
+    timer.unref?.();
+    const finish = (error = null) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      error ? reject(error) : resolve();
+    };
+    child.stderr?.setEncoding?.("utf8");
+    child.stderr?.on?.("data", (chunk) => {
+      stderr = `${stderr}${chunk}`.slice(-4000);
+    });
+    child.on("error", finish);
+    child.on("close", (code) => {
+      finish(code === 0 ? null : new Error(stderr.trim() || `Codex exited with code ${code}`));
+    });
+    child.stdin?.end(prompt);
+  });
+}
+
+function safeCodexEnvironment(environment) {
+  const allowed = [
+    "HOME", "PATH", "CODEX_HOME", "LANG", "LC_ALL", "LC_CTYPE", "TMPDIR",
+    "SSL_CERT_FILE", "SSL_CERT_DIR", "HTTPS_PROXY", "HTTP_PROXY", "ALL_PROXY", "NO_PROXY",
+  ];
+  return Object.fromEntries(allowed.filter((key) => environment[key]).map((key) => [key, environment[key]]));
+}
+
+function assertStructuredRequest(request) {
+  if (!request || typeof request !== "object") throw new TypeError("review request is required");
+  for (const key of ["system", "prompt", "output_schema"]) {
+    if (!request[key]) throw new TypeError(`review request ${key} is required`);
+  }
+}
+
+function machineCode(value) {
+  return /^[a-z][a-z0-9_]{0,127}$/.test(String(value || ""))
+    ? String(value)
+    : "sqm_local_review_error";
+}
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}