@volter/supercode-teams 0.3.141 → 0.3.142

package/bin/workspace/agent-session.mjs

@@ -1,6 +1,9 @@
 // Native session hints choose the nearest actual harness when terminal servers inherited both variables.
 import { spawnSync } from 'node:child_process';
 import { basename } from 'node:path';
+import { openLocalMachine, nodeRpc } from '../../client.mjs';
+import { teamsHome, paths } from '@volter/teams/home';
+import { ownClaim } from '../../live-sessions.mjs';
 export function agentSessionHint(env=process.env){
   if(env.SUPERCODE_AGENT_SESSION)return env.SUPERCODE_AGENT_SESSION;
   const claude=env.CLAUDE_CODE_SESSION_ID,codex=env.CODEX_THREAD_ID;
@@ -18,3 +21,38 @@ export function agentSessionHint(env=process.env){
   }
   throw new Error('native session hints are ambiguous; name --session SESSION');
 }
+
+/** The daemon's retained binding is authoritative even when a launch has an old or empty context. */
+export async function agentSessionEnvironment(env = process.env, session = agentSessionHint(env)) {
+  if (!session) return env;
+  let channel;
+  try {
+    channel = await openLocalMachine(paths(teamsHome(env)).socket);
+    const rpc = await nodeRpc(channel);
+    const identity = await rpc.call('harness.v1.agents.session', { session, claim: ownClaim(env) });
+    if (!identity) return env;
+    if (env.SUPERCODE_AGENT_ID && env.SUPERCODE_AGENT_ID !== identity.agent)
+      throw Object.assign(new Error('session ownership does not match its launch identity'), { code: 'forbidden' });
+    if (env.SUPERCODE_AGENT_ORG && env.SUPERCODE_AGENT_ORG !== identity.org)
+      throw Object.assign(new Error('session Org does not match its launch identity'), { code: 'forbidden' });
+    return { ...env, SUPERCODE_AGENT_CONTEXT: identity.context ?? '', SUPERCODE_AGENT_ID: identity.agent,
+      SUPERCODE_AGENT_ORG: identity.org, SUPERCODE_AGENT_ASSIGNMENTS: JSON.stringify(identity.assignments) };
+  } catch (error) {
+    // An offline/older daemon does not authorize a fallback to a person's context.
+    // An existing launch reader can still be checked by the server itself.
+    if (!['ENOENT', 'ECONNREFUSED', 'machine_offline', -32601].includes(error.code)) throw error;
+    return env;
+  } finally { channel?.close(); }
+}
+
+/** Choosing a context never changes an agent into the connected person. */
+export function agentContextName(contexts, env = process.env, explicit = null) {
+  if (!env.SUPERCODE_AGENT_ID) return explicit ?? env.SUPERCODE_CONTEXT ?? contexts.read().current;
+  const name = explicit ?? (env.SUPERCODE_AGENT_CONTEXT || null);
+  if (!name) throw Object.assign(new Error('agent delegation is unavailable; no custodian context fallback is permitted'), { code: 'authentication_required' });
+  const selected = contexts.read().contexts[name];
+  if (!selected || selected.principal_id !== env.SUPERCODE_AGENT_ID
+    || (env.SUPERCODE_AGENT_ORG && selected.team_id !== env.SUPERCODE_AGENT_ORG))
+    throw Object.assign(new Error('selected context does not belong to this agent and Org'), { code: 'forbidden' });
+  return name;
+}

package/bin/workspace.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { StringDecoder } from 'node:string_decoder';
 import { hostname } from 'node:os';
-import { agentSessionHint } from './workspace/agent-session.mjs';
+import { agentSessionHint, agentSessionEnvironment, agentContextName } from './workspace/agent-session.mjs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
@@ -60,20 +60,8 @@ export async function workspaceMain(argv = process.argv.slice(2), env = process.
   if (verb === 'login') return loginCommand({ flags, origin: sub, rest, home, output });
   if (verb === 'auth') return authCommand({ flags, sub, rest, home, contexts, output, env, dependencies });
   if (verb === 'connect' && flags.enrollment_stdin) adoptEnrollment(contexts, home, flags);
-  if(['agent','sessions'].includes(verb)){
-    const session=flags.session??agentSessionHint(env);
-    if(session){
-      let channel;
-      try{
-        channel=await openLocalMachine(paths(teamsHome()).socket);const rpc=await nodeRpc(channel);
-        const identity=await rpc.call('harness.v1.agents.session',{session});
-        if(identity&&!flags.context&&!env.SUPERCODE_AGENT_CONTEXT)env={...env,SUPERCODE_AGENT_CONTEXT:identity.context,SUPERCODE_AGENT_ID:identity.agent,SUPERCODE_AGENT_ASSIGNMENTS:JSON.stringify(identity.assignments)};
-      }catch(error){
-        // Only absence of an older/offline daemon permits the ordinary plain-session context.
-        if(!['ENOENT','ECONNREFUSED','machine_offline',-32601].includes(error.code))throw error;
-      }finally{channel?.close();}
-    }
-  }
+  if(env.SUPERCODE_AGENT_ID||['agent','sessions'].includes(verb))
+    env=await agentSessionEnvironment(env,flags.session??agentSessionHint(env));
   // Every door called from an agent starts under its delegated context. A sibling product verb
   // must not silently recover the custodian's ordinary login when an agent's reader is bounded.
   const agentContext = env.SUPERCODE_AGENT_CONTEXT || null;
@@ -87,7 +75,7 @@ export async function workspaceMain(argv = process.argv.slice(2), env = process.
     throw new Error('agent delegation is unavailable; no custodian context fallback is permitted');
   }
   const explicitContext = flags.context ?? agentContext ?? env.SUPERCODE_CONTEXT;
-  let selected = explicitContext ?? contexts.read().current;
+  let selected = agentContextName(contexts,env,flags.context??null);
   const urlReference = verb === 'sessions' ? rest.find(value => /^https?:\/\//.test(value)) : null;
   if (!explicitContext && urlReference) selected = contextForUrl(contexts.read(), urlReference) ?? selected;
   if (!selected) usage('no workspace context selected');
@@ -871,7 +859,7 @@ async function machinesCommand(sub, { flags, rest, output, client, context, team
     }
     if (action === 'grant') {
       for (const key of ['to', 'caps', 'ttl']) if (!flags[key]) usage(`--${key} is required`);
-      const subject = /^(user|service|group):(.+)$/.exec(flags.to)?.[2]; if (!subject) usage('--to must be user:ID, service:ID or group:ID');
+      const subject = /^(user|service|agent|group):(.+)$/.exec(flags.to)?.[2]; if (!subject) usage('--to must be user:ID, service:ID, agent:ID or group:ID');
       const ttl = duration(flags.ttl);
       if (flags.session || flags.binding) {
         // One session binding's native live actions (§5).

package/fleet.mjs

@@ -8,9 +8,14 @@ import { harnessTransport, nodeRpc, openRemoteMachine } from './client.mjs';
 import { openMachine } from './machine-door.mjs';
 import { WorkspaceContexts, fromContext } from './context.mjs';
 import { teamsHome } from '@volter/teams/home';
+import { agentSessionEnvironment, agentContextName } from './bin/workspace/agent-session.mjs';
 
 /** Open the channel to the machine `name` names in `context` (or this box's daemon when name is null). */
-export function openOn(name = null, { context = null, env = process.env } = {}) {
+export async function openOn(name = null, { context = null, env = process.env } = {}) {
+  if (name && env.SUPERCODE_AGENT_ID) {
+    env = await agentSessionEnvironment(env);
+    context = agentContextName(new WorkspaceContexts(env.SUPERCODE_HOME ?? resolve(teamsHome(env), '..')), env, context);
+  }
   return openMachine({ machine: name, context, env });
 }
 
@@ -44,6 +49,7 @@ export async function nodeRequest(channel, method, params = {}) {
  * that refused or is offline carries its reason. Nothing is stored.
  */
 export async function fleetDiscover({ context = null, machines = null, params = {}, env = process.env } = {}) {
+  if (env.SUPERCODE_AGENT_ID) env = await agentSessionEnvironment(env);
   // One page from each machine, never its whole catalog (yuerans' was 5,620 sessions, 20 MB, 13.5 s): the caller's
   // limit, or FLEET_PAGE; each machine answers it from its daemon's held index.
   // `--limit 0` is every session, as it always was
@@ -51,7 +57,7 @@ export async function fleetDiscover({ context = null, machines = null, params =
   const home = teamsHome(env);
   const supercodeHome = env.SUPERCODE_HOME ?? resolve(home, '..');
   const contexts = new WorkspaceContexts(supercodeHome);
-  const name = context ?? env.SUPERCODE_CONTEXT ?? contexts.read().current;
+  const name = agentContextName(contexts, env, context);
   if (!name || name === 'local') throw new Error('--fleet discovers the machines of a Teams context: `supercode teams login …`, then `supercode context use NAME` or --context NAME');
   const { client, context: selected } = fromContext({ supercodeHome, name, fetch: globalThis.fetch });
   const token = contexts.credential(selected.credential_ref).token;
@@ -105,4 +111,3 @@ export async function fleetDiscover({ context = null, machines = null, params =
 
 /** Sessions `discover --fleet` asks each machine for when the caller names no limit. */
 const FLEET_PAGE = 50;
-

package/machine.mjs

@@ -682,13 +682,15 @@ export class TeamsMachine extends MachineCore {
     // one follow at a time: a change while one is in flight is followed again when it ends, never beside it (two in flight
     // would leave the earlier subscription unsubscribed)
     let pending = null, followed = '', backoffMs = 0, running = false, again = false;
+    this.stopLiveFollow = () => { clearTimeout(pending); pending = null; again = false; this.live.stop(); };
     const follow = async () => {
       pending = null;
+      if (this.stopping) return;
       if (running) { again = true; return; }
       running = true;
       try { await followNow(); } finally {
         running = false;
-        if (again) { again = false; if (!pending) { pending = setTimeout(follow, 0); pending.unref?.(); } }
+        if (again && !this.stopping) { again = false; if (!pending) { pending = setTimeout(follow, 0); pending.unref?.(); } }
       }
     };
     const followNow = async () => {
@@ -699,6 +701,7 @@ export class TeamsMachine extends MachineCore {
       try {
         if (locators.length) {
           const opened = await this.#serveRequest('harness.v1.sessions.activity.subscribe', { locators }, 30_000);
+          if (this.stopping) return;
           this.liveActivity = opened?.subscription ?? null;
           this.live.codexActivity(opened?.initial ?? [], { replace: true });
         } else { this.liveActivity = null; this.live.codexActivity([], { replace: true }); }
@@ -706,6 +709,7 @@ export class TeamsMachine extends MachineCore {
         this.live.codexFollowedNow();
         if (previous) void this.#serveRequest('harness.v1.sessions.activity.unsubscribe', { subscription: previous }, 30_000).catch(() => {});
       } catch (error) {
+        if (this.stopping) return;
         backoffMs = Math.min(300_000, Math.max(2000, (backoffMs || 1000) * 2));
         this.emit('records-log', `live sessions: the Codex sessions' activity could not be followed (${error.message}); tried again in ${Math.round(backoffMs / 1000)} s`);
         pending = setTimeout(follow, backoffMs); pending.unref?.();
@@ -713,7 +717,7 @@ export class TeamsMachine extends MachineCore {
     };
     // a change is followed after 2 s (changes come in bursts); the first follow after the index's first answer at once,
     // as sends wait on it (the Codex sessions are not known until it is done)
-    this.live.on('codex-followed', () => { if (!pending) { pending = setTimeout(follow, this.live.codexKnown ? 2000 : 0); pending.unref?.(); } });
+    this.live.on('codex-followed', () => { if (!this.stopping && !pending) { pending = setTimeout(follow, this.live.codexKnown ? 2000 : 0); pending.unref?.(); } });
     this.on('internal-notification', (message) => {
       const params = message.params ?? {};
       if (params.subscription && params.subscription === this.liveActivity) this.live.codexActivity(params.activities);
@@ -1158,6 +1162,8 @@ export class TeamsMachine extends MachineCore {
     this.jobs?.stopAll();
     void this.relayEndpoint?.then((endpoint) => endpoint?.close()).catch(() => {});
     this.carrier?.stop();
+    this.stopLiveFollow?.();
+    this.mailStore?.stop();
     clearInterval(this.hookSpoolTimer);
     this.idleNotices?.stop();
     this.agentUpkeep?.stop();
@@ -1353,17 +1359,30 @@ export class TeamsMachine extends MachineCore {
     accept();
     this.log.append({ principal, cap: 'harness', target: '*', outcome: 'opened' });
     const lines = lineSplitter();
+    let forwarding = Promise.resolve();
     stream.on('data', (chunk) => {
       for (const line of lines(chunk)) {
         if (!line) continue;
-        let message;
-        try { message = JSON.parse(line); } catch { continue; }
-        const asked = message.id !== undefined && message.id !== null ? message.id : null;
-        if (asked !== null) message.id = joinId(index, message.id);
-        // a serve that is not there to take it answers the request at once, on this stream only
-        if (!this.#toServe(JSON.stringify(message) + '\n') && asked !== null && !stream.closed) {
-          try { stream.write(`${JSON.stringify({ jsonrpc: '2.0', id: asked, error: { code: -32000, message: 'harness serve is not running; it is being started again' } })}\n`); } catch { /* the stream went */ }
-        }
+        forwarding = forwarding.then(async () => {
+          if (stream.closed) return;
+          if (entry.verify) {
+            const fresh = await entry.verify();
+            if (fresh?.class !== 'operator') {
+              this.log.append({ principal, cap: 'harness', target: '*', outcome: 'refused', detail: 'no live operator grant' });
+              return stream.close('no live operator grant');
+            }
+            entry.admitted = fresh;
+          }
+          if (stream.closed) return;
+          let message;
+          try { message = JSON.parse(line); } catch { return; }
+          const asked = message.id !== undefined && message.id !== null ? message.id : null;
+          if (asked !== null) message.id = joinId(index, message.id);
+          // a serve that is not there to take it answers the request at once, on this stream only
+          if (!this.#toServe(JSON.stringify(message) + '\n') && asked !== null && !stream.closed) {
+            try { stream.write(`${JSON.stringify({ jsonrpc: '2.0', id: asked, error: { code: -32000, message: 'harness serve is not running; it is being started again' } })}\n`); } catch { /* the stream went */ }
+          }
+        }).catch(() => { if (!stream.closed) stream.close('machine authority could not be verified'); });
       }
     });
     stream.on('close', () => { entry.harness = null; });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.141",
+  "version": "0.3.142",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",
@@ -70,7 +70,7 @@
     "@volter/supercode-health": "^0.1.0",
     "@volter/supercode-terminal": "^0.2.54",
     "@volter/supercode-trace": "^0.1.0",
-    "@volter/teams": "0.2.36",
+    "@volter/teams": "0.2.37",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",