@volter/supercode-teams 0.2.139 → 0.2.141

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.139",
+  "version": "0.2.141",
   "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",

package/server/harness-routes.mjs

@@ -7,6 +7,7 @@
 // idempotency check, and last among a team's routes. Each hook returns true when it
 // answered the request.
 import { bearer, hashToken, canRead, canManage, isAdmin } from '@volter/teams/server/auth';
+import { storageReport } from './storage-report.mjs';
 import { validateListQuery, validateSearchQuery, validateReadQuery, validateCaptureBegin, validateCapturePart, canonicalJson, carryDigest } from '../contracts/index.mjs';
 import { normalizeSearch, textFromContent, cursorHash, cursorToken } from './catalog.mjs';
 import { captureDigest, captureMessages, handleOtlpRoute, sha256, validateArtifactName } from './ingest.mjs';
@@ -77,6 +78,7 @@ async function beforeIdempotency({ api, req, res, auth, url, path, sub, requestI
 
 async function team({ api, req, res, auth, url, path, sub, requestId }) {
   let m;
+  if(req.method==='GET'&&sub==='/storage/uploads'){await storageReport({api,res,auth,url,requestId});return true;}
   if(req.method==='GET'&&sub==='/sessions'){await listSessions(api,res,auth,url,requestId,false);return true;}
   if(req.method==='GET'&&sub==='/sessions/search'){await listSessions(api,res,auth,url,requestId,true);return true;}
   if(req.method==='GET'&&sub==='/sessions/events'){await handleCatalogEvents({api,req,res,auth,url,requestId,qobj,canReadMerged,readerProjection,fail});return true;}
@@ -197,14 +199,15 @@ async function listSessions(api,res,auth,url,requestId,search){
 }
 /** A report older than this (four missed heartbeats) says nothing about what the session is doing now. */
 const ACTIVITY_FRESH_MS=60000;
-/** `{since}` while the session's harness is working on a turn, by its connector's latest fresh report; else null. */
-async function workingOf(api,teamId,sessionId){
+/** The connector's latest fresh native turn report; stale or unrecognized reports remain unknown. */
+async function activityOf(api,teamId,sessionId){
   const row=await api.store.one('SELECT a.turn,a.since,a.observed_at FROM session_activity a JOIN origins o ON o.team_id=a.team_id AND o.source_id=a.source_id AND o.harness=a.harness AND o.native_id=a.native_id WHERE a.team_id=? AND o.deleted_at IS NULL AND o.session_id IN (SELECT id FROM sessions WHERE team_id=? AND (id=? OR canonical_id=?)) ORDER BY a.observed_at DESC LIMIT 1',[teamId,teamId,sessionId,sessionId]);
-  return row&&row.turn==='working'&&api.clock.nowMs()-row.observed_at<ACTIVITY_FRESH_MS?{since:row.since??row.observed_at}:null;
+  return row&&['working','idle','needs_input'].includes(row.turn)&&api.clock.nowMs()-row.observed_at<ACTIVITY_FRESH_MS?{state:row.turn,since:row.since??row.observed_at,observedAt:row.observed_at}:{state:'unknown'};
 }
 async function sessionDescriptor(api,res,auth,id,requestId){
   const row=await api.store.authorizedSession({teamId:auth.team_id,principalId:auth.principal_id,credentialId:auth.credential_id,ref:id,now:api.clock.nowMs(),bound:auth.bound});
-  send(res,200,result(api,auth,{...JSON.parse(row.descriptor_json),working:await workingOf(api,auth.team_id,row.id)}),requestId,{ETag:`"${row.revision}"`});
+  const activity=await activityOf(api,auth.team_id,row.id);
+  send(res,200,result(api,auth,{...JSON.parse(row.descriptor_json),turnActivity:activity,working:activity.state==='working'?{since:activity.since}:null}),requestId,{ETag:`"${row.revision}"`});
 }
 async function correlateRoute(api,req,res,auth,path,requestId){
   if(!['user','service'].includes(auth.kind)||auth.role==='viewer')fail(403,'forbidden','credential cannot correlate sessions');
@@ -230,7 +233,8 @@ async function readSession(api,res,auth,id,url,requestId){
   const {rows,beforeCursor,revision}=snapshot;
   const messages=rows.map(row=>({id:row.id,source_id:row.source_id,native_key:row.native_key,recorded_at:row.recorded_at,value:JSON.parse(row.value_json)}));
   const descriptor=JSON.parse(snapshot.descriptor_json);
-  send(res,200,{version:1,context:{server_id:api.serverId,team_id:auth.team_id,principal_id:auth.principal_id},descriptor,working:await workingOf(api,auth.team_id,descriptor.id),names:await sessionNames(api,auth.team_id,descriptor),messages,before_cursor:beforeCursor,event_cursor:snapshot.eventCursor,revision,display:{returned:messages.length,total:snapshot.total,truncated_fields:0}},requestId);
+  const activity=await activityOf(api,auth.team_id,descriptor.id);
+  send(res,200,{version:1,context:{server_id:api.serverId,team_id:auth.team_id,principal_id:auth.principal_id},descriptor,turnActivity:activity,working:activity.state==='working'?{since:activity.since}:null,names:await sessionNames(api,auth.team_id,descriptor),messages,before_cursor:beforeCursor,event_cursor:snapshot.eventCursor,revision,display:{returned:messages.length,total:snapshot.total,truncated_fields:0}},requestId);
 }
 async function readArtifact(api,req,res,auth,id,uploadId,requestId){
   const artifact=await api.store.readArtifact({teamId:auth.team_id,principalId:auth.principal_id,credentialId:auth.credential_id,ref:id,uploadId,now:api.clock.nowMs()}),bytes=Buffer.from(artifact.bytes),range=req.headers.range;

package/server/storage-report.mjs

@@ -0,0 +1,31 @@
+// Administrative, read-only retention inventory. No artifact bytes, native
+// paths, prompts or credentials leave this door; cursors never write storage.
+import { isAdmin } from '@volter/teams/server/auth';
+import { fail, result, send } from '@volter/teams/server/http';
+
+export async function storageReport({ api, res, auth, url, requestId }) {
+  if (!isAdmin(auth)) fail(403, 'forbidden', 'storage inventory requires a team administrator');
+  for (const key of url.searchParams.keys()) if (key !== 'after') fail(400, 'invalid_request', `unknown query field ${key}`);
+  const after = url.searchParams.get('after') ?? '';
+  if (after && !/^upload_[a-zA-Z0-9_-]{1,100}$/.test(after)) fail(400, 'invalid_request', 'invalid upload cursor');
+  const rows = await api.store.query(`WITH page AS MATERIALIZED (
+      SELECT * FROM uploads WHERE team_id=? AND id>? ORDER BY id LIMIT 100
+    ), provenance AS MATERIALIZED (
+      SELECT c.team_id,json_extract(a.value,'$.upload_id') upload_id,
+        c.native_id,c.harness,MIN(c.created_at) captured_at
+      FROM captures c,json_each(c.commit_json,'$.artifacts') a
+      WHERE c.team_id=? AND json_extract(a.value,'$.upload_id') IN (SELECT id FROM page)
+      GROUP BY c.team_id,json_extract(a.value,'$.upload_id')
+    ) SELECT u.id,u.source_id,s.machine_id,m.name machine,u.created_at,u.committed,
+      p.native_id,p.harness,p.captured_at,
+      json_extract(u.manifest_json,'$.role') role,json_extract(u.manifest_json,'$.media_type') media_type,
+      json_extract(u.manifest_json,'$.sha256') sha256,
+      (SELECT COALESCE(SUM(length(bytes)),0) FROM artifact_chunks c WHERE c.team_id=u.team_id AND c.upload_id=u.id) bytes,
+      EXISTS (SELECT 1 FROM session_artifacts a WHERE a.team_id=u.team_id AND a.upload_id=u.id) version_referenced,
+      EXISTS (SELECT 1 FROM continuations c WHERE c.team_id=u.team_id AND instr(c.value_json,u.id)>0) continuation_referenced,
+      EXISTS (SELECT 1 FROM captures c WHERE c.team_id=u.team_id AND c.state='staging' AND instr(c.begin_json,u.id)>0) staging_referenced
+    FROM page u JOIN sources s ON s.team_id=u.team_id AND s.id=u.source_id
+    LEFT JOIN machines m ON m.team_id=s.team_id AND m.id=s.machine_id
+    LEFT JOIN provenance p ON p.team_id=u.team_id AND p.upload_id=u.id ORDER BY u.id`, [auth.team_id, after, auth.team_id]);
+  send(res, 200, result(api, auth, { items: rows, next: rows.length === 100 ? rows.at(-1).id : null }), requestId);
+}

package/worker/index.mjs

@@ -114,7 +114,7 @@ export class TeamsServer extends DurableObject {
     this.ready = ctx.blockConcurrencyWhile(async () => {
       // Read before migrations/maintenance: allocation failures must not hide
       // the table responsible, including hosts with a lower storage limit.
-      logStorageBreakdown(ctx.storage.sql);
+      console.log(`storage: database_bytes=${ctx.storage.sql.databaseSize}`);
       const db = durableSql(ctx.storage);
       migrate({ exec: db.exec, tx: db.tx, version: () => ctx.storage.kv.get('schema_version') ?? 0, setVersion: (n) => ctx.storage.kv.put('schema_version', n) });
       this.api = createTeamsApi({ publicOrigin: normalizePublicOrigin(env.PUBLIC_ORIGIN), identityIssuer: env.VOLTER_ISSUER || null, identityOrganizations: identityOrganizationsFromEnv(env), delegatedIssuer: env.DELEGATED_ISSUER || null });
@@ -131,7 +131,7 @@ export class TeamsServer extends DurableObject {
       this.handler = createHttpHandler(this.api);
       // Retention must also run after a restart: a full object may have failed to re-arm its alarm.
       if (this.api.serverId) await maintain(this.api).catch(error => console.error(`maintain startup: ${error.message}`));
-      if (!(await ctx.storage.getAlarm())) await ctx.storage.setAlarm(Date.now() + MAINTAIN_MS);
+      if (!(await ctx.storage.getAlarm())) await ctx.storage.setAlarm(Date.now() + MAINTAIN_MS).catch(error => console.error(`maintain alarm scheduling failed: ${error.message}`));
     });
   }