@bbigbang/core 0.1.0

package/dist/services/workspaceToolSnapshotPanelSync.js

@@ -0,0 +1,293 @@
+import { deletePanelAttachmentArtifactRows, unlinkPanelAttachmentStoragePaths, } from '../web/panelLifecycle.js';
+import { getPanelById, insertPanel, insertPanelRows, listAllPanelRows, } from '../web/panels.js';
+import { ensureSurfaceOwner } from '../web/surfaceCollaborators.js';
+import { isPlainRecord, parseStateRowJson, } from './workspaceToolExecutionUtils.js';
+import { parseWorkspaceToolManifest } from './workspaceToolManifest.js';
+import { buildToolSnapshotPanelProjection, buildToolSnapshotSchemaFingerprint, deriveWorkspaceToolRuntimeState, workspaceToolRuntimeStateToPanelStatus, } from './workspaceToolPanelProjection.js';
+export class WorkspaceToolSnapshotPanelSyncer {
+    params;
+    constructor(params) {
+        this.params = params;
+    }
+    updateLatestState(params, options) {
+        const now = Date.now();
+        const staleCachedStoragePaths = [];
+        // Transaction boundary: the tool latest_state_json update and the
+        // tool-scoped snapshot panel rewrite commit or roll back together.
+        // The broadcast callback and stale media unlink happen only after commit.
+        const tx = this.db.transaction(() => {
+            this.db.prepare(`UPDATE workspace_tools
+            SET latest_state_json = ?,
+                updated_at = ?
+          WHERE tool_id = ?`).run(params.state ? JSON.stringify(params.state) : null, now, params.toolId);
+            const toolRow = this.db.prepare(`SELECT tool_id as toolId,
+                user_id as userId,
+                agent_id as agentId,
+                source_panel_id as sourcePanelId,
+                panel_id as panelId,
+                active_terminal_id as activeTerminalId,
+                maintenance_conversation_id as maintenanceConversationId,
+                allow_shared_exec as allowSharedExec,
+                manifest_json as manifestJson
+           FROM workspace_tools
+          WHERE tool_id = ?
+            AND deleted_at IS NULL
+          LIMIT 1`).get(params.toolId);
+            const snapshotConversationCandidate = toolRow?.maintenanceConversationId ?? params.maintenanceConversationId ?? null;
+            const snapshotConversationId = snapshotConversationCandidate
+                && this.conversations.getConversation(snapshotConversationCandidate)
+                ? snapshotConversationCandidate
+                : null;
+            if (toolRow?.maintenanceConversationId && !snapshotConversationId) {
+                this.db.prepare(`UPDATE workspace_tools
+              SET maintenance_conversation_id = NULL,
+                  updated_at = ?
+            WHERE tool_id = ?
+              AND maintenance_conversation_id = ?`).run(now, toolRow.toolId, toolRow.maintenanceConversationId);
+            }
+            if (toolRow && snapshotConversationId) {
+                const agent = this.conversations.getAgent(toolRow.agentId);
+                const manifest = parseWorkspaceToolManifest(toolRow.manifestJson);
+                const snapshotSync = this.syncPanel({
+                    panelId: toolRow.panelId,
+                    sourcePanelId: toolRow.sourcePanelId,
+                    toolId: toolRow.toolId,
+                    userId: toolRow.userId,
+                    agentId: toolRow.agentId,
+                    conversationId: snapshotConversationId,
+                    nodeId: agent?.nodeId ?? null,
+                    manifest,
+                    latestState: params.state,
+                    allowSharedExec: toolRow.allowSharedExec === 1,
+                    status: this.resolveDefaultToolPanelStatus(toolRow.toolId, toolRow.activeTerminalId),
+                });
+                if (snapshotSync.panelId !== toolRow.panelId) {
+                    this.db.prepare(`UPDATE workspace_tools
+                SET panel_id = ?,
+                    updated_at = ?
+              WHERE tool_id = ?`).run(snapshotSync.panelId, now, toolRow.toolId);
+                }
+                staleCachedStoragePaths.push(...snapshotSync.staleCachedStoragePaths);
+            }
+        });
+        tx();
+        options?.onCommitted?.();
+        unlinkPanelAttachmentStoragePaths(staleCachedStoragePaths);
+    }
+    syncForTool(toolId, status) {
+        const toolRow = this.db.prepare(`SELECT tool_id as toolId,
+              user_id as userId,
+              agent_id as agentId,
+              source_panel_id as sourcePanelId,
+              panel_id as panelId,
+              active_terminal_id as activeTerminalId,
+              maintenance_conversation_id as maintenanceConversationId,
+              allow_shared_exec as allowSharedExec,
+              manifest_json as manifestJson,
+              latest_state_json as latestStateJson
+         FROM workspace_tools
+        WHERE tool_id = ?
+          AND deleted_at IS NULL
+        LIMIT 1`).get(toolId);
+        if (!toolRow)
+            return;
+        if (!toolRow.panelId && !toolRow.maintenanceConversationId)
+            return;
+        if (toolRow.maintenanceConversationId && !this.conversations.getConversation(toolRow.maintenanceConversationId)) {
+            this.db.prepare(`UPDATE workspace_tools
+            SET maintenance_conversation_id = NULL,
+                updated_at = ?
+          WHERE tool_id = ?
+            AND maintenance_conversation_id = ?`).run(Date.now(), toolRow.toolId, toolRow.maintenanceConversationId);
+            if (!toolRow.panelId)
+                return;
+            toolRow.maintenanceConversationId = null;
+        }
+        const agent = this.conversations.getAgent(toolRow.agentId);
+        const manifest = parseWorkspaceToolManifest(toolRow.manifestJson);
+        const snapshotSync = this.syncPanel({
+            panelId: toolRow.panelId,
+            sourcePanelId: toolRow.sourcePanelId,
+            toolId: toolRow.toolId,
+            userId: toolRow.userId,
+            agentId: toolRow.agentId,
+            conversationId: toolRow.maintenanceConversationId ?? '',
+            nodeId: agent?.nodeId ?? null,
+            manifest,
+            latestState: parseStateRowJson(toolRow.latestStateJson ?? null),
+            allowSharedExec: toolRow.allowSharedExec === 1,
+            status: status ?? this.resolveDefaultToolPanelStatus(toolRow.toolId, toolRow.activeTerminalId),
+        });
+        if (snapshotSync.panelId !== toolRow.panelId) {
+            this.db.prepare(`UPDATE workspace_tools
+            SET panel_id = ?,
+                updated_at = ?
+          WHERE tool_id = ?`).run(snapshotSync.panelId, Date.now(), toolRow.toolId);
+        }
+        unlinkPanelAttachmentStoragePaths(snapshotSync.staleCachedStoragePaths);
+    }
+    syncPanel(spec) {
+        const now = Date.now();
+        const existing = spec.panelId ? getPanelById(this.db, spec.panelId) : null;
+        const sourcePanel = spec.sourcePanelId
+            ? getPanelById(this.db, spec.sourcePanelId)
+            : null;
+        const sourceProps = sourcePanel?.component === 'RowTemplateGrid' && !sourcePanel.archivedAt && isPlainRecord(sourcePanel.props)
+            ? sourcePanel.props
+            : spec.sourcePanelId && existing?.component === 'RowTemplateGrid' && isPlainRecord(existing.props)
+                ? existing.props
+                : null;
+        const liveSourceRows = sourcePanel && !sourcePanel.archivedAt && sourceProps
+            ? listAllPanelRows(this.db, sourcePanel.id).map((sourceRow) => ({
+                rowId: sourceRow.rowId,
+                fields: sourceRow.fields,
+                media: sourceRow.media,
+                nodeId: sourceRow.nodeId ?? spec.nodeId,
+                cachedAssetIds: {},
+            }))
+            : [];
+        const preservedSnapshotRows = liveSourceRows.length === 0 && spec.sourcePanelId && existing?.component === 'RowTemplateGrid'
+            ? listAllPanelRows(this.db, existing.id)
+                .filter((existingRow) => existingRow.rowId !== 'tool-state')
+                .map((existingRow) => ({
+                rowId: existingRow.rowId,
+                fields: existingRow.fields,
+                media: existingRow.media,
+                nodeId: existingRow.nodeId ?? spec.nodeId,
+                cachedAssetIds: {},
+            }))
+            : [];
+        const projection = buildToolSnapshotPanelProjection({
+            sourcePanelId: spec.sourcePanelId,
+            nodeId: spec.nodeId,
+            manifest: spec.manifest,
+            latestState: spec.latestState,
+            allowSharedExec: spec.allowSharedExec,
+            status: spec.status,
+            sourceProps,
+            sourceRows: liveSourceRows,
+            preservedRows: preservedSnapshotRows,
+        });
+        if (!existing || existing.archivedAt) {
+            const panelId = insertPanel(this.db, {
+                id: existing?.archivedAt ? undefined : (spec.panelId ?? undefined),
+                agentId: spec.agentId,
+                conversationId: spec.conversationId,
+                ownerUserId: spec.userId,
+                scopeType: 'tool',
+                scopeId: spec.toolId,
+                component: 'RowTemplateGrid',
+                props: projection.props,
+                actions: projection.actions,
+                rowCount: projection.rowCount,
+                status: spec.status ?? 'idle',
+                result: projection.result,
+                createdAt: now,
+                updatedAt: now,
+            });
+            ensureSurfaceOwner(this.db, {
+                surfaceType: 'panel',
+                surfaceId: panelId,
+                agentId: spec.agentId,
+                createdAt: now,
+            });
+            if (projection.rows.length > 0) {
+                insertPanelRows(this.db, projection.rows.map((row, rowIndex) => ({
+                    panelId,
+                    rowIndex,
+                    rowId: row.rowId,
+                    fields: row.fields,
+                    media: row.media,
+                    nodeId: row.nodeId,
+                    cachedAssetIds: row.cachedAssetIds ?? {},
+                })));
+            }
+            return { panelId, staleCachedStoragePaths: [] };
+        }
+        const previousSchemaFingerprint = buildToolSnapshotSchemaFingerprint(existing.props ?? {});
+        const staleCachedAssetIds = listPanelCachedAssetIds(this.db, existing.id);
+        const staleCachedStoragePaths = this.db.transaction(() => {
+            this.db.prepare(`UPDATE panels
+            SET conversation_id = ?,
+                owner_user_id = ?,
+                scope_type = 'tool',
+                scope_id = ?,
+                component = 'RowTemplateGrid',
+                props_json = ?,
+                actions_json = ?,
+                row_count = ?,
+                status = ?,
+                progress_json = NULL,
+                result_json = ?,
+                updated_at = ?,
+                version = version + 1
+          WHERE id = ?`).run(spec.conversationId, spec.userId, spec.toolId, JSON.stringify(projection.props), JSON.stringify(projection.actions), projection.rowCount, spec.status ?? existing.status, projection.result ? JSON.stringify(projection.result) : null, now, existing.id);
+            ensureSurfaceOwner(this.db, {
+                surfaceType: 'panel',
+                surfaceId: existing.id,
+                agentId: spec.agentId,
+                createdAt: now,
+            });
+            if (previousSchemaFingerprint !== projection.schemaFingerprint) {
+                this.db.prepare(`DELETE FROM panel_state WHERE panel_id = ?`).run(existing.id);
+                this.db.prepare(`DELETE FROM panel_shared_state WHERE panel_id = ?`).run(existing.id);
+            }
+            const storagePaths = deletePanelAttachmentArtifactRows(this.db, {
+                panelId: existing.id,
+                attachmentIds: staleCachedAssetIds,
+            });
+            this.db.prepare('DELETE FROM panel_rows WHERE panel_id = ?').run(existing.id);
+            if (projection.rows.length > 0) {
+                insertPanelRows(this.db, projection.rows.map((row, rowIndex) => ({
+                    panelId: existing.id,
+                    rowIndex,
+                    rowId: row.rowId,
+                    fields: row.fields,
+                    media: row.media,
+                    nodeId: row.nodeId,
+                    cachedAssetIds: row.cachedAssetIds ?? {},
+                })));
+            }
+            return storagePaths;
+        })();
+        return { panelId: existing.id, staleCachedStoragePaths };
+    }
+    get db() {
+        return this.params.db;
+    }
+    get conversations() {
+        return this.params.conversations;
+    }
+    resolveDefaultToolPanelStatus(toolId, activeTerminalId) {
+        const lastRunRow = this.db.prepare(`SELECT status
+         FROM workspace_tool_runs
+        WHERE tool_id = ?
+        ORDER BY started_at DESC
+        LIMIT 1`).get(toolId);
+        return workspaceToolRuntimeStateToPanelStatus(deriveWorkspaceToolRuntimeState({
+            activeTerminalId,
+            lastRunStatus: lastRunRow?.status ?? null,
+        }));
+    }
+}
+function listPanelCachedAssetIds(db, panelId) {
+    const rows = db.prepare(`SELECT cached_asset_ids_json as cachedAssetIdsJson
+       FROM panel_rows
+      WHERE panel_id = ?`).all(panelId);
+    const assetIds = new Set();
+    for (const row of rows) {
+        try {
+            const parsed = JSON.parse(row.cachedAssetIdsJson ?? '{}');
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                continue;
+            for (const value of Object.values(parsed)) {
+                if (typeof value === 'string' && value.trim())
+                    assetIds.add(value);
+            }
+        }
+        catch {
+            // Malformed cache metadata should not block snapshot refresh.
+        }
+    }
+    return [...assetIds];
+}

package/dist/services/workspaceToolTerminalLifecycle.js

@@ -0,0 +1,283 @@
+import { log } from '@bbigbang/runtime-acp';
+import { parseWorkspaceToolManifest } from './workspaceToolManifest.js';
+import { deriveWorkspaceToolRuntimeState, workspaceToolRuntimeStateToPanelStatus, } from './workspaceToolPanelProjection.js';
+import { WorkspaceToolServiceError } from './workspaceToolErrors.js';
+const DEFAULT_PERSISTENT_MAX_RUN_SECONDS = 24 * 60 * 60;
+const PERSISTENT_RUNTIME_ACTION_TIMEOUT_MS = 120_000;
+const DEFAULT_PERSISTENT_RUNTIME_IDLE_TTL_SECONDS = 900;
+const DEFAULT_WORKSPACE_TOOL_MAX_ACTIVE_PERSISTENT_RUNS_PER_AGENT = 3;
+export class WorkspaceToolTerminalLifecycle {
+    deps;
+    activeTerminalBuffers;
+    activePersistentTimeouts = new Map();
+    activePersistentIdleTimeouts = new Map();
+    activePersistentStartupCaptureTimeouts = new Map();
+    terminatingPersistentTerminals = new Set();
+    maxActivePersistentRunsPerAgent;
+    constructor(deps, activeTerminalBuffers) {
+        this.deps = deps;
+        this.activeTerminalBuffers = activeTerminalBuffers;
+        this.maxActivePersistentRunsPerAgent =
+            typeof deps.maxActivePersistentRunsPerAgent === 'number'
+                && Number.isInteger(deps.maxActivePersistentRunsPerAgent)
+                && deps.maxActivePersistentRunsPerAgent > 0
+                ? deps.maxActivePersistentRunsPerAgent
+                : DEFAULT_WORKSPACE_TOOL_MAX_ACTIVE_PERSISTENT_RUNS_PER_AGENT;
+    }
+    getContext(terminalId) {
+        return this.activeTerminalBuffers.get(terminalId);
+    }
+    hasContext(terminalId) {
+        return this.activeTerminalBuffers.has(terminalId);
+    }
+    setContext(terminalId, ctx) {
+        this.activeTerminalBuffers.set(terminalId, ctx);
+    }
+    deleteContext(terminalId) {
+        this.activeTerminalBuffers.delete(terminalId);
+    }
+    isTerminating(terminalId) {
+        return this.terminatingPersistentTerminals.has(terminalId);
+    }
+    assertAgentPersistentRunQuota(agentId) {
+        const row = this.deps.db.prepare(`SELECT COUNT(*) as count
+         FROM workspace_tools
+        WHERE agent_id = ?
+          AND deleted_at IS NULL
+          AND active_terminal_id IS NOT NULL`).get(agentId);
+        if (row.count >= this.maxActivePersistentRunsPerAgent) {
+            throw new WorkspaceToolServiceError(`Agent already has ${this.maxActivePersistentRunsPerAgent} active persistent workspace-tool terminals. Stop one before starting another.`, 409);
+        }
+    }
+    finishActivePersistentRun(toolId, terminalId, completion) {
+        const run = this.deps.db.prepare(`SELECT run_id as runId
+         FROM workspace_tool_runs
+        WHERE tool_id = ?
+          AND terminal_id = ?
+          AND status = 'running'
+        ORDER BY started_at DESC
+        LIMIT 1`).get(toolId, terminalId);
+        this.deps.db.prepare(`UPDATE workspace_tools
+          SET active_terminal_id = NULL,
+              updated_at = ?
+        WHERE tool_id = ?
+          AND active_terminal_id = ?`).run(Date.now(), toolId, terminalId);
+        this.deps.onBeforeFinish?.(terminalId, run?.runId ?? null);
+        this.activeTerminalBuffers.delete(terminalId);
+        this.clearPersistentRunTimeout(terminalId);
+        this.clearPersistentIdleTimeout(terminalId);
+        this.clearPersistentStartupCaptureTimeout(terminalId);
+        if (run) {
+            this.deps.runLedger.completeRun(run.runId, {
+                status: completion.status,
+                endedAt: Date.now(),
+                exitCode: completion.exitCode ?? null,
+                signal: completion.signal ?? null,
+            });
+        }
+        this.syncStatusBestEffort(toolId, completion);
+    }
+    reattachActivePersistentTerminal(row, nodeId) {
+        let manifest;
+        try {
+            manifest = parseWorkspaceToolManifest(row.manifestJson);
+        }
+        catch (error) {
+            log.warn('[workspace-tools] active terminal reconcile skipped invalid manifest', {
+                toolId: row.toolId,
+                terminalId: row.activeTerminalId,
+                error: String(error?.message ?? error),
+            });
+            return false;
+        }
+        const alreadyBuffered = this.activeTerminalBuffers.has(row.activeTerminalId);
+        if (!alreadyBuffered) {
+            this.activeTerminalBuffers.set(row.activeTerminalId, {
+                toolId: row.toolId,
+                runId: row.runningRunId,
+                userId: row.userId,
+                agentId: row.agentId,
+                agentNodeId: nodeId,
+                maintenanceConversationId: row.maintenanceConversationId,
+                manifest,
+                lineBuffer: '',
+            });
+        }
+        const action = row.runningActionId
+            ? manifest.actions.find((candidate) => candidate.actionId === row.runningActionId)
+            : undefined;
+        if (manifest.runtime?.mode !== 'persistent_runtime') {
+            this.schedulePersistentRunTimeout({
+                toolId: row.toolId,
+                agentNodeId: nodeId,
+                terminalId: row.activeTerminalId,
+                maxRunSeconds: action?.maxRunSeconds,
+                startedAt: row.runStartedAt ?? undefined,
+            });
+        }
+        else if (row.runningRunId) {
+            this.schedulePersistentRunTimeout({
+                toolId: row.toolId,
+                agentNodeId: nodeId,
+                terminalId: row.activeTerminalId,
+                maxRunSeconds: action?.maxRunSeconds ?? (PERSISTENT_RUNTIME_ACTION_TIMEOUT_MS / 1000),
+                startedAt: row.runStartedAt ?? undefined,
+            });
+        }
+        else {
+            this.clearPersistentRunTimeout(row.activeTerminalId);
+        }
+        const ctx = this.activeTerminalBuffers.get(row.activeTerminalId);
+        if (ctx) {
+            ctx.idleTimeoutSeconds = manifest.runtime?.mode === 'persistent_runtime'
+                ? manifest.runtime.idleTtlSeconds ?? DEFAULT_PERSISTENT_RUNTIME_IDLE_TTL_SECONDS
+                : action?.idleTimeoutSeconds;
+            this.resetPersistentIdleTimeout(row.activeTerminalId);
+        }
+        return !alreadyBuffered;
+    }
+    async handleTerminalTermination(event) {
+        this.terminatingPersistentTerminals.add(event.terminalId);
+        try {
+            const row = this.deps.db.prepare(`SELECT tool_id as toolId,
+                user_id as userId
+           FROM workspace_tools
+          WHERE active_terminal_id = ?
+            AND deleted_at IS NULL
+          LIMIT 1`).get(event.terminalId);
+            if (!row)
+                return;
+            await this.deps.enqueueToolMutation(row.toolId, async () => {
+                const current = this.deps.db.prepare(`SELECT active_terminal_id as activeTerminalId
+             FROM workspace_tools
+            WHERE tool_id = ?`).get(row.toolId);
+                if (!current?.activeTerminalId || current.activeTerminalId !== event.terminalId) {
+                    return;
+                }
+                const status = event.exitCode === 0
+                    ? 'completed'
+                    : event.disposed && event.exitCode == null
+                        ? 'cancelled'
+                        : 'failed';
+                this.finishActivePersistentRun(row.toolId, event.terminalId, {
+                    status,
+                    exitCode: event.exitCode ?? null,
+                    signal: event.signal ?? null,
+                });
+            });
+        }
+        finally {
+            this.terminatingPersistentTerminals.delete(event.terminalId);
+        }
+    }
+    schedulePersistentRunTimeout(params) {
+        this.clearPersistentRunTimeout(params.terminalId);
+        const seconds = params.maxRunSeconds ?? DEFAULT_PERSISTENT_MAX_RUN_SECONDS;
+        const elapsedMs = params.startedAt ? Math.max(0, Date.now() - params.startedAt) : 0;
+        const timeoutMs = Math.max(0, (seconds * 1000) - elapsedMs);
+        const handle = setTimeout(() => {
+            void Promise.resolve(this.handlePersistentRunTimeout({
+                toolId: params.toolId,
+                agentNodeId: params.agentNodeId,
+                terminalId: params.terminalId,
+                signal: 'timeout',
+            })).catch(() => {
+                // Timeouts are best-effort; the runner logs its own failures.
+            });
+        }, timeoutMs);
+        handle.unref?.();
+        this.activePersistentTimeouts.set(params.terminalId, handle);
+    }
+    resetPersistentIdleTimeout(terminalId) {
+        const ctx = this.activeTerminalBuffers.get(terminalId);
+        if (!ctx?.idleTimeoutSeconds) {
+            this.clearPersistentIdleTimeout(terminalId);
+            return;
+        }
+        this.schedulePersistentIdleTimeout({
+            toolId: ctx.toolId,
+            agentNodeId: ctx.agentNodeId,
+            terminalId,
+            idleTimeoutSeconds: ctx.idleTimeoutSeconds,
+        });
+    }
+    schedulePersistentIdleTimeout(params) {
+        this.clearPersistentIdleTimeout(params.terminalId);
+        const handle = setTimeout(() => {
+            void Promise.resolve(this.handlePersistentRunTimeout({
+                toolId: params.toolId,
+                agentNodeId: params.agentNodeId,
+                terminalId: params.terminalId,
+                signal: 'idle_timeout',
+            })).catch(() => {
+                // Timeouts are best-effort; the runner logs its own failures.
+            });
+        }, params.idleTimeoutSeconds * 1000);
+        handle.unref?.();
+        this.activePersistentIdleTimeouts.set(params.terminalId, handle);
+    }
+    clearPersistentRunTimeout(terminalId) {
+        const handle = this.activePersistentTimeouts.get(terminalId);
+        if (!handle)
+            return;
+        clearTimeout(handle);
+        this.activePersistentTimeouts.delete(terminalId);
+    }
+    clearPersistentIdleTimeout(terminalId) {
+        const handle = this.activePersistentIdleTimeouts.get(terminalId);
+        if (!handle)
+            return;
+        clearTimeout(handle);
+        this.activePersistentIdleTimeouts.delete(terminalId);
+    }
+    clearPersistentStartupCaptureTimeout(terminalId) {
+        const handle = this.activePersistentStartupCaptureTimeouts.get(terminalId);
+        if (!handle)
+            return;
+        clearTimeout(handle);
+        this.activePersistentStartupCaptureTimeouts.delete(terminalId);
+    }
+    schedulePersistentStartupSnapshotFallback(params) {
+        this.clearPersistentStartupCaptureTimeout(params.terminalId);
+        const timer = setTimeout(() => {
+            this.activePersistentStartupCaptureTimeouts.delete(params.terminalId);
+            void Promise.resolve(params.onFallback()).catch(() => {
+                // Fallback is best-effort.
+            });
+        }, params.delayMs);
+        timer.unref?.();
+        this.activePersistentStartupCaptureTimeouts.set(params.terminalId, timer);
+    }
+    async handlePersistentRunTimeout(params) {
+        await this.deps.enqueueToolMutation(params.toolId, async () => {
+            const current = this.deps.db.prepare(`SELECT active_terminal_id as activeTerminalId
+           FROM workspace_tools
+          WHERE tool_id = ?
+            AND deleted_at IS NULL`).get(params.toolId);
+            if (!current?.activeTerminalId || current.activeTerminalId !== params.terminalId) {
+                this.clearPersistentRunTimeout(params.terminalId);
+                this.clearPersistentIdleTimeout(params.terminalId);
+                return;
+            }
+            this.clearPersistentRunTimeout(params.terminalId);
+            this.clearPersistentIdleTimeout(params.terminalId);
+            await this.deps.terminalBroker.closeTerminal(params.agentNodeId, params.terminalId);
+            this.finishActivePersistentRun(params.toolId, params.terminalId, {
+                status: 'timed_out',
+                signal: params.signal ?? 'timeout',
+            });
+        });
+    }
+    syncStatusBestEffort(toolId, completion) {
+        this.deps.latestStateProjector.syncStatusBestEffort(toolId, workspaceToolRuntimeStateToPanelStatus(deriveWorkspaceToolRuntimeState({
+            activeTerminalId: null,
+            lastRunStatus: completion.status,
+        })));
+    }
+}
+export function persistentRuntimeActionTimeoutMs(action) {
+    return action.maxRunSeconds ? action.maxRunSeconds * 1000 : PERSISTENT_RUNTIME_ACTION_TIMEOUT_MS;
+}
+export function defaultPersistentRuntimeIdleTtlSeconds() {
+    return DEFAULT_PERSISTENT_RUNTIME_IDLE_TTL_SECONDS;
+}

package/dist/services/workspaceToolTypes.js

@@ -0,0 +1 @@
+export {};