@agent-link/agent 0.1.272 → 0.1.274

package/dist/connection.js

@@ -3,6 +3,7 @@ import os from 'os';
 import path from 'path';
 import { performance } from 'perf_hooks';
 import { createRequire } from 'module';
+import { spawn } from 'child_process';
 import { loadRuntimeState, saveRuntimeState, getBrainDataDir, getConversationPermission, setConversationPermission, clearConversationPermission, getOrCreateE2EKey, encodeBase64Url, CONFIG_DIR } from './config.js';
 import { handleListDirectory, handleReadFile, handleUpdateFile, handleCreateFile, handleCreateDirectory, handleDeleteFile, handleUploadFile, handleUploadFileChunk, handleDownloadFile, handleDownloadChunkAck } from './directory-handlers.js';
 import { handleGitStatus, handleGitDiff, handleGitStage, handleGitUnstage, handleGitDiscard, handleGitCommit, handleGitWorktreeList, handleGitStash, handleGitPull, handleGitPush, handleGitDeleteFile, resolveToRepoRoot } from './git-handlers.js';
@@ -11,6 +12,8 @@ import { handleCreateLoop, handleUpdateLoop, handleDeleteLoop, handleListLoops,
 import { loadSessionMetadata, loadAllSessionMetadata, deleteSessionMetadata } from './session-metadata.js';
 import { listRecaps, listRecapsWithStatus, getRecapDetail, runActionItemsCli } from './recap.js';
 import { listActions, getActionDetail } from './action.js';
+import { bindActionDraftSession, commitActionDraft, createActionDraft, discardActionDraft, getActionDraft, listActionDrafts, validateActionDraftId, } from './action-drafts.js';
+import { resolveNewActionDraftSessionDir } from './action-draft-session.js';
 import { listIcms } from './playground-icm.js';
 import { listBriefings, getBriefingDetail } from './briefing.js';
 import { listDevops, getDevopsDetail } from './devops.js';
@@ -136,7 +139,7 @@ export function connect(config) {
         }
         catch { /* ignore */ }
     }
-    unsubscribeSessionStarted = addOnSessionStarted(checkPendingActionItem);
+    unsubscribeSessionStarted = addOnSessionStarted(checkPendingSessionLinks);
     // Initialize the tunnel handler for port proxy
     tunnelHandler = createTunnelHandler(send);
     // Initialize the terminal manager for web terminal
@@ -144,7 +147,7 @@ export function connect(config) {
     // Wire up the Team module with send and claude dependencies
     setTeamSendFn(send);
     setTeamClaudeFns({
-        handleChat: claudeHandleChat,
+        handleChat: guardedClaudeHandleChat,
         cancelExecution: claudeCancelExecution,
         addOutputObserver,
         removeOutputObserver,
@@ -159,7 +162,7 @@ export function connect(config) {
     // Initialize the Loop scheduler
     initScheduler({
         send,
-        handleChat: claudeHandleChat,
+        handleChat: guardedClaudeHandleChat,
         cancelExecution: claudeCancelExecution,
         addOutputObserver,
         removeOutputObserver,
@@ -514,10 +517,120 @@ function scheduleReconnect(config) {
     }, delay);
 }
 const BRAIN_DATA_DIR = getBrainDataDir();
+const FOLLOW_THROUGH_SESSION_DIR = path.join(BRAIN_DATA_DIR, 'reports', 'follow-through');
 const BRAIN_SERVER = 'http://localhost:8001';
 // Pending action item IDs: conversationId → actionItemId
 // Used to link a chat's Claude session to an action item for CLI start
 const pendingActionItems = new Map();
+const pendingActionDrafts = new Map();
+let agentUpgradeLaunchStarted = false;
+let agentUpgradePending = false;
+let agentUpgradeRecoveryTimer = null;
+const AGENT_UPGRADE_RECOVERY_TIMEOUT_MS = 10 * 60 * 1000;
+function guardedClaudeHandleChat(...args) {
+    if (agentUpgradePending) {
+        throw new Error('Agent upgrade is in progress. Please wait for the agent to reconnect.');
+    }
+    return claudeHandleChat(...args);
+}
+function collectActiveUpgradeSessions() {
+    const active = [];
+    const pushActive = (conversationId, conv) => {
+        if (!conv.turnActive)
+            return;
+        const sessionId = conv.claudeSessionId ?? conv.copilotSessionId ?? conv.codexSessionId ?? null;
+        active.push({
+            conversationId,
+            sessionId,
+            title: conv.sessionTitle || sessionId || conversationId,
+        });
+    };
+    for (const [convId, conv] of getConversations()) {
+        pushActive(convId, conv);
+    }
+    for (const [convId, conv] of getCopilotConversations()) {
+        pushActive(convId, conv);
+    }
+    for (const [convId, conv] of getCodexConversations()) {
+        pushActive(convId, conv);
+    }
+    for (const [executionId] of getRunningExecutions()) {
+        active.push({
+            conversationId: `loop:${executionId}`,
+            sessionId: executionId,
+            title: `Loop execution ${executionId.slice(0, 8)}`,
+        });
+    }
+    const activeTeam = getActiveTeam();
+    if (activeTeam && ['planning', 'running', 'summarizing'].includes(activeTeam.status)) {
+        active.push({
+            conversationId: activeTeam.conversationId,
+            sessionId: activeTeam.teamId,
+            title: activeTeam.title || `Team ${activeTeam.teamId.slice(0, 8)}`,
+        });
+    }
+    return active;
+}
+function launchDetachedAgentUpgrade(send) {
+    if (agentUpgradeLaunchStarted)
+        return;
+    const active = collectActiveUpgradeSessions();
+    if (active.length > 0) {
+        agentUpgradePending = false;
+        send({
+            type: 'agent_upgrade_blocked',
+            reason: 'active_conversations',
+            activeConversations: active,
+        });
+        return;
+    }
+    agentUpgradeLaunchStarted = true;
+    const env = { ...process.env };
+    delete env.AGENTLINK_PID;
+    try {
+        const child = process.platform === 'win32'
+            ? spawn('cmd.exe', ['/d', '/s', '/c', 'start "" /min agentlink-client upgrade'], {
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true,
+                env,
+            })
+            : spawn('sh', ['-c', 'agentlink-client upgrade >/dev/null 2>&1 &'], {
+                detached: true,
+                stdio: 'ignore',
+                env,
+            });
+        child.once('error', (error) => {
+            agentUpgradeLaunchStarted = false;
+            agentUpgradePending = false;
+            if (agentUpgradeRecoveryTimer) {
+                clearTimeout(agentUpgradeRecoveryTimer);
+                agentUpgradeRecoveryTimer = null;
+            }
+            send({ type: 'agent_upgrade_failed', message: `Failed to start upgrade: ${error.message}` });
+        });
+        child.unref();
+        agentUpgradeRecoveryTimer = setTimeout(() => {
+            agentUpgradeLaunchStarted = false;
+            agentUpgradePending = false;
+            agentUpgradeRecoveryTimer = null;
+            send({
+                type: 'agent_upgrade_failed',
+                message: 'Agent upgrade did not restart the agent. Run the upgrade command manually if this repeats.',
+            });
+        }, AGENT_UPGRADE_RECOVERY_TIMEOUT_MS);
+        agentUpgradeRecoveryTimer.unref?.();
+    }
+    catch (error) {
+        agentUpgradeLaunchStarted = false;
+        agentUpgradePending = false;
+        if (agentUpgradeRecoveryTimer) {
+            clearTimeout(agentUpgradeRecoveryTimer);
+            agentUpgradeRecoveryTimer = null;
+        }
+        send({ type: 'agent_upgrade_failed', message: `Failed to start upgrade: ${error.message}` });
+    }
+}
 function handleServerMessage(msg) {
     console.log(`[AgentLink] ← ${msg.type}`);
     switch (msg.type) {
@@ -544,6 +657,10 @@ function handleServerMessage(msg) {
             break;
         }
         case 'chat': {
+            if (agentUpgradePending) {
+                send({ type: 'error', message: 'Agent upgrade is in progress. Please wait for the agent to reconnect.', conversationId: msg.conversationId });
+                break;
+            }
             const chatConvId = msg.conversationId;
             const existingConv = chatConvId ? getConversation(chatConvId) : getConversation();
             const isBrainMode = msg.brainMode;
@@ -556,9 +673,21 @@ function handleServerMessage(msg) {
             const projectName = msg.projectName;
             const icmId = msg.icmId;
             const actionItemId = msg.actionItemId;
+            const actionDraftId = msg.actionDraftId;
             const explicitWorkDir = msg.workDir;
+            if (actionDraftId) {
+                try {
+                    validateActionDraftId(actionDraftId);
+                }
+                catch (err) {
+                    send({ type: 'error', message: String(err), conversationId: chatConvId });
+                    break;
+                }
+            }
             // Backward compat: brainMode: true without providerId → "brain"
-            const effectiveProviderId = msgProviderId || (isBrainMode ? 'brain' : undefined);
+            const effectiveProviderId = actionDraftId
+                ? 'brain'
+                : (msgProviderId || (isBrainMode ? 'brain' : undefined));
             console.log(`[AgentLink] chat: conversationId=${chatConvId}, existingConv.planMode=${existingConv?.planMode}, providerId=${effectiveProviderId || '(default)'}`);
             const chatOptions = {
                 resumeSessionId: msg.resumeSessionId,
@@ -587,13 +716,19 @@ function handleServerMessage(msg) {
             if (icmId) {
                 chatOptions.icmId = String(icmId);
             }
+            if (actionDraftId) {
+                chatOptions.actionDraftId = actionDraftId;
+            }
             // Determine the working directory for this chat.  For resumed sessions
             // the JSONL may live in a different cwd than the agent's current workDir
             // (e.g. action-item sessions spawned by BrainCore live in $HOME).  When
             // no existingConv is found (agent restarted, or cache-hit skipped
             // resume_conversation), probe the filesystem to find the right directory.
-            let chatDir = explicitWorkDir ?? existingConv?.workDir;
-            if (!chatDir && (recapId || briefingDate || devopsEntityType || projectName || icmId)) {
+            const newActionDraftSessionDir = resolveNewActionDraftSessionDir(BRAIN_DATA_DIR, actionDraftId, explicitWorkDir, chatOptions.resumeSessionId, existingConv);
+            let chatDir = newActionDraftSessionDir ?? explicitWorkDir ?? existingConv?.workDir;
+            if (newActionDraftSessionDir)
+                mkdirSync(FOLLOW_THROUGH_SESSION_DIR, { recursive: true });
+            if (!chatDir && (recapId || briefingDate || devopsEntityType || projectName || icmId || actionDraftId)) {
                 // Brain-mode session: try BRAIN_DATA_DIR first, then homedir fallback
                 const probeSessionId = chatOptions.resumeSessionId
                     || existingConv?.claudeSessionId;
@@ -617,6 +752,9 @@ function handleServerMessage(msg) {
             if (actionItemId && chatConvId) {
                 pendingActionItems.set(chatConvId, actionItemId);
             }
+            if (actionDraftId && chatConvId) {
+                pendingActionDrafts.set(chatConvId, { draftId: actionDraftId, sessionCwd: chatDir });
+            }
             // Auto-switch backend if chat message's providerId requires a different backend
             if (effectiveProviderId) {
                 const requiredBt = getBackendTypeForProvider(effectiveProviderId);
@@ -1170,6 +1308,21 @@ function handleServerMessage(msg) {
             });
             break;
         }
+        case 'trigger_agent_upgrade': {
+            const active = collectActiveUpgradeSessions();
+            if (active.length > 0) {
+                send({
+                    type: 'agent_upgrade_blocked',
+                    reason: 'active_conversations',
+                    activeConversations: active,
+                });
+                break;
+            }
+            agentUpgradePending = true;
+            send({ type: 'agent_upgrade_started' });
+            setTimeout(() => launchDetachedAgentUpgrade(send), 200);
+            break;
+        }
         case 'query_turn_status': {
             const m = msg;
             const buildTurnStatus = (convId, conv) => {
@@ -1245,6 +1398,10 @@ function handleServerMessage(msg) {
             break;
         }
         case 'create_team':
+            if (agentUpgradePending) {
+                send({ type: 'error', message: 'Agent upgrade is in progress. Please wait for the agent to reconnect.' });
+                break;
+            }
             mkdirSync(TEAM_SESSIONS_DIR, { recursive: true });
             handleCreateTeam(msg, TEAM_SESSIONS_DIR, send);
             break;
@@ -1284,6 +1441,10 @@ function handleServerMessage(msg) {
             handleGetLoop(msg, send);
             break;
         case 'run_loop':
+            if (agentUpgradePending) {
+                send({ type: 'error', message: 'Agent upgrade is in progress. Please wait for the agent to reconnect.' });
+                break;
+            }
             handleRunLoop(msg, send);
             break;
         case 'cancel_loop_execution':
@@ -1612,6 +1773,21 @@ function handleServerMessage(msg) {
         case 'complete_action_item':
             handleCompleteActionItem(msg);
             break;
+        case 'create_action_draft':
+            handleCreateActionDraft(msg);
+            break;
+        case 'list_action_drafts':
+            handleListActionDrafts(msg);
+            break;
+        case 'get_action_draft':
+            handleGetActionDraft(msg);
+            break;
+        case 'commit_action_draft':
+            handleCommitActionDraft(msg);
+            break;
+        case 'discard_action_draft':
+            handleDiscardActionDraft(msg);
+            break;
         case 'list_briefings':
             handleListBriefings();
             break;
@@ -2381,6 +2557,78 @@ async function handleCompleteActionItem(msg) {
         send({ type: 'action_item_completed', actionItemId: msg.actionItemId, error: String(err) });
     }
 }
+async function handleCreateActionDraft(msg) {
+    try {
+        const draft = await createActionDraft();
+        send({ type: 'action_draft_created', requestId: msg.requestId, draft });
+    }
+    catch (err) {
+        console.error('[AgentLink] createActionDraft failed:', err);
+        send({
+            type: 'action_draft_created',
+            requestId: msg.requestId,
+            draft: null,
+            error: String(err),
+        });
+    }
+}
+async function handleListActionDrafts(msg) {
+    try {
+        const drafts = await listActionDrafts(msg.status);
+        send({ type: 'action_drafts_list', drafts });
+    }
+    catch (err) {
+        console.error('[AgentLink] listActionDrafts failed:', err);
+        send({ type: 'action_drafts_list', drafts: [], error: String(err) });
+    }
+}
+async function handleGetActionDraft(msg) {
+    try {
+        const draft = await getActionDraft(msg.draftId);
+        send({ type: 'action_draft', draftId: msg.draftId, draft });
+    }
+    catch (err) {
+        console.error(`[AgentLink] getActionDraft failed for ${msg.draftId}:`, err);
+        send({ type: 'action_draft', draftId: msg.draftId, draft: null, error: String(err) });
+    }
+}
+async function handleCommitActionDraft(msg) {
+    try {
+        const result = await commitActionDraft(msg.draftId, msg.expectedRevision);
+        const actionItemId = String(result.action.action_item_id || result.draft.action_item_id || '');
+        send({
+            type: 'action_draft_committed',
+            draftId: msg.draftId,
+            actionItemId,
+            draft: result.draft,
+            action: result.action,
+        });
+    }
+    catch (err) {
+        console.error(`[AgentLink] commitActionDraft failed for ${msg.draftId}:`, err);
+        send({
+            type: 'action_draft_committed',
+            draftId: msg.draftId,
+            actionItemId: null,
+            error: String(err),
+        });
+    }
+}
+async function handleDiscardActionDraft(msg) {
+    try {
+        const draft = await discardActionDraft(msg.draftId);
+        send({ type: 'action_draft_discarded', draftId: msg.draftId, draft });
+    }
+    catch (err) {
+        console.error(`[AgentLink] discardActionDraft failed for ${msg.draftId}:`, err);
+        send({
+            type: 'action_draft_discarded',
+            draftId: msg.draftId,
+            draft: null,
+            error: String(err),
+        });
+    }
+}
 /**
  * Called when a recap chat session starts to check if it's linked to an action item.
  * If so, calls CLI `start` to transition the action item to 'running' status.
@@ -2400,4 +2648,35 @@ export function checkPendingActionItem(conversationId, claudeSessionId) {
         send({ type: 'action_item_started', actionItemId, sessionId: claudeSessionId, error: String(err) });
     });
 }
+function checkPendingActionDraft(conversationId, claudeSessionId) {
+    const pending = pendingActionDrafts.get(conversationId);
+    if (!pending)
+        return;
+    pendingActionDrafts.delete(conversationId);
+    const bind = (attempt) => {
+        console.log(`[AgentLink] Binding action draft ${pending.draftId} to session ${claudeSessionId} (attempt ${attempt + 1})`);
+        bindActionDraftSession(pending.draftId, claudeSessionId, pending.sessionCwd)
+            .then((draft) => {
+            send({ type: 'action_draft', draftId: pending.draftId, draft });
+        })
+            .catch((err) => {
+            if (attempt < 2) {
+                setTimeout(() => bind(attempt + 1), 500 * (attempt + 1));
+                return;
+            }
+            console.error('[AgentLink] bind action draft session failed:', err);
+            send({
+                type: 'action_draft',
+                draftId: pending.draftId,
+                draft: null,
+                error: String(err),
+            });
+        });
+    };
+    bind(0);
+}
+export function checkPendingSessionLinks(conversationId, claudeSessionId) {
+    checkPendingActionItem(conversationId, claudeSessionId);
+    checkPendingActionDraft(conversationId, claudeSessionId);
+}
 //# sourceMappingURL=connection.js.map