@awak-app/simy-cli 0.7.16 → 0.7.18

package/src/sqm/workflow-update.js

@@ -7,6 +7,7 @@ import { pinnedWorkflowSource } from "../delivery-hooks/local-runtime.js";
 
 import { runProviderCommand } from "./provider-command.js";
 import { refreshClaudePlugin } from "./claude-plugin-update.js";
+import { pluginCacheMatches } from "./plugin-cache.js";
 
 import { resolveBackendExecutable } from "../backend-executable.js";
 import { inspectSqmAgentSkill, installSqmAgentSkill, retireLegacySqmGate } from "./agent-skill.js";
@@ -14,13 +15,18 @@ import { inspectSqmAgentSkill, installSqmAgentSkill, retireLegacySqmGate } from
 
 const CHECK_INTERVAL_MS = 60 * 60 * 1000;
 
-export function startWorkflowUpdates({ enabled, sync = syncInstalledWorkflows, intervalMs = CHECK_INTERVAL_MS,
+export function startWorkflowUpdates({ enabled, installMissing = true, sync = syncInstalledWorkflows, intervalMs = CHECK_INTERVAL_MS,
   errorLogger = console.error } = {}) {
   let pending;
   let stopped = !enabled;
   const check = () => {
     if (stopped || pending) return;
-    pending = Promise.resolve().then(sync).catch((error) => {
+    pending = Promise.resolve().then(() => sync({ installMissing })).then((result) => {
+      if (result?.refreshPending) {
+        const details = result.refreshFailures?.map(({ provider, message }) => `${provider}: ${message}`).join('; ');
+        errorLogger(`SIMY workflow sources are prepared, but plugin cache refresh is pending; will retry later.${details ? ` ${details}` : ''}`);
+      }
+    }).catch((error) => {
       errorLogger(`SIMY workflow update failed; will retry later: ${error.message}`);
     }).finally(() => { pending = null; });
   };
@@ -79,16 +85,20 @@ export async function syncInstalledWorkflows({ home = homedir(), installMissing
     if (platforms.length) status = await install({ home, platforms });
     const results = {};
     const failures = [];
+    const refreshFailures = [];
     for (const [provider, refresh] of [
       ["codex", () => refreshCodexPlugin({ status, home, codexHome, resolveExecutable, run })],
       ["claude", () => refreshClaudePlugin({ status, home, claudeHome, resolveExecutable, run })],
     ]) {
       try { results[provider] = await refresh(); }
-      catch (error) { failures.push(error); }
+      catch (error) {
+        failures.push(error);
+        refreshFailures.push({ provider, message: error.message });
+      }
     }
     // Explicit desktop setup prepares both sources even when a provider CLI is
     // absent. Cache refresh remains retryable; no provider is enabled here.
-    if (failures.length && installMissing) return { outcome: "prepared", refreshPending: true };
+    if (failures.length && installMissing) return { outcome: "prepared", refreshPending: true, refreshFailures, providers: results };
     if (failures.length) throw new AggregateError(failures, failures.map((error) => error.message).join("; "));
     if (results.claude.outcome === "updated") return { ...results.claude, providers: results };
     if (results.codex.outcome !== "not_enabled") return results.codex;
@@ -123,8 +133,9 @@ async function refreshCodexPlugin({ status, home, codexHome, resolveExecutable,
     const cacheManifest = path.join(codexHome, "plugins", "cache", marketplace.name,
       "simy", status.codex_plugin.version, ".codex-plugin", "plugin.json");
     const cacheCurrent = async () => {
-      try { return JSON.parse(await readFile(cacheManifest, "utf8")).version === status.codex_plugin.version; }
-      catch (error) { if (error.code === "ENOENT" || error instanceof SyntaxError) return false; throw error; }
+      try { return JSON.parse(await readFile(cacheManifest, "utf8")).version === status.codex_plugin.version &&
+        await pluginCacheMatches(status.codex_plugin.path, path.dirname(path.dirname(cacheManifest))); }
+      catch (error) { if (['ENOENT', 'ENOTDIR'].includes(error.code) || error instanceof SyntaxError) return false; throw error; }
     };
     if (installed.version === status.codex_plugin.version && await cacheCurrent()) return { outcome: "current" };
     await run(executable, ["plugin", "add", selector, "--json"], options);

package/src/team-status-fence-store.js

@@ -0,0 +1,32 @@
+import { mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+// Only an opaque device/account/org/thread digest and a pending OFF version
+// persist. Conversation text and provider identifiers never enter this store.
+export function createTeamStatusFenceStore(root) {
+  const directory = join(root, 'team-status-revocations');
+  const path = key => {
+    if (!/^[a-f0-9]{64}$/.test(key)) throw new Error('Invalid revocation scope');
+    return join(directory, `${key}.json`);
+  };
+  return {
+    async read(key) {
+      let raw;
+      try { raw = await readFile(path(key), 'utf8'); } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+      const value = JSON.parse(raw);
+      if (value?.schemaVersion !== 1 || !Number.isSafeInteger(value.expectedVersion) || value.expectedVersion < 0) throw new Error('Invalid revocation fence');
+      return { expectedVersion: value.expectedVersion };
+    },
+    async write(key, expectedVersion) {
+      await mkdir(directory, { recursive: true, mode: 0o700 });
+      const destination = path(key), temporary = `${destination}.${randomUUID()}.tmp`;
+      try {
+        const handle = await open(temporary, 'wx', 0o600);
+        try { await handle.writeFile(JSON.stringify({schemaVersion:1,expectedVersion})); await handle.sync(); } finally { await handle.close(); }
+        await rename(temporary, destination);
+        if (process.platform !== 'win32') { const parent = await open(directory, 'r'); try { await parent.sync(); } finally { await parent.close(); } }
+      } finally { await rm(temporary, {force:true}); }
+    },
+    async clear(key) { await rm(path(key), {force:true}); },
+  };
+}

package/src/team-threads.js

@@ -0,0 +1,478 @@
+function profileAvatar(value) {
+  if (typeof value !== "string" || value.length > 2048) return {};
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || !url.hostname || url.username || url.password) return {};
+    return { avatarUrl: url.toString() };
+  } catch { return {}; }
+}
+import { createHash } from "node:crypto";
+import { sanitizedText } from "./session-supervision/conversation-context.js";
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const keyPattern = /^[a-f0-9]{64}$/;
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const empty = () => ({
+  state: "loading",
+  members: [],
+  threads: [],
+  own: [],
+  detail: null,
+  pendingStops: [],
+  memberId: null,
+  threadsTruncated: false,
+});
+const invalid = () => {
+  throw new Error("Shared conversations unavailable");
+};
+export const teamThreadKey = (scope, candidate) =>
+  digest(
+    JSON.stringify([scope.fenceKey, candidate.provider, candidate.session]),
+  );
+function projectSummary(row) {
+  if (
+    !uuid.test(row?.memberId) ||
+    !keyPattern.test(row?.threadKey) ||
+    (row.parentThreadKey != null && (!keyPattern.test(row.parentThreadKey) || row.parentThreadKey === row.threadKey)) ||
+    typeof row.title !== "string" ||
+    !row.title.trim() ||
+    row.title.length > 240 ||
+    !["running", "needs_attention", "unknown"].includes(row.state) ||
+    !Number.isFinite(Date.parse(row.observedAt))
+  )
+    invalid();
+  return {
+    memberId: row.memberId,
+    threadKey: row.threadKey,
+    parentThreadKey: row.parentThreadKey ?? null,
+    title: sanitizedText(row.title),
+    state: row.state,
+    observedAt: row.observedAt,
+  };
+}
+export function projectThreadContext(result, org) {
+  if (
+    result?.schemaVersion !== 1 ||
+    result.organizationId !== org ||
+    !Array.isArray(result.members) ||
+    result.members.length > 2000 ||
+    !Array.isArray(result.threads) ||
+    result.threads.length > 200 ||
+    !Array.isArray(result.own) ||
+    result.own.length > 200
+  )
+    invalid();
+  const members = result.members.map((row) => {
+    if (
+      !uuid.test(row?.id) ||
+      typeof row.label !== "string" ||
+      !row.label.trim() ||
+      row.label.length > 240
+    )
+      invalid();
+    return { id: row.id, label: sanitizedText(row.label), ...profileAvatar(row.avatarUrl) };
+  });
+  const own = result.own.map((row) => {
+    if (
+      !keyPattern.test(row?.threadKey) ||
+      !Number.isSafeInteger(row.version) ||
+      row.version < 0 ||
+      typeof row.enabled !== "boolean"
+    )
+      invalid();
+    return {
+      threadKey: row.threadKey,
+      version: row.version,
+      enabled: row.enabled,
+    };
+  });
+  const threads = result.threads.map(projectSummary);
+  if (
+    new Set(members.map((x) => x.id)).size !== members.length ||
+    new Set(own.map((x) => x.threadKey)).size !== own.length
+  )
+    invalid();
+  return { members, own, threads };
+}
+export function createTeamThreads({
+  readScope,
+  request,
+  fenceStore,
+  readContext = async (...args) => (await import("./session-supervision/continuation-analysis.js")).readContinuationContext(...args),
+  onChange = () => {},
+  now = Date.now,
+  pollMs = 30000,
+}) {
+  let value = empty(),
+    scopeKey,
+    generation = 0,
+    controller,
+    busy = false,
+    closed = false,
+    lastPoll = -Infinity,
+    candidates = [],
+    selected = null,
+    memberFilter = null,
+    pending = new Map(),
+    publicationGrants = new Map(),
+    storageFailed = false,
+    lastAllowed = false;
+  function scope() {
+    const current = readScope();
+    if (scopeKey !== current.key || (lastAllowed && !current.allowed)) {
+      controller?.abort();
+      generation++;
+      const sameIdentity = scopeKey === current.key;
+      scopeKey = current.key;
+      const own = sameIdentity && current.authenticated ? value.own : [];
+      value = { ...empty(), own };
+      selected = null;
+      memberFilter = null;
+      if (!sameIdentity) pending = new Map();
+      publicationGrants.clear();
+      lastPoll = -Infinity;
+    }
+    lastAllowed = current.allowed;
+    if (!current.allowed) value.state = "unavailable";
+    return current;
+  }
+  const snapshot = () => {
+    scope();
+    return structuredClone({ ...value, pendingStops: [...pending.keys()], confirmationRequired: value.own.filter(row => row.enabled && publicationGrants.get(row.threadKey) !== row.version).map(row => row.threadKey) });
+  };
+  const fenceKey = (current, key) => digest(`${current.fenceKey}:${key}`);
+  async function run(fn, allowOff = false) {
+    const current = scope();
+    if (
+      busy ||
+      closed ||
+      !current.authenticated ||
+      (!current.allowed && !allowOff)
+    )
+      return false;
+    busy = true;
+    controller = new AbortController();
+    const own = controller,
+      epoch = generation;
+    const valid = () =>
+      !closed &&
+      generation === epoch &&
+      readScope().key === current.key &&
+      readScope().authenticated &&
+      (readScope().allowed || allowOff) &&
+      !own.signal.aborted;
+    const send = async (body) => {
+      if (!valid()) invalid();
+      const result = await request(body, own.signal);
+      if (
+        !valid() ||
+        result?.schemaVersion !== 1 ||
+        result.organizationId !== current.organizationId
+      )
+        invalid();
+      return result;
+    };
+    try {
+      await fn({ current, send, valid, signal: own.signal });
+      return valid();
+    } catch {
+      if (valid()) {
+        value = {
+          ...empty(),
+          own: value.own,
+          state: storageFailed ? "local_storage" : "unavailable",
+        };
+        onChange();
+      }
+      return false;
+    } finally {
+      busy = false;
+    }
+  }
+  async function context(send) {
+    const raw = await send({
+      operation: "context",
+      ...(memberFilter ? { memberId: memberFilter } : {}),
+    });
+    const result = projectThreadContext(raw, readScope().organizationId);
+    if (
+      (raw.memberId ?? null) !== memberFilter ||
+      typeof raw.threadsTruncated !== "boolean"
+    )
+      invalid();
+    value = {
+      ...value,
+      ...result,
+      memberId: memberFilter,
+      threadsTruncated: raw.threadsTruncated,
+      state: "ready",
+    };
+    if (selected && !raw.threadsTruncated && !value.threads.some(row => row.memberId === selected.memberId && row.threadKey === selected.threadKey)) {
+      selected = null;
+      value.detail = null;
+    }
+  }
+  async function clearStop(current, key) {
+    await fenceStore.clear(fenceKey(current, key));
+    pending.delete(key);
+  }
+  async function stop(send, current, key, version) {
+    const result = await send({
+      operation: "consent",
+      threadKey: key,
+      expectedVersion: version,
+      enabled: false,
+    });
+    if (
+      result.threadKey !== key ||
+      result.enabled !== false ||
+      !Number.isSafeInteger(result.version) ||
+      result.version <= version
+    )
+      invalid();
+    await clearStop(current, key);
+    value.own = value.own.map((row) =>
+      row.threadKey === key
+        ? { ...row, enabled: false, version: result.version }
+        : row,
+    );
+  }
+  async function readSelected(send) {
+    if (!selected) return;
+    const selection = { ...selected };
+    const result = await send({ operation: "read", ...selection });
+    if (
+      selected?.memberId !== selection.memberId ||
+      selected?.threadKey !== selection.threadKey
+    )
+      return;
+    const summary = projectSummary(result);
+    if (
+      summary.memberId !== selection.memberId ||
+      summary.threadKey !== selection.threadKey ||
+      !Array.isArray(result.messages) ||
+      result.messages.length > 32 ||
+      typeof result.truncated !== "boolean" ||
+      typeof result.incomplete !== "boolean"
+    )
+      invalid();
+    let total = 0;
+    const messages = result.messages.map((row) => {
+      if (
+        !["user", "assistant"].includes(row?.role) ||
+        typeof row.text !== "string" ||
+        row.text.length > 4000
+      )
+        invalid();
+      total += row.text.length;
+      return { role: row.role, text: sanitizedText(row.text) };
+    });
+    if (total > 24000) invalid();
+    value.detail = {
+      ...summary,
+      messages,
+      truncated: result.truncated,
+      incomplete: result.incomplete,
+    };
+  }
+  function sourceObservedAt(candidate) {
+    const observed = candidate.observation?.observedAt;
+    if (!Number.isFinite(observed) || observed <= 0 || observed > now()) invalid();
+    return new Date(observed).toISOString();
+  }
+  async function payload(candidate, signal) {
+    const result = await readContext(candidate, { signal });
+    if (!Array.isArray(result?.messages) || !result.messages.length) invalid();
+    // Existing provider readers exclude attachments/tool payloads and bound prose.
+    const messages = result.messages.map(({ role, text }) => ({ role, text }));
+    const observation = candidate.observation;
+    const running =
+      candidate.isRunning === true &&
+      observation?.source === "codex_app_server" &&
+      Number.isFinite(observation.observedAt) &&
+      now() - observation.observedAt >= 0 &&
+      now() - observation.observedAt <= 300000;
+    const parent = candidate.parentSession;
+    const parentThreadKey = parent && typeof parent.provider === "string" && typeof parent.session === "string" && parent.session
+      && !(parent.provider === candidate.provider && parent.session === candidate.session)
+      ? teamThreadKey(readScope(), parent) : null;
+    return {
+      parentThreadKey,
+      title: sanitizedText(candidate.title || "Work conversation").slice(
+        0,
+        240,
+      ),
+      state: running ? "running" : "unknown",
+      observedAt: sourceObservedAt(candidate),
+      messages,
+      truncated: result.truncated === true,
+      incomplete: result.incomplete === true,
+    };
+  }
+  async function refresh({ publish = false, memberId = undefined } = {}) {
+    if (memberId !== undefined && memberFilter !== (memberId || null)) {
+      scope();
+      controller?.abort();
+      generation++;
+      memberFilter = memberId || null;
+      selected = null;
+      value.threads = [];
+      value.detail = null;
+      value.memberId = memberFilter;
+      onChange();
+      while (busy && !closed)
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    return run(async ({ current, send, valid, signal }) => {
+      lastPoll = now();
+      await context(send);
+      for (const item of value.own) {
+        const fence = await fenceStore.read(fenceKey(current, item.threadKey));
+        if (!valid()) return;
+        if (fence) {
+          // A lost OFF response (or intervening version) must reconcile against
+          // authenticated current state, rather than retry a stale CAS forever.
+          pending.set(item.threadKey, item.version);
+          if (item.enabled) await stop(send, current, item.threadKey, item.version);
+          else await clearStop(current, item.threadKey);
+        }
+      }
+      if (publish && !storageFailed)
+        for (const item of [...value.own]) {
+          // Server consent alone cannot re-arm publication after a process restart:
+          // an OFF may have failed both durable storage and the network.
+          if (!item.enabled || pending.has(item.threadKey) || publicationGrants.get(item.threadKey) !== item.version) continue;
+          const candidate = candidates.find(
+            (c) => teamThreadKey(current, c) === item.threadKey,
+          );
+          if (!candidate) continue;
+          let body;
+          try {
+            body = await payload(candidate, signal);
+          } catch {
+            continue;
+          }
+          if (!valid() || pending.has(item.threadKey)) return;
+          const receipt = await send({
+            operation: "publish",
+            threadKey: item.threadKey,
+            expectedVersion: item.version,
+            ...body,
+          });
+          if (
+            receipt.threadKey !== item.threadKey ||
+            receipt.enabled !== true ||
+            receipt.version !== item.version
+          )
+            invalid();
+        }
+      await readSelected(send);
+      if (valid()) onChange();
+    });
+  }
+  return {
+    snapshot,
+    tick(sessions) {
+      candidates = sessions;
+      scope();
+      if (!busy && !closed && now() - lastPoll >= pollMs) {
+        lastPoll = now();
+        void refresh({ publish: true });
+      }
+    },
+    refresh,
+    async open({ memberId, threadKey }) {
+      scope();
+      selected = memberId && threadKey ? { memberId, threadKey } : null;
+      value.detail = null;
+      onChange();
+      if (!selected) return true;
+      // An in-flight context/publish must not replace this newer selection.
+      controller?.abort();
+      generation++;
+      while (busy && !closed)
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      return run(async ({ send, valid }) => {
+        await readSelected(send);
+        if (valid()) onChange();
+      });
+    },
+    async stopSharing(threadKey) {
+      scope();
+      if (!keyPattern.test(threadKey) || !value.own.some(row => row.threadKey === threadKey)) return false;
+      return setSharing(null, false, threadKey);
+    },
+    setSharing,
+    close() {
+      closed = true;
+      controller?.abort();
+      generation++;
+      publicationGrants.clear();
+      value = empty();
+    },
+  };
+  async function setSharing(candidate, enabled, existingKey) {
+      const current = scope(),
+        key = existingKey ?? teamThreadKey(current, candidate),
+        item = value.own.find((row) => row.threadKey === key),
+        version = item?.version ?? 0;
+      if (
+        typeof enabled !== "boolean" ||
+        (enabled && (!current.allowed || busy || pending.has(key)))
+      )
+        return false;
+      if (enabled && storageFailed) {
+        // An OFF acknowledgement confirms server removal, not writable local
+        // storage. Revalidate durability before accepting a later explicit ON.
+        if (item?.enabled !== false) return false;
+        // Probe a distinct opaque key so a concurrent OFF cannot lose its fence.
+        const probe = digest(`storage-probe:${current.fenceKey}`);
+        try {
+          await fenceStore.write(probe, 0);
+          await fenceStore.clear(probe);
+        } catch { return false; }
+        if (readScope().key !== current.key || pending.has(key)) return false;
+        storageFailed = false;
+      }
+      if (!enabled) {
+        publicationGrants.delete(key);
+        pending.set(key, version);
+        controller?.abort();
+        generation++;
+        onChange();
+        try {
+          await fenceStore.write(fenceKey(current, key), version);
+        } catch {
+          storageFailed = true;
+          value.state = "local_storage";
+          onChange();
+        }
+      }
+      while (busy && !closed)
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      if (readScope().key !== current.key || !readScope().authenticated) return false;
+      return run(async ({ current, send, valid, signal }) => {
+        if (!enabled) await stop(send, current, key, version);
+        else {
+          const fence = await fenceStore.read(fenceKey(current, key));
+          if (fence) invalid();
+          const body = await payload(candidate, signal);
+          const receipt = await send({
+            operation: "consent",
+            threadKey: key,
+            expectedVersion: version,
+            enabled: true,
+            ...body,
+          });
+          if (
+            receipt.threadKey !== key ||
+            receipt.enabled !== true ||
+            receipt.version !== version + 1
+          )
+            invalid();
+          if (valid() && !pending.has(key)) publicationGrants.set(key, receipt.version);
+        }
+        if (current.allowed) await context(send);
+        if (valid()) onChange();
+      }, !enabled);
+  }
+}