zidane 5.6.14 → 5.7.4

package/dist/chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat.d.ts","names":[],"sources":["../src/chat/agent-prompt.ts","../src/chat/agents-md.ts","../src/chat/auto-compact.ts","../src/chat/auto-update.ts","../src/chat/auto-update-cli.ts","../src/chat/auto-update-hook.ts","../src/chat/boot-profiler.ts","../src/chat/browser.ts","../src/chat/color-gradient.ts","../src/chat/files-discovery.ts","../src/chat/completion-files.ts","../src/chat/completion-skills.ts","../src/chat/config-context.tsx","../src/chat/credentials.ts","../src/chat/discovery-context.tsx","../src/chat/discovery-slot.ts","../src/chat/edit-approval.ts","../src/tools/edit-utils.ts","../src/chat/edit-diff.ts","../src/chat/footer-hints.ts","../src/chat/format.ts","../src/chat/generate-title.ts","../src/chat/mcp-auth-state.ts","../src/chat/mcp-auth-context.tsx","../src/chat/mcp-credentials.ts","../src/chat/mcp-rows.ts","../src/chat/mcp-tool-toggle.ts","../src/chat/mcp-tools-cache.ts","../src/chat/model-catalog.ts","../src/chat/oauth.ts","../src/chat/oauth-redirect.ts","../src/chat/path-display.ts","../src/chat/project-root.ts","../src/chat/project-user-paths.ts","../src/chat/safe-mode.ts","../src/chat/settings-context.tsx","../src/chat/skills-discovery.ts","../src/chat/streaming.ts","../src/chat/theme-context.tsx","../src/chat/themes/catppuccin.ts","../src/chat/themes/gruvbox.ts","../src/chat/themes/vaporwave.ts","../src/chat/todos.ts","../src/chat/turn-operations.ts"],"mappings":"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"}
+{"version":3,"file":"chat.d.ts","names":[],"sources":["../src/chat/agent-prompt.ts","../src/chat/agents-md.ts","../src/chat/auto-compact.ts","../src/chat/auto-update.ts","../src/chat/auto-update-cli.ts","../src/chat/auto-update-hook.ts","../src/chat/boot-profiler.ts","../src/chat/browser.ts","../src/chat/config-context.tsx","../src/chat/credentials.ts","../src/chat/discovery-context.tsx","../src/chat/discovery-slot.ts","../src/chat/footer-hints.ts","../src/chat/generate-title.ts","../src/chat/mcp-auth-state.ts","../src/chat/mcp-auth-context.tsx","../src/chat/mcp-credentials.ts","../src/chat/mcp-rows.ts","../src/chat/mcp-tool-toggle.ts","../src/chat/mcp-tools-cache.ts","../src/chat/oauth.ts","../src/chat/oauth-redirect.ts","../src/chat/path-display.ts","../src/chat/project-root.ts","../src/chat/project-user-paths.ts","../src/chat/safe-mode.ts","../src/chat/settings-context.tsx","../src/chat/skills-discovery.ts","../src/chat/streaming.ts","../src/chat/theme-context.tsx","../src/chat/themes/catppuccin.ts","../src/chat/themes/gruvbox.ts","../src/chat/themes/vaporwave.ts","../src/chat/todos.ts"],"mappings":"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"}

package/dist/chat.js

@@ -1,5 +1,7 @@
-import { $ as mcpToolsCachePath, $n as KEYBINDING_DEF_BY_ACTION, $r as getModelInfo, $t as CATPPUCCIN_FRAPPE, A as getSafelist, Ai as useActiveTodos, An as turnSelectionOwnership, Ar as detectLibc, At as clipHintsToWidth, B as oauthUsesManualCodePaste, Bi as TOKEN_DISCIPLINE_DOCTRINE, Bn as splitLines, Br as credentialsPath, Bt as SETTINGS_CATEGORIES, C as resolveSessionExportTarget, Ci as getArchivedTodosForRun, Cn as saveState, Cr as tryOpenBrowser, Ct as isInteractionTool, D as useSafeModeQueue, Di as pruneTodosByRun, Dn as titleFromTurns, Dr as useUpdateCheck, Dt as useInteractionsActions, E as useSafeModeActions, Ei as pickActiveRunId, En as sumRunCosts, Er as buildUpdateHint, Et as serializeInteractionResponse, F as suggestSafelistEntry, Fi as INTERACTION_GUIDANCE, Fn as computeInlineDiff, Fr as resolvePlatformPackage, Ft as buildHints, G as indexOfEntry, Gn as mergeApprovalAndBodyOutcomes, Gr as writeCredentials, Gt as useSettings, H as supportsOAuth, Hi as buildPlanSystem, Hn as tokenize, Hr as readProviderCredential, Ht as SETTINGS_TOGGLES, I as writeProjects, Ii as INTERACTION_GUIDANCE_NO_PROMPTS, In as computeLineDiff, Ir as AUTO_COMPACT_MIN_GROWTH_FRACTION, It as shortChord, J as discoverProjectMcps, Jn as rewriteMultiEditHeader, Jr as anthropicDescriptor, Jt as resolveChipColor, K as buildMcpServers, Kn as parseEditOutcomesFromResult, Kr as BUILTIN_PROVIDERS, Kt as BUILTIN_THEMES, L as splitPromptSegments, Li as PLAN_MODE_DOCTRINE, Ln as extractEditPayload, Lr as shouldAutoCompact, Lt as listProjectFiles, M as matchesSafelistEntry, Mi as COMMUNICATION_DOCTRINE, Mn as applyEditPayload, Mr as parseSemver, Mt as truncateTrailing, N as projectsFilePath, Ni as DOING_TASKS_DOCTRINE, Nn as buildContextualDiff, Nr as performInPlaceSelfUpdate, Nt as cleanTitle, O as IMPLICITLY_SAFE_TOOLS, Oi as selectActiveTodos, On as toolCallPreview, Or as checkForUpdate, Ot as useInteractionsQueue, P as readProjects, Pi as IDENTITY_PREFIX, Pn as buildUnifiedDiff, Pr as performSelfUpdate, Pt as generateSessionTitle, Q as loadMcpToolsCache, Qn as KEYBINDING_DEFS, Qr as getContextWindow, Qt as GRUVBOX_LIGHT, R as formatPathForCwd, Ri as PLAN_MODE_DOCTRINE_NO_PROMPTS, Rn as filetypeFromPath, Rr as detectAuth, Rt as useEnabledToggleSet, S as renderSession, Si as createTodoTools, Sn as marginTopFor, Sr as buildLinearRamp, St as createInteractionTools, T as SafeModeProvider, Ti as isTodoTool, Tn as stripSpawnTokensLine, Tr as bootTick, Tt as pendingInteractionsFromTurns, U as buildModelCatalog, Ui as envSection, Un as buildEditOutcomesAnnotation, Ur as removeProviderCredential, Ut as SettingsProvider, V as runOAuthLogin, Vi as buildBuildSystem, Vn as summarizeEditPayload, Vr as readCredentials, Vt as SETTINGS_CHOICES, W as filterModelCatalog, Wn as maskToOutcomeKinds, Wr as setProviderCredential, X as projectUserPaths, Xn as summarizeOutcomes, Xr as credKeyOf, Xt as VAPORWAVE_THEME, Y as parseMcpsFile, Yn as stripEditOutcomesAnnotation, Yr as cerebrasDescriptor, Yt as resolveTheme, Z as clearMcpToolsCache, Zn as DEFAULT_KEYBINDINGS, Zr as effectiveContextWindow, Zt as GRUVBOX_DARK, _ as turnContextSize, _i as TODOREAD_TOOL, _n as isTurnHighlighted, _r as collectReferences, _t as splitMarkdownCodeBlocks, a as computeTurnAnchors, ai as discoverAgentsMd, an as useDiscovery, ar as matchesBinding, at as useMcpToolToggleSet, b as defaultSkillScanPaths, bi as TODO_STATUS_GLYPHS, bn as listSessionMeta, br as useCompletion, bt as PRESENT_PLAN_TOOL, c as formatToolCall, ci as BUILD_AGENT, cn as useConfig, cr as readKeybindings, ct as parentServerName, d as useSelectStyle, di as DEFAULT_BUDGET_EXCLUDE_TOOLS, dn as resolveStorageDirs, dr as createSkillsCompletionProvider, dt as patchMcpCredential, ei as modelSupportsReasoning, en as CATPPUCCIN_LATTE, er as KEYBINDING_KEY_COL_WIDTH, et as refreshMcpToolsCatalog, f as useSurfaces, fi as DEFAULT_PERSIST_EXCLUDE_TOOLS, fr as uniqueSkillNamesFromReferences, ft as McpAuthProvider, g as finalizeStreamingMarkdownForOwner, gi as singleAgentRegistry, gn as isEditErrorResult, gr as applyInsert, gt as reduceMcpAuth, h as finalizeStreamingMarkdown, hi as resolveAgentId, hn as eventsFromTurns, hr as uniqueFilesFromReferences, ht as getMcpAuthStatus, i as turnAsText, ii as piIdOf, in as DiscoveryProvider, ir as keybindingsPath, it as useMcpToolToggleMap, j as isOnSafelist, ji as ACTIONS_WITH_CARE_DOCTRINE, jn as updateToolEventOutcomes, jr as detectPackageManager, jt as hintsLength, k as addToSafelist, ki as setTodosForRun, kn as toolResultText, kr as compareSemver, kt as EMPTY_HINTS, l as ThemeProvider, li as BUILTIN_AGENTS, ln as resolveConfig, lr as stripJsonComments, lt as createFileMcpCredentialStore, m as useTheme, mi as accentColor, mn as deriveSessionTitle, mr as createFilesCompletionProvider, mt as useMcpAuthState, n as deleteTurnSafely, ni as openaiDescriptor, nn as CATPPUCCIN_MOCHA, nr as formatBindingForDisplay, nt as subscribeMcpToolsCache, o as TOOL_DISPLAY, oi as renderAgentsMdBlock, on as useDiscoveryOptional, or as mergeKeybindings, ot as buildVisibleMcpRows, p as useSyntaxStyles, pi as PLAN_AGENT, pn as createStateStore, pr as FILES_TRIGGER, pt as useMcpAuthDispatch, q as defaultMcpsConfigPaths, qn as resolveApprovalForPayload, qr as OUTPUT_RESERVE_TOKENS, qt as DEFAULT_THEME, r as truncateTurnsAt, ri as openrouterDescriptor, rn as createDiscoverySlot, rr as groupBindings, rt as buildToolToggle, s as displayNameFor, si as findGitRoot, sn as ConfigProvider, sr as parseBindingSpec, st as indexOfServerRow, t as countNeighbors, ti as modelsForDescriptor, tn as CATPPUCCIN_MACCHIATO, tr as ensureKeybindingsFile, tt as saveMcpToolsCache, u as useColors, ui as DEFAULT_AGENT_ID, un as resolveStoragePaths, ur as SKILLS_TRIGGER, ut as mcpCredentialsPath, v as useStreamBuffer, vi as TODOS_METADATA_KEY, vn as isVisible, vr as findActiveTrigger, vt as ASK_USER_TOOL, w as writeSessionExport, wi as getTodosForRun, wn as selectableTurnIds, wr as bootProfileEnabled, wt as makeRequestInteraction, x as discoverProjectSkills, xi as TODO_WRITE_COUNTS_METADATA_KEY, xn as loadState, xr as blendHsl, xt as buildResumedToolResultsTurn, y as buildSkillsConfig, yi as TODOWRITE_TOOL, yn as lastContextSizeFromTurns, yr as mergeReferences, yt as InteractionsProvider, z as fetchOAuthRedirect, zi as SUBAGENT_GUIDANCE, zn as previewEditPayload, zr as applyApiKeyEnv, zt as DEFAULT_SETTINGS } from "./turn-operations-UAkOjO-u.js";
-import { B as formatTaskStatus, H as previewLine, I as ageString, L as compactPath, R as fmtTokens, U as shortId, V as formatTaskSummary, z as formatDuration } from "./tools-DhrLrOEr.js";
+import { $ as useMcpAuthDispatch, $n as BUILD_AGENT, $t as deriveSessionTitle, A as runOAuthLogin, An as buildUpdateHint, Ar as SUBAGENT_GUIDANCE, B as refreshMcpToolsCatalog, Bn as AUTO_COMPACT_MIN_GROWTH_FRACTION, Bt as CATPPUCCIN_LATTE, C as projectsFilePath, Cn as parseBindingSpec, Cr as COMMUNICATION_DOCTRINE, Ct as listProjectFiles, D as formatPathForCwd, Dn as tryOpenBrowser, Dr as INTERACTION_GUIDANCE_NO_PROMPTS, Dt as SETTINGS_CHOICES, E as writeProjects, En as useCompletion, Er as INTERACTION_GUIDANCE, Et as SETTINGS_CATEGORIES, F as parseMcpsFile, Fn as detectPackageManager, Ft as resolveTheme, G as useMcpToolToggleSet, Gn as readCredentials, Gt as useDiscovery, H as subscribeMcpToolsCache, Hn as detectAuth, Ht as CATPPUCCIN_MOCHA, I as projectUserPaths, In as parseSemver, It as VAPORWAVE_THEME, J as parentServerName, Jn as setProviderCredential, Jt as useConfig, K as buildVisibleMcpRows, Kn as readProviderCredential, Kt as useDiscoveryOptional, L as clearMcpToolsCache, Ln as performInPlaceSelfUpdate, Lt as GRUVBOX_DARK, M as buildMcpServers, Mn as checkForUpdate, Mr as buildBuildSystem, Mt as BUILTIN_THEMES, N as defaultMcpsConfigPaths, Nn as compareSemver, Nr as buildPlanSystem, Nt as DEFAULT_THEME, O as fetchOAuthRedirect, On as bootProfileEnabled, Or as PLAN_MODE_DOCTRINE, Ot as SETTINGS_TOGGLES, P as discoverProjectMcps, Pn as detectLibc, Pr as envSection, Pt as resolveChipColor, Q as McpAuthProvider, Qn as findGitRoot, Qt as createStateStore, R as loadMcpToolsCache, Rn as performSelfUpdate, Rt as GRUVBOX_LIGHT, S as matchesSafelistEntry, Sn as mergeKeybindings, Sr as ACTIONS_WITH_CARE_DOCTRINE, St as shortChord, T as suggestSafelistEntry, Tn as stripJsonComments, Tr as IDENTITY_PREFIX, Tt as DEFAULT_SETTINGS, U as buildToolToggle, Un as applyApiKeyEnv, Ut as createDiscoverySlot, V as saveMcpToolsCache, Vn as shouldAutoCompact, Vt as CATPPUCCIN_MACCHIATO, W as useMcpToolToggleMap, Wn as credentialsPath, Wt as DiscoveryProvider, X as mcpCredentialsPath, Xn as discoverAgentsMd, Xt as resolveStoragePaths, Y as createFileMcpCredentialStore, Yn as writeCredentials, Yt as resolveConfig, Z as patchMcpCredential, Zn as renderAgentsMdBlock, Zt as resolveStorageDirs, _ as useSafeModeQueue, _n as ensureKeybindingsFile, _r as pickActiveRunId, _t as hintsLength, a as useSurfaces, an as saveState, ar as accentColor, at as InteractionsProvider, b as getSafelist, bn as keybindingsPath, br as setTodosForRun, bt as generateSessionTitle, c as useStreamBuffer, cn as sumRunCosts, cr as TODOREAD_TOOL, ct as createInteractionTools, d as discoverProjectSkills, dn as toolResultText, dr as TODO_STATUS_GLYPHS, dt as pendingInteractionsFromTurns, en as eventsFromTurns, er as BUILTIN_AGENTS, et as useMcpAuthState, f as renderSession, fn as updateToolEventOutcomes, fr as TODO_WRITE_COUNTS_METADATA_KEY, ft as serializeInteractionResponse, g as useSafeModeActions, gn as KEYBINDING_KEY_COL_WIDTH, gr as isTodoTool, gt as clipHintsToWidth, h as SafeModeProvider, hn as KEYBINDING_DEF_BY_ACTION, hr as getTodosForRun, ht as EMPTY_HINTS, i as useSelectStyle, in as marginTopFor, ir as PLAN_AGENT, it as ASK_USER_TOOL, j as supportsOAuth, jn as useUpdateCheck, jr as TOKEN_DISCIPLINE_DOCTRINE, jt as useSettings, k as oauthUsesManualCodePaste, kn as bootTick, kr as PLAN_MODE_DOCTRINE_NO_PROMPTS, kt as SettingsProvider, l as buildSkillsConfig, ln as titleFromTurns, lr as TODOS_METADATA_KEY, lt as isInteractionTool, m as writeSessionExport, mn as KEYBINDING_DEFS, mr as getArchivedTodosForRun, mt as useInteractionsQueue, n as ThemeProvider, nn as listSessionMeta, nr as DEFAULT_BUDGET_EXCLUDE_TOOLS, nt as reduceMcpAuth, o as useSyntaxStyles, or as resolveAgentId, ot as PRESENT_PLAN_TOOL, p as resolveSessionExportTarget, pn as DEFAULT_KEYBINDINGS, pr as createTodoTools, pt as useInteractionsActions, q as indexOfServerRow, qn as removeProviderCredential, qt as ConfigProvider, r as useColors, rn as loadState, rr as DEFAULT_PERSIST_EXCLUDE_TOOLS, rt as splitMarkdownCodeBlocks, s as useTheme, sn as stripSpawnTokensLine, sr as singleAgentRegistry, st as buildResumedToolResultsTurn, t as computeTurnAnchors, tn as lastContextSizeFromTurns, tr as DEFAULT_AGENT_ID, tt as getMcpAuthStatus, u as defaultSkillScanPaths, un as toolCallPreview, ur as TODOWRITE_TOOL, ut as makeRequestInteraction, v as IMPLICITLY_SAFE_TOOLS, vn as formatBindingForDisplay, vr as pruneTodosByRun, vt as truncateTrailing, w as readProjects, wn as readKeybindings, wr as DOING_TASKS_DOCTRINE, wt as useEnabledToggleSet, x as isOnSafelist, xn as matchesBinding, xr as useActiveTodos, xt as buildHints, y as addToSafelist, yn as groupBindings, yr as selectActiveTodos, yt as cleanTitle, z as mcpToolsCachePath, zn as resolvePlatformPackage, zt as CATPPUCCIN_FRAPPE } from "./transcript-anchors-BTSZAPVc.js";
+import { B as enabledModelOptions, F as OUTPUT_RESERVE_TOKENS, G as modelSupportsReasoning, H as getModelInfo, I as anthropicDescriptor, J as openrouterDescriptor, K as modelsForDescriptor, L as cerebrasDescriptor, P as BUILTIN_PROVIDERS, R as credKeyOf, U as localDescriptor, V as getContextWindow, W as modelOptionsFor, X as restoreModelOptions, Y as piIdOf, q as openaiDescriptor, z as effectiveContextWindow } from "./tools-BGtJK0vo.js";
+import { a as compactPath, c as formatTaskStatus, d as shortId, f as buildContextBreakdown, i as ageString, l as formatTaskSummary, o as fmtTokens, s as formatDuration, u as previewLine } from "./edit-utils-DnfNoj16.js";
+import { A as splitLines, B as summarizeOutcomes, C as buildContextualDiff, D as extractEditPayload, E as computeLineDiff, F as mergeApprovalAndBodyOutcomes, G as createFilesCompletionProvider, H as createSkillsCompletionProvider, I as parseEditOutcomesFromResult, J as collectReferences, K as uniqueFilesFromReferences, L as resolveApprovalForPayload, M as tokenize, N as buildEditOutcomesAnnotation, O as filetypeFromPath, P as maskToOutcomeKinds, Q as buildLinearRamp, R as rewriteMultiEditHeader, S as applyEditPayload, T as computeInlineDiff, U as uniqueSkillNamesFromReferences, V as SKILLS_TRIGGER, W as FILES_TRIGGER, X as mergeReferences, Y as findActiveTrigger, Z as blendHsl, _ as isEditErrorResult, a as TOOL_DISPLAY, b as selectableTurnIds, c as finalizeStreamingMarkdown, d as turnContextSize, f as splitPromptSegments, h as indexOfEntry, i as turnAsText, j as summarizeEditPayload, k as previewEditPayload, l as finalizeStreamingMarkdownForOwner, m as filterModelCatalog, n as deleteTurnSafely, o as displayNameFor, p as buildModelCatalog, q as applyInsert, r as truncateTurnsAt, s as formatToolCall, t as countNeighbors, v as isTurnHighlighted, w as buildUnifiedDiff, x as turnSelectionOwnership, y as isVisible, z as stripEditOutcomesAnnotation } from "./turn-operations-CCHfR9eC.js";
 //#region src/chat/auto-update-cli.ts
 const UPGRADE_HELP = `Usage: zidane upgrade [options]
 
@@ -198,6 +200,6 @@ function parseArgs(argv) {
 	};
 }
 //#endregion
-export { ACTIONS_WITH_CARE_DOCTRINE, ASK_USER_TOOL, AUTO_COMPACT_MIN_GROWTH_FRACTION, BUILD_AGENT, BUILTIN_AGENTS, BUILTIN_PROVIDERS, BUILTIN_THEMES, CATPPUCCIN_FRAPPE, CATPPUCCIN_LATTE, CATPPUCCIN_MACCHIATO, CATPPUCCIN_MOCHA, COMMUNICATION_DOCTRINE, ConfigProvider, DEFAULT_AGENT_ID, DEFAULT_BUDGET_EXCLUDE_TOOLS, DEFAULT_KEYBINDINGS, DEFAULT_PERSIST_EXCLUDE_TOOLS, DEFAULT_SETTINGS, DEFAULT_THEME, DOING_TASKS_DOCTRINE, DiscoveryProvider, EMPTY_HINTS, FILES_TRIGGER, GRUVBOX_DARK, GRUVBOX_LIGHT, IDENTITY_PREFIX, IMPLICITLY_SAFE_TOOLS, INTERACTION_GUIDANCE, INTERACTION_GUIDANCE_NO_PROMPTS, InteractionsProvider, KEYBINDING_DEFS, KEYBINDING_DEF_BY_ACTION, KEYBINDING_KEY_COL_WIDTH, McpAuthProvider, OUTPUT_RESERVE_TOKENS, PLAN_AGENT, PLAN_MODE_DOCTRINE, PLAN_MODE_DOCTRINE_NO_PROMPTS, PRESENT_PLAN_TOOL, SETTINGS_CATEGORIES, SETTINGS_CHOICES, SETTINGS_TOGGLES, SKILLS_TRIGGER, SUBAGENT_GUIDANCE, SafeModeProvider, SettingsProvider, TODOREAD_TOOL, TODOS_METADATA_KEY, TODOWRITE_TOOL, TODO_STATUS_GLYPHS, TODO_WRITE_COUNTS_METADATA_KEY, TOKEN_DISCIPLINE_DOCTRINE, TOOL_DISPLAY, ThemeProvider, VAPORWAVE_THEME, accentColor, addToSafelist, ageString, anthropicDescriptor, applyApiKeyEnv, applyEditPayload, applyInsert, blendHsl, bootProfileEnabled, bootTick, buildBuildSystem, buildContextualDiff, buildEditOutcomesAnnotation, buildHints, buildLinearRamp, buildMcpServers, buildModelCatalog, buildPlanSystem, buildResumedToolResultsTurn, buildSkillsConfig, buildToolToggle, buildUnifiedDiff, buildUpdateHint, buildVisibleMcpRows, cerebrasDescriptor, checkForUpdate, cleanTitle, clearMcpToolsCache, clipHintsToWidth, collectReferences, compactPath, compareSemver, computeInlineDiff, computeLineDiff, computeTurnAnchors, countNeighbors, createDiscoverySlot, createFileMcpCredentialStore, createFilesCompletionProvider, createInteractionTools, createSkillsCompletionProvider, createStateStore, createTodoTools, credKeyOf, credentialsPath, defaultMcpsConfigPaths, defaultSkillScanPaths, deleteTurnSafely, deriveSessionTitle, detectAuth, detectLibc, detectPackageManager, discoverAgentsMd, discoverProjectMcps, discoverProjectSkills, displayNameFor, effectiveContextWindow, ensureKeybindingsFile, envSection, eventsFromTurns, extractEditPayload, fetchOAuthRedirect, filetypeFromPath, filterModelCatalog, finalizeStreamingMarkdown, finalizeStreamingMarkdownForOwner, findActiveTrigger, findGitRoot, fmtTokens, formatBindingForDisplay, formatDuration, formatPathForCwd, formatTaskStatus, formatTaskSummary, formatToolCall, generateSessionTitle, getArchivedTodosForRun, getContextWindow, getMcpAuthStatus, getModelInfo, getSafelist, getTodosForRun, groupBindings, hintsLength, indexOfEntry, indexOfServerRow, isEditErrorResult, isInteractionTool, isOnSafelist, isTodoTool, isTurnHighlighted, isVisible, keybindingsPath, lastContextSizeFromTurns, listProjectFiles, listSessionMeta, loadMcpToolsCache, loadState, makeRequestInteraction, marginTopFor, maskToOutcomeKinds, matchesBinding, matchesSafelistEntry, mcpCredentialsPath, mcpToolsCachePath, mergeApprovalAndBodyOutcomes, mergeKeybindings, mergeReferences, modelSupportsReasoning, modelsForDescriptor, oauthUsesManualCodePaste, openaiDescriptor, openrouterDescriptor, parentServerName, parseBindingSpec, parseEditOutcomesFromResult, parseMcpsFile, parseSemver, patchMcpCredential, pendingInteractionsFromTurns, performInPlaceSelfUpdate, performSelfUpdate, piIdOf, pickActiveRunId, previewEditPayload, previewLine, projectUserPaths, projectsFilePath, pruneTodosByRun, readCredentials, readKeybindings, readProjects, readProviderCredential, reduceMcpAuth, refreshMcpToolsCatalog, removeProviderCredential, renderAgentsMdBlock, renderSession, resolveAgentId, resolveApprovalForPayload, resolveChipColor, resolveConfig, resolvePlatformPackage, resolveSessionExportTarget, resolveStorageDirs, resolveStoragePaths, resolveTheme, rewriteMultiEditHeader, runOAuthLogin, runUpdateCommand, saveMcpToolsCache, saveState, selectActiveTodos, selectableTurnIds, serializeInteractionResponse, setProviderCredential, setTodosForRun, shortChord, shortId, shouldAutoCompact, singleAgentRegistry, splitLines, splitMarkdownCodeBlocks, splitPromptSegments, stripEditOutcomesAnnotation, stripJsonComments, stripSpawnTokensLine, subscribeMcpToolsCache, suggestSafelistEntry, sumRunCosts, summarizeEditPayload, summarizeOutcomes, supportsOAuth, titleFromTurns, tokenize, toolCallPreview, toolResultText, truncateTrailing, truncateTurnsAt, tryOpenBrowser, turnAsText, turnContextSize, turnSelectionOwnership, uniqueFilesFromReferences, uniqueSkillNamesFromReferences, updateToolEventOutcomes, useActiveTodos, useColors, useCompletion, useConfig, useDiscovery, useDiscoveryOptional, useEnabledToggleSet, useInteractionsActions, useInteractionsQueue, useMcpAuthDispatch, useMcpAuthState, useMcpToolToggleMap, useMcpToolToggleSet, useSafeModeActions, useSafeModeQueue, useSelectStyle, useSettings, useStreamBuffer, useSurfaces, useSyntaxStyles, useTheme, useUpdateCheck, writeCredentials, writeProjects, writeSessionExport };
+export { ACTIONS_WITH_CARE_DOCTRINE, ASK_USER_TOOL, AUTO_COMPACT_MIN_GROWTH_FRACTION, BUILD_AGENT, BUILTIN_AGENTS, BUILTIN_PROVIDERS, BUILTIN_THEMES, CATPPUCCIN_FRAPPE, CATPPUCCIN_LATTE, CATPPUCCIN_MACCHIATO, CATPPUCCIN_MOCHA, COMMUNICATION_DOCTRINE, ConfigProvider, DEFAULT_AGENT_ID, DEFAULT_BUDGET_EXCLUDE_TOOLS, DEFAULT_KEYBINDINGS, DEFAULT_PERSIST_EXCLUDE_TOOLS, DEFAULT_SETTINGS, DEFAULT_THEME, DOING_TASKS_DOCTRINE, DiscoveryProvider, EMPTY_HINTS, FILES_TRIGGER, GRUVBOX_DARK, GRUVBOX_LIGHT, IDENTITY_PREFIX, IMPLICITLY_SAFE_TOOLS, INTERACTION_GUIDANCE, INTERACTION_GUIDANCE_NO_PROMPTS, InteractionsProvider, KEYBINDING_DEFS, KEYBINDING_DEF_BY_ACTION, KEYBINDING_KEY_COL_WIDTH, McpAuthProvider, OUTPUT_RESERVE_TOKENS, PLAN_AGENT, PLAN_MODE_DOCTRINE, PLAN_MODE_DOCTRINE_NO_PROMPTS, PRESENT_PLAN_TOOL, SETTINGS_CATEGORIES, SETTINGS_CHOICES, SETTINGS_TOGGLES, SKILLS_TRIGGER, SUBAGENT_GUIDANCE, SafeModeProvider, SettingsProvider, TODOREAD_TOOL, TODOS_METADATA_KEY, TODOWRITE_TOOL, TODO_STATUS_GLYPHS, TODO_WRITE_COUNTS_METADATA_KEY, TOKEN_DISCIPLINE_DOCTRINE, TOOL_DISPLAY, ThemeProvider, VAPORWAVE_THEME, accentColor, addToSafelist, ageString, anthropicDescriptor, applyApiKeyEnv, applyEditPayload, applyInsert, blendHsl, bootProfileEnabled, bootTick, buildBuildSystem, buildContextBreakdown, buildContextualDiff, buildEditOutcomesAnnotation, buildHints, buildLinearRamp, buildMcpServers, buildModelCatalog, buildPlanSystem, buildResumedToolResultsTurn, buildSkillsConfig, buildToolToggle, buildUnifiedDiff, buildUpdateHint, buildVisibleMcpRows, cerebrasDescriptor, checkForUpdate, cleanTitle, clearMcpToolsCache, clipHintsToWidth, collectReferences, compactPath, compareSemver, computeInlineDiff, computeLineDiff, computeTurnAnchors, countNeighbors, createDiscoverySlot, createFileMcpCredentialStore, createFilesCompletionProvider, createInteractionTools, createSkillsCompletionProvider, createStateStore, createTodoTools, credKeyOf, credentialsPath, defaultMcpsConfigPaths, defaultSkillScanPaths, deleteTurnSafely, deriveSessionTitle, detectAuth, detectLibc, detectPackageManager, discoverAgentsMd, discoverProjectMcps, discoverProjectSkills, displayNameFor, effectiveContextWindow, enabledModelOptions, ensureKeybindingsFile, envSection, eventsFromTurns, extractEditPayload, fetchOAuthRedirect, filetypeFromPath, filterModelCatalog, finalizeStreamingMarkdown, finalizeStreamingMarkdownForOwner, findActiveTrigger, findGitRoot, fmtTokens, formatBindingForDisplay, formatDuration, formatPathForCwd, formatTaskStatus, formatTaskSummary, formatToolCall, generateSessionTitle, getArchivedTodosForRun, getContextWindow, getMcpAuthStatus, getModelInfo, getSafelist, getTodosForRun, groupBindings, hintsLength, indexOfEntry, indexOfServerRow, isEditErrorResult, isInteractionTool, isOnSafelist, isTodoTool, isTurnHighlighted, isVisible, keybindingsPath, lastContextSizeFromTurns, listProjectFiles, listSessionMeta, loadMcpToolsCache, loadState, localDescriptor, makeRequestInteraction, marginTopFor, maskToOutcomeKinds, matchesBinding, matchesSafelistEntry, mcpCredentialsPath, mcpToolsCachePath, mergeApprovalAndBodyOutcomes, mergeKeybindings, mergeReferences, modelOptionsFor, modelSupportsReasoning, modelsForDescriptor, oauthUsesManualCodePaste, openaiDescriptor, openrouterDescriptor, parentServerName, parseBindingSpec, parseEditOutcomesFromResult, parseMcpsFile, parseSemver, patchMcpCredential, pendingInteractionsFromTurns, performInPlaceSelfUpdate, performSelfUpdate, piIdOf, pickActiveRunId, previewEditPayload, previewLine, projectUserPaths, projectsFilePath, pruneTodosByRun, readCredentials, readKeybindings, readProjects, readProviderCredential, reduceMcpAuth, refreshMcpToolsCatalog, removeProviderCredential, renderAgentsMdBlock, renderSession, resolveAgentId, resolveApprovalForPayload, resolveChipColor, resolveConfig, resolvePlatformPackage, resolveSessionExportTarget, resolveStorageDirs, resolveStoragePaths, resolveTheme, restoreModelOptions, rewriteMultiEditHeader, runOAuthLogin, runUpdateCommand, saveMcpToolsCache, saveState, selectActiveTodos, selectableTurnIds, serializeInteractionResponse, setProviderCredential, setTodosForRun, shortChord, shortId, shouldAutoCompact, singleAgentRegistry, splitLines, splitMarkdownCodeBlocks, splitPromptSegments, stripEditOutcomesAnnotation, stripJsonComments, stripSpawnTokensLine, subscribeMcpToolsCache, suggestSafelistEntry, sumRunCosts, summarizeEditPayload, summarizeOutcomes, supportsOAuth, titleFromTurns, tokenize, toolCallPreview, toolResultText, truncateTrailing, truncateTurnsAt, tryOpenBrowser, turnAsText, turnContextSize, turnSelectionOwnership, uniqueFilesFromReferences, uniqueSkillNamesFromReferences, updateToolEventOutcomes, useActiveTodos, useColors, useCompletion, useConfig, useDiscovery, useDiscoveryOptional, useEnabledToggleSet, useInteractionsActions, useInteractionsQueue, useMcpAuthDispatch, useMcpAuthState, useMcpToolToggleMap, useMcpToolToggleSet, useSafeModeActions, useSafeModeQueue, useSelectStyle, useSettings, useStreamBuffer, useSurfaces, useSyntaxStyles, useTheme, useUpdateCheck, writeCredentials, writeProjects, writeSessionExport };
 
 //# sourceMappingURL=chat.js.map

package/dist/chat.js.map

@@ -1 +1 @@
-{"version":3,"file":"chat.js","names":[],"sources":["../src/chat/auto-update-cli.ts"],"sourcesContent":["// ---------------------------------------------------------------------------\n// `zidane upgrade` subcommand — drop-in handler for consumer CLIs.\n//\n// Wraps `checkForUpdate` + `performSelfUpdate` + `performInPlaceSelfUpdate`\n// into a single function the host's `cli.ts` can call. The behavior layers:\n//\n//   - no flags          → check + run the package manager\n//   - `--check`         → check only, print the latest version + bail\n//   - `--in-place`      → skip the PM, download + atomic-rename the binary\n//   - `--dry-run`       → resolve everything but don't actually swap\n//   - `--channel <tag>` → override dist-tag (defaults to `'latest'`)\n//   - `--registry <url>`→ override the npm registry URL\n//\n// Pure I/O — writes to stdout/stderr, returns the exit code the caller\n// should pass to `process.exit`. No React, no OpenTUI; safe to call\n// before / instead of `runTui`.\n// ---------------------------------------------------------------------------\n\nimport {\n  checkForUpdate,\n  compareSemver,\n  detectPackageManager,\n  performInPlaceSelfUpdate,\n  performSelfUpdate,\n  resolvePlatformPackage,\n} from './auto-update'\n\nexport interface RunUpdateCommandOptions {\n  /** Top-level package the user installs (e.g. `'zidane-tui'`). */\n  packageName: string\n  /** Inlined at build time. */\n  currentVersion: string\n  /** Args passed after `upgrade` (typically `process.argv.slice(3)`). */\n  argv: readonly string[]\n  /** Where to persist the TTL cache. Usually `paths.userDir`. */\n  cacheDir?: string\n  /** Default channel when `--channel` isn't passed. Defaults to `'latest'`. */\n  defaultChannel?: string\n  /**\n   * Override the platform-package-name prefix used by `--in-place`.\n   * Defaults to `'<packageName>-'`, matching the `zidane-tui-<key>` layout.\n   */\n  platformPackagePrefix?: string\n  /** Override registry. Defaults to npmjs. */\n  registry?: string\n  /** stdout. Defaults to `process.stdout`. */\n  stdout?: NodeJS.WritableStream\n  /** stderr. Defaults to `process.stderr`. */\n  stderr?: NodeJS.WritableStream\n}\n\nexport interface RunUpdateCommandResult {\n  exitCode: number\n}\n\nconst UPGRADE_HELP = `Usage: zidane upgrade [options]\n\nUpdate the zidane CLI to the latest release.\n\nOptions:\n  --check                   Print the latest version and exit (no install).\n  --in-place                Download the platform binary directly from npm\n                            and atomic-rename over the running binary.\n                            Skips the package manager. Refused on Volta.\n  --dry-run                 Resolve everything but don't actually install.\n  --channel <tag>           dist-tag to query (default: latest).\n  --registry <url>          Override the npm registry.\n  --package-manager <pm>    Force npm | pnpm | yarn | bun | volta.\n  --force                   Run the install even if we're already on latest,\n                            or the registry check failed.\n  -h, --help                Print this help.\n\nEnvironment:\n  NO_UPDATE_NOTIFIER        Silence the background check (set to \"1\").\n  ZIDANE_NO_UPDATE          Same, project-specific.\n`\n\n/**\n * Run the `upgrade` subcommand. Exit code contract:\n *   - `0`  — update succeeded, `--check` reported no update, or `--check`\n *            reported an update (informational only).\n *   - `1`  — update failed (PM exit non-zero, in-place download failed,\n *            registry returned non-2xx).\n *   - `2`  — argv parse error (unknown flag).\n */\nexport async function runUpdateCommand(options: RunUpdateCommandOptions): Promise<RunUpdateCommandResult> {\n  const out = options.stdout ?? process.stdout\n  const err = options.stderr ?? process.stderr\n  const parsed = parseArgs(options.argv)\n  if (parsed.kind === 'error') {\n    err.write(`zidane upgrade: ${parsed.message}\\n`)\n    err.write(UPGRADE_HELP)\n    return { exitCode: 2 }\n  }\n  if (parsed.help) {\n    out.write(UPGRADE_HELP)\n    return { exitCode: 0 }\n  }\n\n  const channel = parsed.channel ?? options.defaultChannel ?? 'latest'\n  const registry = parsed.registry ?? options.registry\n\n  // Always force the check — user typed `upgrade`, env opt-outs shouldn't\n  // get in the way.\n  const status = await checkForUpdate({\n    packageName: options.packageName,\n    currentVersion: options.currentVersion,\n    channel,\n    registry,\n    cacheDir: options.cacheDir,\n    force: true,\n    timeoutMs: 8000,\n  })\n\n  // `--check` is informational — degrade gracefully on registry errors\n  // (offline laptop, restricted proxy) and exit 0 so the user can script\n  // around it without quoting tricks.\n  if (parsed.check) {\n    if (status.source === 'error') {\n      err.write(`Could not check \\`${channel}\\` (${status.error ?? 'unknown error'}). Current: v${options.currentVersion}.\\n`)\n      return { exitCode: 0 }\n    }\n    if (!status.latest) {\n      err.write(`Could not determine latest version on \\`${channel}\\`. Current: v${options.currentVersion}.\\n`)\n      return { exitCode: 0 }\n    }\n    const cmp = compareSemver(status.latest, options.currentVersion)\n    if (cmp > 0)\n      out.write(`v${status.latest} is available on \\`${channel}\\` (current: v${options.currentVersion}).\\n`)\n    else\n      out.write(`Already on v${options.currentVersion} (latest on \\`${channel}\\` is v${status.latest}).\\n`)\n    return { exitCode: 0 }\n  }\n\n  // Install path — a registry error means we don't KNOW if we need an\n  // update. Refuse to spawn the PM blindly unless the user explicitly\n  // asks via `--force`.\n  if (status.source === 'error') {\n    err.write(`zidane upgrade: registry check failed (${status.error ?? 'unknown error'})\\n`)\n    if (!parsed.force) {\n      err.write('Pass --force to attempt the install anyway.\\n')\n      return { exitCode: 1 }\n    }\n  }\n\n  if (status.latest && !parsed.force) {\n    const cmp = compareSemver(status.latest, options.currentVersion)\n    if (cmp <= 0) {\n      out.write(`Already on v${options.currentVersion} (latest on \\`${channel}\\` is v${status.latest}).\\n`)\n      return { exitCode: 0 }\n    }\n  }\n\n  // ---------------------------------------------------------------------\n  // In-place path\n  // ---------------------------------------------------------------------\n\n  if (parsed.inPlace) {\n    const platformPkg = resolvePlatformPackage({\n      prefix: options.platformPackagePrefix ?? `${options.packageName}-`,\n    })\n    if (!platformPkg) {\n      err.write(`No prebuilt binary for ${process.platform}/${process.arch}. Run \\`${options.packageName}-upgrade\\` via your package manager instead.\\n`)\n      return { exitCode: 1 }\n    }\n    out.write(`Downloading ${platformPkg}@${channel}…\\n`)\n    const result = await performInPlaceSelfUpdate({\n      packageName: platformPkg,\n      channel,\n      registry,\n      dryRun: parsed.dryRun,\n    })\n    if (result.status === 'success') {\n      const verb = parsed.dryRun ? 'Would install' : 'Installed'\n      out.write(`${verb} v${result.installedVersion} at ${result.binaryPath}.\\n`)\n      return { exitCode: 0 }\n    }\n    err.write(`In-place update failed: ${result.reason ?? 'unknown error'}\\n`)\n    if (result.status === 'refused')\n      err.write('Falling back to package-manager path (drop --in-place to retry).\\n')\n    return { exitCode: 1 }\n  }\n\n  // ---------------------------------------------------------------------\n  // Package-manager path\n  // ---------------------------------------------------------------------\n\n  const detected = detectPackageManager({ packageName: options.packageName, channel })\n  if (detected.note)\n    out.write(`${detected.note}\\n`)\n  out.write(`Running: ${detected.argv.join(' ')}\\n`)\n  if (parsed.dryRun)\n    return { exitCode: 0 }\n\n  const result = await performSelfUpdate({\n    packageName: options.packageName,\n    channel,\n    packageManager: parsed.packageManager ?? 'auto',\n  })\n  if (result.spawnError) {\n    err.write(`Failed to launch \\`${result.command.argv[0]}\\`: ${result.spawnError}\\n`)\n    err.write('Is the package manager installed and on $PATH?\\n')\n    return { exitCode: 1 }\n  }\n  return { exitCode: result.exitCode ?? 1 }\n}\n\n// ---------------------------------------------------------------------------\n// Argv parser — minimal, just enough to drop into the consumer's `cli.ts`.\n// We deliberately don't pull in commander/yargs for a 5-flag surface.\n// ---------------------------------------------------------------------------\n\ntype ParseResult\n  = | {\n    kind: 'ok'\n    check: boolean\n    inPlace: boolean\n    dryRun: boolean\n    force: boolean\n    help: boolean\n    channel?: string\n    registry?: string\n    packageManager?: 'npm' | 'pnpm' | 'yarn' | 'bun' | 'volta'\n  }\n  | { kind: 'error', message: string }\n\nfunction parseArgs(argv: readonly string[]): ParseResult {\n  let check = false\n  let inPlace = false\n  let dryRun = false\n  let force = false\n  let help = false\n  let channel: string | undefined\n  let registry: string | undefined\n  let packageManager: 'npm' | 'pnpm' | 'yarn' | 'bun' | 'volta' | undefined\n\n  for (let i = 0; i < argv.length; i++) {\n    const a = argv[i]!\n    switch (a) {\n      case '--check': check = true; break\n      case '--in-place':\n      case '--inplace': inPlace = true; break\n      case '--dry-run':\n      case '--dryrun': dryRun = true; break\n      case '--force': force = true; break\n      case '-h':\n      case '--help': help = true; break\n      case '--channel':\n        channel = argv[++i]\n        if (!channel)\n          return { kind: 'error', message: '--channel requires a value' }\n        break\n      case '--registry':\n        registry = argv[++i]\n        if (!registry)\n          return { kind: 'error', message: '--registry requires a value' }\n        break\n      case '--package-manager':\n      case '--pm': {\n        const v = argv[++i]\n        if (!v)\n          return { kind: 'error', message: '--package-manager requires a value' }\n        if (v !== 'npm' && v !== 'pnpm' && v !== 'yarn' && v !== 'bun' && v !== 'volta')\n          return { kind: 'error', message: `unknown package manager: ${v}` }\n        packageManager = v\n        break\n      }\n      default:\n        return { kind: 'error', message: `unknown argument: ${a}` }\n    }\n  }\n\n  return { kind: 'ok', check, inPlace, dryRun, force, help, channel, registry, packageManager }\n}\n"],"mappings":"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"}
+{"version":3,"file":"chat.js","names":[],"sources":["../src/chat/auto-update-cli.ts"],"sourcesContent":["// ---------------------------------------------------------------------------\n// `zidane upgrade` subcommand — drop-in handler for consumer CLIs.\n//\n// Wraps `checkForUpdate` + `performSelfUpdate` + `performInPlaceSelfUpdate`\n// into a single function the host's `cli.ts` can call. The behavior layers:\n//\n//   - no flags          → check + run the package manager\n//   - `--check`         → check only, print the latest version + bail\n//   - `--in-place`      → skip the PM, download + atomic-rename the binary\n//   - `--dry-run`       → resolve everything but don't actually swap\n//   - `--channel <tag>` → override dist-tag (defaults to `'latest'`)\n//   - `--registry <url>`→ override the npm registry URL\n//\n// Pure I/O — writes to stdout/stderr, returns the exit code the caller\n// should pass to `process.exit`. No React, no OpenTUI; safe to call\n// before / instead of `runTui`.\n// ---------------------------------------------------------------------------\n\nimport {\n  checkForUpdate,\n  compareSemver,\n  detectPackageManager,\n  performInPlaceSelfUpdate,\n  performSelfUpdate,\n  resolvePlatformPackage,\n} from './auto-update'\n\nexport interface RunUpdateCommandOptions {\n  /** Top-level package the user installs (e.g. `'zidane-tui'`). */\n  packageName: string\n  /** Inlined at build time. */\n  currentVersion: string\n  /** Args passed after `upgrade` (typically `process.argv.slice(3)`). */\n  argv: readonly string[]\n  /** Where to persist the TTL cache. Usually `paths.userDir`. */\n  cacheDir?: string\n  /** Default channel when `--channel` isn't passed. Defaults to `'latest'`. */\n  defaultChannel?: string\n  /**\n   * Override the platform-package-name prefix used by `--in-place`.\n   * Defaults to `'<packageName>-'`, matching the `zidane-tui-<key>` layout.\n   */\n  platformPackagePrefix?: string\n  /** Override registry. Defaults to npmjs. */\n  registry?: string\n  /** stdout. Defaults to `process.stdout`. */\n  stdout?: NodeJS.WritableStream\n  /** stderr. Defaults to `process.stderr`. */\n  stderr?: NodeJS.WritableStream\n}\n\nexport interface RunUpdateCommandResult {\n  exitCode: number\n}\n\nconst UPGRADE_HELP = `Usage: zidane upgrade [options]\n\nUpdate the zidane CLI to the latest release.\n\nOptions:\n  --check                   Print the latest version and exit (no install).\n  --in-place                Download the platform binary directly from npm\n                            and atomic-rename over the running binary.\n                            Skips the package manager. Refused on Volta.\n  --dry-run                 Resolve everything but don't actually install.\n  --channel <tag>           dist-tag to query (default: latest).\n  --registry <url>          Override the npm registry.\n  --package-manager <pm>    Force npm | pnpm | yarn | bun | volta.\n  --force                   Run the install even if we're already on latest,\n                            or the registry check failed.\n  -h, --help                Print this help.\n\nEnvironment:\n  NO_UPDATE_NOTIFIER        Silence the background check (set to \"1\").\n  ZIDANE_NO_UPDATE          Same, project-specific.\n`\n\n/**\n * Run the `upgrade` subcommand. Exit code contract:\n *   - `0`  — update succeeded, `--check` reported no update, or `--check`\n *            reported an update (informational only).\n *   - `1`  — update failed (PM exit non-zero, in-place download failed,\n *            registry returned non-2xx).\n *   - `2`  — argv parse error (unknown flag).\n */\nexport async function runUpdateCommand(options: RunUpdateCommandOptions): Promise<RunUpdateCommandResult> {\n  const out = options.stdout ?? process.stdout\n  const err = options.stderr ?? process.stderr\n  const parsed = parseArgs(options.argv)\n  if (parsed.kind === 'error') {\n    err.write(`zidane upgrade: ${parsed.message}\\n`)\n    err.write(UPGRADE_HELP)\n    return { exitCode: 2 }\n  }\n  if (parsed.help) {\n    out.write(UPGRADE_HELP)\n    return { exitCode: 0 }\n  }\n\n  const channel = parsed.channel ?? options.defaultChannel ?? 'latest'\n  const registry = parsed.registry ?? options.registry\n\n  // Always force the check — user typed `upgrade`, env opt-outs shouldn't\n  // get in the way.\n  const status = await checkForUpdate({\n    packageName: options.packageName,\n    currentVersion: options.currentVersion,\n    channel,\n    registry,\n    cacheDir: options.cacheDir,\n    force: true,\n    timeoutMs: 8000,\n  })\n\n  // `--check` is informational — degrade gracefully on registry errors\n  // (offline laptop, restricted proxy) and exit 0 so the user can script\n  // around it without quoting tricks.\n  if (parsed.check) {\n    if (status.source === 'error') {\n      err.write(`Could not check \\`${channel}\\` (${status.error ?? 'unknown error'}). Current: v${options.currentVersion}.\\n`)\n      return { exitCode: 0 }\n    }\n    if (!status.latest) {\n      err.write(`Could not determine latest version on \\`${channel}\\`. Current: v${options.currentVersion}.\\n`)\n      return { exitCode: 0 }\n    }\n    const cmp = compareSemver(status.latest, options.currentVersion)\n    if (cmp > 0)\n      out.write(`v${status.latest} is available on \\`${channel}\\` (current: v${options.currentVersion}).\\n`)\n    else\n      out.write(`Already on v${options.currentVersion} (latest on \\`${channel}\\` is v${status.latest}).\\n`)\n    return { exitCode: 0 }\n  }\n\n  // Install path — a registry error means we don't KNOW if we need an\n  // update. Refuse to spawn the PM blindly unless the user explicitly\n  // asks via `--force`.\n  if (status.source === 'error') {\n    err.write(`zidane upgrade: registry check failed (${status.error ?? 'unknown error'})\\n`)\n    if (!parsed.force) {\n      err.write('Pass --force to attempt the install anyway.\\n')\n      return { exitCode: 1 }\n    }\n  }\n\n  if (status.latest && !parsed.force) {\n    const cmp = compareSemver(status.latest, options.currentVersion)\n    if (cmp <= 0) {\n      out.write(`Already on v${options.currentVersion} (latest on \\`${channel}\\` is v${status.latest}).\\n`)\n      return { exitCode: 0 }\n    }\n  }\n\n  // ---------------------------------------------------------------------\n  // In-place path\n  // ---------------------------------------------------------------------\n\n  if (parsed.inPlace) {\n    const platformPkg = resolvePlatformPackage({\n      prefix: options.platformPackagePrefix ?? `${options.packageName}-`,\n    })\n    if (!platformPkg) {\n      err.write(`No prebuilt binary for ${process.platform}/${process.arch}. Run \\`${options.packageName}-upgrade\\` via your package manager instead.\\n`)\n      return { exitCode: 1 }\n    }\n    out.write(`Downloading ${platformPkg}@${channel}…\\n`)\n    const result = await performInPlaceSelfUpdate({\n      packageName: platformPkg,\n      channel,\n      registry,\n      dryRun: parsed.dryRun,\n    })\n    if (result.status === 'success') {\n      const verb = parsed.dryRun ? 'Would install' : 'Installed'\n      out.write(`${verb} v${result.installedVersion} at ${result.binaryPath}.\\n`)\n      return { exitCode: 0 }\n    }\n    err.write(`In-place update failed: ${result.reason ?? 'unknown error'}\\n`)\n    if (result.status === 'refused')\n      err.write('Falling back to package-manager path (drop --in-place to retry).\\n')\n    return { exitCode: 1 }\n  }\n\n  // ---------------------------------------------------------------------\n  // Package-manager path\n  // ---------------------------------------------------------------------\n\n  const detected = detectPackageManager({ packageName: options.packageName, channel })\n  if (detected.note)\n    out.write(`${detected.note}\\n`)\n  out.write(`Running: ${detected.argv.join(' ')}\\n`)\n  if (parsed.dryRun)\n    return { exitCode: 0 }\n\n  const result = await performSelfUpdate({\n    packageName: options.packageName,\n    channel,\n    packageManager: parsed.packageManager ?? 'auto',\n  })\n  if (result.spawnError) {\n    err.write(`Failed to launch \\`${result.command.argv[0]}\\`: ${result.spawnError}\\n`)\n    err.write('Is the package manager installed and on $PATH?\\n')\n    return { exitCode: 1 }\n  }\n  return { exitCode: result.exitCode ?? 1 }\n}\n\n// ---------------------------------------------------------------------------\n// Argv parser — minimal, just enough to drop into the consumer's `cli.ts`.\n// We deliberately don't pull in commander/yargs for a 5-flag surface.\n// ---------------------------------------------------------------------------\n\ntype ParseResult\n  = | {\n    kind: 'ok'\n    check: boolean\n    inPlace: boolean\n    dryRun: boolean\n    force: boolean\n    help: boolean\n    channel?: string\n    registry?: string\n    packageManager?: 'npm' | 'pnpm' | 'yarn' | 'bun' | 'volta'\n  }\n  | { kind: 'error', message: string }\n\nfunction parseArgs(argv: readonly string[]): ParseResult {\n  let check = false\n  let inPlace = false\n  let dryRun = false\n  let force = false\n  let help = false\n  let channel: string | undefined\n  let registry: string | undefined\n  let packageManager: 'npm' | 'pnpm' | 'yarn' | 'bun' | 'volta' | undefined\n\n  for (let i = 0; i < argv.length; i++) {\n    const a = argv[i]!\n    switch (a) {\n      case '--check': check = true; break\n      case '--in-place':\n      case '--inplace': inPlace = true; break\n      case '--dry-run':\n      case '--dryrun': dryRun = true; break\n      case '--force': force = true; break\n      case '-h':\n      case '--help': help = true; break\n      case '--channel':\n        channel = argv[++i]\n        if (!channel)\n          return { kind: 'error', message: '--channel requires a value' }\n        break\n      case '--registry':\n        registry = argv[++i]\n        if (!registry)\n          return { kind: 'error', message: '--registry requires a value' }\n        break\n      case '--package-manager':\n      case '--pm': {\n        const v = argv[++i]\n        if (!v)\n          return { kind: 'error', message: '--package-manager requires a value' }\n        if (v !== 'npm' && v !== 'pnpm' && v !== 'yarn' && v !== 'bun' && v !== 'volta')\n          return { kind: 'error', message: `unknown package manager: ${v}` }\n        packageManager = v\n        break\n      }\n      default:\n        return { kind: 'error', message: `unknown argument: ${a}` }\n    }\n  }\n\n  return { kind: 'ok', check, inPlace, dryRun, force, help, channel, registry, packageManager }\n}\n"],"mappings":"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"}

package/dist/contexts/docker.d.ts

@@ -1,4 +1,4 @@
-import { a as ExecutionContext, s as SpawnConfig } from "../types-KukEp-mi.js";
+import { a as ExecutionContext, s as SpawnConfig } from "../types-CEAMIUXw.js";
 
 //#region src/contexts/docker.d.ts
 declare function createDockerContext(config?: SpawnConfig): ExecutionContext;

package/dist/contexts/docker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docker.d.ts","names":[],"sources":["../../src/contexts/docker.ts"],"mappings":";;;iBAoBgB,mBAAA,CAAoB,MAAA,GAAS,WAAA,GAAc,gBAAA"}
+{"version":3,"file":"docker.d.ts","names":[],"sources":["../../src/contexts/docker.ts"],"mappings":";;;iBAoBgB,mBAAA,CAAoB,MAAA,GAAS,WAAA,GAAc,gBAAgB"}

package/dist/contexts/docker.js.map

@@ -1 +1 @@
-{"version":3,"file":"docker.js","names":[],"sources":["../../src/contexts/docker.ts"],"sourcesContent":["/**\n * Docker execution context.\n *\n * Runs tools inside a Docker container via dockerode.\n * Full isolation with configurable resource limits.\n *\n * Requires `dockerode` as an optional peer dependency.\n */\n\nimport type { Buffer } from 'node:buffer'\nimport type { ContextCapabilities, ExecResult, ExecutionContext, ExecutionHandle, SpawnConfig } from './types'\n\nconst SINGLE_QUOTE_RE = /'/g\n\ninterface ContainerRef {\n  handle: ExecutionHandle\n  container: any\n  docker: any\n}\n\nexport function createDockerContext(config?: SpawnConfig): ExecutionContext {\n  let counter = 0\n  const containers = new Map<string, ContainerRef>()\n  const defaultImage = config?.image ?? 'oven/bun:latest'\n  const defaultCwd = config?.cwd ?? '/workspace'\n  const defaultEnv = config?.env\n  const defaultLimits = config?.limits\n\n  async function getDockerode() {\n    try {\n      const Dockerode = (await import('dockerode')).default\n      return new Dockerode()\n    }\n    catch {\n      throw new Error('dockerode is required for Docker execution context. Install it with: bun add dockerode')\n    }\n  }\n\n  const ctx: ExecutionContext = {\n    type: 'docker',\n\n    capabilities: {\n      shell: true,\n      filesystem: true,\n      network: true,\n      gpu: false,\n    } satisfies ContextCapabilities,\n\n    async spawn(overrides?: SpawnConfig): Promise<ExecutionHandle> {\n      const docker = await getDockerode()\n      const id = `docker-${++counter}`\n      const image = overrides?.image ?? defaultImage\n      const cwd = overrides?.cwd ?? defaultCwd\n\n      // Pull image if not available\n      try {\n        await docker.getImage(image).inspect()\n      }\n      catch {\n        await new Promise<void>((resolve, reject) => {\n          docker.pull(image, (err: Error | null, stream: NodeJS.ReadableStream) => {\n            if (err)\n              return reject(err)\n            docker.modem.followProgress(stream, (err2: Error | null) => {\n              err2 ? reject(err2) : resolve()\n            })\n          })\n        })\n      }\n\n      const limits = { ...defaultLimits, ...overrides?.limits }\n      const hostConfig: Record<string, unknown> = {}\n\n      if (limits?.memory) {\n        hostConfig.Memory = limits.memory * 1024 * 1024\n      }\n      if (limits?.cpu) {\n        hostConfig.NanoCpus = Number.parseFloat(limits.cpu) * 1e9\n      }\n\n      const env = { ...defaultEnv, ...overrides?.env }\n\n      const container = await docker.createContainer({\n        Image: image,\n        Cmd: ['sleep', 'infinity'],\n        WorkingDir: cwd,\n        Env: Object.entries(env).map(([k, v]) => `${k}=${v}`),\n        HostConfig: hostConfig,\n      })\n\n      await container.start()\n\n      const handle: ExecutionHandle = { id, type: 'docker', cwd }\n      containers.set(id, { handle, container, docker })\n      return handle\n    },\n\n    async exec(handle: ExecutionHandle, command: string, options?: { cwd?: string, env?: Record<string, string>, timeout?: number }): Promise<ExecResult> {\n      const ref = containers.get(handle.id)\n      if (!ref)\n        throw new Error(`Container ${handle.id} not found`)\n\n      const execCwd = options?.cwd ?? handle.cwd\n      const env = options?.env\n        ? Object.entries(options.env).map(([k, v]) => `${k}=${v}`)\n        : []\n\n      const exec = await ref.container.exec({\n        Cmd: ['sh', '-c', command],\n        WorkingDir: execCwd,\n        Env: env,\n        AttachStdout: true,\n        AttachStderr: true,\n      })\n\n      const stream = await exec.start({ Detach: false })\n\n      return new Promise<ExecResult>((resolve) => {\n        let stdout = ''\n        let stderr = ''\n        let resolved = false\n\n        // Docker's exec stream is a multiplexed protocol — a single byte\n        // stream that interleaves stdout/stderr frames. `demuxStream`\n        // splits the two onto separate writable sinks. Without it, every\n        // byte landed on `stdout` and `stderr` was permanently empty.\n        const stdoutSink = {\n          write(chunk: Buffer | string) {\n            stdout += typeof chunk === 'string' ? chunk : chunk.toString('utf-8')\n            return true\n          },\n          end() {},\n          on() {},\n          once() {},\n          emit() { return true },\n        }\n        const stderrSink = {\n          write(chunk: Buffer | string) {\n            stderr += typeof chunk === 'string' ? chunk : chunk.toString('utf-8')\n            return true\n          },\n          end() {},\n          on() {},\n          once() {},\n          emit() { return true },\n        }\n        try {\n          ref.docker.modem.demuxStream(stream, stdoutSink, stderrSink)\n        }\n        catch {\n          // Older / different transports may not be multiplexed (TTY mode);\n          // fall back to a raw stdout reader so we don't lose output entirely.\n          stream.on('data', (chunk: Buffer) => {\n            stdout += chunk.toString('utf-8')\n          })\n        }\n\n        const timeout = options?.timeout ?? defaultLimits?.timeout ?? 30\n        const timer = setTimeout(() => {\n          if (resolved)\n            return\n          resolved = true\n          // Best-effort: detach the stream so we stop accumulating bytes\n          // from a runaway exec. The exec itself can't be killed cleanly\n          // through the dockerode exec API; the container's destroy() path\n          // (or a manual `docker exec kill`) is the real cleanup.\n          try { stream.destroy?.() }\n          catch { /* swallow */ }\n          resolve({ stdout, stderr: stderr ? `${stderr}\\n[timeout]` : '[timeout]', exitCode: 124 })\n        }, timeout * 1000)\n\n        stream.on('end', async () => {\n          if (resolved)\n            return\n          resolved = true\n          clearTimeout(timer)\n          let exitCode = 0\n          try {\n            const inspect = await exec.inspect()\n            exitCode = inspect.ExitCode ?? 0\n          }\n          catch {\n            // If inspect fails after a clean stream end, treat as success\n            // — we already received the full output stream.\n          }\n          resolve({ stdout, stderr, exitCode })\n        })\n\n        stream.on('error', (err: Error) => {\n          if (resolved)\n            return\n          resolved = true\n          clearTimeout(timer)\n          resolve({ stdout, stderr: stderr ? `${stderr}\\n${err.message}` : err.message, exitCode: 1 })\n        })\n      })\n    },\n\n    async readFile(handle: ExecutionHandle, path: string): Promise<string> {\n      const result = await ctx.exec(handle, `cat ${JSON.stringify(path)}`)\n      if (result.exitCode !== 0)\n        throw new Error(`Failed to read file: ${result.stderr}`)\n      return result.stdout\n    },\n\n    async writeFile(handle: ExecutionHandle, path: string, content: string): Promise<void> {\n      const escaped = content.replace(SINGLE_QUOTE_RE, String.raw`'\\''`)\n      const result = await ctx.exec(handle, `mkdir -p \"$(dirname ${JSON.stringify(path)})\" && printf '%s' '${escaped}' > ${JSON.stringify(path)}`)\n      if (result.exitCode !== 0)\n        throw new Error(`Failed to write file: ${result.stderr}`)\n    },\n\n    async listFiles(handle: ExecutionHandle, path: string): Promise<string[]> {\n      const result = await ctx.exec(handle, `ls -1 ${JSON.stringify(path)}`)\n      if (result.exitCode !== 0)\n        return []\n      return result.stdout.trim().split('\\n').filter(Boolean)\n    },\n\n    async destroy(handle: ExecutionHandle): Promise<void> {\n      const ref = containers.get(handle.id)\n      if (!ref)\n        return\n\n      try {\n        await ref.container.stop({ t: 5 })\n        await ref.container.remove({ force: true })\n      }\n      catch {\n        // Container may already be stopped\n      }\n\n      containers.delete(handle.id)\n    },\n  }\n\n  return ctx\n}\n"],"mappings":";AAYA,MAAM,kBAAkB;AAQxB,SAAgB,oBAAoB,QAAwC;CAC1E,IAAI,UAAU;CACd,MAAM,6BAAa,IAAI,KAA2B;CAClD,MAAM,eAAe,QAAQ,SAAS;CACtC,MAAM,aAAa,QAAQ,OAAO;CAClC,MAAM,aAAa,QAAQ;CAC3B,MAAM,gBAAgB,QAAQ;CAE9B,eAAe,eAAe;EAC5B,IAAI;GACF,MAAM,aAAa,MAAM,OAAO,cAAc;GAC9C,OAAO,IAAI,WAAW;UAElB;GACJ,MAAM,IAAI,MAAM,yFAAyF;;;CAI7G,MAAM,MAAwB;EAC5B,MAAM;EAEN,cAAc;GACZ,OAAO;GACP,YAAY;GACZ,SAAS;GACT,KAAK;GACN;EAED,MAAM,MAAM,WAAmD;GAC7D,MAAM,SAAS,MAAM,cAAc;GACnC,MAAM,KAAK,UAAU,EAAE;GACvB,MAAM,QAAQ,WAAW,SAAS;GAClC,MAAM,MAAM,WAAW,OAAO;GAG9B,IAAI;IACF,MAAM,OAAO,SAAS,MAAM,CAAC,SAAS;WAElC;IACJ,MAAM,IAAI,SAAe,SAAS,WAAW;KAC3C,OAAO,KAAK,QAAQ,KAAmB,WAAkC;MACvE,IAAI,KACF,OAAO,OAAO,IAAI;MACpB,OAAO,MAAM,eAAe,SAAS,SAAuB;OAC1D,OAAO,OAAO,KAAK,GAAG,SAAS;QAC/B;OACF;MACF;;GAGJ,MAAM,SAAS;IAAE,GAAG;IAAe,GAAG,WAAW;IAAQ;GACzD,MAAM,aAAsC,EAAE;GAE9C,IAAI,QAAQ,QACV,WAAW,SAAS,OAAO,SAAS,OAAO;GAE7C,IAAI,QAAQ,KACV,WAAW,WAAW,OAAO,WAAW,OAAO,IAAI,GAAG;GAGxD,MAAM,MAAM;IAAE,GAAG;IAAY,GAAG,WAAW;IAAK;GAEhD,MAAM,YAAY,MAAM,OAAO,gBAAgB;IAC7C,OAAO;IACP,KAAK,CAAC,SAAS,WAAW;IAC1B,YAAY;IACZ,KAAK,OAAO,QAAQ,IAAI,CAAC,KAAK,CAAC,GAAG,OAAO,GAAG,EAAE,GAAG,IAAI;IACrD,YAAY;IACb,CAAC;GAEF,MAAM,UAAU,OAAO;GAEvB,MAAM,SAA0B;IAAE;IAAI,MAAM;IAAU;IAAK;GAC3D,WAAW,IAAI,IAAI;IAAE;IAAQ;IAAW;IAAQ,CAAC;GACjD,OAAO;;EAGT,MAAM,KAAK,QAAyB,SAAiB,SAAiG;GACpJ,MAAM,MAAM,WAAW,IAAI,OAAO,GAAG;GACrC,IAAI,CAAC,KACH,MAAM,IAAI,MAAM,aAAa,OAAO,GAAG,YAAY;GAErD,MAAM,UAAU,SAAS,OAAO,OAAO;GACvC,MAAM,MAAM,SAAS,MACjB,OAAO,QAAQ,QAAQ,IAAI,CAAC,KAAK,CAAC,GAAG,OAAO,GAAG,EAAE,GAAG,IAAI,GACxD,EAAE;GAEN,MAAM,OAAO,MAAM,IAAI,UAAU,KAAK;IACpC,KAAK;KAAC;KAAM;KAAM;KAAQ;IAC1B,YAAY;IACZ,KAAK;IACL,cAAc;IACd,cAAc;IACf,CAAC;GAEF,MAAM,SAAS,MAAM,KAAK,MAAM,EAAE,QAAQ,OAAO,CAAC;GAElD,OAAO,IAAI,SAAqB,YAAY;IAC1C,IAAI,SAAS;IACb,IAAI,SAAS;IACb,IAAI,WAAW;IAMf,MAAM,aAAa;KACjB,MAAM,OAAwB;MAC5B,UAAU,OAAO,UAAU,WAAW,QAAQ,MAAM,SAAS,QAAQ;MACrE,OAAO;;KAET,MAAM;KACN,KAAK;KACL,OAAO;KACP,OAAO;MAAE,OAAO;;KACjB;IACD,MAAM,aAAa;KACjB,MAAM,OAAwB;MAC5B,UAAU,OAAO,UAAU,WAAW,QAAQ,MAAM,SAAS,QAAQ;MACrE,OAAO;;KAET,MAAM;KACN,KAAK;KACL,OAAO;KACP,OAAO;MAAE,OAAO;;KACjB;IACD,IAAI;KACF,IAAI,OAAO,MAAM,YAAY,QAAQ,YAAY,WAAW;YAExD;KAGJ,OAAO,GAAG,SAAS,UAAkB;MACnC,UAAU,MAAM,SAAS,QAAQ;OACjC;;IAGJ,MAAM,UAAU,SAAS,WAAW,eAAe,WAAW;IAC9D,MAAM,QAAQ,iBAAiB;KAC7B,IAAI,UACF;KACF,WAAW;KAKX,IAAI;MAAE,OAAO,WAAW;aAClB;KACN,QAAQ;MAAE;MAAQ,QAAQ,SAAS,GAAG,OAAO,eAAe;MAAa,UAAU;MAAK,CAAC;OACxF,UAAU,IAAK;IAElB,OAAO,GAAG,OAAO,YAAY;KAC3B,IAAI,UACF;KACF,WAAW;KACX,aAAa,MAAM;KACnB,IAAI,WAAW;KACf,IAAI;MAEF,YAAW,MADW,KAAK,SAAS,EACjB,YAAY;aAE3B;KAIN,QAAQ;MAAE;MAAQ;MAAQ;MAAU,CAAC;MACrC;IAEF,OAAO,GAAG,UAAU,QAAe;KACjC,IAAI,UACF;KACF,WAAW;KACX,aAAa,MAAM;KACnB,QAAQ;MAAE;MAAQ,QAAQ,SAAS,GAAG,OAAO,IAAI,IAAI,YAAY,IAAI;MAAS,UAAU;MAAG,CAAC;MAC5F;KACF;;EAGJ,MAAM,SAAS,QAAyB,MAA+B;GACrE,MAAM,SAAS,MAAM,IAAI,KAAK,QAAQ,OAAO,KAAK,UAAU,KAAK,GAAG;GACpE,IAAI,OAAO,aAAa,GACtB,MAAM,IAAI,MAAM,wBAAwB,OAAO,SAAS;GAC1D,OAAO,OAAO;;EAGhB,MAAM,UAAU,QAAyB,MAAc,SAAgC;GACrF,MAAM,UAAU,QAAQ,QAAQ,iBAAiB,OAAO,GAAG,OAAO;GAClE,MAAM,SAAS,MAAM,IAAI,KAAK,QAAQ,uBAAuB,KAAK,UAAU,KAAK,CAAC,qBAAqB,QAAQ,MAAM,KAAK,UAAU,KAAK,GAAG;GAC5I,IAAI,OAAO,aAAa,GACtB,MAAM,IAAI,MAAM,yBAAyB,OAAO,SAAS;;EAG7D,MAAM,UAAU,QAAyB,MAAiC;GACxE,MAAM,SAAS,MAAM,IAAI,KAAK,QAAQ,SAAS,KAAK,UAAU,KAAK,GAAG;GACtE,IAAI,OAAO,aAAa,GACtB,OAAO,EAAE;GACX,OAAO,OAAO,OAAO,MAAM,CAAC,MAAM,KAAK,CAAC,OAAO,QAAQ;;EAGzD,MAAM,QAAQ,QAAwC;GACpD,MAAM,MAAM,WAAW,IAAI,OAAO,GAAG;GACrC,IAAI,CAAC,KACH;GAEF,IAAI;IACF,MAAM,IAAI,UAAU,KAAK,EAAE,GAAG,GAAG,CAAC;IAClC,MAAM,IAAI,UAAU,OAAO,EAAE,OAAO,MAAM,CAAC;WAEvC;GAIN,WAAW,OAAO,OAAO,GAAG;;EAE/B;CAED,OAAO"}
+{"version":3,"file":"docker.js","names":[],"sources":["../../src/contexts/docker.ts"],"sourcesContent":["/**\n * Docker execution context.\n *\n * Runs tools inside a Docker container via dockerode.\n * Full isolation with configurable resource limits.\n *\n * Requires `dockerode` as an optional peer dependency.\n */\n\nimport type { Buffer } from 'node:buffer'\nimport type { ContextCapabilities, ExecResult, ExecutionContext, ExecutionHandle, SpawnConfig } from './types'\n\nconst SINGLE_QUOTE_RE = /'/g\n\ninterface ContainerRef {\n  handle: ExecutionHandle\n  container: any\n  docker: any\n}\n\nexport function createDockerContext(config?: SpawnConfig): ExecutionContext {\n  let counter = 0\n  const containers = new Map<string, ContainerRef>()\n  const defaultImage = config?.image ?? 'oven/bun:latest'\n  const defaultCwd = config?.cwd ?? '/workspace'\n  const defaultEnv = config?.env\n  const defaultLimits = config?.limits\n\n  async function getDockerode() {\n    try {\n      const Dockerode = (await import('dockerode')).default\n      return new Dockerode()\n    }\n    catch {\n      throw new Error('dockerode is required for Docker execution context. Install it with: bun add dockerode')\n    }\n  }\n\n  const ctx: ExecutionContext = {\n    type: 'docker',\n\n    capabilities: {\n      shell: true,\n      filesystem: true,\n      network: true,\n      gpu: false,\n    } satisfies ContextCapabilities,\n\n    async spawn(overrides?: SpawnConfig): Promise<ExecutionHandle> {\n      const docker = await getDockerode()\n      const id = `docker-${++counter}`\n      const image = overrides?.image ?? defaultImage\n      const cwd = overrides?.cwd ?? defaultCwd\n\n      // Pull image if not available\n      try {\n        await docker.getImage(image).inspect()\n      }\n      catch {\n        await new Promise<void>((resolve, reject) => {\n          docker.pull(image, (err: Error | null, stream: NodeJS.ReadableStream) => {\n            if (err)\n              return reject(err)\n            docker.modem.followProgress(stream, (err2: Error | null) => {\n              err2 ? reject(err2) : resolve()\n            })\n          })\n        })\n      }\n\n      const limits = { ...defaultLimits, ...overrides?.limits }\n      const hostConfig: Record<string, unknown> = {}\n\n      if (limits?.memory) {\n        hostConfig.Memory = limits.memory * 1024 * 1024\n      }\n      if (limits?.cpu) {\n        hostConfig.NanoCpus = Number.parseFloat(limits.cpu) * 1e9\n      }\n\n      const env = { ...defaultEnv, ...overrides?.env }\n\n      const container = await docker.createContainer({\n        Image: image,\n        Cmd: ['sleep', 'infinity'],\n        WorkingDir: cwd,\n        Env: Object.entries(env).map(([k, v]) => `${k}=${v}`),\n        HostConfig: hostConfig,\n      })\n\n      await container.start()\n\n      const handle: ExecutionHandle = { id, type: 'docker', cwd }\n      containers.set(id, { handle, container, docker })\n      return handle\n    },\n\n    async exec(handle: ExecutionHandle, command: string, options?: { cwd?: string, env?: Record<string, string>, timeout?: number }): Promise<ExecResult> {\n      const ref = containers.get(handle.id)\n      if (!ref)\n        throw new Error(`Container ${handle.id} not found`)\n\n      const execCwd = options?.cwd ?? handle.cwd\n      const env = options?.env\n        ? Object.entries(options.env).map(([k, v]) => `${k}=${v}`)\n        : []\n\n      const exec = await ref.container.exec({\n        Cmd: ['sh', '-c', command],\n        WorkingDir: execCwd,\n        Env: env,\n        AttachStdout: true,\n        AttachStderr: true,\n      })\n\n      const stream = await exec.start({ Detach: false })\n\n      return new Promise<ExecResult>((resolve) => {\n        let stdout = ''\n        let stderr = ''\n        let resolved = false\n\n        // Docker's exec stream is a multiplexed protocol — a single byte\n        // stream that interleaves stdout/stderr frames. `demuxStream`\n        // splits the two onto separate writable sinks. Without it, every\n        // byte landed on `stdout` and `stderr` was permanently empty.\n        const stdoutSink = {\n          write(chunk: Buffer | string) {\n            stdout += typeof chunk === 'string' ? chunk : chunk.toString('utf-8')\n            return true\n          },\n          end() {},\n          on() {},\n          once() {},\n          emit() { return true },\n        }\n        const stderrSink = {\n          write(chunk: Buffer | string) {\n            stderr += typeof chunk === 'string' ? chunk : chunk.toString('utf-8')\n            return true\n          },\n          end() {},\n          on() {},\n          once() {},\n          emit() { return true },\n        }\n        try {\n          ref.docker.modem.demuxStream(stream, stdoutSink, stderrSink)\n        }\n        catch {\n          // Older / different transports may not be multiplexed (TTY mode);\n          // fall back to a raw stdout reader so we don't lose output entirely.\n          stream.on('data', (chunk: Buffer) => {\n            stdout += chunk.toString('utf-8')\n          })\n        }\n\n        const timeout = options?.timeout ?? defaultLimits?.timeout ?? 30\n        const timer = setTimeout(() => {\n          if (resolved)\n            return\n          resolved = true\n          // Best-effort: detach the stream so we stop accumulating bytes\n          // from a runaway exec. The exec itself can't be killed cleanly\n          // through the dockerode exec API; the container's destroy() path\n          // (or a manual `docker exec kill`) is the real cleanup.\n          try { stream.destroy?.() }\n          catch { /* swallow */ }\n          resolve({ stdout, stderr: stderr ? `${stderr}\\n[timeout]` : '[timeout]', exitCode: 124 })\n        }, timeout * 1000)\n\n        stream.on('end', async () => {\n          if (resolved)\n            return\n          resolved = true\n          clearTimeout(timer)\n          let exitCode = 0\n          try {\n            const inspect = await exec.inspect()\n            exitCode = inspect.ExitCode ?? 0\n          }\n          catch {\n            // If inspect fails after a clean stream end, treat as success\n            // — we already received the full output stream.\n          }\n          resolve({ stdout, stderr, exitCode })\n        })\n\n        stream.on('error', (err: Error) => {\n          if (resolved)\n            return\n          resolved = true\n          clearTimeout(timer)\n          resolve({ stdout, stderr: stderr ? `${stderr}\\n${err.message}` : err.message, exitCode: 1 })\n        })\n      })\n    },\n\n    async readFile(handle: ExecutionHandle, path: string): Promise<string> {\n      const result = await ctx.exec(handle, `cat ${JSON.stringify(path)}`)\n      if (result.exitCode !== 0)\n        throw new Error(`Failed to read file: ${result.stderr}`)\n      return result.stdout\n    },\n\n    async writeFile(handle: ExecutionHandle, path: string, content: string): Promise<void> {\n      const escaped = content.replace(SINGLE_QUOTE_RE, String.raw`'\\''`)\n      const result = await ctx.exec(handle, `mkdir -p \"$(dirname ${JSON.stringify(path)})\" && printf '%s' '${escaped}' > ${JSON.stringify(path)}`)\n      if (result.exitCode !== 0)\n        throw new Error(`Failed to write file: ${result.stderr}`)\n    },\n\n    async listFiles(handle: ExecutionHandle, path: string): Promise<string[]> {\n      const result = await ctx.exec(handle, `ls -1 ${JSON.stringify(path)}`)\n      if (result.exitCode !== 0)\n        return []\n      return result.stdout.trim().split('\\n').filter(Boolean)\n    },\n\n    async destroy(handle: ExecutionHandle): Promise<void> {\n      const ref = containers.get(handle.id)\n      if (!ref)\n        return\n\n      try {\n        await ref.container.stop({ t: 5 })\n        await ref.container.remove({ force: true })\n      }\n      catch {\n        // Container may already be stopped\n      }\n\n      containers.delete(handle.id)\n    },\n  }\n\n  return ctx\n}\n"],"mappings":"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"}

package/dist/{contexts-BOtMvzli.js → contexts-BD2U_xpi.js}

@@ -1,6 +1,6 @@
 import { dirname, resolve } from "node:path";
-import { spawn } from "node:child_process";
 import { createWriteStream } from "node:fs";
+import { spawn } from "node:child_process";
 import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 //#region src/contexts/process.ts
 /**
@@ -469,4 +469,4 @@ function createSandboxContext(provider) {
 //#endregion
 export { createProcessContext as n, createSandboxContext as t };
 
-//# sourceMappingURL=contexts-BOtMvzli.js.map
+//# sourceMappingURL=contexts-BD2U_xpi.js.map

package/dist/{contexts-BOtMvzli.js.map → contexts-BD2U_xpi.js.map}

@@ -1 +1 @@
-{"version":3,"file":"contexts-BOtMvzli.js","names":["spawnChild"],"sources":["../src/contexts/process.ts","../src/contexts/sandbox.ts"],"sourcesContent":["/**\n * In-process execution context.\n *\n * Runs everything in the current Node/Bun process.\n * No isolation — fastest, used as the default.\n */\n\nimport type { Buffer } from 'node:buffer'\nimport type { ChildProcess } from 'node:child_process'\nimport type { WriteStream } from 'node:fs'\nimport type { ContextCapabilities, ExecResult, ExecutionContext, ExecutionHandle, SpawnConfig, TaskEntry, TaskExitInfo, TaskHandle } from './types'\nimport { spawn as spawnChild } from 'node:child_process'\nimport { createWriteStream } from 'node:fs'\nimport { mkdir, readdir, readFile, writeFile } from 'node:fs/promises'\nimport { dirname, resolve } from 'node:path'\n\n/**\n * Whether the host supports POSIX process groups (the `detached: true` +\n * `process.kill(-pid)` combination). Windows doesn't — its job-object\n * model is shaped differently — so on win32 we fall back to killing the\n * shell wrapper alone (matches pre-fix behavior; better than nothing).\n */\nconst SUPPORTS_PROCESS_GROUPS = process.platform !== 'win32'\n\n/**\n * Default cap on captured stdout / stderr per child. Matches the\n * pre-fix `child_process.exec` setting so existing callers see the\n * same buffer envelope. Output beyond this is truncated and a\n * marker is appended to stderr.\n */\nconst DEFAULT_MAX_BUFFER = 10 * 1024 * 1024\n\n/**\n * Sanitize a task id before it's joined into a filesystem path.\n *\n * We mint `bash_<n>` ids ourselves (no user input flows into the path\n * for `ProcessContext`), so this is defensive — but third-party contexts\n * MAY accept caller-provided ids, so the helper exists for them too.\n * Anything that doesn't match the expected shape is rejected — never\n * coerced — so the call site sees a clear error rather than a\n * traversal-shaped path.\n */\nconst TASK_ID_RE = /^[a-z][\\w-]*$/i\n\nfunction assertSafeTaskId(taskId: string): void {\n  if (!TASK_ID_RE.test(taskId))\n    throw new Error(`Invalid task id \"${taskId}\" — must match ${TASK_ID_RE}.`)\n}\n\n/**\n * Format `date` as `YYYYMMDD-HHMMSS-mmm` in UTC.\n *\n * Pinned to UTC so the lexical sort of two timestamps always matches\n * their chronological order (local time + DST does not). Used as the\n * per-context suffix on background-task log filenames; see the field\n * doc on `contextTimestamp` for the why.\n */\nexport function formatContextTimestamp(date: Date): string {\n  const pad2 = (n: number): string => n.toString().padStart(2, '0')\n  const pad3 = (n: number): string => n.toString().padStart(3, '0')\n  const y = date.getUTCFullYear()\n  const M = pad2(date.getUTCMonth() + 1)\n  const d = pad2(date.getUTCDate())\n  const h = pad2(date.getUTCHours())\n  const m = pad2(date.getUTCMinutes())\n  const s = pad2(date.getUTCSeconds())\n  const ms = pad3(date.getUTCMilliseconds())\n  return `${y}${M}${d}-${h}${m}${s}-${ms}`\n}\n\n/** Pattern of a background-task log filename. Used by tests + tooling. */\nexport const TASK_LOG_FILENAME_RE = /^(bash_\\d+)\\.(\\d{8}-\\d{6}-\\d{3})\\.log$/\n\nexport function createProcessContext(config?: SpawnConfig): ExecutionContext {\n  let counter = 0\n  const handles = new Map<string, ExecutionHandle>()\n  const defaultCwd = config?.cwd ?? process.cwd()\n  const defaultEnv = config?.env\n\n  /**\n   * Per-context background-task registry. Entries live for the context's\n   * lifetime — even after the child exits — so the model can read output\n   * of completed tasks until `destroy()` tears everything down. Kept as\n   * a plain Map (not a class) per code-quality checklist #7: no premature\n   * abstraction. The state and the operations on it live inline.\n   */\n  const tasks = new Map<string, TaskState>()\n  let taskCounter = 0\n\n  /**\n   * Per-context UTC timestamp segment baked into every background task's\n   * log filename. Same `taskCounter` value across two contexts (e.g. a\n   * TUI restart) would otherwise re-open the SAME `bash_<n>.log` file —\n   * we open with `flags: 'a'` so the new task would APPEND into the old\n   * log, producing scrambled output. The timestamp guarantees each\n   * context owns a distinct log filename without forcing the\n   * model-facing task id (`bash_<n>`) to grow longer.\n   *\n   * Format: `YYYYMMDD-HHMMSS-mmm` in UTC.\n   *   - Sortable (lexical sort = chronological sort).\n   *   - Unambiguous (UTC sidesteps DST / locale shifts).\n   *   - Filesystem-safe (digits + hyphens only).\n   *   - Millisecond precision avoids same-second-restart collisions.\n   *\n   * The timestamp is computed once per context, NOT per task — all of a\n   * context's tasks share the same suffix so a directory listing groups\n   * cleanly by \"which run produced these\".\n   */\n  const contextTimestamp = formatContextTimestamp(new Date())\n\n  /**\n   * Last-resort orphan reaper. With `detached: true`, background tasks\n   * are in their OWN process group — when the parent (zidane TUI) dies,\n   * the OS does NOT send them SIGHUP and they keep running indefinitely.\n   * The user's \"Ctrl+C the TUI\" intent is \"stop everything I started\",\n   * not \"leak a `sleep 60` into the background\".\n   *\n   * `process.on('exit')` fires SYNCHRONOUSLY on `process.exit()` AND on\n   * natural shutdown — exactly the seam we need. The handler can only\n   * do synchronous work (Node ignores async), but `process.kill` IS\n   * synchronous, so a SIGTERM-the-group sweep lands cleanly. The kill\n   * is best-effort: already-dead children throw ESRCH (swallowed).\n   *\n   * Registered lazily on first `execBackground` so contexts that never\n   * background a task don't pay the listener cost. Deregistered in\n   * `destroy()` so reconstructed contexts don't accumulate listeners\n   * (Node warns past 10 — a long-running session that switches sessions\n   * frequently would otherwise hit that).\n   */\n  let exitHandlerRegistered = false\n  const exitHandler = (): void => {\n    for (const task of tasks.values()) {\n      if (task.status !== 'running')\n        continue\n      const pid = task.child.pid\n      if (pid === undefined)\n        continue\n      try {\n        if (SUPPORTS_PROCESS_GROUPS)\n          process.kill(-pid, 'SIGTERM')\n        else\n          process.kill(pid, 'SIGTERM')\n      }\n      catch {\n        // ESRCH (already dead) / EPERM (lost ownership). Swallow —\n        // the process either won't kill cleanly OR is already gone,\n        // both acceptable at shutdown.\n      }\n    }\n  }\n\n  return {\n    type: 'process',\n\n    capabilities: {\n      shell: true,\n      filesystem: true,\n      network: true,\n      gpu: false,\n    } satisfies ContextCapabilities,\n\n    async spawn(overrides?: SpawnConfig): Promise<ExecutionHandle> {\n      const id = `process-${++counter}`\n      const cwd = overrides?.cwd ?? defaultCwd\n\n      await mkdir(cwd, { recursive: true })\n\n      const handle: ExecutionHandle = { id, type: 'process', cwd }\n      handles.set(id, handle)\n      return handle\n    },\n\n    async exec(\n      handle: ExecutionHandle,\n      command: string,\n      options?: { cwd?: string, env?: Record<string, string>, timeout?: number, signal?: AbortSignal },\n    ): Promise<ExecResult> {\n      const cwd = options?.cwd ? resolve(handle.cwd, options.cwd) : handle.cwd\n\n      // Pre-aborted fast path: skip the spawn entirely and synthesize a\n      // killed-by-signal result. Saves a spawn round-trip + dodges Node\n      // emitting an immediate `AbortError`.\n      if (options?.signal?.aborted) {\n        return { stdout: '', stderr: 'aborted by signal before spawn', exitCode: 143 }\n      }\n\n      const timeoutMs = (options?.timeout ?? config?.limits?.timeout ?? 30) * 1000\n      const maxBuffer = DEFAULT_MAX_BUFFER\n\n      return new Promise<ExecResult>((resolveP) => {\n        // Spawn as a NEW process group leader so we can kill the whole\n        // subtree on abort. Without `detached: true`, sending SIGTERM to\n        // the shell's pid only kills the shell wrapper — its child\n        // processes (the actual `sleep`, `npm`, `python`, …) get\n        // reparented to init and keep running. `process.kill(-pid, …)`\n        // with a NEGATIVE pid targets the whole process group; that's\n        // the POSIX idiom for \"shut down everything I started\".\n        //\n        // On Windows there are no process groups in the POSIX sense, so\n        // we leave `detached` off and accept the shell-only kill — the\n        // platform's job-object machinery is the path forward there if\n        // we ever need it, but it's not the bug zidane's users are\n        // hitting today.\n        const child = spawnChild('/bin/sh', ['-c', command], {\n          cwd,\n          env: { ...process.env, ...defaultEnv, ...options?.env },\n          stdio: ['ignore', 'pipe', 'pipe'],\n          detached: SUPPORTS_PROCESS_GROUPS,\n        })\n\n        let stdout = ''\n        let stderr = ''\n        let bufferTruncated = false\n        let timedOut = false\n        let killedByAbort = false\n        let settled = false\n\n        const appendCapped = (slot: 'stdout' | 'stderr', chunk: Buffer): void => {\n          const current = slot === 'stdout' ? stdout : stderr\n          if (current.length >= maxBuffer)\n            return\n          const room = maxBuffer - current.length\n          const piece = chunk.length <= room ? chunk.toString('utf8') : chunk.subarray(0, room).toString('utf8')\n          if (slot === 'stdout')\n            stdout += piece\n          else\n            stderr += piece\n          if (chunk.length > room) {\n            bufferTruncated = true\n            // Kill on overflow — matches `execAsync`'s `maxBuffer`\n            // behavior (which kills the child and surfaces an error).\n            killProcessGroup(child, 'SIGTERM')\n          }\n        }\n\n        child.stdout?.on('data', chunk => appendCapped('stdout', chunk as Buffer))\n        child.stderr?.on('data', chunk => appendCapped('stderr', chunk as Buffer))\n\n        const timeoutTimer = timeoutMs > 0\n          ? setTimeout(() => {\n              timedOut = true\n              killProcessGroup(child, 'SIGTERM')\n            }, timeoutMs)\n          : undefined\n\n        const onAbort = (): void => {\n          killedByAbort = true\n          killProcessGroup(child, 'SIGTERM')\n        }\n        const userSignal = options?.signal\n        if (userSignal)\n          userSignal.addEventListener('abort', onAbort, { once: true })\n\n        const settle = (exitCode: number, extraStderr?: string): void => {\n          if (settled)\n            return\n          settled = true\n          if (timeoutTimer)\n            clearTimeout(timeoutTimer)\n          if (userSignal)\n            userSignal.removeEventListener('abort', onAbort)\n          const finalStderr = extraStderr\n            ? (stderr ? `${stderr}\\n${extraStderr}` : extraStderr)\n            : stderr\n          resolveP({ stdout, stderr: finalStderr, exitCode })\n        }\n\n        child.on('error', (err) => {\n          // Spawn failure (ENOENT on `/bin/sh`, EACCES, …). Mirror\n          // `execAsync`'s \"rejects with an Error\" shape by surfacing\n          // the message on stderr and a non-zero exit.\n          settle(1, err.message)\n        })\n\n        child.on('close', (code, signal) => {\n          // Order matters: killed-by-our-abort wins over timeout wins\n          // over natural exit, because the abort listener fires first\n          // when the user cancels mid-timeout-window. All three land\n          // here through `close`, but we tag the stderr suffix /\n          // exit-code differently so callers can tell the cause.\n          if (killedByAbort) {\n            settle(143, 'aborted by signal')\n            return\n          }\n          if (timedOut) {\n            settle(124, `command timed out after ${timeoutMs}ms`)\n            return\n          }\n          if (bufferTruncated) {\n            settle(143, `output exceeded ${maxBuffer}-byte buffer; process killed`)\n            return\n          }\n          if (signal) {\n            // Killed by some other signal we didn't issue. Treat as\n            // signal-killed for consumer compat.\n            settle(128 + 15, `terminated by signal ${signal}`)\n            return\n          }\n          settle(typeof code === 'number' ? code : 1)\n        })\n      })\n    },\n\n    async readFile(handle: ExecutionHandle, path: string): Promise<string> {\n      return readFile(resolve(handle.cwd, path), 'utf-8')\n    },\n\n    async readFileBinary(handle: ExecutionHandle, path: string): Promise<Uint8Array> {\n      // No encoding → returns a Buffer (which is a Uint8Array). Used by\n      // read_file to ferry image / binary content into the multimodal route.\n      const buf = await readFile(resolve(handle.cwd, path))\n      return new Uint8Array(buf)\n    },\n\n    async writeFile(handle: ExecutionHandle, path: string, content: string): Promise<void> {\n      const fullPath = resolve(handle.cwd, path)\n      await mkdir(dirname(fullPath), { recursive: true })\n      await writeFile(fullPath, content, 'utf-8')\n    },\n\n    async listFiles(handle: ExecutionHandle, path: string): Promise<string[]> {\n      return readdir(resolve(handle.cwd, path))\n    },\n\n    async execBackground(\n      handle: ExecutionHandle,\n      command: string,\n      options: {\n        cwd?: string\n        env?: Record<string, string>\n        outputDir: string\n        onExit: (info: TaskExitInfo) => void\n      },\n    ): Promise<TaskHandle> {\n      const cwd = options.cwd ? resolve(handle.cwd, options.cwd) : handle.cwd\n\n      await mkdir(options.outputDir, { recursive: true })\n\n      // Mint id + path. The id is sequential per context (model-facing,\n      // short, ergonomic for `shell_kill`). The log FILENAME embeds the\n      // context's start timestamp so two contexts sharing an `outputDir`\n      // (TUI restart on the same session, concurrent zidane instances,\n      // …) never resolve to the same file — we open with `flags: 'a'`\n      // and a name collision would interleave their output. Path\n      // validation is defensive — we mint our own ids so it never trips\n      // today, but it pins the invariant for forks / third parties.\n      const taskId = `bash_${++taskCounter}`\n      assertSafeTaskId(taskId)\n      const outputPath = resolve(options.outputDir, `${taskId}.${contextTimestamp}.log`)\n\n      // Install the orphan reaper on first task. See `exitHandler`'s\n      // JSDoc for the kill-on-shutdown rationale.\n      if (!exitHandlerRegistered) {\n        process.on('exit', exitHandler)\n        exitHandlerRegistered = true\n      }\n\n      // Open the output file. The timestamped path is unique per context\n      // so a brand-new file is the expected outcome; `flags: 'a'` is kept\n      // as the safe default (preserves bytes if the path collides for any\n      // reason — same-millisecond context creation, manual pre-population,\n      // etc.) rather than blindly truncating. Streams are opened BEFORE\n      // the spawn to avoid a race where the child writes before the stream\n      // is ready — `child_process` buffers stdio until the consumer\n      // attaches, but the FS handle has to exist either way for our pipe.\n      const outputStream: WriteStream = createWriteStream(outputPath, { flags: 'a' })\n      // Surface FS errors (ENOSPC, EACCES on a remounted FS, etc.)\n      // under ZIDANE_DEBUG instead of crashing the host via an\n      // unhandled 'error' event. Without a listener Node escalates\n      // any stream-level error to an uncaughtException and the whole\n      // process exits — the model and the user would lose every\n      // unrelated in-flight piece of work to one bad task's disk\n      // hiccup. Swallow + log is the safer default for a fire-and-\n      // forget log writer; the task's exit code still reports.\n      outputStream.on('error', (err) => {\n        if (process.env.ZIDANE_DEBUG)\n          process.stderr.write(`[zidane/contexts] task ${taskId} log stream error: ${err.message}\\n`)\n      })\n\n      // Spawn as a NEW process group leader so we can kill the whole\n      // subtree on demand. Same primitive `exec` uses for foreground\n      // shells — see the long comment in that method for the\n      // process-group rationale.\n      const child = spawnChild('/bin/sh', ['-c', command], {\n        cwd,\n        env: { ...process.env, ...defaultEnv, ...options.env },\n        stdio: ['ignore', 'pipe', 'pipe'],\n        detached: SUPPORTS_PROCESS_GROUPS,\n      })\n\n      const state: TaskState = {\n        taskId,\n        handleId: handle.id,\n        pid: child.pid ?? -1,\n        command,\n        cwd,\n        startedAt: Date.now(),\n        outputPath,\n        outputStream,\n        child,\n        status: 'running',\n        bytesWritten: 0,\n        settled: false,\n        onExit: options.onExit,\n      }\n      tasks.set(taskId, state)\n\n      // Pipe both streams into the same file. Order between stdout and\n      // stderr is preserved per-stream; cross-stream ordering depends on\n      // Node's event loop — acceptable interleaving for log-shaped\n      // output. Tracked-bytes is updated on every chunk for the\n      // listBackground UX.\n      const appendChunk = (chunk: Buffer): void => {\n        state.bytesWritten += chunk.length\n        outputStream.write(chunk)\n      }\n      child.stdout?.on('data', chunk => appendChunk(chunk as Buffer))\n      child.stderr?.on('data', chunk => appendChunk(chunk as Buffer))\n\n      // Settle path — at-most-once via `settled` flag (checklist #14).\n      // Three trigger sources: `close` (natural OR signal-killed),\n      // `error` (spawn failure), explicit `killBackground` (which\n      // routes through `close` itself after the SIGTERM lands).\n      const settle = (cause: 'close' | 'error', code: number | null, signal: NodeJS.Signals | null, errMessage?: string): void => {\n        if (state.settled)\n          return\n        state.settled = true\n\n        // Determine final status from cause + signal.\n        const status: TaskExitInfo['status']\n          = signal === 'SIGTERM' || state.killRequested\n            ? 'killed'\n            : 'exited'\n        // Signal-killed children report null `code` from Node; map back\n        // to the POSIX `128 + signum` convention so consumers can read\n        // an integer either way.\n        const exitCode = code !== null\n          ? code\n          : signal === 'SIGTERM'\n            ? 143\n            : signal\n              ? 128\n              : 1\n        state.status = status\n        state.exitCode = exitCode\n        if (signal)\n          state.signal = signal\n\n        // Flush + close the WriteStream BEFORE firing onExit — model\n        // may read the file in the same turn it receives the\n        // notification, and a still-open stream can hold tail bytes\n        // back from disk. `stream.end(callback)` is the documented\n        // \"all queued writes are flushed when this fires\" idiom.\n        //\n        // ORDER MATTERS: any error preamble we want in the log file\n        // (spawn failures with no stdout, buffer overflows) MUST be\n        // written BEFORE `end()` — once `end()` is called the stream\n        // is closed for writing and subsequent `.write()` calls are\n        // dropped. Earlier revisions had this reversed and silently\n        // lost ENOENT-on-`/bin/sh` messages.\n        if (errMessage) {\n          try {\n            outputStream.write(`\\n${errMessage}\\n`)\n          }\n          catch {\n            // Stream may have errored before this — best-effort only.\n          }\n        }\n        outputStream.end(() => {\n          // `stateToTaskExitInfo` reads the same fields we just set\n          // on `state`, so the snapshot the consumer gets matches the\n          // post-settle state exactly.\n          try {\n            state.onExit(stateToTaskExitInfo(state))\n          }\n          catch (err) {\n            // Defensive — a buggy onExit callback shouldn't crash the\n            // host. Surface via stderr under ZIDANE_DEBUG; otherwise\n            // swallow. Matches the spawn-tool's bubbleError pattern.\n            if (process.env.ZIDANE_DEBUG)\n              process.stderr.write(`[zidane/contexts] task ${taskId} onExit threw: ${err instanceof Error ? err.message : String(err)}\\n`)\n          }\n        })\n      }\n\n      child.on('close', (code, signal) => settle('close', code, signal))\n      child.on('error', err => settle('error', null, null, `[spawn error] ${err.message}`))\n\n      return { taskId, pid: state.pid, outputPath }\n    },\n\n    async killBackground(handle: ExecutionHandle, taskId: string): Promise<TaskExitInfo | null> {\n      const state = tasks.get(taskId)\n      // Two miss cases collapse into one `null` return: unknown id, AND\n      // known-id-but-not-owned-by-this-handle. The second case is the\n      // subagent-can't-kill-parent-tasks defense; surfacing it as a\n      // distinct error would leak the existence of the parent's task\n      // to the subagent's model, which violates the per-handle\n      // isolation contract.\n      if (!state || state.handleId !== handle.id)\n        return null\n      // Already exited — return the cached info. We don't keep a\n      // separate cached exit; the state itself carries every field\n      // `TaskExitInfo` needs and `stateToTaskExitInfo` projects it.\n      if (state.status !== 'running')\n        return stateToTaskExitInfo(state)\n\n      // Mark the intent BEFORE issuing the kill so the close handler\n      // classifies the exit as `'killed'` even on platforms where the\n      // SIGTERM-via-group lands faster than the close event drains.\n      // (Checklist #14: at-most-once settle, plus correct status\n      // classification regardless of event ordering.)\n      state.killRequested = true\n\n      // Wait for the existing close listener to fire — `settle()` does\n      // all the flushing + onExit work. We just sit on a one-shot\n      // promise tied to the `child.on('close')` we already registered\n      // at spawn time.\n      const closed = new Promise<void>((resolveP) => {\n        if (state.settled) {\n          resolveP()\n          return\n        }\n        const originalOnExit = state.onExit\n        state.onExit = (info) => {\n          originalOnExit(info)\n          resolveP()\n        }\n      })\n\n      killProcessGroup(state.child, 'SIGTERM')\n      await closed\n      return stateToTaskExitInfo(state)\n    },\n\n    async reassignBackgroundTasks(\n      fromHandle: ExecutionHandle,\n      toHandle: ExecutionHandle,\n      newOnExit?: (info: TaskExitInfo) => void,\n    ): Promise<readonly TaskEntry[]> {\n      // No-op when source = destination — keeps the spawn.ts call site\n      // unconditional without forcing it to dedupe.\n      if (fromHandle.id === toHandle.id)\n        return []\n      const promoted: TaskEntry[] = []\n      for (const state of tasks.values()) {\n        if (state.handleId !== fromHandle.id || state.status !== 'running')\n          continue\n        state.handleId = toHandle.id\n        // Replace the natural-exit callback. The original closed over\n        // the spawning agent's hook bus, which is about to be destroyed\n        // — without rewiring, the task's eventual `background:exit`\n        // fires into a torn-down hookable and the parent never learns.\n        if (newOnExit)\n          state.onExit = newOnExit\n        promoted.push(stateToTaskEntry(state))\n      }\n      return promoted\n    },\n\n    async listBackground(handle: ExecutionHandle): Promise<readonly TaskEntry[]> {\n      // Snapshot — callers must not assume the returned array stays\n      // in sync with the live registry. Sorted by startedAt so the\n      // model / UI sees consistent ordering across calls. Scoped to\n      // the calling handle so subagents don't see the parent's tasks\n      // (and vice versa) in their listing.\n      return [...tasks.values()]\n        .filter(s => s.handleId === handle.id)\n        .sort((a, b) => a.startedAt - b.startedAt)\n        .map(stateToTaskEntry)\n    },\n\n    async destroy(handle: ExecutionHandle): Promise<void> {\n      // Kill every still-running background task SPAWNED THROUGH THIS\n      // HANDLE before tearing the handle down. SIGTERM the groups,\n      // await the close + flush, THEN drop the registry entries.\n      // Sequential — destroy is one-shot teardown, the few ms of extra\n      // latency aren't worth the synchronization complexity.\n      //\n      // The handle scope matters when the same `ExecutionContext` is\n      // shared across a parent agent and its `spawn`-ed subagents (the\n      // default — `spawn.ts` passes `execution: ctx.execution`). Each\n      // agent mints its own `ExecutionHandle` and registers its\n      // background tasks under that handle's id. Without the filter,\n      // a child agent's `destroy()` (fired by `spawn.ts`'s `finally`\n      // when the subagent finishes / is cancelled) would walk the\n      // shared registry and SIGTERM the parent's tasks too. So\n      // cancelling a subagent that has its own background shells now\n      // correctly kills JUST those subagent shells, leaving the\n      // parent's intact.\n      const survivors = [...tasks.values()].filter(s => s.handleId === handle.id && !s.settled)\n      await Promise.all(survivors.map(async (state) => {\n        state.killRequested = true\n        await new Promise<void>((resolveP) => {\n          const originalOnExit = state.onExit\n          state.onExit = (info) => {\n            originalOnExit(info)\n            resolveP()\n          }\n          killProcessGroup(state.child, 'SIGTERM')\n        })\n      }))\n      // Drop only this handle's tasks from the registry. Other handles\n      // (siblings, parent) keep their entries.\n      for (const [taskId, state] of tasks) {\n        if (state.handleId === handle.id)\n          tasks.delete(taskId)\n      }\n      handles.delete(handle.id)\n      // Drop the orphan reaper ONLY when no handles remain — otherwise\n      // a child's `destroy()` would strip the parent's safety net. The\n      // reaper protects every still-tracked task in the context, so it\n      // sticks around until the LAST handle is gone.\n      //\n      // Without this guard, the spawn-tool sequence\n      //   parent.spawn(child) → child.run() → child.destroy() (auto)\n      // would deregister the handler mid-parent-lifetime. The parent's\n      // own subsequent Ctrl+C orphan-kill safety would silently degrade.\n      if (exitHandlerRegistered && handles.size === 0) {\n        process.off('exit', exitHandler)\n        exitHandlerRegistered = false\n      }\n    },\n  }\n}\n\n/**\n * Per-task state. Lives in the context's `tasks` registry. Fields are\n * mutated in place by the spawn / close / kill / destroy code paths —\n * the registry isn't immutable. Treat the type as a record-of-cells,\n * not a value.\n */\ninterface TaskState {\n  taskId: string\n  /**\n   * `ExecutionHandle.id` of the spawning agent. The registry is\n   * context-scoped (one Map shared across all handles a context minted),\n   * so a per-task owner tag is what scopes `listBackground` /\n   * `killBackground` / `destroy` to the calling handle's slice.\n   *\n   * Without this, a subagent spawned via `spawn` tool — which inherits\n   * the parent's `ExecutionContext` but mints its OWN handle — would\n   * see (and accidentally kill on `destroy()`) every task the parent\n   * had running. Came up the first time the model spawned a subagent\n   * that ran a background task: the subagent's run-end `destroy()`\n   * SIGTERMed the parent's `npm run dev` mid-flight.\n   */\n  handleId: string\n  pid: number\n  command: string\n  cwd: string\n  startedAt: number\n  outputPath: string\n  outputStream: WriteStream\n  child: ChildProcess\n  status: 'running' | 'exited' | 'killed'\n  exitCode?: number\n  signal?: NodeJS.Signals\n  bytesWritten: number\n  /**\n   * `at-most-once` settle latch. Multiple trigger sources (`close`,\n   * `error`, `kill`) can race; the flag dedupes so `onExit` fires\n   * exactly once per task (checklist #14).\n   */\n  settled: boolean\n  /**\n   * Set by `killBackground` / `destroy` before issuing SIGTERM so the\n   * close handler classifies the exit as `'killed'` even when the\n   * platform delivers the close event ahead of our intent record.\n   */\n  killRequested?: boolean\n  onExit: (info: TaskExitInfo) => void\n}\n\n/**\n * Send `signal` to the child's whole process group. Falls back to a\n * single-process kill on Windows (no POSIX process groups). Shared\n * across the foreground `exec` path, the background spawn / kill\n * paths, and the shutdown-time orphan reaper — keeping one definition\n * so the kill semantics can't drift between them.\n */\nfunction killProcessGroup(child: ChildProcess, signal: NodeJS.Signals): void {\n  const pid = child.pid\n  if (pid === undefined)\n    return\n  try {\n    if (SUPPORTS_PROCESS_GROUPS)\n      process.kill(-pid, signal)\n    else\n      process.kill(pid, signal)\n  }\n  catch {\n    // ESRCH / EPERM — process is already gone (race with natural exit)\n    // or we lost the right to kill it. Both are safe to swallow.\n  }\n}\n\n/**\n * Project a `TaskState` to the `TaskEntry` shape `listBackground` and\n * `reassignBackgroundTasks` return. Single helper keeps the shape\n * consistent across both call sites (and a future addition of fields\n * to `TaskEntry` only needs to land here).\n */\nfunction stateToTaskEntry(state: TaskState): TaskEntry {\n  return {\n    taskId: state.taskId,\n    pid: state.pid,\n    command: state.command,\n    cwd: state.cwd,\n    startedAt: state.startedAt,\n    outputPath: state.outputPath,\n    status: state.status,\n    ...(state.exitCode !== undefined ? { exitCode: state.exitCode } : {}),\n    ...(state.signal ? { signal: state.signal } : {}),\n    bytesWritten: state.bytesWritten,\n  }\n}\n\n/**\n * Project a settled `TaskState` to the `TaskExitInfo` shape `settle()`\n * fires from `onExit` and `killBackground` returns on the\n * cached-exit path. Pre-condition: `state.status !== 'running'`\n * (callers gate on this).\n */\nfunction stateToTaskExitInfo(state: TaskState): TaskExitInfo {\n  return {\n    taskId: state.taskId,\n    status: state.status as Exclude<TaskState['status'], 'running'>,\n    exitCode: state.exitCode ?? 0,\n    ...(state.signal ? { signal: state.signal } : {}),\n    outputPath: state.outputPath,\n    durationMs: Date.now() - state.startedAt,\n    command: state.command,\n  }\n}\n","/**\n * Remote sandbox execution context.\n *\n * Offloads execution to a remote sandbox API (e.g. Rivet, E2B).\n * Specific providers implement the SandboxProvider interface.\n */\n\nimport type { ContextCapabilities, ExecResult, ExecutionContext, ExecutionHandle, SpawnConfig } from './types'\n\n// ---------------------------------------------------------------------------\n// Sandbox provider interface\n// ---------------------------------------------------------------------------\n\nexport interface SandboxProvider {\n  name: string\n  spawn: (config: SpawnConfig) => Promise<{ id: string, cwd: string }>\n  exec: (sandboxId: string, command: string, options?: { cwd?: string, env?: Record<string, string>, timeout?: number }) => Promise<ExecResult>\n  readFile: (sandboxId: string, path: string) => Promise<string>\n  writeFile: (sandboxId: string, path: string, content: string) => Promise<void>\n  listFiles: (sandboxId: string, path: string) => Promise<string[]>\n  destroy: (sandboxId: string) => Promise<void>\n}\n\n// ---------------------------------------------------------------------------\n// Sandbox execution context\n// ---------------------------------------------------------------------------\n\nexport function createSandboxContext(provider: SandboxProvider): ExecutionContext {\n  const sandboxes = new Map<string, string>()\n\n  function getSandboxId(handle: ExecutionHandle): string {\n    const id = sandboxes.get(handle.id)\n    if (!id)\n      throw new Error(`Sandbox ${handle.id} not found`)\n    return id\n  }\n\n  return {\n    type: 'sandbox',\n\n    capabilities: {\n      shell: true,\n      filesystem: true,\n      network: true,\n      gpu: false,\n    } satisfies ContextCapabilities,\n\n    async spawn(config?: SpawnConfig): Promise<ExecutionHandle> {\n      const result = await provider.spawn(config ?? {})\n      const handle: ExecutionHandle = { id: result.id, type: 'sandbox', cwd: result.cwd }\n      sandboxes.set(handle.id, result.id)\n      return handle\n    },\n\n    async exec(handle: ExecutionHandle, command: string, options?): Promise<ExecResult> {\n      return provider.exec(getSandboxId(handle), command, options)\n    },\n\n    async readFile(handle: ExecutionHandle, path: string): Promise<string> {\n      return provider.readFile(getSandboxId(handle), path)\n    },\n\n    async writeFile(handle: ExecutionHandle, path: string, content: string): Promise<void> {\n      return provider.writeFile(getSandboxId(handle), path, content)\n    },\n\n    async listFiles(handle: ExecutionHandle, path: string): Promise<string[]> {\n      return provider.listFiles(getSandboxId(handle), path)\n    },\n\n    async destroy(handle: ExecutionHandle): Promise<void> {\n      const id = sandboxes.get(handle.id)\n      if (!id)\n        return\n      await provider.destroy(id)\n      sandboxes.delete(handle.id)\n    },\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"contexts-BD2U_xpi.js","names":["spawnChild"],"sources":["../src/contexts/process.ts","../src/contexts/sandbox.ts"],"sourcesContent":["/**\n * In-process execution context.\n *\n * Runs everything in the current Node/Bun process.\n * No isolation — fastest, used as the default.\n */\n\nimport type { Buffer } from 'node:buffer'\nimport type { ChildProcess } from 'node:child_process'\nimport type { WriteStream } from 'node:fs'\nimport type { ContextCapabilities, ExecResult, ExecutionContext, ExecutionHandle, SpawnConfig, TaskEntry, TaskExitInfo, TaskHandle } from './types'\nimport { spawn as spawnChild } from 'node:child_process'\nimport { createWriteStream } from 'node:fs'\nimport { mkdir, readdir, readFile, writeFile } from 'node:fs/promises'\nimport { dirname, resolve } from 'node:path'\n\n/**\n * Whether the host supports POSIX process groups (the `detached: true` +\n * `process.kill(-pid)` combination). Windows doesn't — its job-object\n * model is shaped differently — so on win32 we fall back to killing the\n * shell wrapper alone (matches pre-fix behavior; better than nothing).\n */\nconst SUPPORTS_PROCESS_GROUPS = process.platform !== 'win32'\n\n/**\n * Default cap on captured stdout / stderr per child. Matches the\n * pre-fix `child_process.exec` setting so existing callers see the\n * same buffer envelope. Output beyond this is truncated and a\n * marker is appended to stderr.\n */\nconst DEFAULT_MAX_BUFFER = 10 * 1024 * 1024\n\n/**\n * Sanitize a task id before it's joined into a filesystem path.\n *\n * We mint `bash_<n>` ids ourselves (no user input flows into the path\n * for `ProcessContext`), so this is defensive — but third-party contexts\n * MAY accept caller-provided ids, so the helper exists for them too.\n * Anything that doesn't match the expected shape is rejected — never\n * coerced — so the call site sees a clear error rather than a\n * traversal-shaped path.\n */\nconst TASK_ID_RE = /^[a-z][\\w-]*$/i\n\nfunction assertSafeTaskId(taskId: string): void {\n  if (!TASK_ID_RE.test(taskId))\n    throw new Error(`Invalid task id \"${taskId}\" — must match ${TASK_ID_RE}.`)\n}\n\n/**\n * Format `date` as `YYYYMMDD-HHMMSS-mmm` in UTC.\n *\n * Pinned to UTC so the lexical sort of two timestamps always matches\n * their chronological order (local time + DST does not). Used as the\n * per-context suffix on background-task log filenames; see the field\n * doc on `contextTimestamp` for the why.\n */\nexport function formatContextTimestamp(date: Date): string {\n  const pad2 = (n: number): string => n.toString().padStart(2, '0')\n  const pad3 = (n: number): string => n.toString().padStart(3, '0')\n  const y = date.getUTCFullYear()\n  const M = pad2(date.getUTCMonth() + 1)\n  const d = pad2(date.getUTCDate())\n  const h = pad2(date.getUTCHours())\n  const m = pad2(date.getUTCMinutes())\n  const s = pad2(date.getUTCSeconds())\n  const ms = pad3(date.getUTCMilliseconds())\n  return `${y}${M}${d}-${h}${m}${s}-${ms}`\n}\n\n/** Pattern of a background-task log filename. Used by tests + tooling. */\nexport const TASK_LOG_FILENAME_RE = /^(bash_\\d+)\\.(\\d{8}-\\d{6}-\\d{3})\\.log$/\n\nexport function createProcessContext(config?: SpawnConfig): ExecutionContext {\n  let counter = 0\n  const handles = new Map<string, ExecutionHandle>()\n  const defaultCwd = config?.cwd ?? process.cwd()\n  const defaultEnv = config?.env\n\n  /**\n   * Per-context background-task registry. Entries live for the context's\n   * lifetime — even after the child exits — so the model can read output\n   * of completed tasks until `destroy()` tears everything down. Kept as\n   * a plain Map (not a class) per code-quality checklist #7: no premature\n   * abstraction. The state and the operations on it live inline.\n   */\n  const tasks = new Map<string, TaskState>()\n  let taskCounter = 0\n\n  /**\n   * Per-context UTC timestamp segment baked into every background task's\n   * log filename. Same `taskCounter` value across two contexts (e.g. a\n   * TUI restart) would otherwise re-open the SAME `bash_<n>.log` file —\n   * we open with `flags: 'a'` so the new task would APPEND into the old\n   * log, producing scrambled output. The timestamp guarantees each\n   * context owns a distinct log filename without forcing the\n   * model-facing task id (`bash_<n>`) to grow longer.\n   *\n   * Format: `YYYYMMDD-HHMMSS-mmm` in UTC.\n   *   - Sortable (lexical sort = chronological sort).\n   *   - Unambiguous (UTC sidesteps DST / locale shifts).\n   *   - Filesystem-safe (digits + hyphens only).\n   *   - Millisecond precision avoids same-second-restart collisions.\n   *\n   * The timestamp is computed once per context, NOT per task — all of a\n   * context's tasks share the same suffix so a directory listing groups\n   * cleanly by \"which run produced these\".\n   */\n  const contextTimestamp = formatContextTimestamp(new Date())\n\n  /**\n   * Last-resort orphan reaper. With `detached: true`, background tasks\n   * are in their OWN process group — when the parent (zidane TUI) dies,\n   * the OS does NOT send them SIGHUP and they keep running indefinitely.\n   * The user's \"Ctrl+C the TUI\" intent is \"stop everything I started\",\n   * not \"leak a `sleep 60` into the background\".\n   *\n   * `process.on('exit')` fires SYNCHRONOUSLY on `process.exit()` AND on\n   * natural shutdown — exactly the seam we need. The handler can only\n   * do synchronous work (Node ignores async), but `process.kill` IS\n   * synchronous, so a SIGTERM-the-group sweep lands cleanly. The kill\n   * is best-effort: already-dead children throw ESRCH (swallowed).\n   *\n   * Registered lazily on first `execBackground` so contexts that never\n   * background a task don't pay the listener cost. Deregistered in\n   * `destroy()` so reconstructed contexts don't accumulate listeners\n   * (Node warns past 10 — a long-running session that switches sessions\n   * frequently would otherwise hit that).\n   */\n  let exitHandlerRegistered = false\n  const exitHandler = (): void => {\n    for (const task of tasks.values()) {\n      if (task.status !== 'running')\n        continue\n      const pid = task.child.pid\n      if (pid === undefined)\n        continue\n      try {\n        if (SUPPORTS_PROCESS_GROUPS)\n          process.kill(-pid, 'SIGTERM')\n        else\n          process.kill(pid, 'SIGTERM')\n      }\n      catch {\n        // ESRCH (already dead) / EPERM (lost ownership). Swallow —\n        // the process either won't kill cleanly OR is already gone,\n        // both acceptable at shutdown.\n      }\n    }\n  }\n\n  return {\n    type: 'process',\n\n    capabilities: {\n      shell: true,\n      filesystem: true,\n      network: true,\n      gpu: false,\n    } satisfies ContextCapabilities,\n\n    async spawn(overrides?: SpawnConfig): Promise<ExecutionHandle> {\n      const id = `process-${++counter}`\n      const cwd = overrides?.cwd ?? defaultCwd\n\n      await mkdir(cwd, { recursive: true })\n\n      const handle: ExecutionHandle = { id, type: 'process', cwd }\n      handles.set(id, handle)\n      return handle\n    },\n\n    async exec(\n      handle: ExecutionHandle,\n      command: string,\n      options?: { cwd?: string, env?: Record<string, string>, timeout?: number, signal?: AbortSignal },\n    ): Promise<ExecResult> {\n      const cwd = options?.cwd ? resolve(handle.cwd, options.cwd) : handle.cwd\n\n      // Pre-aborted fast path: skip the spawn entirely and synthesize a\n      // killed-by-signal result. Saves a spawn round-trip + dodges Node\n      // emitting an immediate `AbortError`.\n      if (options?.signal?.aborted) {\n        return { stdout: '', stderr: 'aborted by signal before spawn', exitCode: 143 }\n      }\n\n      const timeoutMs = (options?.timeout ?? config?.limits?.timeout ?? 30) * 1000\n      const maxBuffer = DEFAULT_MAX_BUFFER\n\n      return new Promise<ExecResult>((resolveP) => {\n        // Spawn as a NEW process group leader so we can kill the whole\n        // subtree on abort. Without `detached: true`, sending SIGTERM to\n        // the shell's pid only kills the shell wrapper — its child\n        // processes (the actual `sleep`, `npm`, `python`, …) get\n        // reparented to init and keep running. `process.kill(-pid, …)`\n        // with a NEGATIVE pid targets the whole process group; that's\n        // the POSIX idiom for \"shut down everything I started\".\n        //\n        // On Windows there are no process groups in the POSIX sense, so\n        // we leave `detached` off and accept the shell-only kill — the\n        // platform's job-object machinery is the path forward there if\n        // we ever need it, but it's not the bug zidane's users are\n        // hitting today.\n        const child = spawnChild('/bin/sh', ['-c', command], {\n          cwd,\n          env: { ...process.env, ...defaultEnv, ...options?.env },\n          stdio: ['ignore', 'pipe', 'pipe'],\n          detached: SUPPORTS_PROCESS_GROUPS,\n        })\n\n        let stdout = ''\n        let stderr = ''\n        let bufferTruncated = false\n        let timedOut = false\n        let killedByAbort = false\n        let settled = false\n\n        const appendCapped = (slot: 'stdout' | 'stderr', chunk: Buffer): void => {\n          const current = slot === 'stdout' ? stdout : stderr\n          if (current.length >= maxBuffer)\n            return\n          const room = maxBuffer - current.length\n          const piece = chunk.length <= room ? chunk.toString('utf8') : chunk.subarray(0, room).toString('utf8')\n          if (slot === 'stdout')\n            stdout += piece\n          else\n            stderr += piece\n          if (chunk.length > room) {\n            bufferTruncated = true\n            // Kill on overflow — matches `execAsync`'s `maxBuffer`\n            // behavior (which kills the child and surfaces an error).\n            killProcessGroup(child, 'SIGTERM')\n          }\n        }\n\n        child.stdout?.on('data', chunk => appendCapped('stdout', chunk as Buffer))\n        child.stderr?.on('data', chunk => appendCapped('stderr', chunk as Buffer))\n\n        const timeoutTimer = timeoutMs > 0\n          ? setTimeout(() => {\n              timedOut = true\n              killProcessGroup(child, 'SIGTERM')\n            }, timeoutMs)\n          : undefined\n\n        const onAbort = (): void => {\n          killedByAbort = true\n          killProcessGroup(child, 'SIGTERM')\n        }\n        const userSignal = options?.signal\n        if (userSignal)\n          userSignal.addEventListener('abort', onAbort, { once: true })\n\n        const settle = (exitCode: number, extraStderr?: string): void => {\n          if (settled)\n            return\n          settled = true\n          if (timeoutTimer)\n            clearTimeout(timeoutTimer)\n          if (userSignal)\n            userSignal.removeEventListener('abort', onAbort)\n          const finalStderr = extraStderr\n            ? (stderr ? `${stderr}\\n${extraStderr}` : extraStderr)\n            : stderr\n          resolveP({ stdout, stderr: finalStderr, exitCode })\n        }\n\n        child.on('error', (err) => {\n          // Spawn failure (ENOENT on `/bin/sh`, EACCES, …). Mirror\n          // `execAsync`'s \"rejects with an Error\" shape by surfacing\n          // the message on stderr and a non-zero exit.\n          settle(1, err.message)\n        })\n\n        child.on('close', (code, signal) => {\n          // Order matters: killed-by-our-abort wins over timeout wins\n          // over natural exit, because the abort listener fires first\n          // when the user cancels mid-timeout-window. All three land\n          // here through `close`, but we tag the stderr suffix /\n          // exit-code differently so callers can tell the cause.\n          if (killedByAbort) {\n            settle(143, 'aborted by signal')\n            return\n          }\n          if (timedOut) {\n            settle(124, `command timed out after ${timeoutMs}ms`)\n            return\n          }\n          if (bufferTruncated) {\n            settle(143, `output exceeded ${maxBuffer}-byte buffer; process killed`)\n            return\n          }\n          if (signal) {\n            // Killed by some other signal we didn't issue. Treat as\n            // signal-killed for consumer compat.\n            settle(128 + 15, `terminated by signal ${signal}`)\n            return\n          }\n          settle(typeof code === 'number' ? code : 1)\n        })\n      })\n    },\n\n    async readFile(handle: ExecutionHandle, path: string): Promise<string> {\n      return readFile(resolve(handle.cwd, path), 'utf-8')\n    },\n\n    async readFileBinary(handle: ExecutionHandle, path: string): Promise<Uint8Array> {\n      // No encoding → returns a Buffer (which is a Uint8Array). Used by\n      // read_file to ferry image / binary content into the multimodal route.\n      const buf = await readFile(resolve(handle.cwd, path))\n      return new Uint8Array(buf)\n    },\n\n    async writeFile(handle: ExecutionHandle, path: string, content: string): Promise<void> {\n      const fullPath = resolve(handle.cwd, path)\n      await mkdir(dirname(fullPath), { recursive: true })\n      await writeFile(fullPath, content, 'utf-8')\n    },\n\n    async listFiles(handle: ExecutionHandle, path: string): Promise<string[]> {\n      return readdir(resolve(handle.cwd, path))\n    },\n\n    async execBackground(\n      handle: ExecutionHandle,\n      command: string,\n      options: {\n        cwd?: string\n        env?: Record<string, string>\n        outputDir: string\n        onExit: (info: TaskExitInfo) => void\n      },\n    ): Promise<TaskHandle> {\n      const cwd = options.cwd ? resolve(handle.cwd, options.cwd) : handle.cwd\n\n      await mkdir(options.outputDir, { recursive: true })\n\n      // Mint id + path. The id is sequential per context (model-facing,\n      // short, ergonomic for `shell_kill`). The log FILENAME embeds the\n      // context's start timestamp so two contexts sharing an `outputDir`\n      // (TUI restart on the same session, concurrent zidane instances,\n      // …) never resolve to the same file — we open with `flags: 'a'`\n      // and a name collision would interleave their output. Path\n      // validation is defensive — we mint our own ids so it never trips\n      // today, but it pins the invariant for forks / third parties.\n      const taskId = `bash_${++taskCounter}`\n      assertSafeTaskId(taskId)\n      const outputPath = resolve(options.outputDir, `${taskId}.${contextTimestamp}.log`)\n\n      // Install the orphan reaper on first task. See `exitHandler`'s\n      // JSDoc for the kill-on-shutdown rationale.\n      if (!exitHandlerRegistered) {\n        process.on('exit', exitHandler)\n        exitHandlerRegistered = true\n      }\n\n      // Open the output file. The timestamped path is unique per context\n      // so a brand-new file is the expected outcome; `flags: 'a'` is kept\n      // as the safe default (preserves bytes if the path collides for any\n      // reason — same-millisecond context creation, manual pre-population,\n      // etc.) rather than blindly truncating. Streams are opened BEFORE\n      // the spawn to avoid a race where the child writes before the stream\n      // is ready — `child_process` buffers stdio until the consumer\n      // attaches, but the FS handle has to exist either way for our pipe.\n      const outputStream: WriteStream = createWriteStream(outputPath, { flags: 'a' })\n      // Surface FS errors (ENOSPC, EACCES on a remounted FS, etc.)\n      // under ZIDANE_DEBUG instead of crashing the host via an\n      // unhandled 'error' event. Without a listener Node escalates\n      // any stream-level error to an uncaughtException and the whole\n      // process exits — the model and the user would lose every\n      // unrelated in-flight piece of work to one bad task's disk\n      // hiccup. Swallow + log is the safer default for a fire-and-\n      // forget log writer; the task's exit code still reports.\n      outputStream.on('error', (err) => {\n        if (process.env.ZIDANE_DEBUG)\n          process.stderr.write(`[zidane/contexts] task ${taskId} log stream error: ${err.message}\\n`)\n      })\n\n      // Spawn as a NEW process group leader so we can kill the whole\n      // subtree on demand. Same primitive `exec` uses for foreground\n      // shells — see the long comment in that method for the\n      // process-group rationale.\n      const child = spawnChild('/bin/sh', ['-c', command], {\n        cwd,\n        env: { ...process.env, ...defaultEnv, ...options.env },\n        stdio: ['ignore', 'pipe', 'pipe'],\n        detached: SUPPORTS_PROCESS_GROUPS,\n      })\n\n      const state: TaskState = {\n        taskId,\n        handleId: handle.id,\n        pid: child.pid ?? -1,\n        command,\n        cwd,\n        startedAt: Date.now(),\n        outputPath,\n        outputStream,\n        child,\n        status: 'running',\n        bytesWritten: 0,\n        settled: false,\n        onExit: options.onExit,\n      }\n      tasks.set(taskId, state)\n\n      // Pipe both streams into the same file. Order between stdout and\n      // stderr is preserved per-stream; cross-stream ordering depends on\n      // Node's event loop — acceptable interleaving for log-shaped\n      // output. Tracked-bytes is updated on every chunk for the\n      // listBackground UX.\n      const appendChunk = (chunk: Buffer): void => {\n        state.bytesWritten += chunk.length\n        outputStream.write(chunk)\n      }\n      child.stdout?.on('data', chunk => appendChunk(chunk as Buffer))\n      child.stderr?.on('data', chunk => appendChunk(chunk as Buffer))\n\n      // Settle path — at-most-once via `settled` flag (checklist #14).\n      // Three trigger sources: `close` (natural OR signal-killed),\n      // `error` (spawn failure), explicit `killBackground` (which\n      // routes through `close` itself after the SIGTERM lands).\n      const settle = (cause: 'close' | 'error', code: number | null, signal: NodeJS.Signals | null, errMessage?: string): void => {\n        if (state.settled)\n          return\n        state.settled = true\n\n        // Determine final status from cause + signal.\n        const status: TaskExitInfo['status']\n          = signal === 'SIGTERM' || state.killRequested\n            ? 'killed'\n            : 'exited'\n        // Signal-killed children report null `code` from Node; map back\n        // to the POSIX `128 + signum` convention so consumers can read\n        // an integer either way.\n        const exitCode = code !== null\n          ? code\n          : signal === 'SIGTERM'\n            ? 143\n            : signal\n              ? 128\n              : 1\n        state.status = status\n        state.exitCode = exitCode\n        if (signal)\n          state.signal = signal\n\n        // Flush + close the WriteStream BEFORE firing onExit — model\n        // may read the file in the same turn it receives the\n        // notification, and a still-open stream can hold tail bytes\n        // back from disk. `stream.end(callback)` is the documented\n        // \"all queued writes are flushed when this fires\" idiom.\n        //\n        // ORDER MATTERS: any error preamble we want in the log file\n        // (spawn failures with no stdout, buffer overflows) MUST be\n        // written BEFORE `end()` — once `end()` is called the stream\n        // is closed for writing and subsequent `.write()` calls are\n        // dropped. Earlier revisions had this reversed and silently\n        // lost ENOENT-on-`/bin/sh` messages.\n        if (errMessage) {\n          try {\n            outputStream.write(`\\n${errMessage}\\n`)\n          }\n          catch {\n            // Stream may have errored before this — best-effort only.\n          }\n        }\n        outputStream.end(() => {\n          // `stateToTaskExitInfo` reads the same fields we just set\n          // on `state`, so the snapshot the consumer gets matches the\n          // post-settle state exactly.\n          try {\n            state.onExit(stateToTaskExitInfo(state))\n          }\n          catch (err) {\n            // Defensive — a buggy onExit callback shouldn't crash the\n            // host. Surface via stderr under ZIDANE_DEBUG; otherwise\n            // swallow. Matches the spawn-tool's bubbleError pattern.\n            if (process.env.ZIDANE_DEBUG)\n              process.stderr.write(`[zidane/contexts] task ${taskId} onExit threw: ${err instanceof Error ? err.message : String(err)}\\n`)\n          }\n        })\n      }\n\n      child.on('close', (code, signal) => settle('close', code, signal))\n      child.on('error', err => settle('error', null, null, `[spawn error] ${err.message}`))\n\n      return { taskId, pid: state.pid, outputPath }\n    },\n\n    async killBackground(handle: ExecutionHandle, taskId: string): Promise<TaskExitInfo | null> {\n      const state = tasks.get(taskId)\n      // Two miss cases collapse into one `null` return: unknown id, AND\n      // known-id-but-not-owned-by-this-handle. The second case is the\n      // subagent-can't-kill-parent-tasks defense; surfacing it as a\n      // distinct error would leak the existence of the parent's task\n      // to the subagent's model, which violates the per-handle\n      // isolation contract.\n      if (!state || state.handleId !== handle.id)\n        return null\n      // Already exited — return the cached info. We don't keep a\n      // separate cached exit; the state itself carries every field\n      // `TaskExitInfo` needs and `stateToTaskExitInfo` projects it.\n      if (state.status !== 'running')\n        return stateToTaskExitInfo(state)\n\n      // Mark the intent BEFORE issuing the kill so the close handler\n      // classifies the exit as `'killed'` even on platforms where the\n      // SIGTERM-via-group lands faster than the close event drains.\n      // (Checklist #14: at-most-once settle, plus correct status\n      // classification regardless of event ordering.)\n      state.killRequested = true\n\n      // Wait for the existing close listener to fire — `settle()` does\n      // all the flushing + onExit work. We just sit on a one-shot\n      // promise tied to the `child.on('close')` we already registered\n      // at spawn time.\n      const closed = new Promise<void>((resolveP) => {\n        if (state.settled) {\n          resolveP()\n          return\n        }\n        const originalOnExit = state.onExit\n        state.onExit = (info) => {\n          originalOnExit(info)\n          resolveP()\n        }\n      })\n\n      killProcessGroup(state.child, 'SIGTERM')\n      await closed\n      return stateToTaskExitInfo(state)\n    },\n\n    async reassignBackgroundTasks(\n      fromHandle: ExecutionHandle,\n      toHandle: ExecutionHandle,\n      newOnExit?: (info: TaskExitInfo) => void,\n    ): Promise<readonly TaskEntry[]> {\n      // No-op when source = destination — keeps the spawn.ts call site\n      // unconditional without forcing it to dedupe.\n      if (fromHandle.id === toHandle.id)\n        return []\n      const promoted: TaskEntry[] = []\n      for (const state of tasks.values()) {\n        if (state.handleId !== fromHandle.id || state.status !== 'running')\n          continue\n        state.handleId = toHandle.id\n        // Replace the natural-exit callback. The original closed over\n        // the spawning agent's hook bus, which is about to be destroyed\n        // — without rewiring, the task's eventual `background:exit`\n        // fires into a torn-down hookable and the parent never learns.\n        if (newOnExit)\n          state.onExit = newOnExit\n        promoted.push(stateToTaskEntry(state))\n      }\n      return promoted\n    },\n\n    async listBackground(handle: ExecutionHandle): Promise<readonly TaskEntry[]> {\n      // Snapshot — callers must not assume the returned array stays\n      // in sync with the live registry. Sorted by startedAt so the\n      // model / UI sees consistent ordering across calls. Scoped to\n      // the calling handle so subagents don't see the parent's tasks\n      // (and vice versa) in their listing.\n      return [...tasks.values()]\n        .filter(s => s.handleId === handle.id)\n        .sort((a, b) => a.startedAt - b.startedAt)\n        .map(stateToTaskEntry)\n    },\n\n    async destroy(handle: ExecutionHandle): Promise<void> {\n      // Kill every still-running background task SPAWNED THROUGH THIS\n      // HANDLE before tearing the handle down. SIGTERM the groups,\n      // await the close + flush, THEN drop the registry entries.\n      // Sequential — destroy is one-shot teardown, the few ms of extra\n      // latency aren't worth the synchronization complexity.\n      //\n      // The handle scope matters when the same `ExecutionContext` is\n      // shared across a parent agent and its `spawn`-ed subagents (the\n      // default — `spawn.ts` passes `execution: ctx.execution`). Each\n      // agent mints its own `ExecutionHandle` and registers its\n      // background tasks under that handle's id. Without the filter,\n      // a child agent's `destroy()` (fired by `spawn.ts`'s `finally`\n      // when the subagent finishes / is cancelled) would walk the\n      // shared registry and SIGTERM the parent's tasks too. So\n      // cancelling a subagent that has its own background shells now\n      // correctly kills JUST those subagent shells, leaving the\n      // parent's intact.\n      const survivors = [...tasks.values()].filter(s => s.handleId === handle.id && !s.settled)\n      await Promise.all(survivors.map(async (state) => {\n        state.killRequested = true\n        await new Promise<void>((resolveP) => {\n          const originalOnExit = state.onExit\n          state.onExit = (info) => {\n            originalOnExit(info)\n            resolveP()\n          }\n          killProcessGroup(state.child, 'SIGTERM')\n        })\n      }))\n      // Drop only this handle's tasks from the registry. Other handles\n      // (siblings, parent) keep their entries.\n      for (const [taskId, state] of tasks) {\n        if (state.handleId === handle.id)\n          tasks.delete(taskId)\n      }\n      handles.delete(handle.id)\n      // Drop the orphan reaper ONLY when no handles remain — otherwise\n      // a child's `destroy()` would strip the parent's safety net. The\n      // reaper protects every still-tracked task in the context, so it\n      // sticks around until the LAST handle is gone.\n      //\n      // Without this guard, the spawn-tool sequence\n      //   parent.spawn(child) → child.run() → child.destroy() (auto)\n      // would deregister the handler mid-parent-lifetime. The parent's\n      // own subsequent Ctrl+C orphan-kill safety would silently degrade.\n      if (exitHandlerRegistered && handles.size === 0) {\n        process.off('exit', exitHandler)\n        exitHandlerRegistered = false\n      }\n    },\n  }\n}\n\n/**\n * Per-task state. Lives in the context's `tasks` registry. Fields are\n * mutated in place by the spawn / close / kill / destroy code paths —\n * the registry isn't immutable. Treat the type as a record-of-cells,\n * not a value.\n */\ninterface TaskState {\n  taskId: string\n  /**\n   * `ExecutionHandle.id` of the spawning agent. The registry is\n   * context-scoped (one Map shared across all handles a context minted),\n   * so a per-task owner tag is what scopes `listBackground` /\n   * `killBackground` / `destroy` to the calling handle's slice.\n   *\n   * Without this, a subagent spawned via `spawn` tool — which inherits\n   * the parent's `ExecutionContext` but mints its OWN handle — would\n   * see (and accidentally kill on `destroy()`) every task the parent\n   * had running. Came up the first time the model spawned a subagent\n   * that ran a background task: the subagent's run-end `destroy()`\n   * SIGTERMed the parent's `npm run dev` mid-flight.\n   */\n  handleId: string\n  pid: number\n  command: string\n  cwd: string\n  startedAt: number\n  outputPath: string\n  outputStream: WriteStream\n  child: ChildProcess\n  status: 'running' | 'exited' | 'killed'\n  exitCode?: number\n  signal?: NodeJS.Signals\n  bytesWritten: number\n  /**\n   * `at-most-once` settle latch. Multiple trigger sources (`close`,\n   * `error`, `kill`) can race; the flag dedupes so `onExit` fires\n   * exactly once per task (checklist #14).\n   */\n  settled: boolean\n  /**\n   * Set by `killBackground` / `destroy` before issuing SIGTERM so the\n   * close handler classifies the exit as `'killed'` even when the\n   * platform delivers the close event ahead of our intent record.\n   */\n  killRequested?: boolean\n  onExit: (info: TaskExitInfo) => void\n}\n\n/**\n * Send `signal` to the child's whole process group. Falls back to a\n * single-process kill on Windows (no POSIX process groups). Shared\n * across the foreground `exec` path, the background spawn / kill\n * paths, and the shutdown-time orphan reaper — keeping one definition\n * so the kill semantics can't drift between them.\n */\nfunction killProcessGroup(child: ChildProcess, signal: NodeJS.Signals): void {\n  const pid = child.pid\n  if (pid === undefined)\n    return\n  try {\n    if (SUPPORTS_PROCESS_GROUPS)\n      process.kill(-pid, signal)\n    else\n      process.kill(pid, signal)\n  }\n  catch {\n    // ESRCH / EPERM — process is already gone (race with natural exit)\n    // or we lost the right to kill it. Both are safe to swallow.\n  }\n}\n\n/**\n * Project a `TaskState` to the `TaskEntry` shape `listBackground` and\n * `reassignBackgroundTasks` return. Single helper keeps the shape\n * consistent across both call sites (and a future addition of fields\n * to `TaskEntry` only needs to land here).\n */\nfunction stateToTaskEntry(state: TaskState): TaskEntry {\n  return {\n    taskId: state.taskId,\n    pid: state.pid,\n    command: state.command,\n    cwd: state.cwd,\n    startedAt: state.startedAt,\n    outputPath: state.outputPath,\n    status: state.status,\n    ...(state.exitCode !== undefined ? { exitCode: state.exitCode } : {}),\n    ...(state.signal ? { signal: state.signal } : {}),\n    bytesWritten: state.bytesWritten,\n  }\n}\n\n/**\n * Project a settled `TaskState` to the `TaskExitInfo` shape `settle()`\n * fires from `onExit` and `killBackground` returns on the\n * cached-exit path. Pre-condition: `state.status !== 'running'`\n * (callers gate on this).\n */\nfunction stateToTaskExitInfo(state: TaskState): TaskExitInfo {\n  return {\n    taskId: state.taskId,\n    status: state.status as Exclude<TaskState['status'], 'running'>,\n    exitCode: state.exitCode ?? 0,\n    ...(state.signal ? { signal: state.signal } : {}),\n    outputPath: state.outputPath,\n    durationMs: Date.now() - state.startedAt,\n    command: state.command,\n  }\n}\n","/**\n * Remote sandbox execution context.\n *\n * Offloads execution to a remote sandbox API (e.g. Rivet, E2B).\n * Specific providers implement the SandboxProvider interface.\n */\n\nimport type { ContextCapabilities, ExecResult, ExecutionContext, ExecutionHandle, SpawnConfig } from './types'\n\n// ---------------------------------------------------------------------------\n// Sandbox provider interface\n// ---------------------------------------------------------------------------\n\nexport interface SandboxProvider {\n  name: string\n  spawn: (config: SpawnConfig) => Promise<{ id: string, cwd: string }>\n  exec: (sandboxId: string, command: string, options?: { cwd?: string, env?: Record<string, string>, timeout?: number }) => Promise<ExecResult>\n  readFile: (sandboxId: string, path: string) => Promise<string>\n  writeFile: (sandboxId: string, path: string, content: string) => Promise<void>\n  listFiles: (sandboxId: string, path: string) => Promise<string[]>\n  destroy: (sandboxId: string) => Promise<void>\n}\n\n// ---------------------------------------------------------------------------\n// Sandbox execution context\n// ---------------------------------------------------------------------------\n\nexport function createSandboxContext(provider: SandboxProvider): ExecutionContext {\n  const sandboxes = new Map<string, string>()\n\n  function getSandboxId(handle: ExecutionHandle): string {\n    const id = sandboxes.get(handle.id)\n    if (!id)\n      throw new Error(`Sandbox ${handle.id} not found`)\n    return id\n  }\n\n  return {\n    type: 'sandbox',\n\n    capabilities: {\n      shell: true,\n      filesystem: true,\n      network: true,\n      gpu: false,\n    } satisfies ContextCapabilities,\n\n    async spawn(config?: SpawnConfig): Promise<ExecutionHandle> {\n      const result = await provider.spawn(config ?? {})\n      const handle: ExecutionHandle = { id: result.id, type: 'sandbox', cwd: result.cwd }\n      sandboxes.set(handle.id, result.id)\n      return handle\n    },\n\n    async exec(handle: ExecutionHandle, command: string, options?): Promise<ExecResult> {\n      return provider.exec(getSandboxId(handle), command, options)\n    },\n\n    async readFile(handle: ExecutionHandle, path: string): Promise<string> {\n      return provider.readFile(getSandboxId(handle), path)\n    },\n\n    async writeFile(handle: ExecutionHandle, path: string, content: string): Promise<void> {\n      return provider.writeFile(getSandboxId(handle), path, content)\n    },\n\n    async listFiles(handle: ExecutionHandle, path: string): Promise<string[]> {\n      return provider.listFiles(getSandboxId(handle), path)\n    },\n\n    async destroy(handle: ExecutionHandle): Promise<void> {\n      const id = sandboxes.get(handle.id)\n      if (!id)\n        return\n      await provider.destroy(id)\n      sandboxes.delete(handle.id)\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/contexts.d.ts

@@ -1,3 +1,3 @@
-import { a as ExecutionContext, c as TaskEntry, i as ExecResult, l as TaskExitInfo, n as ContextCapabilities, o as ExecutionHandle, r as ContextType, s as SpawnConfig, t as BackgroundTaskStatus, u as TaskHandle } from "./types-KukEp-mi.js";
-import { n as createSandboxContext, r as createProcessContext, t as SandboxProvider } from "./index-CbS75MD3.js";
-export { BackgroundTaskStatus, ContextCapabilities, ContextType, ExecResult, ExecutionContext, ExecutionHandle, SandboxProvider, SpawnConfig, TaskEntry, TaskExitInfo, TaskHandle, createProcessContext, createSandboxContext };
+import { a as ExecutionContext, c as TaskEntry, i as ExecResult, l as TaskExitInfo, n as ContextCapabilities, o as ExecutionHandle, r as ContextType, s as SpawnConfig, t as BackgroundTaskStatus, u as TaskHandle } from "./types-CEAMIUXw.js";
+import { n as createSandboxContext, r as createProcessContext, t as SandboxProvider } from "./index-CZOwAJIX.js";
+export { type BackgroundTaskStatus, type ContextCapabilities, type ContextType, type ExecResult, type ExecutionContext, type ExecutionHandle, type SandboxProvider, type SpawnConfig, type TaskEntry, type TaskExitInfo, type TaskHandle, createProcessContext, createSandboxContext };

package/dist/contexts.js

@@ -1,2 +1,2 @@
-import { n as createProcessContext, t as createSandboxContext } from "./contexts-BOtMvzli.js";
+import { n as createProcessContext, t as createSandboxContext } from "./contexts-BD2U_xpi.js";
 export { createProcessContext, createSandboxContext };