@xelauvas/xela-cli 0.1.0

package/src/commands/install.tsx

@@ -0,0 +1,300 @@
+import { c as _c } from "react/compiler-runtime";
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import React, { useEffect, useState } from 'react';
+import type { CommandResultDisplay } from 'src/commands.js';
+import { logEvent } from 'src/services/analytics/index.js';
+import { StatusIcon } from '../components/design-system/StatusIcon.js';
+import { Box, render, Text } from '../ink.js';
+import { logForDebugging } from '../utils/debug.js';
+import { env } from '../utils/env.js';
+import { errorMessage } from '../utils/errors.js';
+import { checkInstall, cleanupNpmInstallations, cleanupShellAliases, installLatest } from '../utils/nativeInstaller/index.js';
+import { getInitialSettings, updateSettingsForSource } from '../utils/settings/settings.js';
+interface InstallProps {
+  onDone: (result: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+  force?: boolean;
+  target?: string; // 'latest', 'stable', or version like '1.0.34'
+}
+type InstallState = {
+  type: 'checking';
+} | {
+  type: 'cleaning-npm';
+} | {
+  type: 'installing';
+  version: string;
+} | {
+  type: 'setting-up';
+} | {
+  type: 'set-up';
+  messages: string[];
+} | {
+  type: 'success';
+  version: string;
+  setupMessages?: string[];
+} | {
+  type: 'error';
+  message: string;
+  warnings?: string[];
+};
+function getInstallationPath(): string {
+  const isWindows = env.platform === 'win32';
+  const homeDir = homedir();
+  if (isWindows) {
+    // Convert to Windows-style path
+    const windowsPath = join(homeDir, '.local', 'bin', 'claude.exe');
+    // Replace forward slashes with backslashes for Windows display
+    return windowsPath.replace(/\//g, '\\');
+  }
+  return '~/.local/bin/claude';
+}
+function SetupNotes(t0) {
+  const $ = _c(5);
+  const {
+    messages
+  } = t0;
+  if (messages.length === 0) {
+    return null;
+  }
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <Box><Text color="warning"><StatusIcon status="warning" withSpace={true} />Setup notes:</Text></Box>;
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  let t2;
+  if ($[1] !== messages) {
+    t2 = messages.map(_temp);
+    $[1] = messages;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  let t3;
+  if ($[3] !== t2) {
+    t3 = <Box flexDirection="column" gap={0} marginBottom={1}>{t1}{t2}</Box>;
+    $[3] = t2;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  return t3;
+}
+function _temp(message, index) {
+  return <Box key={index} marginLeft={2}><Text dimColor={true}>• {message}</Text></Box>;
+}
+function Install({
+  onDone,
+  force,
+  target
+}: InstallProps): React.ReactNode {
+  const [state, setState] = useState<InstallState>({
+    type: 'checking'
+  });
+  useEffect(() => {
+    async function run() {
+      try {
+        logForDebugging(`Install: Starting installation process (force=${force}, target=${target})`);
+
+        // Install native build first
+        const channelOrVersion = target || getInitialSettings()?.autoUpdatesChannel || 'latest';
+        setState({
+          type: 'installing',
+          version: channelOrVersion
+        });
+
+        // Pass force flag to trigger reinstall even if up to date
+        logForDebugging(`Install: Calling installLatest(channelOrVersion=${channelOrVersion}, forceReinstall=${force})`);
+        const result = await installLatest(channelOrVersion, force);
+        logForDebugging(`Install: installLatest returned version=${result.latestVersion}, wasUpdated=${result.wasUpdated}, lockFailed=${result.lockFailed}`);
+
+        // Check specifically for lock failure
+        if (result.lockFailed) {
+          throw new Error('Could not install - another process is currently installing Claude. Please try again in a moment.');
+        }
+
+        // If we couldn't get the version, there might be an issue
+        if (!result.latestVersion) {
+          logForDebugging('Install: Failed to retrieve version information during install', {
+            level: 'error'
+          });
+        }
+        if (!result.wasUpdated) {
+          logForDebugging('Install: Already up to date');
+        }
+
+        // Set up launcher and shell integration
+        setState({
+          type: 'setting-up'
+        });
+        const setupMessages = await checkInstall(true);
+        logForDebugging(`Install: Setup launcher completed with ${setupMessages.length} messages`);
+        if (setupMessages.length > 0) {
+          setupMessages.forEach(msg => logForDebugging(`Install: Setup message: ${msg.message}`));
+        }
+
+        // Now that native installation succeeded, clean up old npm installations
+        logForDebugging('Install: Cleaning up npm installations after successful install');
+        const {
+          removed,
+          errors,
+          warnings
+        } = await cleanupNpmInstallations();
+        if (removed > 0) {
+          logForDebugging(`Cleaned up ${removed} npm installation(s)`);
+        }
+        if (errors.length > 0) {
+          logForDebugging(`Cleanup errors: ${errors.join(', ')}`);
+          // Continue despite cleanup errors - native install already succeeded
+        }
+
+        // Clean up old shell aliases
+        const aliasMessages = await cleanupShellAliases();
+        if (aliasMessages.length > 0) {
+          logForDebugging(`Shell alias cleanup: ${aliasMessages.map(m => m.message).join('; ')}`);
+        }
+
+        // Log success event
+        logEvent('tengu_claude_install_command', {
+          has_version: result.latestVersion ? 1 : 0,
+          forced: force ? 1 : 0
+        });
+
+        // If user explicitly specified a channel, save it to settings
+        if (target === 'latest' || target === 'stable') {
+          updateSettingsForSource('userSettings', {
+            autoUpdatesChannel: target
+          });
+          logForDebugging(`Install: Saved autoUpdatesChannel=${target} to user settings`);
+        }
+
+        // Combine all warning/info messages (convert SetupMessage to string)
+        const allWarnings = [...warnings, ...aliasMessages.map(m_0 => m_0.message)];
+
+        // Check if there were any setup errors or notes
+        if (setupMessages.length > 0) {
+          setState({
+            type: 'set-up',
+            messages: setupMessages.map(m_1 => m_1.message)
+          });
+          // Still mark as success but show both setup messages and cleanup warnings
+          setTimeout(setState, 2000, {
+            type: 'success' as const,
+            version: result.latestVersion || 'current',
+            setupMessages: [...setupMessages.map(m_2 => m_2.message), ...allWarnings]
+          });
+        } else {
+          // No setup messages, go straight to success (but still show cleanup warnings if any)
+          logForDebugging('Install: Shell PATH already configured');
+          setState({
+            type: 'success',
+            version: result.latestVersion || 'current',
+            setupMessages: allWarnings.length > 0 ? allWarnings : undefined
+          });
+        }
+      } catch (error) {
+        logForDebugging(`Install command failed: ${error}`, {
+          level: 'error'
+        });
+        setState({
+          type: 'error',
+          message: errorMessage(error)
+        });
+      }
+    }
+    void run();
+  }, [force, target]);
+  useEffect(() => {
+    if (state.type === 'success') {
+      // Give success message time to render before exiting
+      setTimeout(onDone, 2000, 'Claude Code installation completed successfully', {
+        display: 'system' as const
+      });
+    } else if (state.type === 'error') {
+      // Give error message time to render before exiting
+      setTimeout(onDone, 3000, 'Claude Code installation failed', {
+        display: 'system' as const
+      });
+    }
+  }, [state, onDone]);
+  return <Box flexDirection="column" marginTop={1}>
+      {state.type === 'checking' && <Text color="claude">Checking installation status...</Text>}
+
+      {state.type === 'cleaning-npm' && <Text color="warning">Cleaning up old npm installations...</Text>}
+
+      {state.type === 'installing' && <Text color="claude">
+          Installing Claude Code native build {state.version}...
+        </Text>}
+
+      {state.type === 'setting-up' && <Text color="claude">Setting up launcher and shell integration...</Text>}
+
+      {state.type === 'set-up' && <SetupNotes messages={state.messages} />}
+
+      {state.type === 'success' && <Box flexDirection="column" gap={1}>
+          <Box>
+            <StatusIcon status="success" withSpace />
+            <Text color="success" bold>
+              Claude Code successfully installed!
+            </Text>
+          </Box>
+          <Box marginLeft={2} flexDirection="column" gap={1}>
+            {state.version !== 'current' && <Box>
+                <Text dimColor>Version: </Text>
+                <Text color="claude">{state.version}</Text>
+              </Box>}
+            <Box>
+              <Text dimColor>Location: </Text>
+              <Text color="text">{getInstallationPath()}</Text>
+            </Box>
+          </Box>
+          <Box marginLeft={2} flexDirection="column" gap={1}>
+            <Box marginTop={1}>
+              <Text dimColor>Next: Run </Text>
+              <Text color="claude" bold>
+                claude --help
+              </Text>
+              <Text dimColor> to get started</Text>
+            </Box>
+          </Box>
+          {state.setupMessages && <SetupNotes messages={state.setupMessages} />}
+        </Box>}
+
+      {state.type === 'error' && <Box flexDirection="column" gap={1}>
+          <Box>
+            <StatusIcon status="error" withSpace />
+            <Text color="error">Installation failed</Text>
+          </Box>
+          <Text color="error">{state.message}</Text>
+          <Box marginTop={1}>
+            <Text dimColor>Try running with --force to override checks</Text>
+          </Box>
+        </Box>}
+    </Box>;
+}
+
+// This is only used from cli.tsx, not as a slash command
+export const install = {
+  type: 'local-jsx' as const,
+  name: 'install',
+  description: 'Install Claude Code native build',
+  argumentHint: '[options]',
+  async call(onDone: (result: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void, _context: unknown, args: string[]) {
+    // Parse arguments
+    const force = args.includes('--force');
+    const nonFlagArgs = args.filter(arg => !arg.startsWith('--'));
+    const target = nonFlagArgs[0]; // 'latest', 'stable', or version like '1.0.34'
+
+    const {
+      unmount
+    } = await render(<Install onDone={(result, options) => {
+      unmount();
+      onDone(result, options);
+    }} force={force} target={target} />);
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["homedir","join","React","useEffect","useState","CommandResultDisplay","logEvent","StatusIcon","Box","render","Text","logForDebugging","env","errorMessage","checkInstall","cleanupNpmInstallations","cleanupShellAliases","installLatest","getInitialSettings","updateSettingsForSource","InstallProps","onDone","result","options","display","force","target","InstallState","type","version","messages","setupMessages","message","warnings","getInstallationPath","isWindows","platform","homeDir","windowsPath","replace","SetupNotes","t0","$","_c","length","t1","Symbol","for","t2","map","_temp","t3","index","Install","ReactNode","state","setState","run","channelOrVersion","autoUpdatesChannel","latestVersion","wasUpdated","lockFailed","Error","level","forEach","msg","removed","errors","aliasMessages","m","has_version","forced","allWarnings","setTimeout","const","undefined","error","install","name","description","argumentHint","call","_context","args","includes","nonFlagArgs","filter","arg","startsWith","unmount"],"sources":["install.tsx"],"sourcesContent":["import { homedir } from 'node:os'\nimport { join } from 'node:path'\nimport React, { useEffect, useState } from 'react'\nimport type { CommandResultDisplay } from 'src/commands.js'\nimport { logEvent } from 'src/services/analytics/index.js'\nimport { StatusIcon } from '../components/design-system/StatusIcon.js'\nimport { Box, render, Text } from '../ink.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { env } from '../utils/env.js'\nimport { errorMessage } from '../utils/errors.js'\nimport {\n  checkInstall,\n  cleanupNpmInstallations,\n  cleanupShellAliases,\n  installLatest,\n} from '../utils/nativeInstaller/index.js'\nimport {\n  getInitialSettings,\n  updateSettingsForSource,\n} from '../utils/settings/settings.js'\n\ninterface InstallProps {\n  onDone: (result: string, options?: { display?: CommandResultDisplay }) => void\n  force?: boolean\n  target?: string // 'latest', 'stable', or version like '1.0.34'\n}\n\ntype InstallState =\n  | { type: 'checking' }\n  | { type: 'cleaning-npm' }\n  | { type: 'installing'; version: string }\n  | { type: 'setting-up' }\n  | { type: 'set-up'; messages: string[] }\n  | { type: 'success'; version: string; setupMessages?: string[] }\n  | { type: 'error'; message: string; warnings?: string[] }\n\nfunction getInstallationPath(): string {\n  const isWindows = env.platform === 'win32'\n  const homeDir = homedir()\n\n  if (isWindows) {\n    // Convert to Windows-style path\n    const windowsPath = join(homeDir, '.local', 'bin', 'claude.exe')\n    // Replace forward slashes with backslashes for Windows display\n    return windowsPath.replace(/\\//g, '\\\\')\n  }\n\n  return '~/.local/bin/claude'\n}\n\nfunction SetupNotes({ messages }: { messages: string[] }): React.ReactNode {\n  if (messages.length === 0) return null\n\n  return (\n    <Box flexDirection=\"column\" gap={0} marginBottom={1}>\n      <Box>\n        <Text color=\"warning\">\n          <StatusIcon status=\"warning\" withSpace />\n          Setup notes:\n        </Text>\n      </Box>\n      {messages.map((message, index) => (\n        <Box key={index} marginLeft={2}>\n          <Text dimColor>• {message}</Text>\n        </Box>\n      ))}\n    </Box>\n  )\n}\n\nfunction Install({ onDone, force, target }: InstallProps): React.ReactNode {\n  const [state, setState] = useState<InstallState>({ type: 'checking' })\n\n  useEffect(() => {\n    async function run() {\n      try {\n        logForDebugging(\n          `Install: Starting installation process (force=${force}, target=${target})`,\n        )\n\n        // Install native build first\n        const channelOrVersion =\n          target || getInitialSettings()?.autoUpdatesChannel || 'latest'\n        setState({ type: 'installing', version: channelOrVersion })\n\n        // Pass force flag to trigger reinstall even if up to date\n        logForDebugging(\n          `Install: Calling installLatest(channelOrVersion=${channelOrVersion}, forceReinstall=${force})`,\n        )\n        const result = await installLatest(channelOrVersion, force)\n        logForDebugging(\n          `Install: installLatest returned version=${result.latestVersion}, wasUpdated=${result.wasUpdated}, lockFailed=${result.lockFailed}`,\n        )\n\n        // Check specifically for lock failure\n        if (result.lockFailed) {\n          throw new Error(\n            'Could not install - another process is currently installing Claude. Please try again in a moment.',\n          )\n        }\n\n        // If we couldn't get the version, there might be an issue\n        if (!result.latestVersion) {\n          logForDebugging(\n            'Install: Failed to retrieve version information during install',\n            { level: 'error' },\n          )\n        }\n\n        if (!result.wasUpdated) {\n          logForDebugging('Install: Already up to date')\n        }\n\n        // Set up launcher and shell integration\n        setState({ type: 'setting-up' })\n        const setupMessages = await checkInstall(true)\n\n        logForDebugging(\n          `Install: Setup launcher completed with ${setupMessages.length} messages`,\n        )\n        if (setupMessages.length > 0) {\n          setupMessages.forEach(msg =>\n            logForDebugging(`Install: Setup message: ${msg.message}`),\n          )\n        }\n\n        // Now that native installation succeeded, clean up old npm installations\n        logForDebugging(\n          'Install: Cleaning up npm installations after successful install',\n        )\n        const { removed, errors, warnings } = await cleanupNpmInstallations()\n\n        if (removed > 0) {\n          logForDebugging(`Cleaned up ${removed} npm installation(s)`)\n        }\n\n        if (errors.length > 0) {\n          logForDebugging(`Cleanup errors: ${errors.join(', ')}`)\n          // Continue despite cleanup errors - native install already succeeded\n        }\n\n        // Clean up old shell aliases\n        const aliasMessages = await cleanupShellAliases()\n        if (aliasMessages.length > 0) {\n          logForDebugging(\n            `Shell alias cleanup: ${aliasMessages.map(m => m.message).join('; ')}`,\n          )\n        }\n\n        // Log success event\n        logEvent('tengu_claude_install_command', {\n          has_version: result.latestVersion ? 1 : 0,\n          forced: force ? 1 : 0,\n        })\n\n        // If user explicitly specified a channel, save it to settings\n        if (target === 'latest' || target === 'stable') {\n          updateSettingsForSource('userSettings', {\n            autoUpdatesChannel: target,\n          })\n          logForDebugging(\n            `Install: Saved autoUpdatesChannel=${target} to user settings`,\n          )\n        }\n\n        // Combine all warning/info messages (convert SetupMessage to string)\n        const allWarnings = [...warnings, ...aliasMessages.map(m => m.message)]\n\n        // Check if there were any setup errors or notes\n        if (setupMessages.length > 0) {\n          setState({\n            type: 'set-up',\n            messages: setupMessages.map(m => m.message),\n          })\n          // Still mark as success but show both setup messages and cleanup warnings\n          setTimeout(setState, 2000, {\n            type: 'success' as const,\n            version: result.latestVersion || 'current',\n            setupMessages: [\n              ...setupMessages.map(m => m.message),\n              ...allWarnings,\n            ],\n          })\n        } else {\n          // No setup messages, go straight to success (but still show cleanup warnings if any)\n          logForDebugging('Install: Shell PATH already configured')\n          setState({\n            type: 'success',\n            version: result.latestVersion || 'current',\n            setupMessages: allWarnings.length > 0 ? allWarnings : undefined,\n          })\n        }\n      } catch (error) {\n        logForDebugging(`Install command failed: ${error}`, {\n          level: 'error',\n        })\n        setState({\n          type: 'error',\n          message: errorMessage(error),\n        })\n      }\n    }\n\n    void run()\n  }, [force, target])\n\n  useEffect(() => {\n    if (state.type === 'success') {\n      // Give success message time to render before exiting\n      setTimeout(\n        onDone,\n        2000,\n        'Claude Code installation completed successfully',\n        {\n          display: 'system' as const,\n        },\n      )\n    } else if (state.type === 'error') {\n      // Give error message time to render before exiting\n      setTimeout(onDone, 3000, 'Claude Code installation failed', {\n        display: 'system' as const,\n      })\n    }\n  }, [state, onDone])\n\n  return (\n    <Box flexDirection=\"column\" marginTop={1}>\n      {state.type === 'checking' && (\n        <Text color=\"claude\">Checking installation status...</Text>\n      )}\n\n      {state.type === 'cleaning-npm' && (\n        <Text color=\"warning\">Cleaning up old npm installations...</Text>\n      )}\n\n      {state.type === 'installing' && (\n        <Text color=\"claude\">\n          Installing Claude Code native build {state.version}...\n        </Text>\n      )}\n\n      {state.type === 'setting-up' && (\n        <Text color=\"claude\">Setting up launcher and shell integration...</Text>\n      )}\n\n      {state.type === 'set-up' && <SetupNotes messages={state.messages} />}\n\n      {state.type === 'success' && (\n        <Box flexDirection=\"column\" gap={1}>\n          <Box>\n            <StatusIcon status=\"success\" withSpace />\n            <Text color=\"success\" bold>\n              Claude Code successfully installed!\n            </Text>\n          </Box>\n          <Box marginLeft={2} flexDirection=\"column\" gap={1}>\n            {state.version !== 'current' && (\n              <Box>\n                <Text dimColor>Version: </Text>\n                <Text color=\"claude\">{state.version}</Text>\n              </Box>\n            )}\n            <Box>\n              <Text dimColor>Location: </Text>\n              <Text color=\"text\">{getInstallationPath()}</Text>\n            </Box>\n          </Box>\n          <Box marginLeft={2} flexDirection=\"column\" gap={1}>\n            <Box marginTop={1}>\n              <Text dimColor>Next: Run </Text>\n              <Text color=\"claude\" bold>\n                claude --help\n              </Text>\n              <Text dimColor> to get started</Text>\n            </Box>\n          </Box>\n          {state.setupMessages && <SetupNotes messages={state.setupMessages} />}\n        </Box>\n      )}\n\n      {state.type === 'error' && (\n        <Box flexDirection=\"column\" gap={1}>\n          <Box>\n            <StatusIcon status=\"error\" withSpace />\n            <Text color=\"error\">Installation failed</Text>\n          </Box>\n          <Text color=\"error\">{state.message}</Text>\n          <Box marginTop={1}>\n            <Text dimColor>Try running with --force to override checks</Text>\n          </Box>\n        </Box>\n      )}\n    </Box>\n  )\n}\n\n// This is only used from cli.tsx, not as a slash command\nexport const install = {\n  type: 'local-jsx' as const,\n  name: 'install',\n  description: 'Install Claude Code native build',\n  argumentHint: '[options]',\n  async call(\n    onDone: (\n      result: string,\n      options?: { display?: CommandResultDisplay },\n    ) => void,\n    _context: unknown,\n    args: string[],\n  ) {\n    // Parse arguments\n    const force = args.includes('--force')\n    const nonFlagArgs = args.filter(arg => !arg.startsWith('--'))\n    const target = nonFlagArgs[0] // 'latest', 'stable', or version like '1.0.34'\n\n    const { unmount } = await render(\n      <Install\n        onDone={(result, options) => {\n          unmount()\n          onDone(result, options)\n        }}\n        force={force}\n        target={target}\n      />,\n    )\n  },\n}\n"],"mappings":"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","ignoreList":[]}

package/src/commands/issue/index.js

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

package/src/commands/keybindings/index.ts

@@ -0,0 +1,13 @@
+import type { Command } from '../../commands.js'
+import { isKeybindingCustomizationEnabled } from '../../keybindings/loadUserBindings.js'
+
+const keybindings = {
+  name: 'keybindings',
+  description: 'Open or create your keybindings configuration file',
+  isEnabled: () => isKeybindingCustomizationEnabled(),
+  supportsNonInteractive: false,
+  type: 'local',
+  load: () => import('./keybindings.js'),
+} satisfies Command
+
+export default keybindings

package/src/commands/keybindings/keybindings.ts

@@ -0,0 +1,53 @@
+import { mkdir, writeFile } from 'fs/promises'
+import { dirname } from 'path'
+import {
+  getKeybindingsPath,
+  isKeybindingCustomizationEnabled,
+} from '../../keybindings/loadUserBindings.js'
+import { generateKeybindingsTemplate } from '../../keybindings/template.js'
+import { getErrnoCode } from '../../utils/errors.js'
+import { editFileInEditor } from '../../utils/promptEditor.js'
+
+export async function call(): Promise<{ type: 'text'; value: string }> {
+  if (!isKeybindingCustomizationEnabled()) {
+    return {
+      type: 'text',
+      value:
+        'Keybinding customization is not enabled. This feature is currently in preview.',
+    }
+  }
+
+  const keybindingsPath = getKeybindingsPath()
+
+  // Write template with 'wx' flag (exclusive create) — fails with EEXIST if
+  // the file already exists. Avoids a stat pre-check (TOCTOU race + extra syscall).
+  let fileExists = false
+  await mkdir(dirname(keybindingsPath), { recursive: true })
+  try {
+    await writeFile(keybindingsPath, generateKeybindingsTemplate(), {
+      encoding: 'utf-8',
+      flag: 'wx',
+    })
+  } catch (e: unknown) {
+    if (getErrnoCode(e) === 'EEXIST') {
+      fileExists = true
+    } else {
+      throw e
+    }
+  }
+
+  // Open in editor
+  const result = await editFileInEditor(keybindingsPath)
+  if (result.error) {
+    return {
+      type: 'text',
+      value: `${fileExists ? 'Opened' : 'Created'} ${keybindingsPath}. Could not open in editor: ${result.error}`,
+    }
+  }
+  return {
+    type: 'text',
+    value: fileExists
+      ? `Opened ${keybindingsPath} in your editor.`
+      : `Created ${keybindingsPath} with template. Opened in your editor.`,
+  }
+}

package/src/commands/login/index.ts

@@ -0,0 +1,14 @@
+import type { Command } from '../../commands.js'
+import { hasAnthropicApiKeyAuth } from '../../utils/auth.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
+export default () =>
+  ({
+    type: 'local-jsx',
+    name: 'login',
+    description: hasAnthropicApiKeyAuth()
+      ? 'Switch Anthropic accounts'
+      : 'Sign in with your Anthropic account',
+    isEnabled: () => !isEnvTruthy(process.env.DISABLE_LOGIN_COMMAND),
+    load: () => import('./login.js'),
+  }) satisfies Command

package/src/commands/login/login.tsx

@@ -0,0 +1,104 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import * as React from 'react';
+import { resetCostState } from '../../bootstrap/state.js';
+import { clearTrustedDeviceToken, enrollTrustedDevice } from '../../bridge/trustedDevice.js';
+import type { LocalJSXCommandContext } from '../../commands.js';
+import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js';
+import { ConsoleOAuthFlow } from '../../components/ConsoleOAuthFlow.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { useMainLoopModel } from '../../hooks/useMainLoopModel.js';
+import { Text } from '../../ink.js';
+import { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js';
+import { refreshPolicyLimits } from '../../services/policyLimits/index.js';
+import { refreshRemoteManagedSettings } from '../../services/remoteManagedSettings/index.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { stripSignatureBlocks } from '../../utils/messages.js';
+import { checkAndDisableAutoModeIfNeeded, checkAndDisableBypassPermissionsIfNeeded, resetAutoModeGateCheck, resetBypassPermissionsCheck } from '../../utils/permissions/bypassPermissionsKillswitch.js';
+import { resetUserCache } from '../../utils/user.js';
+export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext): Promise<React.ReactNode> {
+  return <Login onDone={async success => {
+    context.onChangeAPIKey();
+    // Signature-bearing blocks (thinking, connector_text) are bound to the API key —
+    // strip them so the new key doesn't reject stale signatures.
+    context.setMessages(stripSignatureBlocks);
+    if (success) {
+      // Post-login refresh logic. Keep in sync with onboarding in src/interactiveHelpers.tsx
+      // Reset cost state when switching accounts
+      resetCostState();
+      // Refresh remotely managed settings after login (non-blocking)
+      void refreshRemoteManagedSettings();
+      // Refresh policy limits after login (non-blocking)
+      void refreshPolicyLimits();
+      // Clear user data cache BEFORE GrowthBook refresh so it picks up fresh credentials
+      resetUserCache();
+      // Refresh GrowthBook after login to get updated feature flags (e.g., for claude.ai MCPs)
+      refreshGrowthBookAfterAuthChange();
+      // Clear any stale trusted device token from a previous account before
+      // re-enrolling — prevents sending the old token on bridge calls while
+      // the async enrollTrustedDevice() is in-flight.
+      clearTrustedDeviceToken();
+      // Enroll as a trusted device for Remote Control (10-min fresh-session window)
+      void enrollTrustedDevice();
+      // Reset killswitch gate checks and re-run with new org
+      resetBypassPermissionsCheck();
+      const appState = context.getAppState();
+      void checkAndDisableBypassPermissionsIfNeeded(appState.toolPermissionContext, context.setAppState);
+      if (feature('TRANSCRIPT_CLASSIFIER')) {
+        resetAutoModeGateCheck();
+        void checkAndDisableAutoModeIfNeeded(appState.toolPermissionContext, context.setAppState, appState.fastMode);
+      }
+      // Increment authVersion to trigger re-fetching of auth-dependent data in hooks (e.g., MCP servers)
+      context.setAppState(prev => ({
+        ...prev,
+        authVersion: prev.authVersion + 1
+      }));
+    }
+    onDone(success ? 'Login successful' : 'Login interrupted');
+  }} />;
+}
+export function Login(props) {
+  const $ = _c(12);
+  const mainLoopModel = useMainLoopModel();
+  let t0;
+  if ($[0] !== mainLoopModel || $[1] !== props) {
+    t0 = () => props.onDone(false, mainLoopModel);
+    $[0] = mainLoopModel;
+    $[1] = props;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  let t1;
+  if ($[3] !== mainLoopModel || $[4] !== props) {
+    t1 = () => props.onDone(true, mainLoopModel);
+    $[3] = mainLoopModel;
+    $[4] = props;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  let t2;
+  if ($[6] !== props.startingMessage || $[7] !== t1) {
+    t2 = <ConsoleOAuthFlow onDone={t1} startingMessage={props.startingMessage} />;
+    $[6] = props.startingMessage;
+    $[7] = t1;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  let t3;
+  if ($[9] !== t0 || $[10] !== t2) {
+    t3 = <Dialog title="Login" onCancel={t0} color="permission" inputGuide={_temp}>{t2}</Dialog>;
+    $[9] = t0;
+    $[10] = t2;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  return t3;
+}
+function _temp(exitState) {
+  return exitState.pending ? <Text>Press {exitState.keyName} again to exit</Text> : <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="cancel" />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","resetCostState","clearTrustedDeviceToken","enrollTrustedDevice","LocalJSXCommandContext","ConfigurableShortcutHint","ConsoleOAuthFlow","Dialog","useMainLoopModel","Text","refreshGrowthBookAfterAuthChange","refreshPolicyLimits","refreshRemoteManagedSettings","LocalJSXCommandOnDone","stripSignatureBlocks","checkAndDisableAutoModeIfNeeded","checkAndDisableBypassPermissionsIfNeeded","resetAutoModeGateCheck","resetBypassPermissionsCheck","resetUserCache","call","onDone","context","Promise","ReactNode","success","onChangeAPIKey","setMessages","appState","getAppState","toolPermissionContext","setAppState","fastMode","prev","authVersion","Login","props","$","_c","mainLoopModel","t0","t1","t2","startingMessage","t3","_temp","exitState","pending","keyName"],"sources":["login.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport { resetCostState } from '../../bootstrap/state.js'\nimport {\n  clearTrustedDeviceToken,\n  enrollTrustedDevice,\n} from '../../bridge/trustedDevice.js'\nimport type { LocalJSXCommandContext } from '../../commands.js'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { ConsoleOAuthFlow } from '../../components/ConsoleOAuthFlow.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { useMainLoopModel } from '../../hooks/useMainLoopModel.js'\nimport { Text } from '../../ink.js'\nimport { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js'\nimport { refreshPolicyLimits } from '../../services/policyLimits/index.js'\nimport { refreshRemoteManagedSettings } from '../../services/remoteManagedSettings/index.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { stripSignatureBlocks } from '../../utils/messages.js'\nimport {\n  checkAndDisableAutoModeIfNeeded,\n  checkAndDisableBypassPermissionsIfNeeded,\n  resetAutoModeGateCheck,\n  resetBypassPermissionsCheck,\n} from '../../utils/permissions/bypassPermissionsKillswitch.js'\nimport { resetUserCache } from '../../utils/user.js'\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: LocalJSXCommandContext,\n): Promise<React.ReactNode> {\n  return (\n    <Login\n      onDone={async success => {\n        context.onChangeAPIKey()\n        // Signature-bearing blocks (thinking, connector_text) are bound to the API key —\n        // strip them so the new key doesn't reject stale signatures.\n        context.setMessages(stripSignatureBlocks)\n        if (success) {\n          // Post-login refresh logic. Keep in sync with onboarding in src/interactiveHelpers.tsx\n          // Reset cost state when switching accounts\n          resetCostState()\n          // Refresh remotely managed settings after login (non-blocking)\n          void refreshRemoteManagedSettings()\n          // Refresh policy limits after login (non-blocking)\n          void refreshPolicyLimits()\n          // Clear user data cache BEFORE GrowthBook refresh so it picks up fresh credentials\n          resetUserCache()\n          // Refresh GrowthBook after login to get updated feature flags (e.g., for claude.ai MCPs)\n          refreshGrowthBookAfterAuthChange()\n          // Clear any stale trusted device token from a previous account before\n          // re-enrolling — prevents sending the old token on bridge calls while\n          // the async enrollTrustedDevice() is in-flight.\n          clearTrustedDeviceToken()\n          // Enroll as a trusted device for Remote Control (10-min fresh-session window)\n          void enrollTrustedDevice()\n          // Reset killswitch gate checks and re-run with new org\n          resetBypassPermissionsCheck()\n          const appState = context.getAppState()\n          void checkAndDisableBypassPermissionsIfNeeded(\n            appState.toolPermissionContext,\n            context.setAppState,\n          )\n          if (feature('TRANSCRIPT_CLASSIFIER')) {\n            resetAutoModeGateCheck()\n            void checkAndDisableAutoModeIfNeeded(\n              appState.toolPermissionContext,\n              context.setAppState,\n              appState.fastMode,\n            )\n          }\n          // Increment authVersion to trigger re-fetching of auth-dependent data in hooks (e.g., MCP servers)\n          context.setAppState(prev => ({\n            ...prev,\n            authVersion: prev.authVersion + 1,\n          }))\n        }\n        onDone(success ? 'Login successful' : 'Login interrupted')\n      }}\n    />\n  )\n}\n\nexport function Login(props: {\n  onDone: (success: boolean, mainLoopModel: string) => void\n  startingMessage?: string\n}): React.ReactNode {\n  const mainLoopModel = useMainLoopModel()\n\n  return (\n    <Dialog\n      title=\"Login\"\n      onCancel={() => props.onDone(false, mainLoopModel)}\n      color=\"permission\"\n      inputGuide={exitState =>\n        exitState.pending ? (\n          <Text>Press {exitState.keyName} again to exit</Text>\n        ) : (\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"cancel\"\n          />\n        )\n      }\n    >\n      <ConsoleOAuthFlow\n        onDone={() => props.onDone(true, mainLoopModel)}\n        startingMessage={props.startingMessage}\n      />\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/commands/logout/index.ts

@@ -0,0 +1,10 @@
+import type { Command } from '../../commands.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
+export default {
+  type: 'local-jsx',
+  name: 'logout',
+  description: 'Sign out from your Anthropic account',
+  isEnabled: () => !isEnvTruthy(process.env.DISABLE_LOGOUT_COMMAND),
+  load: () => import('./logout.js'),
+} satisfies Command