@volter/teams 0.1.13 → 0.1.15

package/browser-channel.mjs

@@ -135,6 +135,36 @@ export function openBrowserMachine({ origin, teamId, machineId, token }, { WebSo
   });
 }
 
+/**
+ * The machine running session `sessionId` of team `teamId`, reached with a workplace's session token (scope
+ * `control`) for a session its owner bound to the token's Room and Conversation: the server finds the machine.
+ */
+export function openBrowserSession({ origin, teamId, sessionId, token }, { WebSocketImpl = globalThis.WebSocket } = {}) {
+  const url = `${String(origin).replace(/^http/, 'ws')}/api/v1/teams/${encodeURIComponent(teamId)}/sessions/${encodeURIComponent(sessionId)}/channel`;
+  const socket = new WebSocketImpl(url, [CHANNEL_PROTOCOL, `bearer.${token}`]);
+  const channel = new BrowserChannel(socket);
+  return new Promise((resolve, reject) => {
+    socket.addEventListener('open', () => socket.send(frame({ p: PROTOCOL, nv: NODE_PROTOCOL })), { once: true });
+    channel.once('hello', (hello) => (hello.error ? reject(new Error(hello.error)) : resolve(channel)));
+    socket.addEventListener('error', () => reject(new Error(`could not reach session ${sessionId} through ${origin}`)), { once: true });
+    socket.addEventListener('close', () => reject(new Error('the server closed the session channel')), { once: true });
+  });
+}
+
+/**
+ * One line typed into the channel's session as its user's own turn. Resolves with the machine's answer:
+ * `{ code: 0, turn_id, door: 'runtime' | 'pane' | 'waiting' }` (waiting: filed, typed when the session's composer
+ * is free), or `{ code, text }` when it was not delivered; rejects when the machine refuses the stream.
+ */
+export async function sendBrowserTurn(channel, text) {
+  const stream = await channel.open('mail', { request: { op: 'turn', text } });
+  return new Promise((resolve) => {
+    let answer = '';
+    stream.on('data', (chunk) => { answer += chunk; });
+    stream.on('close', () => { try { resolve(JSON.parse(answer)); } catch { resolve({ code: 1, text: answer || 'no answer from the machine' }); } });
+  });
+}
+
 /** A pane's terminal stream: 'data' (text), 'hello', 'notice', 'close'; write(text), resize(cols, rows), close(). */
 export async function attachBrowserPane(channel, { pane, mode = 'observe', cols = 120, rows = 40 }) {
   const stream = await channel.open('terminal', { pane, mode, cols, rows });

package/machine-core.mjs

@@ -207,7 +207,8 @@ export class MachineCore extends EventEmitter {
       return refuse('no machine grant for this caller');
     }
     const index = this.nextConnection++;
-    const entry = { channel, admitted, principal: claim.principal, verify: () => this.#admitClaim(claim), localAdmission: () => admitFromGrants(claim, { custodianId: this.custodianId, grants: this.linkGrants }) };
+    // A delegated caller's claim also carries the name its workplace signed for it (who typed a turn).
+    const entry = { channel, admitted, principal: claim.principal, name: typeof claim.name === 'string' ? claim.name : null, verify: () => this.#admitClaim(claim), localAdmission: () => admitFromGrants(claim, { custodianId: this.custodianId, grants: this.linkGrants }) };
     this.connections.set(index, entry);
     stream.on('close', () => { this.connections.delete(index); this.connectionClosed(index); });
     this.log.append({ principal: entry.principal, cap: 'connect', target: '*', outcome: admitted.class, detail: 'server' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/teams",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "type": "module",
   "description": "Volter Teams, the neutral team plane: machine identity and daemon core, the local door and server link, admission from machine grants, product doors, and the Teams server's neutral routes (company RFC 0008).",
   "license": "MIT",

package/server/core.mjs

@@ -66,4 +66,18 @@ export async function maintain(api){const now=api.clock.nowMs();await api.store.
         {sql:'INSERT OR IGNORE INTO capture_expiries(team_id,source_id,id,expired_at) SELECT team_id,source_id,id,? FROM uploads WHERE committed=0 AND created_at+86400000<=?',params:[now,now]},
         {sql:'DELETE FROM uploads WHERE committed=0 AND created_at+86400000<=?',params:[now]},
         {sql:'DELETE FROM journal WHERE created_at+86400000<=?',params:[now]},
-      ]);}
+      ]);
+  // Every capture writes its session a new version with a full copy of its messages, so versions pile up (hundreds
+  // per session) until listing them outgrew a Worker's memory. Kept: each session's current version, the newest
+  // version from each of its sources (the next capture and a correlation read that one), and every version an
+  // unexpired list, search or history cursor names. The rest go, a bounded batch per run.
+  const stale=await api.store.query(`SELECT v.team_id,v.session_id,v.revision FROM session_versions v JOIN sessions s ON s.team_id=v.team_id AND s.id=v.session_id
+    WHERE v.revision<>s.revision
+    AND EXISTS (SELECT 1 FROM session_versions n WHERE n.team_id=v.team_id AND n.session_id=v.session_id AND n.revision>v.revision AND json_extract(n.source_projection_json,'$.source_id') IS json_extract(v.source_projection_json,'$.source_id'))
+    AND NOT EXISTS (SELECT 1 FROM cursors c, json_each(c.snapshot_json) j WHERE c.team_id=v.team_id AND c.kind IN ('list','search') AND c.expires_at>? AND json_extract(j.value,'$[0]')=v.session_id AND json_extract(j.value,'$[1]')=v.revision)
+    AND NOT EXISTS (SELECT 1 FROM cursors c WHERE c.team_id=v.team_id AND c.kind='history' AND c.expires_at>? AND json_extract(c.snapshot_json,'$.session_id')=v.session_id AND json_extract(c.snapshot_json,'$.revision')=v.revision)
+    LIMIT ${VERSION_PRUNE_BATCH}`,[now,now]);
+  if(stale.length)await api.store.transaction(stale.flatMap(({team_id,session_id,revision})=>['messages','session_artifacts','session_versions'].map(table=>({sql:`DELETE FROM ${table} WHERE team_id=? AND session_id=? AND revision=?`,params:[team_id,session_id,revision]}))));
+  return {pruned_versions:stale.length};}
+/** Session versions `maintain` removes per run: small enough for one Durable Object alarm, drains a backlog in hours. */
+const VERSION_PRUNE_BATCH=50;

package/server/delegated.mjs

@@ -87,7 +87,7 @@ const SESSION_TOKEN_MAX_S = 15 * 60;
 
 /**
  * What a session-view token admits (RH2 ADR 0008), or null: { subject, issuer, teamId, sessionRef, room, conversation,
- * scope, expiresAt }. It names one session (by its id or the harness's own) of one team, and the Room and Conversation
+ * scope, name, expiresAt }. It names one session (by its id or the harness's own) of one team, and the Room and Conversation
  * viewing it; the server admits it only for a session its owner bound to that Room and Conversation.
  */
 export async function delegatedSessionOf(api, token) {
@@ -99,7 +99,10 @@ export async function delegatedSessionOf(api, token) {
   if (!['view', 'control'].includes(claims.scope)) return null;
   const now = Math.floor(api.clock.nowMs() / 1000);
   if (claims.exp - now > SESSION_TOKEN_MAX_S || (typeof claims.iat === 'number' && claims.exp - claims.iat > SESSION_TOKEN_MAX_S)) return null;
-  return { conversation: claims.conversation, expiresAt: claims.exp * 1000, issuer: claims.iss, room: claims.room, scope: claims.scope, sessionRef: session.id, subject: claims.sub, teamId: session.team };
+  // The member's name as the workplace knows it: who the session is told typed a turn. From the signed token, never
+  // from what the browser sends.
+  const name = typeof claims.name === 'string' && claims.name.trim() ? claims.name.trim().slice(0, 80) : null;
+  return { conversation: claims.conversation, expiresAt: claims.exp * 1000, issuer: claims.iss, name, room: claims.room, scope: claims.scope, sessionRef: session.id, subject: claims.sub, teamId: session.team };
 }
 
 /** A token's claims when it is one this server trusts: signed by the issuer's key, for this server, in its lifetime. */

package/server/machine-link.mjs

@@ -16,7 +16,7 @@
 // and the caps the token names, expiring with the token; its channel closes then, or when the surface is unpublished.
 import { Channel } from '../channel.mjs';
 import { bearer } from './auth.mjs';
-import { delegatedAccessOf, delegatedPrincipal, looksDelegated, surfaceCaps } from './delegated.mjs';
+import { delegatedAccessOf, delegatedPrincipal, delegatedSessionOf, looksDelegated, surfaceCaps } from './delegated.mjs';
 import { delegatedGrantIssuer, publicationFor } from './publications.mjs';
 
 const LINK_PROTOCOL = 'supercode-machine-link.v1';
@@ -55,7 +55,7 @@ export async function machineGrantRows(api, teamId, machineId) {
 async function claimFor(api, auth, machineId) {
   if (auth.kind === 'delegated') {
     const row = await api.store.one('SELECT id, revision FROM machine_grants WHERE team_id=? AND machine_id=? AND id=? AND expires_at>?', [auth.team_id, machineId, auth.grant_id, api.clock.nowMs()]);
-    return row ? { principal: auth.principal_id, groups: [], grants: [row.id], revisions: { [row.id]: row.revision } } : null;
+    return row ? { principal: auth.principal_id, groups: [], grants: [row.id], revisions: { [row.id]: row.revision }, ...(auth.name ? { name: auth.name } : {}) } : null;
   }
   const machine = await api.store.one('SELECT custodian_id FROM machines WHERE team_id=? AND id=? AND revoked_at IS NULL', [auth.team_id, machineId]);
   if (!machine) return null;
@@ -151,10 +151,14 @@ export async function machineGrantRoute({ api, req, res, auth, machineId, grantI
  */
 export async function authorizeMachineUpgrade(api, { authenticate, url, headers }) {
   if (api.publicOrigin && headers.host !== new URL(api.publicOrigin).host) return { status: 400, code: 'invalid_request', message: 'request Host does not match configured public origin' };
-  const match = /^\/api\/v1\/teams\/([^/]+)\/machines\/([^/]+)\/(link|channel)$/.exec(new URL(url, 'http://local').pathname);
+  const pathname = new URL(url, 'http://local').pathname;
+  const presented = bearerFrom(headers);
+  // A Room member typing into a session bound to their Room: the session names the machine, the server finds it.
+  const session = /^\/api\/v1\/teams\/([^/]+)\/sessions\/([^/]+)\/channel$/.exec(pathname);
+  if (session) return api.delegatedIssuer && looksDelegated(presented) ? await delegatedSessionChannel(api, session[1], decodeURIComponent(session[2]), presented) : { status: 404, code: 'not_found', message: 'not found' };
+  const match = /^\/api\/v1\/teams\/([^/]+)\/machines\/([^/]+)\/(link|channel)$/.exec(pathname);
   if (!match) return { status: 404, code: 'not_found', message: 'not found' };
   const [, teamId, machineId, door] = match;
-  const presented = bearerFrom(headers);
   if (door === 'channel' && api.delegatedIssuer && looksDelegated(presented)) return await delegatedChannel(api, teamId, machineId, presented);
   const auth = await authenticate(api, presented);
   if (!auth) return { status: 401, code: 'authentication_required', message: 'authentication required' };
@@ -205,6 +209,52 @@ async function delegatedChannel(api, teamId, machineId, token) {
   return { door: 'channel', teamId, machineId, auth: { kind: 'delegated', team_id: teamId, principal_id: principal, group_ids: [], grant_id: id, grant_issuer: issuer, expires_at: access.expiresAt } };
 }
 
+/**
+ * A session-view token's channel (RH2 ADR 0008): the member's own browser types a turn into one session its owner
+ * bound to the token's Room and Conversation. `control` scope only; the grant minted is `interact` on exactly that
+ * session (`session:<harness>/<native id>`) on the machine it runs on, for the token's life, and the claim carries
+ * the member's name from the token. Anything else is refused as a session that does not exist.
+ */
+async function delegatedSessionChannel(api, teamId, sessionRef, token) {
+  const unknown = { status: 404, code: 'not_found', message: 'session not found' };
+  const access = await delegatedSessionOf(api, token);
+  if (!access) return { status: 401, code: 'authentication_required', message: 'authentication required' };
+  if (access.teamId !== teamId || access.scope !== 'control' || access.sessionRef !== sessionRef) return unknown;
+  const target = await boundSessionTarget(api, teamId, access);
+  if (!target) return unknown;
+  const now = api.clock.nowMs(), id = api.ids.next('grant'), principal = delegatedPrincipal(access);
+  const issuer = `delegated:${new URL(access.issuer).host}:session:${target.sessionId}`;
+  await api.store.guardedTransaction([
+    { sql: 'SELECT 1 ok FROM machines WHERE team_id=? AND id=? AND revoked_at IS NULL', params: [teamId, target.machineId], code: 'not_found', status: 404, message: 'session not found' },
+  ], [
+    { sql: "DELETE FROM machine_grants WHERE team_id=? AND issuer_id LIKE 'delegated:%' AND expires_at<=?", params: [teamId, now] },
+    { sql: 'INSERT INTO machine_grants(team_id,id,machine_id,subject_id,caps_json,targets_json,issuer_id,created_at,expires_at) VALUES (?,?,?,?,?,?,?,?,?)', params: [teamId, id, target.machineId, principal, JSON.stringify(['interact']), JSON.stringify([`session:${target.harness}/${target.nativeId}`]), issuer, now, access.expiresAt] },
+  ]).catch((error) => { if (error.code !== 'not_found') throw error; return null; });
+  return { door: 'channel', teamId, machineId: target.machineId, auth: { kind: 'delegated', team_id: teamId, principal_id: principal, group_ids: [], grant_id: id, grant_issuer: issuer, expires_at: access.expiresAt, name: access.name } };
+}
+
+/**
+ * Where a bound session runs: its family's newest origin from an active connector on an enrolled machine, preferring
+ * the harness session the token names. Null unless the session's owner bound it to the token's Room and Conversation.
+ */
+async function boundSessionTarget(api, teamId, access) {
+  const named = await api.store.query('SELECT id, canonical_id FROM sessions WHERE team_id=? AND deleted_at IS NULL AND (id=? OR id IN (SELECT session_id FROM origins WHERE team_id=? AND native_id=? AND deleted_at IS NULL))', [teamId, access.sessionRef, teamId, access.sessionRef]);
+  for (const found of named) {
+    let root = found;
+    for (let hops = 0; root?.canonical_id && hops < 16; hops += 1) root = await api.store.one('SELECT id, canonical_id FROM sessions WHERE team_id=? AND id=? AND deleted_at IS NULL', [teamId, root.canonical_id]);
+    if (!root || root.canonical_id) continue;
+    const bound = await api.store.one('SELECT 1 ok FROM session_view_bindings WHERE team_id=? AND session_id=? AND issuer=? AND room=? AND conversation=?', [teamId, root.id, access.issuer, access.room, access.conversation]);
+    if (!bound) continue;
+    const origin = await api.store.one(`SELECT o.harness, o.native_id, o.session_id, src.machine_id FROM origins o
+      JOIN sources src ON src.team_id=o.team_id AND src.id=o.source_id AND src.state='active' AND src.machine_id IS NOT NULL
+      JOIN machines m ON m.team_id=src.team_id AND m.id=src.machine_id AND m.revoked_at IS NULL
+      WHERE o.team_id=? AND o.deleted_at IS NULL AND o.session_id IN (SELECT id FROM sessions WHERE team_id=? AND deleted_at IS NULL AND (id=? OR canonical_id=?))
+      ORDER BY (o.native_id=?) DESC, o.sequence DESC LIMIT 1`, [teamId, teamId, root.id, root.id, access.sessionRef]);
+    if (origin) return { sessionId: root.id, harness: origin.harness, nativeId: origin.native_id, machineId: origin.machine_id };
+  }
+  return null;
+}
+
 /** Close every delegated channel whose grant came from one publication (issuer from delegatedGrantIssuer): it was unpublished. */
 export function closeDelegatedChannels(api, teamId, machineId, grantIssuer, reason = 'unpublished') {
   let closed = 0;