@agent-link/agent 0.1.289 → 0.1.292

package/dist/connection.js

@@ -22,7 +22,7 @@ import { listBrainSessions, loadBrainChatEntries, sendBrainChatMessage, getBrain
 import { listProviders, saveProvider, deleteProvider, getDefaultProviderId, setDefaultProviderId, getBackendTypeForProvider } from './providers.js';
 import { createTunnelHandler } from './tunnel.js';
 import { createTerminalManager } from './terminal.js';
-import { existsSync, mkdirSync } from 'fs';
+import { existsSync, mkdirSync, readdirSync, statSync } from 'fs';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 const TEAM_SESSIONS_DIR = path.join(CONFIG_DIR, 'team-sessions');
@@ -33,7 +33,7 @@ import { claudeCapabilities } from './backends/types.js';
 import { searchSessions } from './search-sessions.js';
 import { formatSessionExport, isSessionExportFormat } from './session-export.js';
 import { listMemoryFiles, updateMemoryFile, deleteMemoryFile } from './memory.js';
-import { decodeKey, parseMessage, encryptAndSend, e2eEncrypt, e2eDecrypt, isE2EEncrypted } from './encryption.js';
+import { decodeKey, parseMessage, encryptAndSend, encryptAndSendConfirmed, e2eEncrypt, e2eDecrypt, isE2EEncrypted } from './encryption.js';
 import { setTeamSendFn, setTeamClaudeFns, getActiveTeam, serializeTeam } from './team.js';
 import { refreshEntraToken, isTokenExpired } from './entra.js';
 import { initEntraTimers, startEntraRetryTimer, stopEntraRetryTimer, scheduleEntraRefresh, cancelEntraRefresh, } from './agent-entra-timer.js';
@@ -57,6 +57,8 @@ const state = {
     workDir: process.cwd(),
     config: null,
     entraToken: null,
+    acceptingWork: true,
+    relayReady: false,
 };
 let unsubscribeSend = null;
 let unsubscribeCopilotSend = null;
@@ -147,6 +149,8 @@ export function connect(config) {
     state.workDir = config.dir;
     state.config = config;
     state.shouldReconnect = true;
+    state.acceptingWork = true;
+    state.relayReady = false;
     setBackendType(config.agent ?? 'claude');
     // Initialize E2E encryption key
     const ignoreConfig = !!process.env.AGENTLINK_NO_STATE;
@@ -309,6 +313,7 @@ function doConnect(config, onRegistered, onError) {
                     settled = true;
                     onRegistered(state.sessionId);
                 }
+                state.relayReady = state.config?.entra !== true;
                 // Always check for session ID changes and update runtime state
                 if (previousSessionId && previousSessionId !== newSessionId) {
                     console.warn(`[AgentLink] Session ID changed: ${previousSessionId} → ${newSessionId}`);
@@ -421,6 +426,7 @@ function doConnect(config, onRegistered, onError) {
         }
     });
     ws.on('close', () => {
+        state.relayReady = false;
         stopHeartbeat();
         console.log('[AgentLink] Disconnected from server');
         if (state.shouldReconnect) {
@@ -518,6 +524,46 @@ export function send(msg) {
         console.warn(`[AgentLink] Cannot send ${msg.type}: WebSocket not open (readyState=${state.ws?.readyState})`);
     }
 }
+export async function sendAndFlush(msg, timeoutMs = 1500) {
+    await sendQueue;
+    const ws = state.ws;
+    if (!ws || ws.readyState !== WebSocket.OPEN)
+        return;
+    let payload = msg;
+    if (state.e2eKey && state.e2eNegotiated) {
+        payload = await e2eEncrypt(msg, state.e2eKey);
+    }
+    let timeout;
+    try {
+        await Promise.race([
+            encryptAndSendConfirmed(ws, payload, state.sessionKey),
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => reject(new Error(`WebSocket send did not drain within ${timeoutMs}ms`)), timeoutMs);
+                timeout.unref();
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+export function beginShutdown() {
+    state.acceptingWork = false;
+}
+export function getConnectionStatus() {
+    return {
+        websocketConnected: state.ws?.readyState === WebSocket.OPEN,
+        relayReady: state.relayReady,
+        acceptingWork: state.acceptingWork,
+        sessionId: state.sessionId,
+        workDir: state.workDir,
+        backend: state.config?.agent ?? 'claude',
+        conversations: getConversations().size
+            + getCopilotConversations().size
+            + getCodexConversations().size,
+    };
+}
 function buildWsUrl(config) {
     const base = config.server.replace(/\/$/, '');
     const params = new URLSearchParams({
@@ -576,13 +622,35 @@ const pendingActionItems = new Map();
 const pendingActionDrafts = new Map();
 function handleServerMessage(msg) {
     console.log(`[AgentLink] ← ${msg.type}`);
+    const shutdownAllowedMessages = new Set([
+        'ping',
+        'pong',
+        'entra_auth_ok',
+        'entra_auth_failed',
+        'cancel_execution',
+        'terminal_close',
+        'tunnel_ws_close',
+    ]);
+    if (!state.acceptingWork && !shutdownAllowedMessages.has(msg.type)) {
+        send({
+            type: 'error',
+            code: 'agent_shutting_down',
+            message: 'Agent is shutting down and is not accepting new work.',
+            conversationId: msg.conversationId,
+            requestId: msg.requestId,
+            rejectedType: msg.type,
+        });
+        return;
+    }
     switch (msg.type) {
         case 'entra_auth_ok':
+            state.relayReady = true;
             console.log(`[AgentLink] Entra identity verified: ${msg.email}`);
             stopEntraRetryTimer();
             scheduleEntraRefresh();
             break;
         case 'entra_auth_failed': {
+            state.relayReady = false;
             const reason = msg.reason;
             console.error(`[AgentLink] Entra auth failed: ${reason}`);
             if (reason === 'token_expired') {
@@ -1610,9 +1678,13 @@ function handleServerMessage(msg) {
                 }
             }
             else {
-                // Same backend (claude), existing logic
+                // Same backend (claude): reconnect provider sync must not interrupt
+                // an active Claude process.
                 const conv = getConversation(conversationId);
-                if (conv) {
+                if (conv?.turnActive) {
+                    conv.providerId = providerId;
+                }
+                else if (conv) {
                     const result = restartConversation(conversationId, { providerId });
                     if (result.wasTurnActive) {
                         send({ type: 'execution_cancelled', conversationId });
@@ -1758,6 +1830,9 @@ function handleServerMessage(msg) {
         case 'retry_action_item':
             handleRetryActionItem(msg);
             break;
+        case 'reopen_action_item':
+            handleReopenActionItem(msg);
+            break;
         case 'create_action_draft':
             handleCreateActionDraft(msg);
             break;
@@ -2495,6 +2570,41 @@ async function handleDismissActionItem(msg) {
     }
 }
 // ── Actions Feed handlers ──────────────────────────────────────────────
+// Resolve the on-disk artifact reference for an action item, if any. All
+// follow-through items write their deliverables to
+//   {BRAIN_DATA_DIR}/reports/follow-through/artifacts/{action_item_id}/
+// We surface it as a structured field so the card can show a "View artifact"
+// link without the frontend having to parse file paths out of summary prose.
+// Returns { artifact_path, artifact_label, artifact_is_dir } or {} when none.
+function resolveArtifact(actionItemId) {
+    try {
+        if (!actionItemId)
+            return {};
+        const dir = path.join(BRAIN_DATA_DIR, 'reports', 'follow-through', 'artifacts', actionItemId);
+        if (!existsSync(dir))
+            return {};
+        const entries = readdirSync(dir).filter(f => !f.startsWith('.'));
+        if (entries.length === 0)
+            return {};
+        // Prefer a single primary document: if exactly one file, link straight to
+        // it; otherwise link to the directory and let the user pick.
+        const files = entries.filter(f => {
+            try {
+                return statSync(path.join(dir, f)).isFile();
+            }
+            catch {
+                return false;
+            }
+        });
+        if (files.length === 1) {
+            return { artifact_path: path.join(dir, files[0]), artifact_label: files[0], artifact_is_dir: false };
+        }
+        return { artifact_path: dir, artifact_label: `${files.length || entries.length} files`, artifact_is_dir: true };
+    }
+    catch {
+        return {};
+    }
+}
 async function handleListActions() {
     try {
         const actions = await listActions();
@@ -2508,6 +2618,7 @@ async function handleListActions() {
             ...a,
             meeting_name: a.meeting_name ?? (a.recap_id ? meetingNameByRecapId.get(a.recap_id) : undefined),
             work_dir: a.work_dir ?? a.session_cwd ?? homeDir,
+            ...resolveArtifact(a.action_item_id),
         }));
         console.log(`[AgentLink] → actions_list (${actionsWithWorkDir.length} items)`);
         send({ type: 'actions_list', actions: actionsWithWorkDir });
@@ -2571,6 +2682,36 @@ async function handleRetryActionItem(msg) {
         clearTimeout(timer);
     }
 }
+async function handleReopenActionItem(msg) {
+    // Reopen reactivates a terminal item (completed/dropped -> ready) and must
+    // re-index it in the dispatcher, so POST to BrainServer's REST endpoint
+    // rather than a bare CLI set-status.
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15000);
+    try {
+        const res = await fetch(`${BRAIN_SERVER}/api/actions/${encodeURIComponent(msg.actionItemId)}/reopen`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(msg.reopenedFrom ? { reopened_from: msg.reopenedFrom } : {}),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            // Forward the HTTP status so the client can treat a 409 (item already
+            // reopened / no longer terminal) as "already reopened", not an error.
+            send({ type: 'action_item_reopened', actionItemId: msg.actionItemId, status: res.status, error: `reopen failed: HTTP ${res.status}` });
+            return;
+        }
+        console.log(`[AgentLink] → action_item_reopened (${msg.actionItemId})`);
+        send({ type: 'action_item_reopened', actionItemId: msg.actionItemId });
+    }
+    catch (err) {
+        console.error(`[AgentLink] reopenActionItem failed for ${msg.actionItemId}:`, err);
+        send({ type: 'action_item_reopened', actionItemId: msg.actionItemId, error: String(err) });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 async function handleCreateActionDraft(msg) {
     try {
         const draft = await createActionDraft();