@iaforged/context-code 1.3.5 → 1.3.6

package/dist/src/core/cli/runtime/sessionLifecycle.js

@@ -0,0 +1,199 @@
+import { feature } from '../../../recovery/bunBundleShim.js';
+import { createRequire } from 'module';
+import { dirname } from 'path';
+import { getCwd } from '../../../utils/cwd.js';
+import { loadConversationForResume } from '../../../utils/conversationRecovery.js';
+import { logEvent } from '../../../services/analytics/index.js';
+import { logError } from '../../../utils/log.js';
+import { gracefulShutdownSync } from '../../../utils/gracefulShutdown.js';
+import { isPolicyAllowed } from '../../../services/policyLimits/index.js';
+import { isEnvTruthy } from '../legacy/printCliAdapter.js';
+import { externalMetadataToAppState } from '../../../state/onChangeAppState.js';
+import { setMainLoopModelOverride } from '../../../bootstrap/state.js';
+import { asSessionId } from '../../../types/ids.js';
+import { hydrateFromCCRv2InternalEvents, hydrateRemoteSession, resetSessionFilePointer, restoreSessionMetadata, saveMode, } from '../../../utils/sessionStorage.js';
+import { switchSession, isSessionPersistenceDisabled } from '../../../bootstrap/state.js';
+import { restoreSessionStateFromLog, } from '../../../utils/sessionRestore.js';
+import { parseSessionIdentifier } from '../../../utils/sessionUrl.js';
+import { processSessionStartHooks } from '../../../utils/sessionStart.js';
+const require = createRequire(import.meta.url);
+export async function loadInitialMessages(setAppState, options) {
+    const persistSession = !isSessionPersistenceDisabled();
+    if (options.continue) {
+        try {
+            logEvent('tengu_continue_print', {});
+            const result = await loadConversationForResume(undefined, undefined);
+            if (result) {
+                if (feature('COORDINATOR_MODE') && options.coordinatorModeModule) {
+                    const warning = options.coordinatorModeModule.matchSessionMode(result.mode);
+                    if (warning) {
+                        process.stderr.write(warning + '\n');
+                        const { getAgentDefinitionsWithOverrides, getActiveAgentsFromList } = require('../../../tools/AgentTool/loadAgentsDir.js');
+                        getAgentDefinitionsWithOverrides.cache.clear?.();
+                        const freshAgentDefs = await getAgentDefinitionsWithOverrides(getCwd());
+                        setAppState(prev => ({
+                            ...prev,
+                            agentDefinitions: {
+                                ...freshAgentDefs,
+                                allAgents: freshAgentDefs.allAgents,
+                                activeAgents: getActiveAgentsFromList(freshAgentDefs.allAgents),
+                            },
+                        }));
+                    }
+                }
+                if (!options.forkSession && result.sessionId) {
+                    switchSession(asSessionId(result.sessionId), result.fullPath ? dirname(result.fullPath) : null);
+                    if (persistSession) {
+                        await resetSessionFilePointer();
+                    }
+                }
+                restoreSessionStateFromLog(result, setAppState);
+                restoreSessionMetadata(options.forkSession
+                    ? { ...result, worktreeSession: undefined }
+                    : result);
+                if (feature('COORDINATOR_MODE') && options.coordinatorModeModule) {
+                    saveMode(options.coordinatorModeModule.isCoordinatorMode()
+                        ? 'coordinator'
+                        : 'normal');
+                }
+                return {
+                    messages: result.messages,
+                    turnInterruptionState: result.turnInterruptionState,
+                    agentSetting: result.agentSetting,
+                };
+            }
+        }
+        catch (error) {
+            logError(error);
+            gracefulShutdownSync(1);
+            return { messages: [] };
+        }
+    }
+    if (options.teleport) {
+        try {
+            if (!isPolicyAllowed('allow_remote_sessions')) {
+                throw new Error("Remote sessions are disabled by your organization's policy.");
+            }
+            logEvent('tengu_teleport_print', {});
+            if (typeof options.teleport !== 'string') {
+                throw new Error('No session ID provided for teleport');
+            }
+            const { checkOutTeleportedSessionBranch, processMessagesForTeleportResume, teleportResumeCodeSession, validateGitState, } = await import('../../../utils/teleport.js');
+            await validateGitState();
+            const teleportResult = await teleportResumeCodeSession(options.teleport);
+            const { branchError } = await checkOutTeleportedSessionBranch(teleportResult.branch);
+            return {
+                messages: processMessagesForTeleportResume(teleportResult.log, branchError),
+            };
+        }
+        catch (error) {
+            logError(error);
+            gracefulShutdownSync(1);
+            return { messages: [] };
+        }
+    }
+    if (options.resume) {
+        try {
+            logEvent('tengu_resume_print', {});
+            const parsedSessionId = parseSessionIdentifier(typeof options.resume === 'string' ? options.resume : '');
+            if (!parsedSessionId) {
+                let msg = 'Error: --resume requires a valid session ID when used with --print. Usage: claude -p --resume <session-id>';
+                if (typeof options.resume === 'string') {
+                    msg += `. Session IDs must be in UUID format (e.g., 550e8400-e29b-41d4-a716-446655440000). Provided value "${options.resume}" is not a valid UUID`;
+                }
+                options.emitLoadError(msg, options.outputFormat);
+                gracefulShutdownSync(1);
+                return { messages: [] };
+            }
+            if (isEnvTruthy(process.env.CLAUDE_CODE_USE_CCR_V2)) {
+                const [, metadata] = await Promise.all([
+                    hydrateFromCCRv2InternalEvents(parsedSessionId.sessionId),
+                    options.restoredWorkerState,
+                ]);
+                if (metadata) {
+                    setAppState(externalMetadataToAppState(metadata));
+                    if (typeof metadata.model === 'string') {
+                        setMainLoopModelOverride(metadata.model);
+                    }
+                }
+            }
+            else if (parsedSessionId.isUrl &&
+                parsedSessionId.ingressUrl &&
+                isEnvTruthy(process.env.ENABLE_SESSION_PERSISTENCE)) {
+                await hydrateRemoteSession(parsedSessionId.sessionId, parsedSessionId.ingressUrl);
+            }
+            const result = await loadConversationForResume(parsedSessionId.sessionId, parsedSessionId.jsonlFile || undefined);
+            if (!result || result.messages.length === 0) {
+                if (parsedSessionId.isUrl ||
+                    isEnvTruthy(process.env.CLAUDE_CODE_USE_CCR_V2)) {
+                    return {
+                        messages: await (options.sessionStartHooksPromise ??
+                            processSessionStartHooks('startup')),
+                    };
+                }
+                options.emitLoadError(`No conversation found with session ID: ${parsedSessionId.sessionId}`, options.outputFormat);
+                gracefulShutdownSync(1);
+                return { messages: [] };
+            }
+            if (options.resumeSessionAt) {
+                const index = result.messages.findIndex(m => m.uuid === options.resumeSessionAt);
+                if (index < 0) {
+                    options.emitLoadError(`No message found with message.uuid of: ${options.resumeSessionAt}`, options.outputFormat);
+                    gracefulShutdownSync(1);
+                    return { messages: [] };
+                }
+                result.messages = index >= 0 ? result.messages.slice(0, index + 1) : [];
+            }
+            if (feature('COORDINATOR_MODE') && options.coordinatorModeModule) {
+                const warning = options.coordinatorModeModule.matchSessionMode(result.mode);
+                if (warning) {
+                    process.stderr.write(warning + '\n');
+                    const { getAgentDefinitionsWithOverrides, getActiveAgentsFromList } = require('../../../tools/AgentTool/loadAgentsDir.js');
+                    getAgentDefinitionsWithOverrides.cache.clear?.();
+                    const freshAgentDefs = await getAgentDefinitionsWithOverrides(getCwd());
+                    setAppState(prev => ({
+                        ...prev,
+                        agentDefinitions: {
+                            ...freshAgentDefs,
+                            allAgents: freshAgentDefs.allAgents,
+                            activeAgents: getActiveAgentsFromList(freshAgentDefs.allAgents),
+                        },
+                    }));
+                }
+            }
+            if (!options.forkSession && result.sessionId) {
+                switchSession(asSessionId(result.sessionId), result.fullPath ? dirname(result.fullPath) : null);
+                if (persistSession) {
+                    await resetSessionFilePointer();
+                }
+            }
+            restoreSessionStateFromLog(result, setAppState);
+            restoreSessionMetadata(options.forkSession
+                ? { ...result, worktreeSession: undefined }
+                : result);
+            if (feature('COORDINATOR_MODE') && options.coordinatorModeModule) {
+                saveMode(options.coordinatorModeModule.isCoordinatorMode()
+                    ? 'coordinator'
+                    : 'normal');
+            }
+            return {
+                messages: result.messages,
+                turnInterruptionState: result.turnInterruptionState,
+                agentSetting: result.agentSetting,
+            };
+        }
+        catch (error) {
+            logError(error);
+            const errorMessage = error instanceof Error
+                ? `Failed to resume session: ${error.message}`
+                : 'Failed to resume session with --print mode';
+            options.emitLoadError(errorMessage, options.outputFormat);
+            gracefulShutdownSync(1);
+            return { messages: [] };
+        }
+    }
+    return {
+        messages: await (options.sessionStartHooksPromise ??
+            processSessionStartHooks('startup')),
+    };
+}

package/dist/src/core/cli/runtime/sessionStateEmitters.js

@@ -0,0 +1,10 @@
+import { notifySessionMetadataChanged, notifySessionStateChanged } from '../../../utils/sessionState.js';
+export function emitSessionRunningState() {
+    notifySessionStateChanged('running');
+}
+export function emitSessionIdleState() {
+    notifySessionStateChanged('idle');
+}
+export function emitSessionModelMetadata(model) {
+    notifySessionMetadataChanged({ model });
+}

package/dist/src/core/cli/runtime/structuredIORuntime.js

@@ -0,0 +1,175 @@
+import { feature } from '../../../recovery/bunBundleShim.js';
+import { randomUUID } from 'crypto';
+import { writeToStdout } from '../../../utils/process.js';
+import { jsonStringify } from '../../../utils/slowOperations.js';
+import { permissionPromptToolResultToPermissionDecision, outputSchema as permissionToolOutputSchema, } from '../../../utils/permissions/PermissionPromptToolResultSchema.js';
+import { hasPermissionsToUseTool } from '../../../utils/permissions/permissions.js';
+import { applyPermissionUpdates, executePermissionRequestHooks, notifySessionStateChanged, persistPermissionUpdates, } from '../legacy/structuredIOCliAdapter.js';
+import { ndjsonSafeStringify } from '../../../cli/ndjsonSafeStringify.js';
+export const SANDBOX_NETWORK_ACCESS_TOOL_NAME = 'SandboxNetworkAccess';
+function serializeDecisionReason(reason) {
+    if (!reason)
+        return undefined;
+    if ((feature('BASH_CLASSIFIER') || feature('TRANSCRIPT_CLASSIFIER')) &&
+        reason.type === 'classifier') {
+        return reason.reason;
+    }
+    switch (reason.type) {
+        case 'rule':
+        case 'mode':
+        case 'subcommandResults':
+        case 'permissionPromptTool':
+            return undefined;
+        case 'hook':
+        case 'asyncAgent':
+        case 'sandboxOverride':
+        case 'workingDir':
+        case 'safetyCheck':
+        case 'other':
+            return reason.reason;
+    }
+}
+function buildRequiresActionDetails(tool, input, toolUseID, requestId) {
+    let description;
+    try {
+        description =
+            tool.getActivityDescription?.(input) ??
+                tool.getToolUseSummary?.(input) ??
+                tool.userFacingName(input);
+    }
+    catch {
+        description = tool.name;
+    }
+    return {
+        tool_name: tool.name,
+        action_description: description,
+        tool_use_id: toolUseID,
+        request_id: requestId,
+        input,
+    };
+}
+export function createPrependedUserMessage(content) {
+    return (jsonStringify({
+        type: 'user',
+        session_id: '',
+        message: { role: 'user', content },
+        parent_tool_use_id: null,
+    }) + '\n');
+}
+export function writeStructuredOutput(message) {
+    writeToStdout(ndjsonSafeStringify(message) + '\n');
+}
+async function executePermissionRequestHooksForSDK(toolName, toolUseID, input, toolUseContext, suggestions) {
+    const appState = toolUseContext.getAppState();
+    const permissionMode = appState.toolPermissionContext.mode;
+    const hookGenerator = executePermissionRequestHooks(toolName, toolUseID, input, toolUseContext, permissionMode, suggestions, toolUseContext.abortController.signal);
+    for await (const hookResult of hookGenerator) {
+        if (hookResult.permissionRequestResult &&
+            (hookResult.permissionRequestResult.behavior === 'allow' ||
+                hookResult.permissionRequestResult.behavior === 'deny')) {
+            const decision = hookResult.permissionRequestResult;
+            if (decision.behavior === 'allow') {
+                const finalInput = decision.updatedInput || input;
+                const permissionUpdates = decision.updatedPermissions ?? [];
+                if (permissionUpdates.length > 0) {
+                    persistPermissionUpdates(permissionUpdates);
+                    const currentAppState = toolUseContext.getAppState();
+                    const updatedContext = applyPermissionUpdates(currentAppState.toolPermissionContext, permissionUpdates);
+                    toolUseContext.setAppState(prev => {
+                        if (prev.toolPermissionContext === updatedContext)
+                            return prev;
+                        return { ...prev, toolPermissionContext: updatedContext };
+                    });
+                }
+                return {
+                    behavior: 'allow',
+                    updatedInput: finalInput,
+                    userModified: false,
+                    decisionReason: {
+                        type: 'hook',
+                        hookName: 'PermissionRequest',
+                    },
+                };
+            }
+            return {
+                behavior: 'deny',
+                message: decision.message || 'Permission denied by PermissionRequest hook',
+                decisionReason: {
+                    type: 'hook',
+                    hookName: 'PermissionRequest',
+                },
+            };
+        }
+    }
+    return undefined;
+}
+export function createCanUseToolRuntime({ sendRequest, getPendingPermissionRequests, onPermissionPrompt, }) {
+    return async (tool, input, toolUseContext, assistantMessage, toolUseID, forceDecision) => {
+        const mainPermissionResult = forceDecision ??
+            (await hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage, toolUseID));
+        if (mainPermissionResult.behavior === 'allow' ||
+            mainPermissionResult.behavior === 'deny') {
+            return mainPermissionResult;
+        }
+        const hookAbortController = new AbortController();
+        const parentSignal = toolUseContext.abortController.signal;
+        const onParentAbort = () => hookAbortController.abort();
+        parentSignal.addEventListener('abort', onParentAbort, { once: true });
+        try {
+            const hookPromise = executePermissionRequestHooksForSDK(tool.name, toolUseID, input, toolUseContext, mainPermissionResult.suggestions).then(decision => ({ source: 'hook', decision }));
+            const requestId = randomUUID();
+            onPermissionPrompt?.(buildRequiresActionDetails(tool, input, toolUseID, requestId));
+            const sdkPromise = sendRequest({
+                subtype: 'can_use_tool',
+                tool_name: tool.name,
+                input,
+                permission_suggestions: mainPermissionResult.suggestions,
+                blocked_path: mainPermissionResult.blockedPath,
+                decision_reason: serializeDecisionReason(mainPermissionResult.decisionReason),
+                tool_use_id: toolUseID,
+                agent_id: toolUseContext.agentId,
+            }, permissionToolOutputSchema(), hookAbortController.signal, requestId).then(result => ({ source: 'sdk', result }));
+            const winner = await Promise.race([hookPromise, sdkPromise]);
+            if (winner.source === 'hook') {
+                if (winner.decision) {
+                    sdkPromise.catch(() => { });
+                    hookAbortController.abort();
+                    return winner.decision;
+                }
+                const sdkResult = await sdkPromise;
+                return permissionPromptToolResultToPermissionDecision(sdkResult.result, tool, input, toolUseContext);
+            }
+            return permissionPromptToolResultToPermissionDecision(winner.result, tool, input, toolUseContext);
+        }
+        catch (error) {
+            return permissionPromptToolResultToPermissionDecision({
+                behavior: 'deny',
+                message: `Tool permission request failed: ${error}`,
+                toolUseID,
+            }, tool, input, toolUseContext);
+        }
+        finally {
+            if (getPendingPermissionRequests().length === 0) {
+                notifySessionStateChanged('running');
+            }
+            parentSignal.removeEventListener('abort', onParentAbort);
+        }
+    };
+}
+export function createSandboxAskCallbackRuntime(sendRequest) {
+    return async (hostPattern) => {
+        try {
+            const result = await sendRequest({
+                subtype: 'can_use_tool',
+                tool_name: SANDBOX_NETWORK_ACCESS_TOOL_NAME,
+                input: { host: hostPattern.host },
+                tool_use_id: randomUUID(),
+                description: `Allow network connection to ${hostPattern.host}?`,
+            }, permissionToolOutputSchema());
+            return result.behavior === 'allow';
+        }
+        catch {
+            return false;
+        }
+    };
+}

package/dist/src/core/cli/runtime/updateRuntime.js

@@ -0,0 +1,292 @@
+import { MACRO } from '../../../recovery/bunBundleShim.js';
+import chalk from 'chalk';
+import { logEvent } from '../../../services/analytics/index.js';
+import { getLatestVersion, installGlobalPackage, } from '../../../utils/autoUpdater.js';
+import { regenerateCompletionCache } from '../../../utils/completionCache.js';
+import { getGlobalConfig, saveGlobalConfig, } from '../../../utils/config.js';
+import { logForDebugging } from '../../../utils/debug.js';
+import { getDoctorDiagnostic } from '../../../utils/doctorDiagnostic.js';
+import { gracefulShutdown } from '../../../utils/gracefulShutdown.js';
+import { installOrUpdateContextPackage, localInstallationExists, } from '../../../utils/localInstaller.js';
+import { installLatest as installLatestNative, removeInstalledSymlink, } from '../../../utils/nativeInstaller/index.js';
+import { getPackageManager } from '../../../utils/nativeInstaller/packageManagers.js';
+import { writeToStdout } from '../../../utils/process.js';
+import { gte } from '../../../utils/semver.js';
+import { getInitialSettings } from '../../../utils/settings/settings.js';
+export async function update() {
+    logEvent('tengu_update_check', {});
+    writeToStdout(`Current version: ${MACRO.VERSION}\n`);
+    const channel = getInitialSettings()?.autoUpdatesChannel ?? 'latest';
+    writeToStdout(`Checking for updates to ${channel} version...\n`);
+    logForDebugging('update: Starting update check');
+    logForDebugging('update: Running diagnostic');
+    const diagnostic = await getDoctorDiagnostic();
+    logForDebugging(`update: Installation type: ${diagnostic.installationType}`);
+    logForDebugging(`update: Config install method: ${diagnostic.configInstallMethod}`);
+    if (diagnostic.multipleInstallations.length > 1) {
+        writeToStdout('\n');
+        writeToStdout(chalk.yellow('Warning: Multiple installations found') + '\n');
+        for (const install of diagnostic.multipleInstallations) {
+            const current = diagnostic.installationType === install.type
+                ? ' (currently running)'
+                : '';
+            writeToStdout(`- ${install.type} at ${install.path}${current}\n`);
+        }
+    }
+    if (diagnostic.warnings.length > 0) {
+        writeToStdout('\n');
+        for (const warning of diagnostic.warnings) {
+            logForDebugging(`update: Warning detected: ${warning.issue}`);
+            logForDebugging(`update: Showing warning: ${warning.issue}`);
+            writeToStdout(chalk.yellow(`Warning: ${warning.issue}\n`));
+            writeToStdout(chalk.bold(`Fix: ${warning.fix}\n`));
+        }
+    }
+    const config = getGlobalConfig();
+    if (!config.installMethod &&
+        diagnostic.installationType !== 'package-manager') {
+        writeToStdout('\n');
+        writeToStdout('Updating configuration to track installation method...\n');
+        let detectedMethod = 'unknown';
+        switch (diagnostic.installationType) {
+            case 'npm-local':
+                detectedMethod = 'local';
+                break;
+            case 'native':
+                detectedMethod = 'native';
+                break;
+            case 'npm-global':
+                detectedMethod = 'global';
+                break;
+            default:
+                detectedMethod = 'unknown';
+        }
+        saveGlobalConfig(current => ({
+            ...current,
+            installMethod: detectedMethod,
+        }));
+        writeToStdout(`Installation method set to: ${detectedMethod}\n`);
+    }
+    if (diagnostic.installationType === 'development') {
+        writeToStdout('\n');
+        writeToStdout(chalk.yellow('Warning: Cannot update development build') + '\n');
+        await gracefulShutdown(1);
+    }
+    if (diagnostic.installationType === 'package-manager') {
+        const packageManager = await getPackageManager();
+        writeToStdout('\n');
+        if (packageManager === 'homebrew') {
+            writeToStdout('Context is managed by Homebrew.\n');
+            const latest = await getLatestVersion(channel);
+            if (latest && !gte(MACRO.VERSION, latest)) {
+                writeToStdout(`Update available: ${MACRO.VERSION} → ${latest}\n`);
+                writeToStdout('\n');
+                writeToStdout('To update, run:\n');
+                writeToStdout(chalk.bold('  brew upgrade context-code') + '\n');
+            }
+            else {
+                writeToStdout('Context is up to date!\n');
+            }
+        }
+        else if (packageManager === 'winget') {
+            writeToStdout('Context is managed by winget.\n');
+            const latest = await getLatestVersion(channel);
+            if (latest && !gte(MACRO.VERSION, latest)) {
+                writeToStdout(`Update available: ${MACRO.VERSION} → ${latest}\n`);
+                writeToStdout('\n');
+                writeToStdout('To update, run:\n');
+                writeToStdout(chalk.bold('  winget upgrade Anthropic.ContextCode') + '\n');
+            }
+            else {
+                writeToStdout('Context is up to date!\n');
+            }
+        }
+        else if (packageManager === 'apk') {
+            writeToStdout('Context is managed by apk.\n');
+            const latest = await getLatestVersion(channel);
+            if (latest && !gte(MACRO.VERSION, latest)) {
+                writeToStdout(`Update available: ${MACRO.VERSION} → ${latest}\n`);
+                writeToStdout('\n');
+                writeToStdout('To update, run:\n');
+                writeToStdout(chalk.bold('  apk upgrade context-code') + '\n');
+            }
+            else {
+                writeToStdout('Context is up to date!\n');
+            }
+        }
+        else {
+            writeToStdout('Context is managed by a package manager.\n');
+            writeToStdout('Please use your package manager to update.\n');
+        }
+        await gracefulShutdown(0);
+    }
+    if (config.installMethod &&
+        diagnostic.configInstallMethod !== 'not set' &&
+        diagnostic.installationType !== 'package-manager') {
+        const runningType = diagnostic.installationType;
+        const configExpects = diagnostic.configInstallMethod;
+        const typeMapping = {
+            'npm-local': 'local',
+            'npm-global': 'global',
+            native: 'native',
+            development: 'development',
+            unknown: 'unknown',
+        };
+        const normalizedRunningType = typeMapping[runningType] || runningType;
+        if (normalizedRunningType !== configExpects &&
+            configExpects !== 'unknown') {
+            writeToStdout('\n');
+            writeToStdout(chalk.yellow('Warning: Configuration mismatch') + '\n');
+            writeToStdout(`Config expects: ${configExpects} installation\n`);
+            writeToStdout(`Currently running: ${runningType}\n`);
+            writeToStdout(chalk.yellow(`Updating the ${runningType} installation you are currently using`) + '\n');
+            saveGlobalConfig(current => ({
+                ...current,
+                installMethod: normalizedRunningType,
+            }));
+            writeToStdout(`Config updated to reflect current installation method: ${normalizedRunningType}\n`);
+        }
+    }
+    if (diagnostic.installationType === 'native') {
+        logForDebugging('update: Detected native installation, using native updater');
+        try {
+            const result = await installLatestNative(channel, true);
+            if (result.lockFailed) {
+                const pidInfo = result.lockHolderPid
+                    ? ` (PID ${result.lockHolderPid})`
+                    : '';
+                writeToStdout(chalk.yellow(`Another Context process${pidInfo} is currently running. Please try again in a moment.`) + '\n');
+                await gracefulShutdown(0);
+            }
+            if (!result.latestVersion) {
+                process.stderr.write('Failed to check for updates\n');
+                await gracefulShutdown(1);
+            }
+            if (result.latestVersion === MACRO.VERSION) {
+                writeToStdout(chalk.green(`Context Code is up to date (${MACRO.VERSION})`) + '\n');
+            }
+            else {
+                writeToStdout(chalk.green(`Successfully updated from ${MACRO.VERSION} to version ${result.latestVersion}`) + '\n');
+                await regenerateCompletionCache();
+            }
+            await gracefulShutdown(0);
+        }
+        catch (error) {
+            process.stderr.write('Error: Failed to install native update\n');
+            process.stderr.write(String(error) + '\n');
+            process.stderr.write('Try running "context doctor" for diagnostics\n');
+            await gracefulShutdown(1);
+        }
+    }
+    if (config.installMethod !== 'native') {
+        await removeInstalledSymlink();
+    }
+    logForDebugging('update: Checking npm registry for latest version');
+    logForDebugging(`update: Package URL: ${MACRO.PACKAGE_URL}`);
+    const npmTag = channel === 'stable' ? 'stable' : 'latest';
+    const npmCommand = `npm view ${MACRO.PACKAGE_URL}@${npmTag} version`;
+    logForDebugging(`update: Running: ${npmCommand}`);
+    const latestVersion = await getLatestVersion(channel);
+    logForDebugging(`update: Latest version from npm: ${latestVersion || 'FAILED'}`);
+    if (!latestVersion) {
+        logForDebugging('update: Failed to get latest version from npm registry');
+        process.stderr.write(chalk.red('Failed to check for updates') + '\n');
+        process.stderr.write('Unable to fetch latest version from npm registry\n');
+        process.stderr.write('\n');
+        process.stderr.write('Possible causes:\n');
+        process.stderr.write('  • Network connectivity issues\n');
+        process.stderr.write('  • npm registry is unreachable\n');
+        process.stderr.write('  • Corporate proxy/firewall blocking npm\n');
+        if (MACRO.PACKAGE_URL && !MACRO.PACKAGE_URL.startsWith('@anthropic')) {
+            process.stderr.write('  • Internal/development build not published to npm\n');
+        }
+        process.stderr.write('\n');
+        process.stderr.write('Try:\n');
+        process.stderr.write('  • Check your internet connection\n');
+        process.stderr.write('  • Run with --debug flag for more details\n');
+        const packageName = MACRO.PACKAGE_URL ||
+            (process.env.USER_TYPE === 'ant'
+                ? '@anthropic-ai/claude-cli'
+                : '@anthropic-ai/context-code');
+        process.stderr.write(`  • Manually check: npm view ${packageName} version\n`);
+        process.stderr.write('  • Check if you need to login: npm whoami\n');
+        await gracefulShutdown(1);
+    }
+    if (latestVersion === MACRO.VERSION) {
+        writeToStdout(chalk.green(`Context Code is up to date (${MACRO.VERSION})`) + '\n');
+        await gracefulShutdown(0);
+    }
+    writeToStdout(`New version available: ${latestVersion} (current: ${MACRO.VERSION})\n`);
+    writeToStdout('Installing update...\n');
+    let useLocalUpdate = false;
+    let updateMethodName = '';
+    switch (diagnostic.installationType) {
+        case 'npm-local':
+            useLocalUpdate = true;
+            updateMethodName = 'local';
+            break;
+        case 'npm-global':
+            useLocalUpdate = false;
+            updateMethodName = 'global';
+            break;
+        case 'unknown': {
+            const isLocal = await localInstallationExists();
+            useLocalUpdate = isLocal;
+            updateMethodName = isLocal ? 'local' : 'global';
+            writeToStdout(chalk.yellow('Warning: Could not determine installation type') + '\n');
+            writeToStdout(`Attempting ${updateMethodName} update based on file detection...\n`);
+            break;
+        }
+        default:
+            process.stderr.write(`Error: Cannot update ${diagnostic.installationType} installation\n`);
+            await gracefulShutdown(1);
+    }
+    writeToStdout(`Using ${updateMethodName} installation update method...\n`);
+    logForDebugging(`update: Update method determined: ${updateMethodName}`);
+    logForDebugging(`update: useLocalUpdate: ${useLocalUpdate}`);
+    let status;
+    if (useLocalUpdate) {
+        logForDebugging('update: Calling installOrUpdateContextPackage() for local update');
+        status = await installOrUpdateContextPackage(channel);
+    }
+    else {
+        logForDebugging('update: Calling installGlobalPackage() for global update');
+        status = await installGlobalPackage();
+    }
+    logForDebugging(`update: Installation status: ${status}`);
+    switch (status) {
+        case 'success':
+            writeToStdout(chalk.green(`Successfully updated from ${MACRO.VERSION} to version ${latestVersion}`) + '\n');
+            await regenerateCompletionCache();
+            break;
+        case 'no_permissions':
+            process.stderr.write('Error: Insufficient permissions to install update\n');
+            if (useLocalUpdate) {
+                process.stderr.write('Try manually updating with:\n');
+                process.stderr.write(`  cd ~/.context/local && npm update ${MACRO.PACKAGE_URL}\n`);
+            }
+            else {
+                process.stderr.write('Try running with sudo or fix npm permissions\n');
+                process.stderr.write('Or consider using native installation with: context install\n');
+            }
+            await gracefulShutdown(1);
+            break;
+        case 'install_failed':
+            process.stderr.write('Error: Failed to install update\n');
+            if (useLocalUpdate) {
+                process.stderr.write('Try manually updating with:\n');
+                process.stderr.write(`  cd ~/.context/local && npm update ${MACRO.PACKAGE_URL}\n`);
+            }
+            else {
+                process.stderr.write('Or consider using native installation with: context install\n');
+            }
+            await gracefulShutdown(1);
+            break;
+        case 'in_progress':
+            process.stderr.write('Error: Another instance is currently performing an update\n');
+            process.stderr.write('Please wait and try again later\n');
+            await gracefulShutdown(1);
+            break;
+    }
+    await gracefulShutdown(0);
+}