@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/commands/brief.js

@@ -0,0 +1,94 @@
+import { feature } from '../recovery/bunBundleShim.js';
+import { z } from 'zod/v4';
+import { getKairosActive, setUserMsgOptIn } from '../bootstrap/state.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
+import { logEvent, } from '../services/analytics/index.js';
+import { isBriefEntitled } from '../tools/BriefTool/BriefTool.js';
+import { BRIEF_TOOL_NAME } from '../tools/BriefTool/prompt.js';
+import { lazySchema } from '../utils/lazySchema.js';
+// Zod guards against fat-fingered GB pushes (same pattern as pollConfig.ts /
+// cronScheduler.ts). A malformed config falls back to DEFAULT_BRIEF_CONFIG
+// entirely rather than being partially trusted.
+const briefConfigSchema = lazySchema(() => z.object({
+    enable_slash_command: z.boolean(),
+}));
+const DEFAULT_BRIEF_CONFIG = {
+    enable_slash_command: false,
+};
+// No TTL — this gate controls slash-command *visibility*, not a kill switch.
+// CACHED_MAY_BE_STALE still has one background-update flip (first call kicks
+// off fetch; second call sees fresh value), but no additional flips after that.
+// The tool-availability gate (tengu_kairos_brief in isBriefEnabled) keeps its
+// 5-min TTL because that one IS a kill switch.
+function getBriefConfig() {
+    const raw = getFeatureValue_CACHED_MAY_BE_STALE('tengu_kairos_brief_config', DEFAULT_BRIEF_CONFIG);
+    const parsed = briefConfigSchema().safeParse(raw);
+    return parsed.success ? parsed.data : DEFAULT_BRIEF_CONFIG;
+}
+const brief = {
+    type: 'local-jsx',
+    name: 'brief',
+    description: 'Alternar el modo solo-resumen (brief-only)',
+    isEnabled: () => {
+        if (feature('KAIROS') || feature('KAIROS_BRIEF')) {
+            return getBriefConfig().enable_slash_command;
+        }
+        return false;
+    },
+    immediate: true,
+    load: () => Promise.resolve({
+        async call(onDone, context) {
+            const current = context.getAppState().isBriefOnly;
+            const newState = !current;
+            // Entitlement check only gates the on-transition — off is always
+            // allowed so a user whose GB gate flipped mid-session isn't stuck.
+            if (newState && !isBriefEntitled()) {
+                logEvent('tengu_brief_mode_toggled', {
+                    enabled: false,
+                    gated: true,
+                    source: 'slash_command',
+                });
+                onDone('La herramienta brief no está habilitada para tu cuenta', {
+                    display: 'system',
+                });
+                return null;
+            }
+            // Two-way: userMsgOptIn tracks isBriefOnly so the tool is available
+            // exactly when brief mode is on. This invalidates prompt cache on
+            // each toggle (tool list changes), but a stale tool list is worse —
+            // when /brief is enabled mid-session the model was previously left
+            // without the tool, emitting plain text the filter hides.
+            setUserMsgOptIn(newState);
+            context.setAppState(prev => {
+                if (prev.isBriefOnly === newState)
+                    return prev;
+                return { ...prev, isBriefOnly: newState };
+            });
+            logEvent('tengu_brief_mode_toggled', {
+                enabled: newState,
+                gated: false,
+                source: 'slash_command',
+            });
+            // The tool list change alone isn't a strong enough signal mid-session
+            // (model may keep emitting plain text from inertia, or keep calling a
+            // tool that just vanished). Inject an explicit reminder into the next
+            // turn's context so the transition is unambiguous.
+            // Skip when Kairos is active: isBriefEnabled() short-circuits on
+            // getKairosActive() so the tool never actually leaves the list, and
+            // the Kairos system prompt already mandates SendUserMessage.
+            // Inline <system-reminder> wrap — importing wrapInSystemReminder from
+            // utils/messages.ts pulls constants/xml.ts into the bridge SDK bundle
+            // via this module's import chain, tripping the excluded-strings check.
+            const metaMessages = getKairosActive()
+                ? undefined
+                : [
+                    `<system-reminder>\n${newState
+                        ? `El modo brief ahora está activado. Usa la herramienta ${BRIEF_TOOL_NAME} para toda la salida orientada al usuario; el texto plano fuera de ella estará oculto a la vista del usuario.`
+                        : `El modo brief ahora está desactivado. La herramienta ${BRIEF_TOOL_NAME} ya no está disponible; responde con texto plano.`}\n</system-reminder>`,
+                ];
+            onDone(newState ? 'Modo solo-resumen activado' : 'Modo solo-resumen desactivado', { display: 'system', metaMessages });
+            return null;
+        },
+    }),
+};
+export default brief;

package/dist/src/commands/btw/btw.js

@@ -0,0 +1,234 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { useInterval } from 'usehooks-ts';
+import { Markdown } from '../../components/Markdown.js';
+import { SpinnerGlyph } from '../../components/Spinner/SpinnerGlyph.js';
+import { DOWN_ARROW, UP_ARROW } from '../../constants/figures.js';
+import { getSystemPrompt } from '../../constants/prompts.js';
+import { useModalOrTerminalSize } from '../../context/modalContext.js';
+import { getSystemContext, getUserContext } from '../../context.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import ScrollBox from '../../ink/components/ScrollBox.js';
+import { Box, Text } from '../../ink.js';
+import { createAbortController } from '../../utils/abortController.js';
+import { saveGlobalConfig } from '../../utils/config.js';
+import { errorMessage } from '../../utils/errors.js';
+import { getLastCacheSafeParams } from '../../utils/forkedAgent.js';
+import { getMessagesAfterCompactBoundary } from '../../utils/messages.js';
+import { runSideQuestion } from '../../utils/sideQuestion.js';
+import { asSystemPrompt } from '../../utils/systemPromptType.js';
+const CHROME_ROWS = 5;
+const OUTER_CHROME_ROWS = 6;
+const SCROLL_LINES = 3;
+function BtwSideQuestion(t0) {
+    const $ = _c(25);
+    const { question, context, onDone } = t0;
+    const [response, setResponse] = useState(null);
+    const [error, setError] = useState(null);
+    const [frame, setFrame] = useState(0);
+    const scrollRef = useRef(null);
+    const { rows } = useModalOrTerminalSize(useTerminalSize());
+    let t1;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+        t1 = () => setFrame(_temp);
+        $[0] = t1;
+    }
+    else {
+        t1 = $[0];
+    }
+    useInterval(t1, response || error ? null : 80);
+    let t2;
+    if ($[1] !== onDone) {
+        t2 = function handleKeyDown(e) {
+            if (e.key === "escape" || e.key === "return" || e.key === " " || e.ctrl && (e.key === "c" || e.key === "d")) {
+                e.preventDefault();
+                onDone(undefined, {
+                    display: "skip"
+                });
+                return;
+            }
+            if (e.key === "up" || e.ctrl && e.key === "p") {
+                e.preventDefault();
+                scrollRef.current?.scrollBy(-SCROLL_LINES);
+            }
+            if (e.key === "down" || e.ctrl && e.key === "n") {
+                e.preventDefault();
+                scrollRef.current?.scrollBy(SCROLL_LINES);
+            }
+        };
+        $[1] = onDone;
+        $[2] = t2;
+    }
+    else {
+        t2 = $[2];
+    }
+    const handleKeyDown = t2;
+    let t3;
+    let t4;
+    if ($[3] !== context || $[4] !== question) {
+        t3 = () => {
+            const abortController = createAbortController();
+            const fetchResponse = async function fetchResponse() {
+                ;
+                try {
+                    const cacheSafeParams = await buildCacheSafeParams(context);
+                    const result = await runSideQuestion({
+                        question,
+                        cacheSafeParams
+                    });
+                    if (!abortController.signal.aborted) {
+                        if (result.response) {
+                            setResponse(result.response);
+                        }
+                        else {
+                            setError("No response received");
+                        }
+                    }
+                }
+                catch (t5) {
+                    const err = t5;
+                    if (!abortController.signal.aborted) {
+                        setError(errorMessage(err) || "Failed to get response");
+                    }
+                }
+            };
+            fetchResponse();
+            return () => {
+                abortController.abort();
+            };
+        };
+        t4 = [question, context];
+        $[3] = context;
+        $[4] = question;
+        $[5] = t3;
+        $[6] = t4;
+    }
+    else {
+        t3 = $[5];
+        t4 = $[6];
+    }
+    useEffect(t3, t4);
+    const maxContentHeight = Math.max(5, rows - CHROME_ROWS - OUTER_CHROME_ROWS);
+    let t5;
+    if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+        t5 = _jsxs(Text, { color: "warning", bold: true, children: ["/btw", " "] });
+        $[7] = t5;
+    }
+    else {
+        t5 = $[7];
+    }
+    let t6;
+    if ($[8] !== question) {
+        t6 = _jsxs(Box, { children: [t5, _jsx(Text, { dimColor: true, children: question })] });
+        $[8] = question;
+        $[9] = t6;
+    }
+    else {
+        t6 = $[9];
+    }
+    let t7;
+    if ($[10] !== error || $[11] !== frame || $[12] !== response) {
+        t7 = _jsx(ScrollBox, { ref: scrollRef, flexDirection: "column", flexGrow: 1, children: error ? _jsx(Text, { color: "error", children: error }) : response ? _jsx(Markdown, { children: response }) : _jsxs(Box, { children: [_jsx(SpinnerGlyph, { frame: frame, messageColor: "warning" }), _jsx(Text, { color: "warning", children: "Answering..." })] }) });
+        $[10] = error;
+        $[11] = frame;
+        $[12] = response;
+        $[13] = t7;
+    }
+    else {
+        t7 = $[13];
+    }
+    let t8;
+    if ($[14] !== maxContentHeight || $[15] !== t7) {
+        t8 = _jsx(Box, { marginTop: 1, marginLeft: 2, maxHeight: maxContentHeight, children: t7 });
+        $[14] = maxContentHeight;
+        $[15] = t7;
+        $[16] = t8;
+    }
+    else {
+        t8 = $[16];
+    }
+    let t9;
+    if ($[17] !== error || $[18] !== response) {
+        t9 = (response || error) && _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [UP_ARROW, "/", DOWN_ARROW, " to scroll \u00B7 Space, Enter, or Escape to dismiss"] }) });
+        $[17] = error;
+        $[18] = response;
+        $[19] = t9;
+    }
+    else {
+        t9 = $[19];
+    }
+    let t10;
+    if ($[20] !== handleKeyDown || $[21] !== t6 || $[22] !== t8 || $[23] !== t9) {
+        t10 = _jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 1, tabIndex: 0, autoFocus: true, onKeyDown: handleKeyDown, children: [t6, t8, t9] });
+        $[20] = handleKeyDown;
+        $[21] = t6;
+        $[22] = t8;
+        $[23] = t9;
+        $[24] = t10;
+    }
+    else {
+        t10 = $[24];
+    }
+    return t10;
+}
+/**
+ * Build CacheSafeParams for the side question fork.
+ *
+ * The preferred source is getLastCacheSafeParams — the exact
+ * systemPrompt/userContext/systemContext bytes the main thread sent on its
+ * last request (captured in stopHooks). Reusing them guarantees a byte-
+ * identical prefix and thus a prompt cache hit. We pair these with the
+ * current toolUseContext (for thinkingConfig/tools) and current messages
+ * (for up-to-date context).
+ *
+ * Fallback (first turn before stop hooks fire, or prompt-suggestion
+ * disabled): rebuild from scratch. This may miss the cache if the main loop
+ * applied buildEffectiveSystemPrompt extras (--agent, --system-prompt,
+ * --append-system-prompt, coordinator mode).
+ */
+function _temp(f) {
+    return f + 1;
+}
+function stripInProgressAssistantMessage(messages) {
+    const last = messages.at(-1);
+    if (last?.type === 'assistant' && last.message.stop_reason === null) {
+        return messages.slice(0, -1);
+    }
+    return messages;
+}
+async function buildCacheSafeParams(context) {
+    const forkContextMessages = getMessagesAfterCompactBoundary(stripInProgressAssistantMessage(context.messages));
+    const saved = getLastCacheSafeParams();
+    if (saved) {
+        return {
+            systemPrompt: saved.systemPrompt,
+            userContext: saved.userContext,
+            systemContext: saved.systemContext,
+            toolUseContext: context,
+            forkContextMessages
+        };
+    }
+    const [rawSystemPrompt, userContext, systemContext] = await Promise.all([getSystemPrompt(context.options.tools, context.options.mainLoopModel, [], context.options.mcpClients), getUserContext(), getSystemContext()]);
+    return {
+        systemPrompt: asSystemPrompt(rawSystemPrompt),
+        userContext,
+        systemContext,
+        toolUseContext: context,
+        forkContextMessages
+    };
+}
+export async function call(onDone, context, args) {
+    const question = args?.trim();
+    if (!question) {
+        onDone('Usage: /btw <your question>', {
+            display: 'system'
+        });
+        return null;
+    }
+    saveGlobalConfig(current => ({
+        ...current,
+        btwUseCount: current.btwUseCount + 1
+    }));
+    return _jsx(BtwSideQuestion, { question: question, context: context, onDone: onDone });
+}

package/dist/src/commands/btw/index.js

@@ -0,0 +1,9 @@
+const btw = {
+    type: 'local-jsx',
+    name: 'btw',
+    description: 'Hacer una pregunta rápida sin interrumpir la conversación principal',
+    immediate: true,
+    argumentHint: '<pregunta>',
+    load: () => import('./btw.js'),
+};
+export default btw;

package/dist/src/commands/bughunter/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

package/dist/src/commands/chrome/chrome.js

@@ -0,0 +1,291 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { useState } from 'react';
+import { Select } from '../../components/CustomSelect/select.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { Box, Text } from '../../ink.js';
+import { useAppState } from '../../state/AppState.js';
+import { isClaudeAISubscriber } from '../../utils/auth.js';
+import { openBrowser } from '../../utils/browser.js';
+import { CLAUDE_IN_CHROME_MCP_SERVER_NAME, openInChrome } from '../../utils/claudeInChrome/common.js';
+import { isChromeExtensionInstalled } from '../../utils/claudeInChrome/setup.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { env } from '../../utils/env.js';
+import { isRunningOnHomespace } from '../../utils/envUtils.js';
+const CHROME_EXTENSION_URL = 'https://claude.ai/chrome';
+const CHROME_PERMISSIONS_URL = 'https://clau.de/chrome/permissions';
+const CHROME_RECONNECT_URL = 'https://clau.de/chrome/reconnect';
+function ClaudeInChromeMenu(t0) {
+    const $ = _c(41);
+    const { onDone, isExtensionInstalled: installed, configEnabled, isClaudeAISubscriber, isWSL } = t0;
+    const mcpClients = useAppState(_temp);
+    const [selectKey, setSelectKey] = useState(0);
+    const [enabledByDefault, setEnabledByDefault] = useState(configEnabled ?? false);
+    const [showInstallHint, setShowInstallHint] = useState(false);
+    const [isExtensionInstalled, setIsExtensionInstalled] = useState(installed);
+    let t1;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+        t1 = false && isRunningOnHomespace();
+        $[0] = t1;
+    }
+    else {
+        t1 = $[0];
+    }
+    const isHomespace = t1;
+    let t2;
+    if ($[1] !== mcpClients) {
+        t2 = mcpClients.find(_temp2);
+        $[1] = mcpClients;
+        $[2] = t2;
+    }
+    else {
+        t2 = $[2];
+    }
+    const chromeClient = t2;
+    const isConnected = chromeClient?.type === "connected";
+    let t3;
+    if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+        t3 = function openUrl(url) {
+            if (isHomespace) {
+                openBrowser(url);
+            }
+            else {
+                openInChrome(url);
+            }
+        };
+        $[3] = t3;
+    }
+    else {
+        t3 = $[3];
+    }
+    const openUrl = t3;
+    let t4;
+    if ($[4] !== enabledByDefault) {
+        t4 = function handleAction(action) {
+            bb22: switch (action) {
+                case "install-extension":
+                    {
+                        setSelectKey(_temp3);
+                        setShowInstallHint(true);
+                        openUrl(CHROME_EXTENSION_URL);
+                        break bb22;
+                    }
+                case "reconnect":
+                    {
+                        setSelectKey(_temp4);
+                        isChromeExtensionInstalled().then(installed_0 => {
+                            setIsExtensionInstalled(installed_0);
+                            if (installed_0) {
+                                setShowInstallHint(false);
+                            }
+                        });
+                        openUrl(CHROME_RECONNECT_URL);
+                        break bb22;
+                    }
+                case "manage-permissions":
+                    {
+                        setSelectKey(_temp5);
+                        openUrl(CHROME_PERMISSIONS_URL);
+                        break bb22;
+                    }
+                case "toggle-default":
+                    {
+                        const newValue = !enabledByDefault;
+                        saveGlobalConfig(current => ({
+                            ...current,
+                            claudeInChromeDefaultEnabled: newValue
+                        }));
+                        setEnabledByDefault(newValue);
+                    }
+            }
+        };
+        $[4] = enabledByDefault;
+        $[5] = t4;
+    }
+    else {
+        t4 = $[5];
+    }
+    const handleAction = t4;
+    let options;
+    if ($[6] !== enabledByDefault || $[7] !== isExtensionInstalled) {
+        options = [];
+        const requiresExtensionSuffix = isExtensionInstalled ? "" : " (requires extension)";
+        if (!isExtensionInstalled && !isHomespace) {
+            let t5;
+            if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+                t5 = {
+                    label: "Install Chrome extension",
+                    value: "install-extension"
+                };
+                $[9] = t5;
+            }
+            else {
+                t5 = $[9];
+            }
+            options.push(t5);
+        }
+        let t5;
+        if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+            t5 = _jsx(Text, { children: "Manage permissions" });
+            $[10] = t5;
+        }
+        else {
+            t5 = $[10];
+        }
+        let t6;
+        if ($[11] !== requiresExtensionSuffix) {
+            t6 = {
+                label: _jsxs(_Fragment, { children: [t5, _jsx(Text, { dimColor: true, children: requiresExtensionSuffix })] }),
+                value: "manage-permissions"
+            };
+            $[11] = requiresExtensionSuffix;
+            $[12] = t6;
+        }
+        else {
+            t6 = $[12];
+        }
+        let t7;
+        if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+            t7 = _jsx(Text, { children: "Reconnect extension" });
+            $[13] = t7;
+        }
+        else {
+            t7 = $[13];
+        }
+        let t8;
+        if ($[14] !== requiresExtensionSuffix) {
+            t8 = {
+                label: _jsxs(_Fragment, { children: [t7, _jsx(Text, { dimColor: true, children: requiresExtensionSuffix })] }),
+                value: "reconnect"
+            };
+            $[14] = requiresExtensionSuffix;
+            $[15] = t8;
+        }
+        else {
+            t8 = $[15];
+        }
+        const t9 = `Enabled by default: ${enabledByDefault ? "Yes" : "No"}`;
+        let t10;
+        if ($[16] !== t9) {
+            t10 = {
+                label: t9,
+                value: "toggle-default"
+            };
+            $[16] = t9;
+            $[17] = t10;
+        }
+        else {
+            t10 = $[17];
+        }
+        options.push(t6, t8, t10);
+        $[6] = enabledByDefault;
+        $[7] = isExtensionInstalled;
+        $[8] = options;
+    }
+    else {
+        options = $[8];
+    }
+    const isDisabled = isWSL || true && !isClaudeAISubscriber;
+    let t5;
+    if ($[18] !== onDone) {
+        t5 = () => onDone();
+        $[18] = onDone;
+        $[19] = t5;
+    }
+    else {
+        t5 = $[19];
+    }
+    let t6;
+    if ($[20] === Symbol.for("react.memo_cache_sentinel")) {
+        t6 = _jsx(Text, { children: "Claude in Chrome works with the Chrome extension to let you control your browser directly from Context Code. Navigate websites, fill forms, capture screenshots, record GIFs, and debug with console logs and network requests." });
+        $[20] = t6;
+    }
+    else {
+        t6 = $[20];
+    }
+    let t7;
+    if ($[21] !== isWSL) {
+        t7 = isWSL && _jsx(Text, { color: "error", children: "Claude in Chrome is not supported in WSL at this time." });
+        $[21] = isWSL;
+        $[22] = t7;
+    }
+    else {
+        t7 = $[22];
+    }
+    let t8;
+    if ($[23] !== isClaudeAISubscriber) {
+        t8 = true && !isClaudeAISubscriber && _jsx(Text, { color: "error", children: "Claude in Chrome requires a claude.ai subscription." });
+        $[23] = isClaudeAISubscriber;
+        $[24] = t8;
+    }
+    else {
+        t8 = $[24];
+    }
+    let t9;
+    if ($[25] !== handleAction || $[26] !== isConnected || $[27] !== isDisabled || $[28] !== isExtensionInstalled || $[29] !== options || $[30] !== selectKey || $[31] !== showInstallHint) {
+        t9 = !isDisabled && _jsxs(_Fragment, { children: [!isHomespace && _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Estado:", " ", isConnected ? _jsx(Text, { color: "success", children: "Activado" }) : _jsx(Text, { color: "inactive", children: "Desactivado" })] }), _jsxs(Text, { children: ["Extensi\u00F3n:", " ", isExtensionInstalled ? _jsx(Text, { color: "success", children: "Instalada" }) : _jsx(Text, { color: "warning", children: "No detectada" })] })] }), _jsx(Select, { options: options, onChange: handleAction, hideIndexes: true }, selectKey), showInstallHint && _jsxs(Text, { color: "warning", children: ["Una vez instalada, selecciona ", "\"Reconectar extensión\"", " para conectar."] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Uso: " }), _jsx(Text, { children: "context --chrome" }), _jsx(Text, { dimColor: true, children: " o " }), _jsx(Text, { children: "context --no-chrome" })] }), _jsx(Text, { dimColor: true, children: "Los permisos a nivel de sitio se heredan de la extensi\u00F3n de Chrome. Gestiona los permisos en la configuraci\u00F3n de la extensi\u00F3n de Chrome para controlar en qu\u00E9 sitios puede navegar, hacer clic y escribir Context." })] });
+        $[25] = handleAction;
+        $[26] = isConnected;
+        $[27] = isDisabled;
+        $[28] = isExtensionInstalled;
+        $[29] = options;
+        $[30] = selectKey;
+        $[31] = showInstallHint;
+        $[32] = t9;
+    }
+    else {
+        t9 = $[32];
+    }
+    let t10;
+    if ($[33] === Symbol.for("react.memo_cache_sentinel")) {
+        t10 = _jsx(Text, { dimColor: true, children: "Learn more: https://code.claude.com/docs/en/chrome" });
+        $[33] = t10;
+    }
+    else {
+        t10 = $[33];
+    }
+    let t11;
+    if ($[34] !== t7 || $[35] !== t8 || $[36] !== t9) {
+        t11 = _jsxs(Box, { flexDirection: "column", gap: 1, children: [t6, t7, t8, t9, t10] });
+        $[34] = t7;
+        $[35] = t8;
+        $[36] = t9;
+        $[37] = t11;
+    }
+    else {
+        t11 = $[37];
+    }
+    let t12;
+    if ($[38] !== t11 || $[39] !== t5) {
+        t12 = _jsx(Dialog, { title: "Claude in Chrome (Beta)", onCancel: t5, color: "chromeYellow", children: t11 });
+        $[38] = t11;
+        $[39] = t5;
+        $[40] = t12;
+    }
+    else {
+        t12 = $[40];
+    }
+    return t12;
+}
+function _temp5(k) {
+    return k + 1;
+}
+function _temp4(k_0) {
+    return k_0 + 1;
+}
+function _temp3(k_1) {
+    return k_1 + 1;
+}
+function _temp2(c) {
+    return c.name === CLAUDE_IN_CHROME_MCP_SERVER_NAME;
+}
+function _temp(s) {
+    return s.mcp.clients;
+}
+export const call = async function (onDone) {
+    const isExtensionInstalled = await isChromeExtensionInstalled();
+    const config = getGlobalConfig();
+    const isSubscriber = isClaudeAISubscriber();
+    const isWSL = env.isWslEnvironment();
+    return _jsx(ClaudeInChromeMenu, { onDone: onDone, isExtensionInstalled: isExtensionInstalled, configEnabled: config.claudeInChromeDefaultEnabled, isClaudeAISubscriber: isSubscriber, isWSL: isWSL });
+};

package/dist/src/commands/chrome/index.js

@@ -0,0 +1,11 @@
+import { getIsNonInteractiveSession } from '../../bootstrap/state.js';
+const command = {
+    name: 'chrome',
+    description: 'Configuración de Context in Chrome (Beta)',
+    availability: ['claude-ai'],
+    isEnabled: () => !getIsNonInteractiveSession(),
+    isHidden: true,
+    type: 'local-jsx',
+    load: () => import('./chrome.js'),
+};
+export default command;