// src/entrypoints/cli.tsx
async function main(): Promise<void> {
  const args = process.argv.slice(2)

  if (
    args.length === 1 &&
    ['--version', '-v', '-V'].includes(args[0])
  ) {
    console.log(`${MACRO.VERSION} (Claude Code)`)
    return
  }

  // Chrome、Daemon、Bridge 等特殊入口……

  if (args.includes('--bare')) {
    process.env.CLAUDE_CODE_SIMPLE = '1'
  }

  const {
    main: cliMain,
  } = await import('../main.js')

  await cliMain()
}

import { main } from '../main.js'

if (args.includes('--bare')) {
  process.env.CLAUDE_CODE_SIMPLE = '1'
}

const simpleMode =
  process.env.CLAUDE_CODE_SIMPLE === '1'

const program =
  new CommanderCommand()
    .configureHelp(createSortedHelpConfig())
    .enablePositionalOptions()

program
  .name('claude')
  .description(
    'Claude Code - starts an interactive session by default...',
  )
  .argument('[prompt]', 'Your prompt', String)
  .option('-p, --print', 'Print response and exit')
  .option('--model <model>', 'Model for the current session')
  .option('--permission-mode <mode>', 'Permission mode')
  .option('--mcp-config <configs...>', 'Load MCP servers')
  // ...
  .action(async (prompt, options) => {
    // 默认 Claude 会话
  })

program.command('mcp')
program.command('plugin')
program.command('doctor')
program.command('config')
// ...

await program.parseAsync(process.argv)

program.hook('preAction', async () => {
  await init()
  initSinks()
  // 初始化设置、认证、日志基础设施……
})

prompt
options

prompt = '检查登录模块'

options = {
  model: 'sonnet',
  permissionMode: 'plan',
  mcpConfig: ['./mcp.json'],
  print: undefined,
  inputFormat: undefined,
  outputFormat: undefined,
  sdkUrl: undefined,
}

process.stdin.isTTY === true
// 用户在终端运行 claude，stdin 通常来自键盘

process.stdin.isTTY === false
// stdin 通常来自管道或 SDK 子进程

if (process.stdin.isTTY || process.argv.includes('mcp')) {
  return prompt
}

if (inputFormat === 'stream-json') {
  return process.stdin
}

let data = '';
const onData = (chunk: string) => {
  data += chunk;
};
process.stdin.on('data', onData);
// If no data arrives in 3s, stop waiting and warn. Stdin is likely an
// inherited pipe from a parent that isn't writing (subprocess spawned
// without explicit stdin handling). 3s covers slow producers like curl,
// jq on large files, python with import overhead. The warning makes
// silent data loss visible for the rare producer that's slower still.
const timedOut = await peekForStdinData(process.stdin, 3000);
process.stdin.off('data', onData);
if (timedOut) {
  process.stderr.write('Warning: no stdin data received in 3s, proceeding without it. ' + 'If piping from a slow command, redirect stdin explicitly: < /dev/null to skip, or wait longer.\n');
}
return [prompt, data].filter(Boolean).join('\n')

const { mode: permissionMode } =
  initialPermissionModeFromCLI({
    permissionModeCli,
    dangerouslySkipPermissions,
  })

const { toolPermissionContext } =
  await initializeToolPermissionContext({
    allowedToolsCli: allowedTools,
    disallowedToolsCli: disallowedTools,
    baseToolsCli: baseTools,
    permissionMode,
    allowDangerouslySkipPermissions,
    addDirs: addDir,
  })

const tools = getTools(toolPermissionContext)

permissionModeCli // 'plan'
permissionMode    // 'plan'
allowedTools      // []
disallowedTools   // []
addDir            // []

function initialPermissionModeFromCLI({
  permissionModeCli,
  dangerouslySkipPermissions,
}) {
  const settings = getSettings_DEPRECATED() ?? {}

  const candidates = [
    dangerouslySkipPermissions
      ? 'bypassPermissions'
      : undefined,
    permissionModeCli
      ? permissionModeFromString(permissionModeCli)
      : undefined,
    settings.permissions?.defaultMode,
  ]

  const mode = candidates.find(Boolean) ?? 'default'
  return { mode }
}

async function initializeToolPermissionContext(args) {
  const allowRules =
    parseToolListFromCLI(args.allowedToolsCli)
  const denyRules =
    parseToolListFromCLI(args.disallowedToolsCli)

  let context = {
    mode: args.permissionMode,
    alwaysAllowRules: { cliArg: allowRules },
    alwaysDenyRules: { cliArg: denyRules },
    alwaysAskRules: {},
    additionalWorkingDirectories: new Map(),
  }

  context = applyPermissionRulesToPermissionContext(
    context,
    loadAllPermissionRulesFromDisk(),
  )

  for (const dir of args.addDirs) {
    const result =
      await validateDirectoryForWorkspace(dir, context)

    if (result.resultType === 'success') {
      context = applyPermissionUpdate(context, {
        type: 'addDirectories',
        directories: [result.absolutePath],
        destination: 'cliArg',
      })
    }
  }

  return { toolPermissionContext: context }
}

{
  mode: 'plan',
  alwaysAllowRules: { cliArg: [] },
  alwaysDenyRules: { cliArg: [] },
  alwaysAskRules: {},
  additionalWorkingDirectories: Map(0) {},
}

function getTools(permissionContext) {
  const allTools = getAllBaseTools()

  const allowedTools = filterToolsByDenyRules(
    allTools,
    permissionContext,
  )

  return allowedTools.filter(tool => tool.isEnabled())
}

const tools = getTools(toolPermissionContext)

tools.map(tool => tool.name)
// [
//   'Agent', 'Bash', 'Glob', 'Grep',
//   'Read', 'Edit', 'Write',
//   'WebFetch', 'WebSearch', 'Skill',
//   ...
// ]

tools.find(tool => tool.name === 'Read')
// {
//   name: 'Read',
//   searchHint: 'read files, images, PDFs, notebooks',
//   inputSchema: ZodObject(...),
//   isEnabled: [Function],
//   isReadOnly: [Function],
//   checkPermissions: [AsyncFunction],
//   call: [AsyncFunction],
//   ...
// }

async function hasPermissionsToUseTool(
  tool,
  input,
  context,
) {
  const permissionContext =
    context.getAppState().toolPermissionContext

  if (getDenyRuleForTool(permissionContext, tool)) {
    return { behavior: 'deny' }
  }

  if (getAskRuleForTool(permissionContext, tool)) {
    return { behavior: 'ask' }
  }

  const toolResult =
    await tool.checkPermissions(input, context)

  // deny、显式 ask 和安全检查不能被普通模式覆盖
  if (
    toolResult.behavior === 'deny' ||
    toolResult.decisionReason?.type === 'rule' ||
    toolResult.decisionReason?.type === 'safetyCheck'
  ) {
    return toolResult
  }

  if (permissionContext.mode === 'bypassPermissions') {
    return { behavior: 'allow' }
  }

  if (toolAlwaysAllowedRule(permissionContext, tool)) {
    return { behavior: 'allow' }
  }

  let result = toolResult.behavior === 'passthrough'
    ? { behavior: 'ask' }
    : toolResult

  if (
    permissionContext.mode === 'dontAsk' &&
    result.behavior === 'ask'
  ) {
    return { behavior: 'deny' }
  }

  if (
    permissionContext.mode === 'auto' &&
    result.behavior === 'ask'
  ) {
    return classifyYoloAction(/* ... */)
  }

  return result
}

tool.name // 'Edit'
input     // { file_path: '/Users/me/shop/src/login.ts', ... }

{ behavior: 'allow' } // 执行
{ behavior: 'ask' }   // 询问用户
{ behavior: 'deny' }  // 拒绝