termdock 1.4.313 → 1.4.315

package/dist/server/agent/collaborationTmuxDelivery.js

@@ -36,12 +36,16 @@ function paneInputKey(pane) {
     return `${pane.serverPid}:${pane.sessionId}:${pane.paneId}:${pane.panePid}`;
 }
 /** Serialize TD paste/submit pairs for this exact runtime pane. */
-export function writeCollaborationTmuxPane(run, pane, prompt, stdin, assertCurrent) {
-    return serializeTerminalInput(paneInputKey(pane), () => writeTmuxPrompt(run, pane, prompt, stdin, assertCurrent));
+export function writeCollaborationTmuxPane(run, pane, prompt, stdin, assertCurrent, progress) {
+    progress?.('queue_wait');
+    return serializeTerminalInput(paneInputKey(pane), () => {
+        progress?.('queue_acquired');
+        return writeTmuxPrompt(run, pane, prompt, stdin, assertCurrent, progress);
+    });
 }
 async function writeTmuxPrompt(run, pane, prompt, 
 /** Body travels on stdin so tmux cannot parse its semicolons/backslashes. */
-stdin, assertCurrent) {
+stdin, assertCurrent, progress) {
     await assertSamePane(run, pane);
     assertCurrent?.();
     // A fixed pane target is independent of the current window, keyboard focus
@@ -64,6 +68,7 @@ stdin, assertCurrent) {
     try {
         // Paste once, then send one unbracketed CR after 50ms. No screen parsing,
         // Agent-specific recovery, consumption confirmation or additional Enter.
+        progress?.('paste_attempted');
         await stdin([
             // The body arrives on stdin, not argv: it is user content, and in a
             // `\;` chain argv is a language where `;` and `\` mean something.
@@ -73,9 +78,11 @@ stdin, assertCurrent) {
             // for it to rewrite — the flag is insurance, not the mechanism.
             'paste-buffer', '-p', '-r', '-d', '-b', buffer, '-t', pane.paneId,
         ], normalizePromptForPaste(prompt));
+        progress?.('paste_written');
         await waitForPromptSubmit();
         await assertSamePane(run, pane);
         assertCurrent?.();
+        progress?.('submit_attempted');
         await run([
             // The submit key rides outside the paste block: inside it, an editor
             // inserts a pasted CR as text instead of acting on it. Pasting the bare
@@ -83,6 +90,7 @@ stdin, assertCurrent) {
             'set-buffer', '-b', buffer, '--', '\r', ';',
             'paste-buffer', '-d', '-b', buffer, '-t', pane.paneId,
         ]);
+        progress?.('submit_written');
     }
     finally {
         // -d consumed the buffer on the happy path; this sweeps up after a failed

package/dist/server/agent/integrationCli.js

@@ -28,12 +28,18 @@ export const INTEGRATION_HELP = `td integration — local scoped integration adm
     Minimum CLI/running service 1.4.309; capabilities.session_resume_configuration=true.
     Errors: RESUME_CONFIGURATION_CHANGED, EXACT_RESUME_UNSUPPORTED,
     SESSION_GENERATION_MISMATCH, SESSION_OPERATION_IN_PROGRESS, LAUNCHER_UNAVAILABLE.
-  diagnostics <TD-session-id> (read the last restore check; administrator only)
+  diagnostics <TD-session-id> (read stored launch/restore diagnostics; administrator only)
+    1.4.314 adds phase/timestamps, paste/submit write facts and target-change
+    evidence; no argv/environment/credentials or application readiness claim.
+    Prior versions cannot reconstruct missing launch evidence retroactively.
   create --file <policy.json> --credential-file <private-output.json>
   update --file <policy.json> (same identity/group; preserves the credential)
   revoke <principal-id>
 Credentials are saved as a private file and never printed. Workers set
 TERMDOCK_INTEGRATION_CREDENTIAL_FILE, then use td collab --principal <id> …
+Session owners: grant session.rename / session.close independently (minimum CLI/service 1.4.315).
+Use td collab --principal <id> session rename|close --help for lifecycle constraints.
+An empty administrator terminal is not required once a live local group is provisioned.
 Ordinary messages: permissions message.send, message.read, events.read;
 td collab --principal <id> --help lists send/reply/history and event examples.
 No task or user acceptance is required for a message-driven integration.
@@ -217,11 +223,17 @@ export async function runIntegrationCollab(command, port, io) {
             return subscribe(socketPath, `/events?${params}`, credential, command.options.timeout ? duration(String(command.options.timeout)) : undefined, io.write);
         }
         if (command.action === 'session') {
+            if (command.operation === 'rename' && capability.session_rename !== true)
+                throw new CollaborationError('SESSION_RENAME_UNSUPPORTED', 'CLI/service must support session.rename (minimum 1.4.315)', 409);
+            if (command.operation === 'close' && capability.session_close !== true)
+                throw new CollaborationError('SESSION_CLOSE_UNSUPPORTED', 'CLI/service must support session.close (minimum 1.4.315)', 409);
+            if (command.operation === 'retry-cold' && capability.session_cold_retry !== true)
+                throw new CollaborationError('SESSION_COLD_RETRY_UNSUPPORTED', 'CLI and running service must support explicit cold retry (minimum 1.4.314)', 409);
             if (command.operation === 'release' && (capability.session_runtime_release !== true || capability.session_lifecycle_generation !== true || capability.stable_session_identity !== true))
                 throw new CollaborationError('SESSION_RELEASE_UNSUPPORTED', 'CLI and running service must support the lifecycle contract (minimum 1.4.309)', 409);
-            const route = command.operation === 'create' ? '/sessions' : `/sessions/${encodeURIComponent(command.target)}${['restore', 'release'].includes(command.operation) ? `/${command.operation}` : ''}`;
+            const route = command.operation === 'create' ? '/sessions' : `/sessions/${encodeURIComponent(command.target)}${['restore', 'release', 'retry-cold', 'rename', 'close'].includes(command.operation) ? `/${command.operation}` : ''}`;
             const body = command.operation === 'create' ? { group_id: command.options.group, launch_profile: command.options['launch-profile'], cwd: command.options.cwd, idempotency_key: command.options['idempotency-key'] }
-                : ['restore', 'release'].includes(command.operation) ? { ...(command.operation === 'release' ? { generation: Number(command.options.generation) } : {}), idempotency_key: command.options['idempotency-key'] } : undefined;
+                : ['restore', 'release', 'retry-cold', 'rename', 'close'].includes(command.operation) ? { ...(['release', 'retry-cold', 'rename', 'close'].includes(command.operation) ? { generation: Number(command.options.generation), ...(command.operation === 'rename' ? { name: command.options.name } : {}) } : {}), idempotency_key: command.options['idempotency-key'] } : undefined;
             io.write(JSON.stringify(parsed(await request(socketPath, command.operation === 'get' ? 'GET' : 'POST', route, body, headers(credential)))));
             return 0;
         }

package/dist/server/agent/integrationServer.js

@@ -70,7 +70,7 @@ export class IntegrationRuntime {
         };
         app.get('/admin/groups', run(req => { admin(req); return { groups: options.messages.list().filter(g => !g.federated).map(g => ({ id: g.id, name: g.name })) }; }));
         app.get('/admin/capabilities', run(req => { admin(req); return this.capabilities(); }));
-        app.get('/admin/sessions/:id/restore-diagnostics', run(req => { admin(req); return this.sessions.restoreDiagnostics(req.params.id); }));
+        app.get('/admin/sessions/:id/restore-diagnostics', run(req => { admin(req); return { ...this.sessions.restoreDiagnostics(req.params.id), ...this.sessions.launchDiagnostics(req.params.id) }; }));
         app.get('/admin/sessions/:id/resume-configuration', run(async (req) => { admin(req); return this.sessions.resumeConfiguration(req.params.id); }));
         app.post('/admin/sessions/:id/resume-configuration', run(async (req) => { admin(req); return { session: publicIntegrationSession(await this.sessions.confirmResumeConfiguration(req.params.id, req.body?.generation, req.body?.fingerprint)) }; }));
         app.post('/admin/sessions/:id/startup-input/clear', run(async (req) => {
@@ -197,7 +197,10 @@ export class IntegrationRuntime {
         }));
         app.get('/sessions/:id', run(async (req) => { const p = principal(req); this.authorize(p, 'session.read'); return { session: publicIntegrationSession(await this.sessions.get(p, req.params.id)) }; }));
         app.post('/sessions/:id/restore', run(async (req) => { const p = principal(req); this.authorize(p, 'session.restore'); const session = await this.sessions.restore(p, req.params.id, req.body?.idempotency_key); this.sync(); return { session: publicIntegrationSession(session) }; }));
+        app.post('/sessions/:id/retry-cold', run(async (req) => { const p = principal(req); this.authorize(p, 'session.create'); const session = await this.sessions.retryCold(p, req.params.id, req.body?.generation, req.body?.idempotency_key); this.sync(); return { session: publicIntegrationSession(session) }; }));
         app.post('/sessions/:id/release', run(async (req) => { const p = principal(req); this.authorize(p, 'session.release'); const session = await this.sessions.release(p, req.params.id, req.body?.generation, req.body?.idempotency_key); this.sync(); return { session: publicIntegrationSession(session) }; }));
+        app.post('/sessions/:id/rename', run(async (req) => { const p = principal(req); this.authorize(p, 'session.rename'); const session = await this.sessions.rename(p, req.params.id, req.body?.generation, req.body?.name, req.body?.idempotency_key); this.sync(); return { session: publicIntegrationSession(session) }; }));
+        app.post('/sessions/:id/close', run(async (req) => { const p = principal(req); this.authorize(p, 'session.close'); const session = await this.sessions.closeSession(p, req.params.id, req.body?.generation, req.body?.idempotency_key); this.sync(); return { session: publicIntegrationSession(session) }; }));
         app.get('/events', run((req, res) => {
             const p = principal(req);
             this.authorize(p, 'events.read', req.query.group);
@@ -226,6 +229,10 @@ export class IntegrationRuntime {
             session_startup_input_clear: true, session_startup_input_clear_min_version: '1.4.310',
             agent_launch_process_check: true, agent_launch_process_check_min_version: '1.4.312',
             terminal_input_runtime_fence: true, terminal_input_runtime_fence_min_version: '1.4.313',
+            session_launch_diagnostics: true, session_launch_diagnostics_min_version: '1.4.314',
+            session_cold_retry: true, session_cold_retry_min_version: '1.4.314',
+            session_rename: true, session_rename_min_version: '1.4.315',
+            session_close: true, session_close_min_version: '1.4.315',
             integration_policy_update: true,
             session_restore_diagnostics: true,
             native_identity_linux_flock_owner: process.platform === 'linux',
@@ -329,6 +336,14 @@ export class IntegrationRuntime {
                     updates.push({ sourceKey: `session:${session.session_id}`, sourceVersion: JSON.stringify(publicIntegrationSession(session)), event: {
                             group_id: session.group_id, kind: `session.${session.state}`, created_at: session.updated_at, source: 'system', actor: { integration_id: session.principal_id }, payload: { session: publicIntegrationSession(session) }
                         } });
+            for (const session of this.sessions.snapshot())
+                if (groups.has(session.group_id) && session.name_updated_at)
+                    updates.push({
+                        sourceKey: `session-name:${session.session_id}`, sourceVersion: JSON.stringify([session.name, session.name_updated_at, session.name_generation]), event: {
+                            group_id: session.group_id, kind: 'session.renamed', created_at: session.name_updated_at, source: 'system',
+                            actor: { integration_id: session.principal_id }, payload: { session_id: session.session_id, name: session.name, generation: session.name_generation, operation_id: session.name_operation_id }
+                        }
+                    });
             updates.sort((a, b) => a.event.created_at - b.event.created_at);
             this.store.append(updates);
         }