@volter/supercode-teams 0.2.144 → 0.2.145

package/machine.mjs

@@ -198,6 +198,8 @@ export class TeamsMachine extends MachineCore {
     // `stop()` can abandon it rather than leave a timer running past the daemon.
     this.voiceProcesses = new Map(); // session address -> optional voice pack child
     this.inputInFlight = new Set(); // one input transaction per pane
+    this.inputRepairsPath = join(this.home, 'input-repairs.json');
+    this.inputRepairs = readJson(this.inputRepairsPath, {});
     this.pendingInitialInputs = new Map(); // launch key → { abort, task }
     this.pendingStartups = new Map();
     this.registerDoor('harness', (entry, stream, accept, refuse, index) => this.#serveHarness(index, entry, stream, accept, refuse));
@@ -223,9 +225,12 @@ export class TeamsMachine extends MachineCore {
 
   async afterListen() {
     this.#startMailWatch();
+    if(Object.keys(this.inputRepairs).length)this.#watchInputRepairs();
   }
 
   async beforeClose() {
+    clearInterval(this.inputRepairTimer);this.inputRepairTimer=null;
+    await this.inputRepairWork;
     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
@@ -237,6 +242,7 @@ export class TeamsMachine extends MachineCore {
     this.pendingStartups.clear();
     await Promise.allSettled([...this.pendingInitialInputs.values()].map(({ task }) => task));
     this.pendingInitialInputs.clear();
+    clearInterval(this.inputRepairTimer);this.inputRepairTimer=null;
   }
 
   async afterStop() {
@@ -886,13 +892,21 @@ export class TeamsMachine extends MachineCore {
   }
 
   async #deliverPaneText(session, contextKey, text, options = {}) {
+    if(this.inputRepairs[contextKey])return {delivered:false,reason:'input-cleanup-pending',cleanup_required:true};
     if (this.inputInFlight.has(session.id)) return { delivered: false, reason: 'input-in-flight' };
     this.inputInFlight.add(session.id);
     try {
       const kind = this.#paneKind(contextKey, session);
       if (kind === 'claude-code' || kind === 'codex') {
         if (typeof terminal.deliverComposerInput !== 'function') return { delivered: false, reason: 'terminal-package-too-old' };
-        return await terminal.deliverComposerInput(this.host, session.id, kind, submission(text, false), options);
+        const result=await terminal.deliverComposerInput(this.host, session.id, kind, submission(text, false), options);
+        if(result.cleanup_required){
+          this.inputRepairs[contextKey]={session:session.id,kind,text:result.cleanup_remaining??submission(text,false),at:Date.now(),reason:result.cleanup_reason};
+          writeJson(this.inputRepairsPath,this.inputRepairs);this.#watchInputRepairs();
+          this.log.append({principal:null,cap:'control',target:`pane:${contextKey}`,outcome:'input-cleanup-pending',detail:result.cleanup_reason});
+        }
+        const {cleanup_remaining,...receipt}=result;
+        return receipt;
       }
       const delivery = await this.host.sendInput(session.id, submission(text), { ...options, submitMode: 'single' });
       return { delivered: true, delivery };
@@ -903,6 +917,38 @@ export class TeamsMachine extends MachineCore {
     }
   }
 
+  #watchInputRepairs() {
+    if(this.inputRepairTimer)return;
+    this.inputRepairTimer=setInterval(()=>{
+      if(this.inputRepairWork)return;
+      this.inputRepairWork=this.#repairInputs().catch(error=>this.emit('mail-watch-stderr',`input cleanup: ${error.message}`)).finally(()=>{this.inputRepairWork=null;});
+    },2000);
+    this.inputRepairTimer.unref?.();
+  }
+
+  async #repairInputs() {
+    for(const [pane,repair] of Object.entries(this.inputRepairs)) {
+      if(this.inputInFlight.has(repair.session)||this.suspended.has(pane))continue;
+      const session=await this.#paneByContext(pane);
+      if(!session||session.id!==repair.session||session.dead){
+        delete this.inputRepairs[pane];writeJson(this.inputRepairsPath,this.inputRepairs);
+        this.log.append({principal:null,cap:'control',target:`pane:${pane}`,outcome:'input-cleanup-pane-gone'});continue;
+      }
+      if(!terminal.restoreComposerInput)continue;
+      this.inputInFlight.add(session.id);
+      try {
+        const result=await terminal.restoreComposerInput(this.host,session.id,repair.kind,repair.text);
+        if(result.restored){
+          delete this.inputRepairs[pane];writeJson(this.inputRepairsPath,this.inputRepairs);
+          this.log.append({principal:null,cap:'control',target:`pane:${pane}`,outcome:'input-cleanup-restored'});
+        }else if(result.remaining&&result.remaining!==repair.text){
+          repair.text=result.remaining;repair.reason=result.reason;writeJson(this.inputRepairsPath,this.inputRepairs);
+        }
+      }finally{this.inputInFlight.delete(session.id);}
+    }
+    if(!Object.keys(this.inputRepairs).length){clearInterval(this.inputRepairTimer);this.inputRepairTimer=null;}
+  }
+
   /** The program a pane runs, as the terminal package names kinds: what it was
    *  launched as, else what its foreground command is. */
   #paneKind(contextKey, session) {
@@ -1338,7 +1384,7 @@ export class TeamsMachine extends MachineCore {
         // `title` is what a viewer should show: the override if one is set, else the tmux label.
         return rows.filter((row) => row.session.id && shown(row.session.contextKey)).map(({ session: s, attention, rank, notify, evidence }) => ({
           pane: s.contextKey, dead: Boolean(s.dead), label: s.label, title: titles[`pane:${s.contextKey}`] ?? s.label, cwd: s.cwd, owned: s.owned, activeCommand: s.activeCommand, pid: s.rootPid ?? null, size: s.size, suspended: this.suspended.has(s.contextKey),
-          attention, rank, notify, evidence,
+          attention, rank, notify, evidence, input_cleanup: this.inputRepairs[s.contextKey] ? {pending:true,at:this.inputRepairs[s.contextKey].at,reason:this.inputRepairs[s.contextKey].reason} : null,
         }));
       }
       case 'launch': {

package/native-codex-pane.mjs

@@ -11,14 +11,36 @@ const seed = JSON.parse(readFileSync(path, 'utf8'));
 const directory = mkdtempSync(join(tmpdir(), 'sc-codex-'));
 const socketPath = join(directory, 'native.sock');
 const endpoint = `unix://${socketPath}`;
-// Configuration is evaluated by the native server. Model, approval and
-// workspace options remain the TUI's own thread-start/resume arguments.
+// Configuration is evaluated by the native server. Remote resume/fork refuses
+// permission overrides on the TUI command: translate those existing choices
+// into server configuration without changing the requested policy.
 const config = [];
+const tuiArguments = [];
+const continuing = seed.arguments.includes('resume') || seed.arguments.includes('fork');
+const writableRoots = [];
 for (let index = 0; index < seed.arguments.length; index += 1) {
   const arg = seed.arguments[index];
-  if (['-c', '--config', '--enable', '--disable'].includes(arg)) config.push(arg, seed.arguments[++index]);
-  else if (/^--(?:config|enable|disable)=/.test(arg)) config.push(arg);
+  if (continuing && ['--dangerously-bypass-approvals-and-sandbox', '--yolo'].includes(arg)) {
+    config.push('-c', 'approval_policy="never"', '-c', 'sandbox_mode="danger-full-access"');
+  } else if (continuing && arg === '--full-auto') {
+    config.push('-c', 'approval_policy="on-request"', '-c', 'sandbox_mode="workspace-write"');
+  } else if (continuing && ['-a', '--ask-for-approval', '-s', '--sandbox', '--add-dir'].includes(arg)) {
+    const value = seed.arguments[++index];
+    if (value === undefined) throw new Error(`${arg} requires a value`);
+    if (arg === '--add-dir') writableRoots.push(value);
+    else config.push('-c', `${['-a','--ask-for-approval'].includes(arg)?'approval_policy':'sandbox_mode'}=${JSON.stringify(value)}`);
+  } else if (continuing && /^--(?:ask-for-approval|sandbox|add-dir)=/.test(arg)) {
+    const at=arg.indexOf('='), name=arg.slice(0,at), value=arg.slice(at+1);
+    if(name==='--add-dir')writableRoots.push(value);
+    else config.push('-c', `${name==='--sandbox'?'sandbox_mode':'approval_policy'}=${JSON.stringify(value)}`);
+  } else {
+    tuiArguments.push(arg);
+    if (['-c', '--config', '--enable', '--disable'].includes(arg)) {
+      const value=seed.arguments[++index];config.push(arg,value);tuiArguments.push(value);
+    } else if (/^--(?:config|enable|disable)=/.test(arg)) config.push(arg);
+  }
 }
+if(writableRoots.length)config.push('-c',`sandbox_workspace_write.writable_roots=${JSON.stringify(writableRoots)}`);
 const server = spawn(seed.program, ['app-server', '--listen', endpoint, ...config], { stdio: ['ignore', 'ignore', 'inherit'] });
 let tui;
 let ended = false;
@@ -38,7 +60,7 @@ try {
   const staged = `${path}.${process.pid}`;
   writeFileSync(staged, JSON.stringify({ ...seed, socketPath, ownerPid: process.pid }), { mode: 0o600 });
   renameSync(staged, path);
-  const args = [...seed.arguments, '--remote', endpoint];
+  const args = [...tuiArguments, '--remote', endpoint];
   if (!args.some((arg) => arg === '-C' || arg === '--cd' || arg.startsWith('--cd='))) args.push('--cd', process.cwd());
   if (seed.initialInput) args.push('--', seed.initialInput);
   tui = spawn(seed.program, args, { stdio: 'inherit' });

package/package.json

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