@awak-app/simy-cli 0.5.60 → 0.5.62

package/src/sqm/history-store.js

@@ -0,0 +1,108 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { formatSqmCoverage } from "./report.js";
+import { defaultSessionRoot } from "../session-store.js";
+
+const LIMIT = 100;
+const hash = value => createHash("sha256").update(value).digest("hex");
+
+export function sqmHistoryScope(webOrigin, session) {
+  if (!session?.account_id || !session?.organization_id) return null;
+  return { webOrigin: new URL(webOrigin).origin, accountId: session.account_id, organizationId: session.organization_id };
+}
+
+// One atomic file per run prevents the daemon and independent CLI commands from
+// overwriting each other's history. Only display metadata is persisted.
+export function createSqmHistoryStore({ root = defaultSessionRoot(), now = () => Date.now() } = {}) {
+  const cache = new Map();
+  const directory = scope => scope?.webOrigin && scope?.accountId && scope?.organizationId
+    ? join(root, "sqm-history", hash(JSON.stringify([new URL(scope.webOrigin).origin, scope.accountId, scope.organizationId]))) : null;
+  async function list(scope) {
+    const dir = directory(scope);
+    if (!dir) return [];
+    const cached = cache.get(dir);
+    if (cached && now() - cached.at < 3000) return cached.items;
+    let names;
+    try { names = await readdir(dir); } catch (error) { if (error.code === "ENOENT") return []; throw error; }
+    const items = (await Promise.all(names.filter(name => /^[a-f0-9]{64}\.json$/.test(name)).map(async name => {
+      try {
+        const text = await readFile(join(dir, name), "utf8");
+        if (text.length > 16_384) return null;
+        return metadata(JSON.parse(text));
+      } catch { return null; }
+    }))).filter(Boolean).sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    cache.set(dir, { at: now(), items });
+    return items;
+  }
+  return {
+    async record(scope, entry) {
+      const dir = directory(scope), item = metadata(entry);
+      if (!dir || !item) return false;
+      await mkdir(dir, { recursive: true, mode: 0o700 });
+      const target = join(dir, `${hash(item.key)}.json`), temp = `${target}.${randomUUID()}.tmp`;
+      try {
+        await writeFile(temp, JSON.stringify(item), { mode: 0o600 });
+        await rename(temp, target);
+      } finally { await rm(temp, { force: true }); cache.delete(dir); }
+      const items = await list(scope);
+      for (const kind of ["analysis", "check"]) {
+        await Promise.all(items.filter(row => row.kind === kind).slice(LIMIT).map(row => rm(join(dir, `${hash(row.key)}.json`), { force: true })));
+      }
+      cache.delete(dir);
+      return true;
+    },
+    async items(scope) {
+      // A saved running row is not evidence that this process owns its lease.
+      return (await list(scope)).map(item => ({ ...item, state: item.state === "running" ? "interrupted" : item.state }));
+    },
+    async detail(scope, key) {
+      const item = (await this.items(scope)).find(item => item.key === key);
+      if (!item) return null;
+      return { key, instruction: item.instruction || `SQM local review · ${item.provider || "local"}`,
+        result: item.result || "", error: item.state === "interrupted" ? "This client stopped before the local run finished. Check the web workspace for its current retry status." : item.error || "", links: [] };
+    },
+  };
+}
+
+function metadata(entry) {
+  if (!entry || !["analysis", "check"].includes(entry.kind) || typeof entry.key !== "string" || !entry.key.startsWith(entry.kind === "analysis" ? "sqm:" : "sqm-check:")) return null;
+  if (!["running", "completed", "failed", "unavailable", "interrupted", "verification_pending"].includes(entry.state) || !Number.isFinite(Date.parse(entry.startedAt))) return null;
+  const item = {};
+  for (const name of ["key", "id", "kind", "label", "state", "provider", "phase", "repository", "startedAt", "finishedAt", "instruction", "result", "error"]) {
+    if (typeof entry[name] === "string") item[name] = entry[name].slice(0, ["instruction", "result", "error"].includes(name) ? 4096 : 512);
+  }
+  return item;
+}
+
+export function projectSqmHistory(items, live = { activeCount: 0, items: [] }) {
+  const analyses = new Map(items.filter(item => item.kind === "analysis").map(item => [item.key, item]));
+  for (const item of live.items || []) analyses.set(item.key, { ...analyses.get(item.key), ...item });
+  const rows = items => items.sort((a, b) => (b.startedAt || "").localeCompare(a.startedAt || "")).slice(0, LIMIT)
+    .map(({ instruction, result, error, ...item }) => item);
+  return { sqmTasks: { activeCount: live.activeCount || 0, items: rows([...analyses.values()]) },
+    sqmChecks: { activeCount: 0, items: rows(items.filter(item => item.kind === "check")) } };
+}
+
+export function createSqmCheckRecorder({ root, scope, phase, cwd, baseBranch, onError = () => console.warn("Could not save the local SQM check history.") }) {
+  if (!scope?.webOrigin || !scope?.accountId || !scope?.organizationId) return async () => {};
+  const history = createSqmHistoryStore({ root });
+  const key = `sqm-check:${randomUUID()}`;
+  const startedAt = new Date().toISOString();
+  return async result => {
+    const proof = result.proof, identity = proof?.repository_identity || result.repository_identity || result.min_check?.repository_identity;
+    const repository = identity?.repository || result.repository;
+    const outcome = proof?.outcome.status || result.min_check?.status || result.status;
+    const state = outcome === "unavailable" ? "unavailable" : ["failed", "preliminary_failed"].includes(outcome) ? "failed" : ["requires_human", "requires_post_deploy"].includes(outcome) ? "verification_pending" : "completed";
+    const summary = proof ? [`Full check: ${proof.outcome.status}`, formatSqmCoverage(proof), `Evidence upload: ${result.upload?.uploaded ? "uploaded" : "kept locally"}`].join("\n")
+      : state === "unavailable" ? "SQM could not obtain a verified result. Retry the command to see current diagnostics."
+      : state === "failed" && !identity ? "The command did not finish. Retry it to see current diagnostics."
+      : `Min-check: ${result.min_check?.status || result.status} · ${(result.preliminary_findings || result.min_check?.preliminary_findings)?.length || 0} preliminary finding(s) · ${(result.matched_modules || result.min_check?.matched_modules)?.length || 0} matched module(s).\nThis is a preflight; run the full check for signed verification.`;
+    try {
+      await history.record(scope, { key, id: key, kind: "check", phase, state, startedAt, finishedAt: new Date().toISOString(), repository,
+        label: `${phase === "min" ? "Min-check" : "Check"} · ${repository || basename(cwd)}`,
+        instruction: [repository || basename(cwd), `Base: ${identity?.base_ref || baseBranch}`, identity?.head_commit ? `Head: ${identity.head_commit}` : ""].filter(Boolean).join("\n"),
+        result: summary });
+    } catch { onError(); }
+  };
+}

package/src/sqm/index.js

@@ -1,3 +1,4 @@
+import { createSqmCheckRecorder } from "./history-store.js";
 import { evaluateKnowledgeBundle } from "./checkers.js";
 import { loadKnowledgeBundle } from "./bundle-store.js";
 import { uploadRunEvidence } from "./evidence-client.js";
@@ -15,6 +16,8 @@ export function createSqmChecker({
   accountId,
   organizationId,
   deviceId,
+  webOrigin,
+  historyRoot,
   evidenceEndpoint,
   uploadRunEvidenceImpl = uploadRunEvidence,
   inspectRepositoryImpl = inspectRepository,
@@ -27,7 +30,7 @@ export function createSqmChecker({
   let pinnedRepository = null;
   let latestMinCheck = null;
 
-  return async function checkCurrentRepository(_attempt = null, { phase = "min" } = {}) {
+  const checkCurrentRepository = async function(_attempt = null, { phase = "min" } = {}) {
     let repository;
     try {
       repository = await inspectRepositoryImpl(cwd, { baseBranch, runCommand: dependencies.runCommand });
@@ -64,6 +67,13 @@ export function createSqmChecker({
       return { ...unavailable(`SQM ${phase} execution failed: ${message(error)}`, repository.repository), bundle: bundleIdentity(loaded.bundle), warnings: [...loaded.warnings, `SQM ${phase} execution failed: ${message(error)}`] };
     }
   };
+  return async (attempt, options = {}) => {
+    const save = createSqmCheckRecorder({ root: historyRoot, scope: historyRoot ? { webOrigin, accountId, organizationId } : null, phase: options.phase || "min", cwd, baseBranch });
+    try {
+      const result = await checkCurrentRepository(attempt, options);
+      await save(result); return result;
+    } catch (error) { await save({ status: "failed" }); throw error; }
+  };
 }
 
 export async function runSqmMinCheck(options) {

package/src/sqm/review-worker.js

@@ -86,6 +86,9 @@ export function createSqmLocalReviewWorker({
   beginWork = () => () => {},
   onError = () => {},
   onChange = () => {},
+  getHistoryScope = () => null,
+  recordHistory = async () => {},
+  onHistoryError = () => {},
 } = {}) {
   if (!api || typeof api.request !== "function") throw new TypeError("api.request is required");
   let activeJobId = null;
@@ -93,9 +96,19 @@ export function createSqmLocalReviewWorker({
   let closed = false;
   let issue = null;
   const history = [];
-  const updateTask = (id, state) => {
+  const historyScopes = new WeakMap();
+  const visibleHistory = () => history.filter(item => historyScopes.get(item) === JSON.stringify(getHistoryScope()));
+  const persist = async (scope, item) => {
+    try { await recordHistory(scope, item); } catch { onHistoryError(); /* History failure must not fail a leased review. */ }
+  };
+  const updateTask = async (id, state, scope) => {
     const item = history.find(item => item.id === id);
-    if (item) item.state = state;
+    if (item) {
+      item.state = state; item.finishedAt = new Date().toISOString();
+      item.result = state === "completed" ? "SQM review submitted." : "";
+      item.error = state === "failed" ? "Local review failed. Check the SQM workspace for retry status." : "";
+      await persist(scope, item);
+    }
     onChange();
   };
 
@@ -108,10 +121,15 @@ export function createSqmLocalReviewWorker({
   });
 
   const processClaim = async (claim, provider) => {
+    const historyScope = getHistoryScope();
     activeJobId = claim.job_id;
+    const priorIndex = history.findIndex(item => item.id === claim.job_id);
+    if (priorIndex >= 0) history.splice(priorIndex, 1);
     history.unshift({ id: claim.job_id, key: `sqm:${claim.job_id}`, label: `SQM · ${String(claim.job_id).slice(0, 8)}`,
-      state: "running", provider, startedAt: new Date().toISOString() });
+      kind: "analysis", state: "running", provider, startedAt: new Date().toISOString() });
+    historyScopes.set(history[0], JSON.stringify(historyScope));
     history.splice(50);
+    await persist(historyScope, history[0]);
     onChange();
     let heartbeatTimer = null;
     const heartbeat = () => {
@@ -127,7 +145,7 @@ export function createSqmLocalReviewWorker({
         analysis_output: analysis.output,
         executor_model: analysis.model,
       });
-      if (advanced.completed) { updateTask(claim.job_id, "completed"); return advanced; }
+      if (advanced.completed) { await updateTask(claim.job_id, "completed", historyScope); return advanced; }
       const adjudication = await runReview(advanced.request, provider);
       const completed = await api.request({
         action: "complete",
@@ -136,10 +154,10 @@ export function createSqmLocalReviewWorker({
         adjudication_output: adjudication.output,
         executor_model: adjudication.model || analysis.model,
       });
-      updateTask(claim.job_id, "completed");
+      await updateTask(claim.job_id, "completed", historyScope);
       return completed;
     } catch (error) {
-      updateTask(claim.job_id, "failed");
+      await updateTask(claim.job_id, "failed", historyScope);
       throw error;
     } finally {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
@@ -152,9 +170,9 @@ export function createSqmLocalReviewWorker({
     snapshot() {
       return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, issue };
     },
-    desktopTasks() { return { activeCount: activeJobId ? 1 : 0, items: history.map(item => ({ ...item })) }; },
+    desktopTasks() { return { activeCount: activeJobId ? 1 : 0, items: visibleHistory().map(item => ({ ...item })) }; },
     desktopTaskDetail(key) {
-      const item = history.find(item => item.key === key);
+      const item = visibleHistory().find(item => item.key === key);
       return item ? { key, instruction: `SQM local review · ${item.provider}`, result: item.state === "completed" ? "SQM review submitted." : "", error: item.state === "failed" ? "Local review failed. Check the SQM workspace for retry status." : "", links: [] } : null;
     },
     resetHistory() { if (!pollPromise) { history.splice(0); issue = null; } },