@awak-app/simy-cli 0.7.21 → 0.7.23

package/src/sqm/provider-plugin-repair.js

@@ -0,0 +1,105 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, readFile, realpath, rm } from 'node:fs/promises';
+import { resolveBackendExecutable } from '../backend-executable.js';
+import { inspectProviderPlugins } from './provider-plugin-status.js';
+import { runProviderCommand } from './provider-command.js';
+import { inspectSqmAgentSkill, installSqmAgentSkill } from './agent-skill.js';
+import { CLAUDE_MARKETPLACE, CLAUDE_PLUGIN_SELECTOR } from './claude-plugin.js';
+
+const fail = reason => Object.assign(new Error('SIMY plugin repair could not be verified.'), { code: 'plugin_repair_failed', reason });
+
+// Explicit user action only. Repair one provider, under the same lock as the
+// background workflow updater. Never change SIMY consent, login or hook trust.
+export async function repairProviderPlugin({ provider, home = homedir(),
+  codexHome = process.env.CODEX_HOME || join(home, '.codex'),
+  claudeHome = process.env.CLAUDE_CONFIG_DIR || join(home, '.claude'),
+  signal, authorize = async () => {}, onDiagnostic = () => {},
+  inspect = inspectProviderPlugins, inspectSources = inspectSqmAgentSkill,
+  prepare = installSqmAgentSkill, resolveExecutable = resolveBackendExecutable,
+  run = runProviderCommand,
+} = {}) {
+  if (!['codex', 'claude'].includes(provider)) throw fail('unsupported_provider');
+  const startedAt = Date.now();
+  const check = async () => {
+    if (signal?.aborted) throw fail('cancelled');
+    await authorize();
+    if (signal?.aborted) throw fail('cancelled');
+  };
+  const options = { home, codexHome, claudeHome, providers: [provider], details: true,
+    timeoutMs: 20_000, signal, onDiagnostic, resolveExecutable, run };
+  const inventory = async () => (await inspect(options))[provider];
+  const command = async args => {
+    await check();
+    const executable = await resolveExecutable(provider, { signal, timeoutMs: 5_000 });
+    if (!executable) throw fail('cli_missing');
+    return run(executable, args, { cwd: home, signal, timeout: 20_000, maxBuffer: 1024 * 1024,
+      env: { ...process.env, HOME: home, ...(provider === 'codex' ? { CODEX_HOME: codexHome } : { CLAUDE_CONFIG_DIR: claudeHome }) } });
+  };
+  let locked = false;
+  const lock = join(home, '.simy', 'integrations', 'workflow-update.lock');
+  try {
+    await check();
+    let current = await inventory();
+    if (current?.state === 'enabled') return { state: 'repaired', plugin: current };
+    if (!['missing', 'disabled'].includes(current?.state)) throw fail(current?.reason || 'verification_failed');
+    if (provider === 'claude' && current.scope && current.scope !== 'user') throw fail('scope_requires_attention');
+    await mkdir(join(home, '.simy', 'integrations'), { recursive: true });
+    try { await mkdir(lock); locked = true; }
+    catch (error) { if (error.code === 'EEXIST') throw fail('busy'); throw error; }
+    await check();
+    // Reinspect after obtaining the lock; another updater may have finished.
+    current = await inventory();
+    if (current?.state === 'enabled') return { state: 'repaired', plugin: current };
+    if (!['missing', 'disabled'].includes(current?.state)) throw fail(current?.reason || 'verification_failed');
+    if (provider === 'claude' && current.scope && current.scope !== 'user') throw fail('scope_requires_attention');
+    let sources = await inspectSources({ home });
+    if (provider === 'codex' && current.state === 'disabled') {
+      const payload = JSON.parse((await command(['plugin', 'list', '--json'])).stdout);
+      const entry = payload.installed?.find(item => item.pluginId === current.selector);
+      if (entry?.source?.source !== 'local' || !entry.source.path ||
+          await realpath(entry.source.path) !== await realpath(sources.codex_plugin.path)) throw fail('source_conflict');
+      const marketplace = JSON.parse(await readFile(sources.codex_plugin.marketplace_path, 'utf8'));
+      if (current.selector !== `simy@${marketplace.name}`) throw fail('source_conflict');
+    }
+    if (provider === 'claude') {
+      const marketplaces = JSON.parse((await command(['plugin', 'marketplace', 'list', '--json'])).stdout);
+      if (!Array.isArray(marketplaces)) throw fail('invalid_inventory');
+      const existing = marketplaces.find(item => item.name === CLAUDE_MARKETPLACE);
+      if (existing && (existing.source !== 'directory' || !existing.path ||
+          await realpath(existing.path) !== await realpath(sources.claude_plugin.marketplace_root))) throw fail('source_conflict');
+    }
+    await check();
+    sources = await prepare({ home, platforms: [provider], migrateLegacyGate: false });
+    if (provider === 'codex') {
+      const marketplace = JSON.parse(await readFile(sources.codex_plugin.marketplace_path, 'utf8'));
+      if (!/^[A-Za-z0-9_-]+$/.test(marketplace.name || '')) throw fail('source_conflict');
+      const selector = `simy@${marketplace.name}`;
+      if (current.selector && current.selector !== selector) throw fail('source_conflict');
+      await command(['plugin', 'add', selector, '--json']);
+    } else {
+      // The managed marketplace installer preserves unrelated provider settings.
+      const marketplaces = JSON.parse((await command(['plugin', 'marketplace', 'list', '--json'])).stdout);
+      if (!Array.isArray(marketplaces)) throw fail('invalid_inventory');
+      const existing = marketplaces.find(item => item.name === CLAUDE_MARKETPLACE);
+      if (existing && (existing.source !== 'directory' || !existing.path ||
+          await realpath(existing.path) !== await realpath(sources.claude_plugin.marketplace_root))) throw fail('source_conflict');
+      if (!existing) {
+        await command(['plugin', 'marketplace', 'add', sources.claude_plugin.marketplace_root]);
+      }
+      await command(['plugin', current.state === 'missing' ? 'install' : 'enable', CLAUDE_PLUGIN_SELECTOR, '--scope', 'user']);
+    }
+    await check();
+    const verified = await inventory();
+    if (verified?.state !== 'enabled') throw fail(verified?.reason || 'verification_failed');
+    return { state: 'repaired', plugin: verified };
+  } catch (error) {
+    const reason = error?.reason || (signal?.aborted ? 'cancelled' : error?.code === 'provider_timeout' ? 'timeout' :
+      error instanceof SyntaxError ? 'invalid_inventory' :
+      ['EACCES', 'EPERM', 'EROFS'].includes(error?.code) ? 'permission_denied' : 'command_failed');
+    onDiagnostic({ provider, reason, elapsedMs: Date.now() - startedAt });
+    throw fail(reason);
+  } finally {
+    if (locked) await rm(lock, { recursive: true, force: true });
+  }
+}

package/src/sqm/provider-plugin-status.js

@@ -14,13 +14,22 @@ export async function inspectProviderPlugins({ home = homedir(),
   codexHome = process.env.CODEX_HOME || join(home, '.codex'),
   claudeHome = process.env.CLAUDE_CONFIG_DIR || join(home, '.claude'),
   resolveExecutable = resolveBackendExecutable, run = runProviderCommand,
-  timeoutMs = 5_000, signal,
+  timeoutMs = 5_000, signal, providers = ['codex', 'claude'], details = false,
+  onDiagnostic = () => {},
 } = {}) {
+  if (providers.some(provider => !['codex', 'claude'].includes(provider))) throw new Error('Unsupported provider.');
   const inspect = async provider => {
+    const startedAt = Date.now();
+    const unavailable = reason => {
+      const elapsedMs = Date.now() - startedAt;
+      onDiagnostic({ provider, reason, elapsedMs });
+      return { ...unavailablePluginStatus(), ...(details ? { reason, elapsedMs } : {}) };
+    };
     try {
-      if (signal?.aborted) return unavailablePluginStatus();
+      if (signal?.aborted) return unavailable('cancelled');
       const executable = await resolveExecutable(provider, { signal, timeoutMs });
-      if (!executable || signal?.aborted) return unavailablePluginStatus();
+      if (signal?.aborted) return unavailable('cancelled');
+      if (!executable) return unavailable('cli_missing');
       const { stdout } = await run(executable, ['plugin', 'list', '--json'], {
         timeout: timeoutMs, maxBuffer: 1024 * 1024, signal, cwd: home,
         env: { ...process.env, HOME: home,
@@ -28,7 +37,7 @@ export async function inspectProviderPlugins({ home = homedir(),
       });
       const payload = JSON.parse(stdout);
       const entries = provider === 'codex' ? payload?.installed : payload;
-      if (!Array.isArray(entries)) return unavailablePluginStatus();
+      if (!Array.isArray(entries)) return unavailable('invalid_inventory');
       const matches = entries.filter(entry => provider === 'codex'
         ? typeof entry?.pluginId === 'string' && /^simy@[A-Za-z0-9_-]+$/.test(entry.pluginId)
         : entry?.id === CLAUDE_PLUGIN_SELECTOR);
@@ -42,11 +51,14 @@ export async function inspectProviderPlugins({ home = homedir(),
       const entry = matches[0];
       if (!entry || provider === 'codex' && entry.installed === false) return { state: 'missing', installed: false, enabled: false };
       if (typeof entry.enabled !== 'boolean' || provider === 'codex' && entry.installed !== true ||
-        provider === 'claude' && !scopes.includes(entry.scope)) return unavailablePluginStatus();
+        provider === 'claude' && !scopes.includes(entry.scope)) return unavailable('invalid_inventory');
       return { state: entry.enabled ? 'enabled' : 'disabled', installed: true, enabled: entry.enabled,
+        ...(details ? { selector: provider === 'codex' ? entry.pluginId : entry.id } : {}),
         ...(provider === 'claude' ? { scope: entry.scope, enablementContext: 'home' } : {}) };
-    } catch { return unavailablePluginStatus(); }
+    } catch (error) {
+      return unavailable(signal?.aborted ? 'cancelled' : error?.code === 'provider_timeout' ? 'timeout' :
+        error instanceof SyntaxError ? 'invalid_inventory' : 'command_failed');
+    }
   };
-  const [codex, claude] = await Promise.all([inspect('codex'), inspect('claude')]);
-  return { codex, claude };
+  return Object.fromEntries(await Promise.all(providers.map(async provider => [provider, await inspect(provider)])));
 }

package/src/sqm/review-worker.js

@@ -115,11 +115,12 @@ export function createSqmLocalReviewWorker({
   getHistoryScope = () => null,
   getWorkspaceUrl = () => null,
   recordHistory = async () => {},
+  readHistory = async () => [],
   onHistoryError = () => {},
   now = () => Date.now(),
   providerFailureCooldownMs = 5 * 60_000,
   getRecoveryKey = () => null,
-  failureCircuit = createSqmFailureCircuit(),
+  failureCircuit = createSqmFailureCircuit({ now }),
 } = {}) {
   if (!api || typeof api.request !== "function") throw new TypeError("api.request is required");
   let activeJobId = null;
@@ -158,6 +159,7 @@ export function createSqmLocalReviewWorker({
       item.state = state; item.finishedAt = new Date().toISOString();
       item.result = state === "completed" ? "SQM review submitted." : "";
       item.error = state === "failed" ? formatFailure(failure, failureReported) : "";
+      if (state === 'completed') for (const field of ['errorCode', 'errorStage', 'httpStatus', 'providerDiagnostic']) delete item[field];
       if (failure) { item.phase = failure.stage; item.errorStage = failure.stage; item.errorCode = failure.code; item.httpStatus = failure.status; item.providerDiagnostic = failure.providerDiagnostic; }
       await persist(scope, item);
     }
@@ -273,20 +275,22 @@ export function createSqmLocalReviewWorker({
     snapshot() {
       const pause = currentPause();
       const circuit = failureCircuit.snapshot(getHistoryScope());
+      const requiresInteraction = pause && !pause.recoverable && pause.recoveryKey === getRecoveryKey(getProvider());
+      const waitingForRecovery = circuit.recovery_pending && !requiresInteraction && !activeJobId;
       return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, suspended,
-        paused: pausedEnvironment !== null || circuit.paused_until_update || circuit.storage_unavailable,
-        pause_reason: circuit.provider_retry_exhausted ? "provider_retry_failed_until_update" : circuit.paused_until_update ? "consecutive_failures_until_update" : circuit.storage_unavailable ? "failure_state_unavailable" : pauseReason,
+        paused: !activeJobId && (pausedEnvironment !== null || circuit.recovery_pending || circuit.storage_unavailable),
+        pause_reason: activeJobId ? null : requiresInteraction ? pause.code : waitingForRecovery ? "automatic_recovery_pending" : circuit.storage_unavailable ? "failure_state_unavailable" : pauseReason,
         ...circuit, issue: issueContext === contextKey(getProvider(), getHistoryScope()) ? issue : null,
-        ...(pause ? { provider_pause: { code: pause.code, status: pause.status,
-          retry_at: circuit.provider_retry_exhausted ? null : new Date(pause.retryAt).toISOString(),
-          message: circuit.provider_retry_exhausted ? "The provider retry failed. New SQM reviews are paused until SIMY is updated." : pause.message } } : {}) };
+        ...(pause && !activeJobId ? { provider_pause: { code: pause.code, status: pause.status,
+          retry_at: new Date(Math.max(pause.retryAt, circuit.next_retry_at || 0)).toISOString(),
+          message: waitingForRecovery ? "SIMY will automatically retry after the recovery cooldown. No update or manual confirmation is required." : pause.message } } : {}) };
     },
     desktopTasks() { return { activeCount: activeJobId ? 1 : 0, items: visibleHistory().map(item => ({ ...item, canStop: item.id === activeJobId })) }; },
     desktopTaskDetail(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.error || "", links: item.webUrl ? [{ label: "Analysis details", url: item.webUrl }] : [] } : null;
     },
-    retry() { if (closed || suspended || pollPromise || failureCircuit.snapshot(getHistoryScope()).paused_until_update) return false; pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null; onChange(); return true; },
+    retry() { if (closed || suspended || pollPromise || failureCircuit.snapshot(getHistoryScope()).recovery_pending) return false; pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null; onChange(); return true; },
     resetHistory() { if (!pollPromise) { history.splice(0); issue = null; pausedEnvironment = null; pauseReason = null; } },
     poll() {
       if (closed || suspended || pollPromise) return pollPromise || Promise.resolve(null);
@@ -295,7 +299,8 @@ export function createSqmLocalReviewWorker({
         const pause = currentPause();
         // Known provider failures already have a bounded cooldown. Do not let
         // the environment gate suppress their recovery probe indefinitely.
-        if (!pause?.recoverable || (pause.recoveryKey === getRecoveryKey(getProvider()) && now() < pause.retryAt)) return Promise.resolve(null);
+        if (pause?.recoveryKey === getRecoveryKey(getProvider()) &&
+            (!pause.recoverable || now() < pause.retryAt)) return Promise.resolve(null);
         pausedEnvironment = null; pauseReason = null;
       } else if (pausedEnvironment !== null) {
         pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null;
@@ -323,6 +328,23 @@ export function createSqmLocalReviewWorker({
           lease_seconds: leaseSeconds,
         }, { signal: reviewController.signal });
         if (issue) { issue = null; onChange(); }
+        if (claim?.recovered === true && claim.completed === true && typeof claim.job_id === 'string') {
+          // The server completed this exact saved result without re-running a
+          // provider. Reflect the original job's completion locally as well.
+          if (!history.some(item => item.id === claim.job_id)) {
+            let saved;
+            try { saved = (await readHistory(historyScope)).find(item => item.key === `sqm:${claim.job_id}`); }
+            catch { onHistoryError(); }
+            const item = { ...saved, id: claim.job_id, key: `sqm:${claim.job_id}`, kind: 'analysis',
+              label: saved?.label || `SQM · ${claim.job_id.slice(0, 8)}`, provider: saved?.provider || provider,
+              startedAt: saved?.startedAt || new Date().toISOString(), webUrl: saved?.webUrl || analysisTaskUrl(workspaceUrl, claim.job_id) };
+            history.unshift(item); historyScopes.set(item, JSON.stringify(historyScope)); history.splice(50);
+          }
+          await updateTask(claim.job_id, 'completed', historyScope);
+          await failureCircuit.success(historyScope);
+          pauses.delete(key);
+          return claim;
+        }
         if (!claim?.claimed) {
           // A successful empty claim proves SIMY access recovered, but it says
           // nothing about a local provider that has not executed again yet.

package/src/update-detachment/history-recovery.js

@@ -0,0 +1,51 @@
+import {readFile,writeFile,mkdir,realpath} from 'node:fs/promises';
+import {join,resolve} from 'node:path';
+import {createHash,randomUUID} from 'node:crypto';
+import {digest} from './state-store.js';
+import {readDispatchGate,reconcileDispatchHistory} from './dispatch-gate.js';
+import {createUpdateRuntime} from './runtime.js';
+import {createUpdateCoordinator} from './coordinator.js';
+import {readSession,isSessionValid} from '../session-store.js';
+import {webApiUrl,webApiHeaders} from '../web-api.js';
+import {acquireDesktopProcessLock} from '../desktop-process-lock.js';
+import {listRecords} from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+export async function planDispatchHistoryRecovery({root}) {
+ root=await realpath(root);const state=readDispatchGate(root),items=[];
+ for(const attempt of Object.values(state.attempts)) {
+  const item={attemptId:attempt.id,attemptDigest:digest(attempt),disposition:attempt.phase==='confirmed'?'already_confirmed':'retain_blocked_unknown'};
+  const ref=attempt.provenance?.recordRef;
+  if(attempt.phase==='result_saved' && ref?.startsWith(resolve(root,'direct-tasks')+'/')) {
+   try {
+    const bytes=await readFile(ref),result=JSON.parse(bytes),match=/^(.*):provider:([1-9][0-9]*)$/.exec(attempt.id);
+    if(await realpath(ref)===ref && match && result.id===match[1] && result.id===attempt.provenance.taskId && digest(result.id)===attempt.taskHash &&
+      result.invocation_count===Number(match[2]) && ['succeeded','failed','stopped'].includes(result.status) && Object.values(state.receipts).some(r=>r.attemptId===attempt.id && r.generation===attempt.generation && r.resultRef===ref)) {
+     item.disposition='saved_terminal_result';item.evidence={ref,sha256:sha(bytes),status:result.status};
+    }
+   } catch { /* Unknown effects remain blocked, including removed test output. */ }
+  }
+  items.push(item);
+ }
+ const audit={version:1,gateDigest:digest(state),expectedRevision:state.revision,expectedGeneration:state.generation,items};
+ const directory=join(root,'update-detachment','recovery');await mkdir(directory,{recursive:true,mode:0o700});
+ const auditRef=join(directory,randomUUID()+'.json'),bytes=JSON.stringify(audit,null,2)+'\n';await writeFile(auditRef,bytes,{flag:'wx',mode:0o600});
+ return {auditRef,auditDigest:sha(bytes),revision:state.revision,generation:state.generation,results:items.filter(i=>i.disposition==='saved_terminal_result').length,blocked:items.filter(i=>i.disposition==='retain_blocked_unknown').length,replayAttempts:false};
+}
+export async function applyDispatchHistoryRecovery({root,auditRef,auditDigest}) {
+ root=await realpath(root);const lock=await acquireDesktopProcessLock(root);
+ try {const audit=JSON.parse(await readFile(auditRef,'utf8'));return reconcileDispatchHistory({root,auditRef,auditDigest,expectedRevision:audit.expectedRevision,expectedGeneration:audit.expectedGeneration});}
+ finally {await lock.release();}
+}
+export async function reconnectRecoveredHistory({root,origin='https://app.simy.one'}) {
+ root=await realpath(root);const lock=await acquireDesktopProcessLock(root);
+ try {
+  const session=await readSession(origin,root);if(!isSessionValid(session,Date.now(),origin))throw Error('Existing device sign-in required.');
+  const response=await fetch(webApiUrl('desktop-access',{webOrigin:origin,apiBaseUrl:session.api_base_url}),{headers:webApiHeaders(session),signal:AbortSignal.timeout(10000)});
+  const access=await response.json();if(!response.ok || access.state!=='ready' || access.organizationId!==session.organization_id)throw Error('Current server entitlement required.');
+  const runtime=createUpdateRuntime({root,origin,readContext:()=>({actor:{account:session.account_id,device:session.device_id,origin},runs:[],directTasks:[],localTasks:[]}),listRecords:()=>listRecords(join(root,'delivery-hooks'))});
+  // Reconciliation reads exact results or retained fences. It never resumes a task.
+  const coordinator=createUpdateCoordinator({store:runtime.store,gate:runtime.gate,boundary:runtime.boundary,reconcile:runtime.reconcile,initialState:'recovery_required'});
+  if(digest(await readSession(origin,root))!==digest(session))throw Error('Device connection changed.');
+  return await coordinator.reconnect();
+ } finally {await lock.release();}
+}

package/src/update-detachment/runtime.js

@@ -6,7 +6,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { readFile, lstat, readlink, realpath } from 'node:fs/promises';
 import { atomicSave, readState, digest, withLock } from './state-store.js';
-import { readDispatchGate, adoptHookOwner, DISPATCH_PROTOCOL, confirmDispatch, flushDispatchIntake, readTaskAdmission } from './dispatch-gate.js';
+import { readDispatchGate, unresolvedDispatchAttempts, adoptHookOwner, DISPATCH_PROTOCOL, confirmDispatch, flushDispatchIntake, readTaskAdmission } from './dispatch-gate.js';
 import { createLedgerCoordinatorAdapters } from './ledger-adapter.js';
 import { listDispatchRegistrations, normalizeDispatchIdentity } from './provenance.js';
 import { reconcileSession } from './reconcile.js';
@@ -182,7 +182,7 @@ export function createUpdateRuntime({ root, origin, readContext, listRecords, ob
       confirmDispatch({root,attemptId:attempt.id});
     }
     ledger=readDispatchGate(root);
-    const unresolved=Object.values(ledger.attempts).filter(attempt=>attempt.phase!=='confirmed' && !workers.some(task=>task.handle.attemptId===attempt.id && attempt.taskHash===digest(task.taskId) && attempt.identityHash===digest(task.identity) && attempt.generation===task.generation));
+    const unresolved=unresolvedDispatchAttempts(ledger).filter(attempt=> !workers.some(task=>task.handle.attemptId===attempt.id && attempt.taskHash===digest(task.taskId) && attempt.identityHash===digest(task.identity) && attempt.generation===task.generation));
     if(unresolved.length)return {safe:false,liveExecutions:0,pendingWrites:0,unsettledPermissions:0};
     const currentGate=readDispatchGate(root);
     if(currentGate.connection!=='detaching' || currentGate.generation!==startingGate.generation)throw failure('boundary_owner_changed');
@@ -194,7 +194,7 @@ export function createUpdateRuntime({ root, origin, readContext, listRecords, ob
   const reconcile=async()=> {
     const actor=context().actor, assessments=[];
     const workers=(transaction?.tasks || []).filter(task=>task.handle);
-    if(Object.values(readDispatchGate(root).attempts).some(attempt=>attempt.phase!=='confirmed' && !workers.some(task=>task.handle.attemptId===attempt.id)))return {verified:false,unresolvedAttempts:1};
+    if(unresolvedDispatchAttempts(readDispatchGate(root)).some(attempt=> !workers.some(task=>task.handle.attemptId===attempt.id)))return {verified:false,unresolvedAttempts:1};
     for (const task of transaction?.tasks || []) {
       if(task.handle) {
         if(actor?.account!==task.identity.account || actor?.origin!==task.identity.origin || actor?.device!==task.identity.device || task.identity.root!==root)return {verified:false,unresolvedAttempts:1};