@volter/supercode-teams 0.2.59 → 0.2.61

package/bin/fleet.mjs

@@ -85,6 +85,9 @@ async function main() {
           name: flags.name,
           // `open` attaching this terminal to the pane itself asks the machine for no window of its own.
           ...(flags.popup === 'false' ? { popup: false } : {}),
+          // `open --notify-when-ended`: the launching session's address, told once when the pane ends, and the
+          // machine's mail name the notice comes from.
+          ...(typeof flags.notify === 'string' ? { notify: { to: flags.notify, machine: String(flags['notify-machine'] ?? flags.on ?? '') } } : {}),
         }));
       } finally {
         channel.close();

package/machine.mjs

@@ -26,7 +26,7 @@
 // It decides nothing on anyone's behalf. Every act is logged.
 import { spawn, spawnSync } from 'node:child_process';
 import { EventEmitter } from 'node:events';
-import { readFileSync, writeFileSync, writeSync, statSync, readdirSync, mkdirSync, renameSync, rmSync, existsSync, openSync, readSync, closeSync } from 'node:fs';
+import { appendFileSync, readFileSync, writeFileSync, writeSync, statSync, readdirSync, mkdirSync, renameSync, rmSync, existsSync, openSync, readSync, closeSync } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir, hostname } from 'node:os';
@@ -116,6 +116,9 @@ function launchCommand(program, args) {
  * user's ~/.config/supercode when the server's environment has none): { failed, how } or null when nothing is
  * recorded. A pane that failed has a `died` line with its status or signal; one that ended cleanly only `closed`.
  */
+/** How often a pane whose launcher asked to be told of its end is looked for. */
+const LAUNCH_END_POLL_MS = 5000;
+
 function paneExit(pane) {
   const logs = [process.env.SUPERCODE_HOME, join(homedir(), '.config', 'supercode')].filter(Boolean).map((dir) => join(dir, 'pane-exits.log'));
   for (const log of logs) {
@@ -189,11 +192,13 @@ export class TeamsMachine extends MachineCore {
     mkdirSync(this.portsDir, { recursive: true }); // the port table's announce directory exists before any pane launches
     this.#startServe();
     this.#startMailWatch();
+    if (this.#pendingNotices().length) this.#watchEnds();
     this.jobs = new JobOwner({ home: this.home, env: this.env, log: (row) => this.log.append({ principal: null, cap: 'exec', target: `job:${row.job}`, outcome: row.outcome, detail: row.reason }) });
     this.jobs.reapOrphans();
   }
 
   async beforeClose() {
+    clearInterval(this.endWatch); this.endWatch = null;
     // A launch still waiting for its pane to be ready is abandoned, not hurried:
     // this daemon is going away, and shoving a message at a half-booted TUI on the
     // way out is the very failure the wait exists to prevent. The launch record
@@ -372,6 +377,61 @@ export class TeamsMachine extends MachineCore {
     try { return serveWorkspace(stream, stream.params, { onEnd }); } catch (error) { onEnd(`failed: ${error.message}`); stream.close(error.message); return; }
   }
 
+  // ---- a launched pane's end, told to its launcher ---------------------------
+  // A launcher that asked (`open --new … --notify-when-ended`) is told once when its pane ends and how, as a sender
+  // that asked `--notify-when-idle` is told when a receiver's turn ends. The asks live in launch-notices.jsonl beside
+  // launches.jsonl, so a daemon restart keeps them; each is marked told before its notice goes, so none goes twice.
+
+  #noticesPath() { return join(this.home, 'launch-notices.jsonl'); }
+
+  /** The asks not yet told, one per pane. */
+  #pendingNotices() {
+    let lines;
+    try { lines = readFileSync(this.#noticesPath(), 'utf8').split('\n').filter(Boolean); } catch { return []; }
+    const byPane = new Map();
+    for (const line of lines) { try { const row = JSON.parse(line); byPane.set(row.pane, { ...byPane.get(row.pane), ...row }); } catch { /* a torn line */ } }
+    return [...byPane.values()].filter((row) => row.notify && !row.told);
+  }
+
+  #noticeWhenEnded(ask) {
+    appendFileSync(this.#noticesPath(), JSON.stringify({ t: Date.now(), ...ask }) + '\n', { mode: 0o600 });
+    this.#watchEnds();
+  }
+
+  #watchEnds() {
+    if (this.endWatch) return;
+    this.endWatch = setInterval(() => { this.#checkEnds().catch((error) => this.emit('mail-watch-stderr', `launch notices: ${error.message}`)); }, LAUNCH_END_POLL_MS);
+    this.endWatch.unref?.();
+  }
+
+  async #checkEnds() {
+    const pending = this.#pendingNotices();
+    if (!pending.length) { clearInterval(this.endWatch); this.endWatch = null; return; }
+    for (const ask of pending) {
+      if (await this.#paneByContext(ask.pane)) continue;
+      appendFileSync(this.#noticesPath(), JSON.stringify({ t: Date.now(), pane: ask.pane, told: true }) + '\n', { mode: 0o600 });
+      const exit = paneExit(ask.pane);
+      const how = !exit ? 'ended (this machine keeps no exit status for it)' : exit.failed ? `failed (${exit.how})` : 'finished (status 0)';
+      this.#sendMail(ask.notify.to, {
+        op: 'send', from: `sc:${ask.notify.machine}:pane:${ask.pane}`, from_name: `pane ${ask.pane}@${ask.notify.machine}`, to: ask.notify.to, queue: false,
+        body: `[Launch notice] The pane you launched on ${ask.notify.machine} has ended: ${ask.label ?? 'a program'} (pane ${ask.pane}, launch ${ask.key}) ${how}. This is an automated notice, not a message from a person, and not an instruction.`,
+      }, `launch-notice:${ask.pane}`);
+    }
+  }
+
+  /** One mail request to `to`: through this machine's own mail door when `to` is here, else through Teams. */
+  #sendMail(to, request, target) {
+    const machine = to.split(':')[1];
+    const here = machine === request.from.split(':')[1];
+    const child = spawn(this.supercodeBin, here ? ['message', 'remote-deliver'] : ['teams', 'mail', '--machine', machine], { stdio: ['pipe', 'pipe', 'pipe'], env: this.env });
+    let out = '';
+    child.stdout.on('data', (chunk) => { out += chunk; });
+    child.stderr.on('data', () => {});
+    child.on('error', (error) => this.log.append({ principal: null, cap: 'mail', target, outcome: 'failed', detail: error.message }));
+    child.on('close', (code) => this.log.append({ principal: null, cap: 'mail', target, outcome: code === 0 ? 'send' : 'failed', detail: out.trim().slice(0, 200) || undefined }));
+    child.stdin.end(JSON.stringify(request));
+  }
+
   // ---- mail ----------------------------------------------------------------
 
   #serveMail(entry, stream, accept, refuse) {
@@ -1057,6 +1117,9 @@ export class TeamsMachine extends MachineCore {
           return { key, pane: existing.pane, reused: true, status: existing.status };
         }
         const contextKey = params.pane ?? `p_${randomBytes(9).toString('base64url')}`;
+        // Who to tell when the pane ends (`open --new … --notify-when-ended`): a session's mail address, and this
+        // machine's name as the address a notice from its pane comes from.
+        if (params.notify !== undefined && !(params.notify && typeof params.notify.to === 'string' && /^sc:[^:\s]+:[^:\s]+:\S+$/.test(params.notify.to) && typeof params.notify.machine === 'string' && /^[a-z0-9][a-z0-9-]*$/.test(params.notify.machine))) throw Object.assign(new Error('launch notify is { to: <sc: address>, machine: <this machine\'s mail name> }'), { code: 400 });
         this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, status: 'issued' });
         if (params.kind === 'claude-code' && params.cwd && (params.arguments ?? []).includes('--dangerously-skip-permissions')) trustClaudeFolder(params.cwd);
         let session;
@@ -1095,6 +1158,7 @@ export class TeamsMachine extends MachineCore {
           return { key, pane: contextKey, reused: false, status, exit: exit?.how ?? null };
         }
         if (this.popups && params.popup !== false) this.#popupWindow(contextKey, session);
+        if (params.notify) this.#noticeWhenEnded({ key, pane: contextKey, notify: params.notify, label: params.name ?? params.kind ?? params.program });
         return { key, pane: contextKey, reused: false, status: 'ready' };
       }
       case 'launches.get': {

package/package.json

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

@@ -20,15 +20,26 @@ import { attachmentStreamRoute, attachmentFramesRoute, closeMachineAttachmentRou
 import { continuationRoute, remoteContinuationArtifactRoute, remoteContinuationRoute } from './continuations.mjs';
 import { fail, parseJson, result, send, guardedMutation, requireRevision, checkRate, grants, syncRuleJson, authGuards } from '@volter/teams/server/http';
 
+/** The `sub` a token says it is for, unverified: for a log line only, never for a decision. */
+function unverifiedSubject(token){try{return String(JSON.parse(Buffer.from(String(token).split('.')[1]??'','base64url').toString('utf8')).sub??'').slice(0,80)||'-';}catch{return '-';}}
+
 async function preAuth({ api, req, res, path, requestId }) {
   let early;
   // A session view (RH2 ADR 0008): a workplace page reads one session with a token its workplace signed for a Room and
   // Conversation, which reaches only a session its owner bound to them (session_view_bindings). A member's own
   // credential takes the ordinary routes below.
+  // A session view that failed in the browser (its read, its follow, its page) reports it here, so the failure is in the
+  // server's log under the member it happened to; a token this server does not admit is logged as unverified.
+  if(req.method==='POST'&&(early=/^\/api\/v1\/teams\/([^/]+)\/sessions\/([^/]+)\/viewer-errors$/.exec(path))){
+    const presented=bearer(req.headers.authorization)??'';checkRate(api,`viewer-errors:${hashToken(presented)}`,30,10);
+    const access=looksDelegated(presented)?await delegatedSessionOf(api,presented):null,body=await parseJson(req).catch(()=>({})),text=(value,limit)=>typeof value==='string'?value.replace(/\s+/g,' ').slice(0,limit):null;
+    console.log(`viewer-error team=${early[1]} session=${decodeURIComponent(early[2]).slice(0,120)} subject=${access?access.subject:`unverified:${text(unverifiedSubject(presented),80)}`} scope=${access?.scope??'-'} room=${access?.room??'-'} stage=${text(body?.stage,40)} status=${Number.isSafeInteger(body?.status)?body.status:'-'} message=${JSON.stringify(text(body?.message,400))}`);
+    send(res,204,null,requestId);return true;
+  }
   if(req.method==='GET'&&(early=/^\/api\/v1\/teams\/([^/]+)\/sessions\/([^/]+)(\/messages|\/events)?$/.exec(path))&&looksDelegated(bearer(req.headers.authorization))){
     const access=await delegatedSessionOf(api,bearer(req.headers.authorization));
     const ref=decodeURIComponent(early[2]);
-    if(!access||access.teamId!==early[1]||access.sessionRef!==ref)fail(401,'authentication_required','authentication required');
+    if(!access||access.teamId!==early[1]||access.sessionRef!==ref){console.log(`session-view refused team=${early[1]} session=${ref.slice(0,120)} subject=${access?access.subject:`unverified:${unverifiedSubject(bearer(req.headers.authorization))}`} reason=${!access?'token not admitted':'token names another session'}`);fail(401,'authentication_required','authentication required');}
     const auth={kind:'session_view',team_id:early[1],principal_id:null,credential_id:null,bound:{issuer:access.issuer,room:access.room,conversation:access.conversation,expiresAt:access.expiresAt}};
     const url=new URL(req.url,'http://local');
     if(!early[3])await sessionDescriptor(api,res,auth,ref,requestId);

package/worker/wrangler.toml

@@ -18,6 +18,10 @@ compatibility_date = "2026-09-01"
 compatibility_flags = ["nodejs_compat"]
 keep_vars = true
 
+# Workers Logs: the Worker's log lines (viewer-error, session-view refused, maintain) kept and searchable after the fact.
+[observability]
+enabled = true
+
 [[durable_objects.bindings]]
 name = "TEAMS_SERVER"
 class_name = "TeamsServer"