@junctionpanel/server 0.1.77 → 0.1.79

package/dist/server/server/session.js

@@ -1672,11 +1672,14 @@ export class Session {
         });
         if (worktreeArchiveTarget) {
             try {
-                await this.archiveJunctionWorktree({
+                const archiveResult = await this.archiveJunctionWorktree({
                     targetPath: worktreeArchiveTarget.targetPath,
                     repoRoot: worktreeArchiveTarget.repoRoot,
                     requestId,
                 });
+                if (!archiveResult.success || archiveResult.error) {
+                    throw new Error(archiveResult.error?.message ?? 'Failed to auto-archive worktree');
+                }
             }
             catch (error) {
                 this.sessionLogger.warn({ err: error, agentId, cwd: archivedRecord.cwd }, 'Failed to auto-archive worktree after agent archive');
@@ -5150,85 +5153,138 @@ export class Session {
         if (resolvedWorktree) {
             targetPath = resolvedWorktree.worktreePath;
         }
-        const removedAgents = new Set();
-        const preservedArchivedRecords = new Map();
-        const cleanedUpAt = new Date().toISOString();
-        const agents = this.agentManager.listAgents();
-        for (const agent of agents) {
-            if (this.isPathWithinRoot(targetPath, agent.cwd)) {
+        const archivedAt = new Date().toISOString();
+        const preDeleteArchivedWorktree = await this.buildArchivedWorktreeState(targetPath, archivedAt);
+        const recordsById = new Map((await this.agentStorage.list()).map((record) => [record.id, record]));
+        const liveAgents = this.agentManager
+            .listAgents()
+            .filter((agent) => this.isPathWithinRoot(targetPath, agent.cwd));
+        for (const agent of liveAgents) {
+            if (recordsById.has(agent.id)) {
+                continue;
+            }
+            await this.agentStorage.applySnapshot(agent, {
+                internal: agent.internal,
+            });
+            const record = await this.agentStorage.get(agent.id);
+            if (record) {
+                recordsById.set(record.id, record);
+            }
+        }
+        const internalRecordIds = new Set();
+        const archivedRecords = new Map();
+        const newlyArchivedRecordIds = new Set();
+        for (const record of recordsById.values()) {
+            if (!this.isPathWithinRoot(targetPath, record.cwd)) {
+                continue;
+            }
+            if (record.internal) {
+                internalRecordIds.add(record.id);
+                continue;
+            }
+            if (!record.archivedAt) {
+                newlyArchivedRecordIds.add(record.id);
+            }
+            archivedRecords.set(record.id, {
+                ...record,
+                archivedAt: record.archivedAt ?? archivedAt,
+                archivedWorktree: record.archivedWorktree ?? preDeleteArchivedWorktree,
+            });
+        }
+        const succeededArchivedAgentIds = [];
+        const succeededArchivedAgentIdSet = new Set();
+        let responseArchivedAt = null;
+        let responseError = null;
+        for (const [recordId, record] of archivedRecords.entries()) {
+            try {
+                await this.agentStorage.upsert(record);
+                if (newlyArchivedRecordIds.has(recordId) && !succeededArchivedAgentIdSet.has(recordId)) {
+                    succeededArchivedAgentIdSet.add(recordId);
+                    succeededArchivedAgentIds.push(recordId);
+                    responseArchivedAt = responseArchivedAt ?? record.archivedAt ?? archivedAt;
+                }
+            }
+            catch (error) {
+                if (!responseError) {
+                    responseError = this.toCheckoutError(error);
+                }
+                this.sessionLogger.warn({ err: error, agentId: recordId, cwd: record.cwd }, 'Failed to persist archived worktree record');
+            }
+        }
+        if (succeededArchivedAgentIdSet.size !== newlyArchivedRecordIds.size) {
+            return {
+                success: false,
+                archivedAgentIds: succeededArchivedAgentIds,
+                archivedAt: responseArchivedAt,
+                error: responseError ?? {
+                    code: 'UNKNOWN',
+                    message: 'Failed to persist archived records before worktree cleanup',
+                },
+            };
+        }
+        try {
+            for (const agent of liveAgents) {
                 try {
                     await this.agentManager.closeAgent(agent.id);
                 }
                 catch {
                     // ignore cleanup errors
                 }
-                const record = await this.agentStorage.get(agent.id);
-                if (record?.archivedAt) {
-                    preservedArchivedRecords.set(agent.id, {
-                        ...record,
-                        archivedWorktree: record.archivedWorktree
-                            ? {
-                                ...record.archivedWorktree,
-                                cleanupState: 'deleted',
-                                cleanedUpAt,
-                            }
-                            : record.archivedWorktree,
-                    });
-                    continue;
-                }
-                removedAgents.add(agent.id);
+            }
+            await this.killTerminalsUnderPath(targetPath);
+            await deleteJunctionWorktree({
+                cwd: options.repoRoot,
+                worktreePath: targetPath,
+                junctionHome: this.junctionHome,
+            });
+            const cleanedUpAt = new Date().toISOString();
+            const finalizedArchivedRecords = Array.from(archivedRecords.values()).map((record) => ({
+                ...record,
+                archivedWorktree: record.archivedWorktree
+                    ? {
+                        ...record.archivedWorktree,
+                        cleanupState: 'deleted',
+                        cleanedUpAt,
+                    }
+                    : record.archivedWorktree,
+            }));
+            const persistedFinalizedRecords = [];
+            for (const record of finalizedArchivedRecords) {
                 try {
-                    await this.agentStorage.remove(agent.id);
+                    await this.agentStorage.upsert(record);
+                    persistedFinalizedRecords.push(record);
                 }
-                catch {
-                    // ignore cleanup errors
+                catch (error) {
+                    if (!responseError) {
+                        responseError = this.toCheckoutError(error);
+                    }
+                    this.sessionLogger.warn({ err: error, agentId: record.id, cwd: record.cwd }, 'Failed to finalize archived worktree record');
                 }
             }
-        }
-        const registryRecords = await this.agentStorage.list();
-        for (const record of registryRecords) {
-            if (this.isPathWithinRoot(targetPath, record.cwd)) {
-                if (record.archivedAt) {
-                    preservedArchivedRecords.set(record.id, {
-                        ...record,
-                        archivedWorktree: record.archivedWorktree
-                            ? {
-                                ...record.archivedWorktree,
-                                cleanupState: 'deleted',
-                                cleanedUpAt,
-                            }
-                            : record.archivedWorktree,
-                    });
-                    continue;
-                }
-                removedAgents.add(record.id);
+            for (const recordId of internalRecordIds) {
                 try {
-                    await this.agentStorage.remove(record.id);
+                    await this.agentStorage.remove(recordId);
                 }
                 catch {
                     // ignore cleanup errors
                 }
             }
+            for (const record of persistedFinalizedRecords) {
+                await this.forwardStoredAgentRecordUpdate(record);
+            }
         }
-        await this.killTerminalsUnderPath(targetPath);
-        await deleteJunctionWorktree({
-            cwd: options.repoRoot,
-            worktreePath: targetPath,
-            junctionHome: this.junctionHome,
-        });
-        for (const record of preservedArchivedRecords.values()) {
-            await this.agentStorage.upsert(record);
-        }
-        for (const agentId of removedAgents) {
-            this.emit({
-                type: 'agent_deleted',
-                payload: {
-                    agentId,
-                    requestId: options.requestId,
-                },
-            });
+        catch (error) {
+            if (!responseError) {
+                responseError = this.toCheckoutError(error);
+            }
         }
-        return Array.from(removedAgents);
+        const success = responseError === null;
+        return {
+            success,
+            archivedAgentIds: succeededArchivedAgentIds,
+            archivedAt: succeededArchivedAgentIds.length > 0 ? responseArchivedAt ?? archivedAt : null,
+            error: responseError,
+        };
     }
     async handleJunctionWorktreeArchiveRequest(msg) {
         const { requestId } = msg;
@@ -5254,7 +5310,8 @@ export class Session {
                     type: 'junction_worktree_archive_response',
                     payload: {
                         success: false,
-                        removedAgents: [],
+                        archivedAgentIds: [],
+                        archivedAt: null,
                         error: {
                             code: 'NOT_ALLOWED',
                             message: 'Worktree is not a Junction-owned worktree',
@@ -5268,7 +5325,7 @@ export class Session {
             if (!repoRoot) {
                 throw new Error('Unable to resolve repo root for worktree');
             }
-            const removedAgents = await this.archiveJunctionWorktree({
+            const archiveResult = await this.archiveJunctionWorktree({
                 targetPath,
                 repoRoot,
                 requestId,
@@ -5276,9 +5333,7 @@ export class Session {
             this.emit({
                 type: 'junction_worktree_archive_response',
                 payload: {
-                    success: true,
-                    removedAgents,
-                    error: null,
+                    ...archiveResult,
                     requestId,
                 },
             });
@@ -5288,7 +5343,8 @@ export class Session {
                 type: 'junction_worktree_archive_response',
                 payload: {
                     success: false,
-                    removedAgents: [],
+                    archivedAgentIds: [],
+                    archivedAt: null,
                     error: this.toCheckoutError(error),
                     requestId,
                 },