@awak-app/simy-cli 0.7.16 → 0.7.17

package/src/team-threads.js

@@ -0,0 +1,457 @@
+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(),
+    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 ? value.own : [];
+      value = { ...empty(), own };
+      selected = null;
+      memberFilter = null;
+      if (!sameIdentity) pending = new Map();
+      lastPoll = -Infinity;
+    }
+    lastAllowed = current.allowed;
+    if (!current.allowed) value.state = "unavailable";
+    return current;
+  }
+  const snapshot = () => {
+    scope();
+    return structuredClone({ ...value, pendingStops: [...pending.keys()] });
+  };
+  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,
+    };
+  }
+  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: new Date(now()).toISOString(),
+      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) {
+          pending.set(item.threadKey, fence.expectedVersion);
+          await stop(send, current, item.threadKey, fence.expectedVersion);
+        }
+      }
+      if (publish && !storageFailed)
+        for (const item of [...value.own]) {
+          if (!item.enabled || pending.has(item.threadKey)) 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 setSharing(candidate, enabled) {
+      const current = scope(),
+        key = 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) {
+        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 (current.allowed) await context(send);
+        if (valid()) onChange();
+      }, !enabled);
+    },
+    close() {
+      closed = true;
+      controller?.abort();
+      generation++;
+      value = empty();
+    },
+  };
+}