@volter/supercode-teams 0.2.90 → 0.2.92

package/bin/teams.mjs

@@ -135,6 +135,8 @@ async function main() {
         const socket = await machine.start();
         out({ id: machine.id, socket, home, protocol: NODE_PROTOCOL, floor: machine.floor });
         const stop = async () => { await machine.stop(); process.exit(0); };
+        // Another daemon took the socket path: this one serves nobody, and its children would run beside that one's.
+        machine.once('superseded', (path) => { process.stderr.write(`supercode teams: another machine daemon now serves ${path}; this one stops\n`); void stop(); });
         process.on('SIGINT', stop);
         process.on('SIGTERM', stop);
         return;

package/bin/workspace.mjs

@@ -732,6 +732,8 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     // A connected machine is a person's: each pane it launches opens a window on its screen (SUPERCODE_POPUPS=0: none).
     const machine = new TeamsMachine({ home: daemonHome, supercode: binary, popups: process.env.SUPERCODE_POPUPS !== '0', ...(flags.tmux_socket ? { tmuxSocket: String(flags.tmux_socket) } : {}), link: { server: context.origin, teamId: context.team_id, machineId: saved.machine.id, credential: saved.credential.token, incarnationId: connector.state.incarnation_id, configuration: () => connector.configuration() }, onTurn: (turn) => connector.noteTurn(turn) });
     machine.on('link', (event) => { if (event.event === 'replaced') process.stderr.write(`supercode teams: ${event.error}. Two connectors were running for this machine; stop one of them (\`supercode teams disconnect\` where it should not run).\n`); });
+    // The connector is the service's daemon and keeps serving; a daemon that took its socket path is the one to stop.
+    machine.on('superseded', (path) => process.stderr.write(`supercode teams: another machine daemon replaced this connector's socket at ${path}; stop it (supercode teams status)\n`));
     const stopAll = async () => { await machine.stop().catch(() => {}); await connector.stop(); await core.close(); await largeCore.close(); await slowCore.close(); await liveCore.close(); await lifecycle.close(); state.update(current => current ? ({ ...current, process: undefined }) : null); };
     try { await connector.start({ roots: () => saved.roots }); await machine.start(); } catch (error) { await stopAll(); throw error; }
     output({ version: 1, context: scope(context), data: { machine: saved.machine, source: saved.source, roots: saved.roots.map(({ path: _path, ...item }) => item), socket: machine.socketPath, foreground: true } });

package/machine.mjs

@@ -96,6 +96,8 @@ function trustClaudeFolder(cwd) {
 
 /** How long a launch watches its new pane before answering, so a program that ends at once is reported. */
 const LAUNCH_SETTLE_MS = 500;
+/** How many typed lines' keys a machine remembers; a server retries a line for minutes, not thousands of lines. */
+const TURN_KEYS_KEPT = 1000;
 
 /**
  * What a pane runs for a launch: the program with its arguments, or, when the caller named a whole command line
@@ -139,6 +141,9 @@ function paneExit(pane) {
 }
 
 export class TeamsMachine extends MachineCore {
+  /** Typed lines by key → the answer their first attempt gives (see #serveTurn). */
+  #turnKeys = new Map();
+
   /**
    * `link`: { server, teamId, machineId, credential, incarnationId, configuration } to hold the
    * server link; `configuration()` resolves the machine's current configuration from the server
@@ -485,6 +490,17 @@ export class TeamsMachine extends MachineCore {
     // The user-turn door every supercode has (harness.v1 sessions.message, as_user): the session's runtime input,
     // its pane's empty composer, or its mailbox until the composer is free. The sender is named after the member.
     const answer = (value) => { if (!stream.closed) { stream.write(JSON.stringify(value)); stream.close('delivered'); } };
+    // A keyed line is typed once: the server retries a line whose open outlived its bound, and the attempt it gave up
+    // on may still be accepted here. A repeat of a key answers what its first attempt answers.
+    const turnKey = typeof request.turn_key === 'string' && request.turn_key.length <= 128 ? `${target}\u0000${request.turn_key}` : null;
+    const seen = turnKey ? this.#turnKeys.get(turnKey) : null;
+    if (seen) { void seen.then(answer); return; }
+    let settle;
+    if (turnKey) {
+      this.#turnKeys.set(turnKey, new Promise((resolve) => { settle = resolve; }));
+      if (this.#turnKeys.size > TURN_KEYS_KEPT) this.#turnKeys.delete(this.#turnKeys.keys().next().value);
+    }
+    const reply = (value) => { settle?.(value); answer(value); };
     const at = Date.now();
     this.#serveRequest('harness.v1.sessions.message', {
       locator: { harness, session_id: session, storage: { kind: 'file', path: '' } },
@@ -495,12 +511,12 @@ export class TeamsMachine extends MachineCore {
       const delivered = result?.message_id && !result.refusal;
       this.log.append({ principal, cap: 'interact', target, outcome: delivered ? 'turn' : 'failed', detail: result?.refusal?.message?.slice(0, 200) });
       if (delivered) try { this.onTurn?.({ harness, session, text: request.text, at, source: { via: 'room', from: { principalId: principal ?? null, name: entry.name ?? null } } }); } catch { /* the turn is delivered either way */ }
-      answer(delivered
+      reply(delivered
         ? { code: 0, turn_id: result.message_id, door: result.delivery?.how === 'waiting' ? 'waiting' : (result.delivery?.door ?? 'pane') }
         : { code: 1, text: result?.refusal?.message ?? 'the session did not take the turn' });
     }, (error) => {
       this.log.append({ principal, cap: 'interact', target, outcome: 'failed', detail: error.message.slice(0, 200) });
-      answer({ code: 1, text: error.message });
+      reply({ code: 1, text: error.message });
     });
   }
 

package/package.json

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