@awak-app/simy-cli 0.7.16 → 0.7.18

package/src/desktop-host.js

@@ -5,6 +5,8 @@ import { createLedgerCoordinatorAdapters } from "./update-detachment/ledger-adap
 import { createUpdateCoordinator } from "./update-detachment/coordinator.js";
 import { sessionWorkState, compareSessionWork, reconcileFamilyCompletion, expireSessionWorkState } from './session-supervision/work-state.js';
 import { createPullRequestObserver } from './session-supervision/pull-requests.js';
+import { createTeamThreads, teamThreadKey } from './team-threads.js';
+import { createTeamStatusFenceStore } from './team-status-fence-store.js';
 import { sessionDecisionPresentation } from './session-supervision/decision-presentation.js';
 import { PROVIDER_LINKS, readProviderLinks, writeProviderLink, requireProviderLink } from "./provider-links.js";
 import { randomUUID } from "node:crypto";
@@ -221,6 +223,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let statisticsSelection = { key: null, generation: 0 };
   const stopNotifier = createStopNotifier({ emit: event => { if (!closed && !relay) emit(event); } });
   if (env.SIMY_REMOTE_CHILD !== "1" && process.platform !== "win32") remoteHosts = (dependencies.createRemoteHostManager || createRemoteHostManager)({ root, onChange: () => { if (!closed && !relay) setImmediate(() => { void publish().catch(() => {}); }); } });
+  let teamThreads;
   let currentAccess = { state: 'checking', organizationId: null, organizationName: null };
   let nativeDevelopmentReports = { state: 'loading', enrollments: [] };
   let nativeDevelopmentReportsScope = null;
@@ -713,6 +716,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks) { publishAgain = true; return; }
         if (connectionRevision !== requestedConnectionRevision || !sameAccess(sampledAccess, agent?.getDesktopAccess ? agent.getDesktopAccess() : await readAccess())) { publishAgain = true; return; }
         status.nativeDevelopmentReports = { state: 'loading', enrollments: [] };
+        status.teamThreads = teamThreads?.snapshot();
         if (!closed && !relay) emitStatus(status);
         return;
       }
@@ -764,6 +768,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
       status.sessionSupervision = { ...discovery, refreshing: Boolean(sessionRefresh), sessions: reconcileFamilyCompletion(sessions.map(candidate => ({ ...candidate,
         decisionRequest: sessionDecisionPresentation(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`)),
         workState: sessionWorkState(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`) || stateRunsBySession.get(`${candidate.provider}:${candidate.session}`), { provider: discovery.providers?.[candidate.provider] }) }))).sort(compareSessionWork) };
+      teamThreads?.tick(sessions);
+      status.teamThreads = teamThreads?.snapshot();
+      for (const session of status.sessionSupervision.sessions) {
+        const key = teamThreadKey(agent.getTeamThreadsScope?.() || {}, session);
+        const own = status.teamThreads?.own.find(item => item.threadKey === key);
+        session.teamSharing = { threadKey: key, enabled: own?.enabled === true, pendingStop: status.teamThreads?.pendingStops.includes(key) === true, confirmationRequired: status.teamThreads?.confirmationRequired.includes(key) === true };
+      }
       const latestAccess = await accessSnapshot();
       if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks ||
         !desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope ||
@@ -779,12 +790,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
         if (accessScope(latestConnectionStatus?.access) !== requestedScope || !desktopAccessReady(latestConnectionStatus?.access)) { publishAgain = true; return; }
         status = { ...structuredClone(latestConnectionStatus), deliveryHooks: status.deliveryHooks, sessionSupervision: status.sessionSupervision };
       }
+      status.teamThreads = teamThreads?.snapshot();
       if (!closed && !relay) emitStatus(status);
     }).finally(() => { publishing = null; if (publishAgain && !closed) { publishAgain = false; setImmediate(() => { void publish().catch(() => {}); }); } });
     return publishing;
   };
   const stopAgent = async () => {
     clearInterval(timer);
+    teamThreads?.close();
     pluginInspectionAbort.abort();
     activeStatisticsRead?.controller.abort();
     discoveryStopped = true;
@@ -843,6 +856,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
       },
     });
     if (env.SIMY_UPDATE_TRANSFER_TOKEN) await coordinator.reconnect();
+    teamThreads = createTeamThreads({
+      readScope: () => agent.getTeamThreadsScope?.() || {key: accessScope(currentAccess),allowed:false,authenticated:false},
+      request: (body,signal) => agent.requestTeamThreads(body,signal),
+      fenceStore: createTeamStatusFenceStore(root),
+      readContext: dependencies.readTeamThreadContext,
+      onChange: () => { if(!closed) setImmediate(() => {void publish().catch(() => {});}); },
+    });
     stopWorkflows = (dependencies.startWorkflowUpdates || startWorkflowUpdates)({ enabled: env.SIMY_AUTO_UPDATE !== "0" });
     updater.on?.("change", () => { void publish().catch(() => {}); });
     updater.start({ registry: agent.registry, coordinator, isDesktopIdle: () => !unfinishedDesktopWork,
@@ -1105,15 +1125,39 @@ export async function startDesktopHost({ input = process.stdin, output = process
         const commandScope = accessScope(access);
         if (!desktopActionAllowed(access, command)) throw Object.assign(new Error('Desktop access is required.'), { code: 'desktop_access_required' });
         const recoveryControl = ['provider_disconnect', 'session_unmonitor'].includes(action) ||
-          ['session_set_auto_continue', 'session_set_email_reports'].includes(action) && command.enabled === false;
+          ['session_set_auto_continue', 'session_set_email_reports', 'team_thread_share'].includes(action) && command.enabled === false;
         if (['detach_update', 'update_reconnect'].includes(action)) requireDesktopAccess(access);
         else if (!recoveryControl && desktopAccessReady(access) && !desktopActionAllowed({ state: 'unavailable' }, command)) await authorizeWork();
 
         if (!coordinator.acceptsNewWork() && !recoveryControl && !["refresh", "reconnect", "task_detail", "check_update", "quit", "delivery_stop", "delivery_pause", "delivery_reject"].includes(action)) {
           throw new Error("The update connection requires recovery.");
         }
+        if (['team_threads_refresh','team_thread_open','team_thread_share'].includes(action)) {
+          let ok;
+          if(action === 'team_threads_refresh') ok = await teamThreads.refresh({memberId:command.memberId});
+          else if(action === 'team_thread_open') ok = await teamThreads.open({memberId:command.memberId,threadKey:command.threadKey});
+          else {
+            if (command.organizationId !== undefined && command.organizationId !== access.organizationId) throw new Error('Sharing organization changed. Confirm again.');
+            // Publication reads this host's provider context. Never reinterpret
+            // a remote or ambiguous identity as a same-ID local conversation.
+            if ((command.hostId && command.hostId !== 'local') || (!command.hostId && remoteHosts?.hasSession(command.session))) {
+              throw new Error('Team sharing requires an explicitly selected local conversation.');
+            }
+            const selected = sessionStatus.sessions.find(item => (!item.hostId || item.hostId === 'local') && item.provider === command.provider && item.session === command.session);
+            if (command.enabled === false) {
+              // Revocation uses authenticated own rows, never provider context.
+              const key = command.threadKey ?? teamThreadKey(agent.getTeamThreadsScope(), { provider: command.provider, session: command.session });
+              ok = await teamThreads.stopSharing(key);
+            } else {
+              if(!selected || command.threadKey) throw new Error('Refresh and select your conversation again.');
+              ok = await teamThreads.setSharing(selected,command.enabled);
+            }
+          }
+          emit({type:'result',id:command.id,ok:ok===true}); void publish().catch(() => {}); return;
+        }
+
         let commandProviderLink;
-        if (command.provider && !["provider_connect", "provider_disconnect", "delivery_stop", "delivery_pause", "delivery_reject", "session_untrack", "session_unmonitor"].includes(action) &&
+        if (command.provider && !["refresh", "provider_connect", "provider_disconnect", "delivery_stop", "delivery_pause", "delivery_reject", "session_untrack", "session_unmonitor"].includes(action) &&
           !(action === "session_set_auto_continue" && command.enabled === false)) {
           commandProviderLink = await requireProviderLink({ root: deliveryRoot, provider: command.provider });
         }
@@ -1424,6 +1468,22 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await authorizeWork(commandScope);
           const result = await deadlines.decide(context, { ...command, requestId: command.requestId || command.decisionId });
           if (result.status === 'conflict') throw Object.assign(new Error('Deadline changed; refresh before deciding.'), { code: 'conflict' });
+        } else if (action === "session_set_pinned") {
+          if (typeof command.enabled !== 'boolean') throw new Error('Choose whether to pin this conversation.');
+          const candidate = await selectedSession(command, { preferObserved: true });
+          await authorizeWork(commandScope);
+          const pinScope = command.pinScope ?? 'legacy';
+          if (typeof pinScope !== 'string' || !pinScope || pinScope.length > 512) throw new Error('Invalid pin scope.');
+          await updateRecord(deliveryRoot, command.provider, command.session, previous => {
+            const scopes = new Set(Array.isArray(previous?.listPinScopes) ? previous.listPinScopes : previous?.listPinned ? ['legacy'] : []);
+            if (command.enabled) scopes.add(pinScope); else scopes.delete(pinScope);
+            return {
+              ...(previous || { schemaVersion: 1, provider: command.provider, session: command.session, cwd: candidate.cwd, observedAt: Date.now() }),
+              listPinned: scopes.size > 0, listPinScopes: [...scopes],
+              ...(command.enabled ? { listMetadata: { title: candidate.title || '', createdAt: candidate.createdAt ?? null, lastActivityAt: candidate.lastActivityAt ?? null } } : {}),
+            };
+          });
+          refreshSessions(true);
         } else if (action === "session_archive" || action === "session_restore") {
           const candidate = await selectedSession(command, { preferObserved: true });
           await authorizeWork(commandScope);