@volter/supercode-teams 0.3.124 → 0.3.125

package/bin/teams.mjs

@@ -31,6 +31,7 @@
 // CLI in ./workspace.mjs.
 import { appendFileSync, createWriteStream, readFileSync, writeFileSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
 import { noteStep, rotatedLogs, slowLogPath, timeCommand } from '@volter/supercode-harness-sdk/slow-log';
@@ -195,7 +196,15 @@ async function main() {
       }
       // `machine restart [--machine M] [--reason text]`: the daemon (this one, or M's through the server) restarts under its service.
       if (sub === 'restart') return withNode(async (rpc) => out(await rpc.call('machine.restart', { reason: flags.reason ? String(flags.reason) : null })));
-      die('machine start|status|restart');
+      // `machine boards [list]` and `machine boards unregister <root>`: the board homes this machine's connector follows
+      // and publishes, and one no longer followed (a proof's scratch home: t_f7b219b8)
+      if (sub === 'boards') {
+        const [action = 'list', root] = rest;
+        if (action === 'list') return withNode(async (rpc) => out(await rpc.call('harness.v1.boards.list', {})));
+        if (action === 'unregister' && root) return withNode(async (rpc) => out(await rpc.call('harness.v1.boards.unregister', { root: resolve(root) })));
+        die('machine boards [list] | machine boards unregister <root>');
+      }
+      die('machine start|status|restart|boards');
     }
     case 'slow': {
       // `slow [--since 1h|30m|<iso>]`: the slow log on this machine, grouped by what was slow (kind and name), the

package/bin/workspace.mjs

@@ -1477,7 +1477,9 @@ function stampStderr() {
   const decoder = new StringDecoder('utf8');
   let atStart = true;
   process.stderr.write = (chunk, ...rest) => {
-    const text = typeof chunk === 'string' ? chunk : decoder.write(Buffer.from(chunk));
+    // a string written while a Buffer's split character is pending ends that character first (as U+FFFD, the bytes
+    // it had), so the bytes are never held back to land after the string
+    const text = typeof chunk === 'string' ? decoder.end() + chunk : decoder.write(Buffer.from(chunk));
     // an empty write (or a Buffer holding only part of a character) changes no line
     if (!text) return write(text, ...rest);
     const stamp = new Date().toISOString();
@@ -1497,7 +1499,10 @@ async function releaseSkills() {
   const release = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..');
   try {
     if (JSON.parse(readFileSync(join(release, 'package.json'), 'utf8')).name !== '@volter/supercode') return [];
-    const { installSkills } = await import(pathToFileURL(join(release, 'lib', 'skills.mjs')).href);
+    const { installSkills, notThisHomesOwner } = await import(pathToFileURL(join(release, 'lib', 'skills.mjs')).href);
+    // only as the home's owner (a `sudo -E` connect would leave root-owned skill folders in the user's harness homes)
+    const refused = notThisHomesOwner?.();
+    if (refused) return [`skills not installed (${refused}); run \`supercode skills install\` as the home's owner`];
     return installSkills();
   } catch { return []; }
 }

package/board-events.mjs

@@ -5,8 +5,8 @@
 // Each board home's cursor is kept beside the connector, so a restart resumes where it left off; a published event's id
 // is derived from its server, team, source and publication, so a follower that starts over republishes the same ids.
 import { spawn } from 'node:child_process';
-import { mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { createHash } from 'node:crypto';
 import { createInterface } from 'node:readline';
 import { TeamsClient, retryAfterMs, spentClause } from '@volter/teams/http-client';
@@ -91,6 +91,23 @@ export class BoardEvents {
     }
     return { root, registered: true, refused: this.refused };
   }
+  /**
+   * A home no longer followed: its follower ended for good and its record dropped, so no restart brings it back
+   * (t_f7b219b8: 16 scratch proof homes on aarons-mac-mini, each with its own follower, after every daemon start). By an
+   * operator (`supercode teams machine boards unregister <root>`), or here for a home whose folder is gone. Its cards
+   * already published stay on the team.
+   */
+  unregister(path, why = 'unregistered') {
+    let root = resolve(String(path));
+    try { root = realpathSync(root); } catch { /* gone: named as it was registered */ }
+    if (!this.state.boards[root]) return { root, unregistered: false };
+    delete this.state.boards[root]; delete this.state.sources[root]; this.save();
+    this.waits.delete(root);
+    const child = this.followers.get(root);
+    if (child) { child.gone = true; end(child); }
+    this.log(`board events of ${root}: no longer followed (${why})`);
+    return { root, unregistered: true };
+  }
   start() {
     this.started = true;
     for (const root of Object.keys(this.state.boards)) this.follow(root);
@@ -101,6 +118,9 @@ export class BoardEvents {
   follow(root) {
     if (this.followers.has(root) || this.stopped || this.refused) return;
     const board = this.state.boards[root];
+    if (!board) return; // unregistered while it waited
+    // a home whose folder is gone (a proof's scratch home, removed) has no board left to follow: dropped, not retried
+    if (!existsSync(root)) { this.unregister(root, 'its folder is gone'); return; }
     // In a process group of its own (end): the follower is the native binary, the orchestrator it runs and the one that
     // hands the line to, and ending the first alone left the others running, holding its output open.
     const child = spawn(this.binary, ['workflow', 'events', '--root', root, ...(board.cursor ? ['--after', board.cursor] : [])], { env: this.env, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
@@ -148,7 +168,7 @@ export class BoardEvents {
     child.on('close', async (code) => {
       await frames;
       this.followers.delete(root);
-      if (this.stopped || this.refused) return;
+      if (this.stopped || this.refused || child.gone) return;
       if (child.again) { this.follow(root); return; } // registered again: on the orchestrator the home names now
       // its last lines, a stack among them when the store's own error ended it (orchestrator.mjs)
       if (code && !board.error) this.log(`board events of ${root}: workflow events ended (${code}): ${stderr.trim().split('\n').slice(-12).join('\n  ')}`);

package/machine.mjs

@@ -3990,11 +3990,15 @@ export class TeamsMachine extends MachineCore {
         if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('a caller is resolved only for a process on this machine'), { code: 403 });
         return { caller: await this.#callerOf(entry, params) };
       }
-      case 'harness.v1.boards.register': case 'harness.v1.boards.list': {
+      case 'harness.v1.boards.register': case 'harness.v1.boards.list': case 'harness.v1.boards.unregister': {
         // A board home this machine keeps, published to its team by its connector (board-events.mjs).
         if (!operator) throw Object.assign(new Error('operators only'), { code: 403 });
         if (!this.boardEvents) throw Object.assign(new Error('this daemon serves no team: a board is published by a connected machine (`supercode teams connect`)'), { code: 409 });
         if (method === 'harness.v1.boards.list') return this.boardEvents.list();
+        if (method === 'harness.v1.boards.unregister') {
+          if (typeof params.root !== 'string' || !params.root) throw Object.assign(new Error('name the board home (root)'), { code: 400 });
+          return this.boardEvents.unregister(params.root);
+        }
         if (typeof params.root !== 'string' || !params.root) throw Object.assign(new Error('name the board home (root)'), { code: 400 });
         const registered = this.boardEvents.register(params.root);
         // The home's board owner acts as its boards: the caller it names for a board of that home is taken from it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.124",
+  "version": "0.3.125",
   "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.34",
+    "@volter/teams": "0.2.35",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",

package/worker/index.mjs

@@ -145,7 +145,7 @@ export class TeamsServer extends DurableObject {
 
 /** What the Durable Object's runtime said of a failed call (its error's own flags), for the log and the answer. */
 const objectFailure = (error) => ({
-  name: String(error?.name ?? 'Error'),
+  name: String(error?.name ?? 'Error').slice(0, 100),
   message: String(error?.message ?? error).slice(0, 200),
   retryable: error?.retryable === true,
   overloaded: error?.overloaded === true,
@@ -173,12 +173,16 @@ export default {
   },
 };
 
+/** The error names an unauthenticated caller is told; any other (a library's or the runtime's own) is said as
+ *  `Error`, and is in the log line only (#1246 review). */
+const PUBLIC_NAMES = new Set(['Error', 'TypeError', 'RangeError', 'ReferenceError', 'SyntaxError', 'AbortError', 'TimeoutError', 'DOMException']);
+
 /** Failures before the HTTP handler (object initialization, migrations, storage, a reset) as our API contract, not a
  *  platform HTML page. The answer goes to callers not yet authenticated, so it names only the error's kind and the
  *  runtime's flags; its message (storage or SQL text, internal paths) is in the log line its request id leads to. */
 function unavailable(failure, retried) {
   const requestId = crypto.randomUUID();
   console.error(JSON.stringify({ event: 'teams_unavailable', request_id: requestId, failure, ...(retried ? { first: retried } : {}) }));
-  const cause = `${failure.name}${failure.reset ? ', object reset' : ''}${failure.overloaded ? ', overloaded' : ''}${retried ? ', after one retry' : ''}`;
-  return Response.json({ version: 1, error: { code: 'unavailable', message: `Teams server is temporarily unavailable (${cause})`, request_id: requestId, retryable: true, cause: { name: failure.name, retryable: failure.retryable, overloaded: failure.overloaded, remote: failure.remote, reset: failure.reset } } }, { status: 503, headers: { 'Retry-After': failure.overloaded ? '15' : '5', 'X-Request-ID': requestId } });
+  const cause = `${PUBLIC_NAMES.has(failure.name) ? failure.name : 'Error'}${failure.reset ? ', object reset' : ''}${failure.overloaded ? ', overloaded' : ''}${retried ? ', after one retry' : ''}`;
+  return Response.json({ version: 1, error: { code: 'unavailable', message: `Teams server is temporarily unavailable (${cause})`, request_id: requestId, retryable: true, cause: { name: PUBLIC_NAMES.has(failure.name) ? failure.name : 'Error', retryable: failure.retryable, overloaded: failure.overloaded, remote: failure.remote, reset: failure.reset } } }, { status: 503, headers: { 'Retry-After': failure.overloaded ? '15' : '5', 'X-Request-ID': requestId } });
 }