start-ai-cli 0.1.0 → 0.2.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,49 +1,144 @@
-# start-ai-cli
+# start-ai-cli - AI coding CLI launcher
 
-Open Codex CLI, Claude Code, and Cursor CLI from the current directory in one Windows Terminal window.
+[![npm version](https://img.shields.io/npm/v/start-ai-cli.svg)](https://www.npmjs.com/package/start-ai-cli)
+[![npm downloads](https://img.shields.io/npm/dm/start-ai-cli.svg)](https://www.npmjs.com/package/start-ai-cli)
+[![license: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
-## Requirements
+`start-ai-cli` is an npm package and command line tool for launching selected AI coding CLIs from the same project directory. It can open Codex CLI, Claude Code, and Cursor CLI in separate terminal tabs or windows so every assistant starts in the current workspace.
+
+Use it when you want one command to choose and start your AI coding agents:
+
+```bash
+npx start-ai-cli
+```
+
+## Features
 
-- Windows
-- Node.js 18 or newer
-- Windows Terminal available as `wt.exe`
-- Codex CLI available as `codex`
-- Claude Code CLI available as `claude`
-- Cursor CLI available as `agent`
+- Interactively chooses which Codex CLI, Claude Code CLI, and Cursor CLI tools to launch.
+- Remembers your enabled tools in a global config file for the next run.
+- Opens each available tool in its own Windows Terminal tab or macOS Terminal window.
+- Skips missing CLIs instead of failing when at least one supported tool is available.
+- Works as a global npm command or one-off `npx` command.
 
 ## Install
 
+Run without installing:
+
 ```bash
-npm install -g start-ai-cli
+npx start-ai-cli
 ```
 
-For local development from this directory:
+Install globally:
 
 ```bash
-npm link
+npm install -g start-ai-cli
 ```
 
-## Usage
-
-Run the command from the project directory you want both tools to use:
+Then run it from the project directory you want the AI tools to use:
 
 ```bash
 start-ai-cli
 ```
 
-It opens Windows Terminal with three tabs:
+## Supported Tools
+
+| Tool | Required command | Terminal title |
+| --- | --- | --- |
+| Codex CLI | `codex` | `Codex` |
+| Claude Code | `claude` | `Claude` |
+| Cursor CLI | `agent` | `Cursor` |
+
+On Windows, `start-ai-cli` uses Windows Terminal (`wt.exe`) with PowerShell. On macOS, it uses Terminal.app through `osascript`.
 
-- `Codex`, running `codex`
-- `Claude`, running `claude`
-- `Cursor`, running `agent`
+## Requirements
+
+- Windows or macOS
+- Node.js 22 or newer
+- Windows Terminal available as `wt.exe` on Windows
+- PowerShell 7 available as `pwsh.exe`, or Windows PowerShell, on Windows
+- Terminal.app and `osascript` available on macOS
+- At least one supported AI coding CLI available in `PATH`
 
 ## Options
 
 ```bash
+start-ai-cli
+start-ai-cli --all
+start-ai-cli --no-interactive
 start-ai-cli --help
 start-ai-cli --version
 ```
 
+By default, `start-ai-cli` opens an interactive selector. Use Up/Down to move, Space to enable or disable an available CLI, Enter to open the selected tools, or `q`/Esc to cancel. Missing CLIs are shown as unavailable and cannot be selected.
+
+Use `--all` or `--no-interactive` in scripts and automation to launch every available CLI without prompting.
+
+## Global Config
+
+Interactive selections are saved to:
+
+```text
+~/.start-ai-cli/config.json
+```
+
+The config stores enabled tool ids:
+
+```json
+{
+  "enabledClis": ["codex", "claude", "cursor"]
+}
+```
+
+Delete this file to reset the saved defaults.
+
+## Troubleshooting
+
+### `start-ai-cli cannot start: no CLI tools found in PATH`
+
+Install or expose at least one supported command in your shell:
+
+- `codex` for Codex CLI
+- `claude` for Claude Code
+- `agent` for Cursor CLI
+
+### A CLI does not appear as available in the prompt
+
+Make sure its command is installed and available in `PATH`:
+
+- `codex` for Codex CLI
+- `claude` for Claude Code
+- `agent` for Cursor CLI
+
+### `start-ai-cli cannot prompt in a non-interactive terminal`
+
+Run with `--all` or `--no-interactive` when using CI, scripts, or shell pipelines:
+
+```bash
+start-ai-cli --all
+```
+
+### `start-ai-cli cannot start: no selected CLI tools are available`
+
+Choose at least one installed CLI in the prompt, or run `start-ai-cli --all` to launch every available tool.
+
+### `start-ai-cli cancelled`
+
+The interactive selector was closed with `q` or Esc. Run `start-ai-cli` again and press Enter after selecting at least one available CLI.
+
+### Windows Terminal was not found
+
+Install Windows Terminal and make sure `wt.exe` is available in `PATH`.
+
+### PowerShell was not found
+
+Install PowerShell 7 (`pwsh.exe`) or make sure Windows PowerShell (`powershell.exe`) is available.
+
+## Package Links
+
+- npm package: https://www.npmjs.com/package/start-ai-cli
+- GitHub repository: https://github.com/guoxiao0521/open-ai-cli
+- Issues: https://github.com/guoxiao0521/open-ai-cli/issues
+
 ## Development
 
 ```bash
@@ -54,6 +149,8 @@ npm run publish:dry-run
 
 ## Publish
 
+`README.md` and npm metadata changes appear on npm after publishing a new package version.
+
 ```bash
 npm login --registry=https://registry.npmjs.org/
 npm publish

package/bin/start-ai-cli.js

@@ -1,170 +1,668 @@
-#!/usr/bin/env node
-
+#!/usr/bin/env node
+
 import { spawn, spawnSync } from 'node:child_process';
-import { readFileSync, realpathSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve, win32 as pathWin32 } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import React, { useState } from 'react';
+import { Box, Text, render, useApp, useInput } from 'ink';
+
+const COMMAND = 'start-ai-cli';
+
+const HARD_REQUIREMENTS_BY_PLATFORM = {
+  win32: [{ command: 'wt.exe', label: 'Windows Terminal (wt.exe)' }],
+  darwin: [{ command: 'osascript', label: 'AppleScript runner (osascript)' }]
+};
+
+const CLI_COMMANDS = [
+  { id: 'codex', command: 'codex', label: 'Codex CLI (codex)', title: 'Codex' },
+  { id: 'claude', command: 'claude', label: 'Claude Code CLI (claude)', title: 'Claude' },
+  { id: 'cursor', command: 'agent', label: 'Cursor CLI (agent)', title: 'Cursor' }
+];
+
+const DEFAULT_WINDOWS_SHELL_COMMAND = 'pwsh.exe';
+const DEFAULT_ENABLED_CLI_IDS = CLI_COMMANDS.map(({ id }) => id);
+const EMPTY_SELECTION_MESSAGE = 'Select at least one available CLI.';
+
+const HELP_TEXT = `Usage:
+  ${COMMAND}
+  ${COMMAND} --all
+  ${COMMAND} --help
+  ${COMMAND} --version
+
+Interactively choose which CLI tools to open in the current directory:
+  - Codex: runs "codex"
+  - Claude: runs "claude"
+  - Cursor: runs "agent"
+
+Options:
+  --all, --no-interactive  Open every available CLI without prompting
+  --help, -h              Show this help
+  --version, -v           Show the package version
+
+Requirements:
+  - Windows with Windows Terminal (wt.exe) and PowerShell, or macOS with Terminal.app
+  - Codex CLI available as "codex"
+  - Claude Code CLI available as "claude"
+  - Cursor CLI available as "agent"
+`;
+
+export function parseArgs(args) {
+  if (args.includes('--help') || args.includes('-h')) {
+    return { action: 'help' };
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    return { action: 'version' };
+  }
+
+  const nonInteractive = args.includes('--all') || args.includes('--no-interactive');
+  const known = new Set(['--all', '--no-interactive']);
+  const unknown = args.filter((arg) => arg.startsWith('-') && !known.has(arg));
+  if (unknown.length > 0) {
+    return { action: 'error', message: `Unknown option: ${unknown.join(', ')}` };
+  }
+
+  return { action: 'open', interactive: !nonInteractive };
+}
+
+export function getPackageVersion() {
+  const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+  return packageJson.version;
+}
+
+export function getConfigPath({ homeDirectory = homedir() } = {}) {
+  return resolve(homeDirectory, '.start-ai-cli', 'config.json');
+}
+
+export function normalizeEnabledCliIds(enabledCliIds, cliCommands = CLI_COMMANDS) {
+  const validIds = new Set(cliCommands.map(({ id }) => id));
+  if (!Array.isArray(enabledCliIds)) {
+    return cliCommands.map(({ id }) => id);
+  }
+
+  const normalized = [];
+  for (const id of enabledCliIds) {
+    if (typeof id === 'string' && validIds.has(id) && !normalized.includes(id)) {
+      normalized.push(id);
+    }
+  }
+
+  return normalized;
+}
+
+export function readConfig({
+  configPath = getConfigPath(),
+  readFileFn = readFileSync
+} = {}) {
+  try {
+    const config = JSON.parse(readFileFn(configPath, 'utf8'));
+    return {
+      enabledClis: normalizeEnabledCliIds(config.enabledClis)
+    };
+  } catch {
+    return {
+      enabledClis: [...DEFAULT_ENABLED_CLI_IDS]
+    };
+  }
+}
+
+export function writeConfig({
+  configPath = getConfigPath(),
+  enabledClis,
+  mkdirFn = mkdirSync,
+  writeFileFn = writeFileSync
+} = {}) {
+  const config = {
+    enabledClis: normalizeEnabledCliIds(enabledClis)
+  };
+  mkdirFn(dirname(configPath), { recursive: true });
+  writeFileFn(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+  return config;
+}
+
+export function inspectCliCommands({
+  env = process.env,
+  platform = process.platform,
+  commandExistsFn = commandExists,
+  cliCommands = CLI_COMMANDS
+} = {}) {
+  return cliCommands.map((cli) => ({
+    ...cli,
+    available: commandExistsFn(cli.command, { env, platform })
+  }));
+}
+
+export function getAvailableTabsFromInspection(inspectedClis) {
+  return inspectedClis.filter(({ available }) => available);
+}
+
+export function getMissingLabelsFromInspection(inspectedClis) {
+  return inspectedClis
+    .filter(({ available }) => !available)
+    .map(({ label }) => label);
+}
+
+export function filterTabsByEnabledCliIds(tabs, enabledCliIds) {
+  const enabled = new Set(normalizeEnabledCliIds(enabledCliIds));
+  return tabs.filter(({ id }) => enabled.has(id));
+}
 
-const COMMAND = 'start-ai-cli';
-
-const REQUIRED_COMMANDS = [
-  { command: 'wt.exe', label: 'Windows Terminal (wt.exe)' },
-  { command: 'codex', label: 'Codex CLI (codex)' },
-  { command: 'claude', label: 'Claude Code CLI (claude)' },
-  { command: 'agent', label: 'Cursor CLI (agent)' }
-];
-
-const HELP_TEXT = `Usage:
-  ${COMMAND}
-  ${COMMAND} --help
-  ${COMMAND} --version
-
-Opens Windows Terminal with three tabs in the current directory:
-  - Codex: runs "codex"
-  - Claude: runs "claude"
-  - Cursor: runs "agent"
-
-Requirements:
-  - Windows
-  - Windows Terminal (wt.exe)
-  - Codex CLI available as "codex"
-  - Claude Code CLI available as "claude"
-  - Cursor CLI available as "agent"
-`;
-
-export function parseArgs(args) {
-  if (args.includes('--help') || args.includes('-h')) {
-    return { action: 'help' };
-  }
+export function isInteractiveTerminal({
+  input = process.stdin,
+  output = process.stdout
+} = {}) {
+  return Boolean(input.isTTY && output.isTTY);
+}
 
-  if (args.includes('--version') || args.includes('-v')) {
-    return { action: 'version' };
+export class CliSelectionCancelledError extends Error {
+  constructor() {
+    super('CLI selection cancelled.');
+    this.name = 'CliSelectionCancelledError';
   }
+}
 
-  const unknown = args.filter((arg) => arg.startsWith('-'));
-  if (unknown.length > 0) {
-    return { action: 'error', message: `Unknown option: ${unknown.join(', ')}` };
-  }
+function getFirstAvailableCliIndex(inspectedClis) {
+  const index = inspectedClis.findIndex(({ available }) => available);
+  return index === -1 ? 0 : index;
+}
 
-  return { action: 'open' };
+function getAvailableCliIds(inspectedClis) {
+  return new Set(inspectedClis.filter(({ available }) => available).map(({ id }) => id));
 }
 
-export function getPackageVersion() {
-  const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-  return packageJson.version;
+function orderSelectedIds(selectedIds, inspectedClis) {
+  const selected = new Set(selectedIds);
+  return inspectedClis.filter(({ id }) => selected.has(id)).map(({ id }) => id);
 }
 
-export function buildWtArgs({ cwd, codexCommand = 'codex', claudeCommand = 'claude', cursorCommand = 'agent' }) {
-  return [
-    'new-tab',
-    '--title',
-    'Codex',
-    '-d',
-    cwd,
-    'powershell.exe',
-    '-NoExit',
-    '-Command',
-    codexCommand,
-    ';',
-    'new-tab',
-    '--title',
-    'Claude',
-    '-d',
-    cwd,
-    'powershell.exe',
-    '-NoExit',
-    '-Command',
-    claudeCommand,
-    ';',
-    'new-tab',
-    '--title',
-    'Cursor',
-    '-d',
-    cwd,
-    'powershell.exe',
-    '-NoExit',
-    '-Command',
-    cursorCommand
-  ];
+export function createCliSelectionState({
+  inspectedClis,
+  defaultEnabledCliIds
+}) {
+  const availableIds = getAvailableCliIds(inspectedClis);
+  return {
+    cursorIndex: getFirstAvailableCliIndex(inspectedClis),
+    selectedIds: normalizeEnabledCliIds(defaultEnabledCliIds, inspectedClis)
+      .filter((id) => availableIds.has(id)),
+    errorMessage: null
+  };
 }
 
-export function commandExists(command, { env = process.env } = {}) {
-  const result = spawnSync('where.exe', [command], {
-    env,
-    stdio: 'ignore',
-    windowsHide: true
-  });
+export function moveCliSelectionCursor({
+  state,
+  inspectedClis,
+  direction
+}) {
+  if (inspectedClis.every(({ available }) => !available)) {
+    return state;
+  }
 
-  return result.status === 0;
+  let cursorIndex = state.cursorIndex;
+  for (let i = 0; i < inspectedClis.length; i++) {
+    cursorIndex = (cursorIndex + direction + inspectedClis.length) % inspectedClis.length;
+    if (inspectedClis[cursorIndex].available) {
+      return {
+        ...state,
+        cursorIndex,
+        errorMessage: null
+      };
+    }
+  }
+
+  return state;
 }
 
-export function getMissingRequirements({ platform = process.platform, env = process.env } = {}) {
-  if (platform !== 'win32') {
-    return ['Windows is required.'];
+export function toggleCliSelectionAtCursor({
+  state,
+  inspectedClis
+}) {
+  const cli = inspectedClis[state.cursorIndex];
+  if (!cli?.available) {
+    return state;
+  }
+
+  const selected = new Set(state.selectedIds);
+  if (selected.has(cli.id)) {
+    selected.delete(cli.id);
+  } else {
+    selected.add(cli.id);
   }
 
-  return REQUIRED_COMMANDS
-    .filter(({ command }) => !commandExists(command, { env }))
-    .map(({ label }) => `${label} was not found in PATH.`);
+  return {
+    ...state,
+    selectedIds: orderSelectedIds(selected, inspectedClis),
+    errorMessage: null
+  };
 }
 
-export function launchTerminals({ cwd = process.cwd(), env = process.env } = {}) {
-  const child = spawn('wt.exe', buildWtArgs({ cwd }), {
-    cwd,
-    env,
-    detached: true,
-    stdio: 'ignore',
-    windowsHide: false
-  });
+export function confirmCliSelection({
+  state,
+  inspectedClis
+}) {
+  const availableIds = getAvailableCliIds(inspectedClis);
+  const selectedIds = orderSelectedIds(
+    state.selectedIds.filter((id) => availableIds.has(id)),
+    inspectedClis
+  );
+
+  if (selectedIds.length === 0) {
+    return {
+      confirmed: false,
+      state: {
+        ...state,
+        selectedIds,
+        errorMessage: EMPTY_SELECTION_MESSAGE
+      }
+    };
+  }
 
-  child.unref();
+  return {
+    confirmed: true,
+    selectedIds
+  };
 }
 
-export function main(args = process.argv.slice(2), options = {}) {
-  const parsed = parseArgs(args);
+export function CliSelectionPrompt({
+  inspectedClis,
+  defaultEnabledCliIds,
+  onSubmit,
+  onCancel
+}) {
+  const { exit } = useApp();
+  const [state, setState] = useState(() => createCliSelectionState({
+    inspectedClis,
+    defaultEnabledCliIds
+  }));
 
-  if (parsed.action === 'help') {
-    console.log(HELP_TEXT.trimEnd());
-    return 0;
-  }
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setState((current) => moveCliSelectionCursor({
+        state: current,
+        inspectedClis,
+        direction: -1
+      }));
+      return;
+    }
 
-  if (parsed.action === 'version') {
-    console.log(getPackageVersion());
-    return 0;
-  }
+    if (key.downArrow) {
+      setState((current) => moveCliSelectionCursor({
+        state: current,
+        inspectedClis,
+        direction: 1
+      }));
+      return;
+    }
 
-  if (parsed.action === 'error') {
-    console.error(parsed.message);
-    console.error(`Run "${COMMAND} --help" for usage.`);
-    return 1;
-  }
+    if (input === ' ') {
+      setState((current) => toggleCliSelectionAtCursor({
+        state: current,
+        inspectedClis
+      }));
+      return;
+    }
+
+    if (key.return) {
+      const result = confirmCliSelection({
+        state,
+        inspectedClis
+      });
 
-  const missing = getMissingRequirements(options);
-  if (missing.length > 0) {
-    console.error(`${COMMAND} cannot start:`);
-    for (const message of missing) {
-      console.error(`- ${message}`);
+      if (result.confirmed) {
+        onSubmit(result.selectedIds);
+        exit();
+        return;
+      }
+
+      setState(result.state);
+      return;
     }
-    return 1;
-  }
 
-  launchTerminals(options);
-  console.log('Opened Codex CLI, Claude Code, and Cursor CLI in Windows Terminal.');
-  return 0;
+    if (input === 'q' || key.escape) {
+      onCancel();
+      exit();
+    }
+  });
+
+  const selected = new Set(state.selectedIds);
+  return React.createElement(
+    Box,
+    { flexDirection: 'column' },
+    React.createElement(Text, { bold: true }, 'Select CLI tools to launch'),
+    ...inspectedClis.map((cli, index) => {
+      const focused = index === state.cursorIndex;
+      const marker = focused ? '>' : ' ';
+      const checked = selected.has(cli.id) ? '[x]' : '[ ]';
+      const availability = cli.available ? 'available' : 'not found in PATH';
+      const color = cli.available && focused ? 'cyan' : undefined;
+
+      return React.createElement(
+        Text,
+        {
+          key: cli.id,
+          color,
+          dimColor: !cli.available
+        },
+        `${marker} ${checked} ${cli.label} - ${availability}`
+      );
+    }),
+    state.errorMessage
+      ? React.createElement(Text, { color: 'red' }, state.errorMessage)
+      : null,
+    React.createElement(
+      Text,
+      { dimColor: true },
+      'Use Up/Down to move, Space to toggle, Enter to open, q/Esc to cancel.'
+    )
+  );
 }
 
-export function isEntrypoint(argvPath = process.argv[1], moduleUrl = import.meta.url) {
-  if (!argvPath) {
-    return false;
-  }
+export async function promptForEnabledCliIds({
+  input = process.stdin,
+  output = process.stdout,
+  inspectedClis,
+  defaultEnabledCliIds,
+  renderFn = render
+}) {
+  return new Promise((resolve, reject) => {
+    let app;
+    let settled = false;
+    const settle = (callback, value) => {
+      if (settled) {
+        return;
+      }
 
-  const argvRealPath = realpathSync(resolve(argvPath));
-  const moduleRealPath = realpathSync(fileURLToPath(moduleUrl));
+      settled = true;
+      callback(value);
+      app?.unmount();
+    };
 
-  return argvRealPath === moduleRealPath;
+    app = renderFn(
+      React.createElement(CliSelectionPrompt, {
+        inspectedClis,
+        defaultEnabledCliIds,
+        onSubmit: (selectedIds) => settle(resolve, selectedIds),
+        onCancel: () => settle(reject, new CliSelectionCancelledError())
+      }),
+      {
+        stdin: input,
+        stdout: output,
+        stderr: output,
+        exitOnCtrlC: false
+      }
+    );
+  });
 }
+
+export function buildWtArgs({ cwd, tabs, shellCommand = DEFAULT_WINDOWS_SHELL_COMMAND }) {
+  const result = [];
+  for (let i = 0; i < tabs.length; i++) {
+    if (i > 0) result.push(';');
+    result.push(
+      'new-tab',
+      '--title',
+      tabs[i].title,
+      '-d',
+      cwd,
+      shellCommand,
+      '-NoExit',
+      '-ExecutionPolicy',
+      'Bypass',
+      '-Command',
+      tabs[i].command
+    );
+  }
+  return result;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function appleScriptQuote(value) {
+  return JSON.stringify(String(value));
+}
+
+export function buildMacTerminalScript({ cwd, tabs }) {
+  const commands = tabs.map(({ command }) => `cd ${shellQuote(cwd)} && ${command}`);
+  const lines = [
+    'tell application "Terminal"',
+    '  activate'
+  ];
+
+  for (const command of commands) {
+    lines.push(`  do script ${appleScriptQuote(command)}`);
+  }
+
+  lines.push('end tell');
+  return lines.join('\n');
+}
+
+export function buildMacTerminalArgs({ cwd, tabs }) {
+  return ['-e', buildMacTerminalScript({ cwd, tabs })];
+}
+
+export function commandExists(command, { env = process.env, platform = process.platform } = {}) {
+  const executable = platform === 'win32' ? 'where.exe' : 'sh';
+  const args = platform === 'win32'
+    ? [command]
+    : ['-lc', `command -v ${shellQuote(command)}`];
+
+  const result = spawnSync(executable, args, {
+    env,
+    stdio: 'ignore',
+    windowsHide: true
+  });
+
+  return result.status === 0;
+}
+
+function getSystemWindowsPowerShellPath(env = process.env) {
+  const systemRoot = env.SystemRoot ?? env.SYSTEMROOT ?? env.windir ?? env.WINDIR;
+  if (!systemRoot) {
+    return null;
+  }
+
+  return pathWin32.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+}
+
+export function getWindowsShellCommand({
+  env = process.env,
+  platform = process.platform,
+  commandExistsFn = commandExists,
+  fileExistsFn = existsSync
+} = {}) {
+  if (platform !== 'win32') {
+    return null;
+  }
+
+  if (commandExistsFn('pwsh.exe', { env, platform })) {
+    return 'pwsh.exe';
+  }
+
+  if (commandExistsFn('powershell.exe', { env, platform })) {
+    return 'powershell.exe';
+  }
+
+  const systemPowerShellPath = getSystemWindowsPowerShellPath(env);
+  if (systemPowerShellPath && fileExistsFn(systemPowerShellPath)) {
+    return systemPowerShellPath;
+  }
+
+  return null;
+}
+
+export function getMissingRequirements({
+  platform = process.platform,
+  env = process.env,
+  commandExistsFn = commandExists
+} = {}) {
+  const requirements = HARD_REQUIREMENTS_BY_PLATFORM[platform];
+  if (!requirements) {
+    return ['Windows or macOS is required.'];
+  }
+
+  const missing = requirements
+    .filter(({ command }) => !commandExistsFn(command, { env, platform }))
+    .map(({ label }) => `${label} was not found in PATH.`);
+
+  if (platform === 'win32' && !getWindowsShellCommand({ env, platform, commandExistsFn })) {
+    missing.push('PowerShell (pwsh.exe or powershell.exe) was not found.');
+  }
+
+  return missing;
+}
+
+export function getAvailableCliTabs({
+  env = process.env,
+  platform = process.platform,
+  commandExistsFn = commandExists
+} = {}) {
+  return CLI_COMMANDS.filter(({ command }) => commandExistsFn(command, { env, platform }));
+}
+
+export function getMissingCliLabels({
+  env = process.env,
+  platform = process.platform,
+  commandExistsFn = commandExists
+} = {}) {
+  return CLI_COMMANDS
+    .filter(({ command }) => !commandExistsFn(command, { env, platform }))
+    .map(({ label }) => label);
+}
+
+export function launchTerminals({ cwd = process.cwd(), env = process.env, platform = process.platform, tabs = CLI_COMMANDS } = {}) {
+  const executable = platform === 'win32' ? 'wt.exe' : 'osascript';
+  const shellCommand = platform === 'win32' ? getWindowsShellCommand({ env, platform }) : undefined;
+  if (platform === 'win32' && !shellCommand) {
+    throw new Error('PowerShell (pwsh.exe or powershell.exe) was not found.');
+  }
+
+  const args = platform === 'win32'
+    ? buildWtArgs({ cwd, tabs, shellCommand })
+    : buildMacTerminalArgs({ cwd, tabs });
+
+  const child = spawn(executable, args, {
+    cwd,
+    env,
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: false
+  });
+
+  child.unref();
+}
+
+export async function main(args = process.argv.slice(2), options = {}) {
+  const parsed = parseArgs(args);
+
+  if (parsed.action === 'help') {
+    console.log(HELP_TEXT.trimEnd());
+    return 0;
+  }
+
+  if (parsed.action === 'version') {
+    console.log(getPackageVersion());
+    return 0;
+  }
+
+  if (parsed.action === 'error') {
+    console.error(parsed.message);
+    console.error(`Run "${COMMAND} --help" for usage.`);
+    return 1;
+  }
+
+  const missing = getMissingRequirements(options);
+  if (missing.length > 0) {
+    console.error(`${COMMAND} cannot start:`);
+    for (const message of missing) {
+      console.error(`- ${message}`);
+    }
+    return 1;
+  }
+
+  const inspectedClis = inspectCliCommands(options);
+  const missingClis = getMissingLabelsFromInspection(inspectedClis);
+  for (const label of missingClis) {
+    console.warn(`Warning: ${label} was not found in PATH, skipping.`);
+  }
+
+  const availableTabs = getAvailableTabsFromInspection(inspectedClis);
+  if (availableTabs.length === 0) {
+    console.error(`${COMMAND} cannot start: no CLI tools found in PATH.`);
+    return 1;
+  }
+
+  let tabsToLaunch = availableTabs;
+  if (parsed.interactive) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    if (!isInteractiveTerminal({ input, output })) {
+      console.error(`${COMMAND} cannot prompt in a non-interactive terminal.`);
+      console.error(`Run "${COMMAND} --all" to open every available CLI without prompting.`);
+      return 1;
+    }
+
+    const config = readConfig(options);
+    let enabledClis;
+    try {
+      enabledClis = await promptForEnabledCliIds({
+        input,
+        output,
+        inspectedClis,
+        defaultEnabledCliIds: config.enabledClis,
+        renderFn: options.renderFn
+      });
+    } catch (error) {
+      if (error instanceof CliSelectionCancelledError) {
+        console.error(`${COMMAND} cancelled.`);
+        return 1;
+      }
 
-if (isEntrypoint()) {
-  process.exitCode = main();
-}
+      throw error;
+    }
+
+    try {
+      writeConfig({ ...options, enabledClis });
+    } catch (error) {
+      console.warn(`Warning: could not save CLI selection: ${error.message}`);
+    }
+
+    tabsToLaunch = filterTabsByEnabledCliIds(availableTabs, enabledClis);
+    if (tabsToLaunch.length === 0) {
+      console.error(`${COMMAND} cannot start: no selected CLI tools are available.`);
+      return 1;
+    }
+  }
+
+  const launchTerminalsFn = options.launchTerminalsFn ?? launchTerminals;
+  launchTerminalsFn({ ...options, tabs: tabsToLaunch });
+  const launched = tabsToLaunch.map(({ title }) => title).join(', ');
+  const terminalName = (options.platform ?? process.platform) === 'win32' ? 'Windows Terminal' : 'Terminal.app';
+  console.log(`Opened ${launched} in ${terminalName}.`);
+  return 0;
+}
+
+export function isEntrypoint(argvPath = process.argv[1], moduleUrl = import.meta.url) {
+  if (!argvPath) {
+    return false;
+  }
+
+  const argvRealPath = realpathSync(resolve(argvPath));
+  const moduleRealPath = realpathSync(fileURLToPath(moduleUrl));
+
+  return argvRealPath === moduleRealPath;
+}
+
+if (isEntrypoint()) {
+  main()
+    .then((exitCode) => {
+      process.exitCode = exitCode;
+    })
+    .catch((error) => {
+      console.error(error.message);
+      process.exitCode = 1;
+    });
+}

package/package.json

@@ -1,45 +1,78 @@
-{
-  "name": "start-ai-cli",
-  "version": "0.1.0",
-  "description": "Open Codex CLI, Claude Code, and Cursor CLI in Windows Terminal tabs from the current directory.",
-  "type": "module",
-  "bin": {
-    "start-ai-cli": "bin/start-ai-cli.js"
-  },
-  "scripts": {
-    "test": "node --test",
-    "pack:dry-run": "npm pack --dry-run",
-    "publish:dry-run": "npm publish --dry-run"
-  },
-  "files": [
-    "bin/",
-    "README.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "codex",
-    "claude",
-    "cursor",
-    "cli",
-    "terminal",
-    "windows-terminal"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/guoxiao0521/open-ai-cli.git"
-  },
-  "bugs": {
-    "url": "https://github.com/guoxiao0521/open-ai-cli/issues"
-  },
-  "homepage": "https://github.com/guoxiao0521/open-ai-cli#readme",
-  "os": [
-    "win32"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
-  }
-}
+{
+  "name": "start-ai-cli",
+  "version": "0.2.0",
+  "description": "Launch selected Codex CLI, Claude Code, and Cursor CLI tools from one project directory in Windows Terminal or macOS Terminal.",
+  "type": "module",
+  "main": "bin/start-ai-cli.js",
+  "exports": "./bin/start-ai-cli.js",
+  "bin": {
+    "start-ai-cli": "bin/start-ai-cli.js"
+  },
+  "scripts": {
+    "test": "node --test",
+    "pack:dry-run": "npm pack --dry-run",
+    "publish:dry-run": "npm publish --dry-run"
+  },
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "start-ai-cli",
+    "open-ai-cli",
+    "ai-cli",
+    "ai-agent",
+    "ai-coding",
+    "ai-coding-agent",
+    "coding-agent",
+    "codex",
+    "codex-cli",
+    "openai-codex",
+    "claude",
+    "claude-code",
+    "claude-code-cli",
+    "cursor",
+    "cursor-cli",
+    "cursor-agent",
+    "cli",
+    "cli-launcher",
+    "developer-tools",
+    "terminal",
+    "terminal-tabs",
+    "windows-terminal",
+    "macos",
+    "macos-terminal",
+    "productivity"
+  ],
+  "author": {
+    "name": "guoxiao0521",
+    "url": "https://github.com/guoxiao0521"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/guoxiao0521/open-ai-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/guoxiao0521/open-ai-cli/issues"
+  },
+  "homepage": "https://github.com/guoxiao0521/open-ai-cli#readme",
+  "os": [
+    "win32",
+    "darwin"
+  ],
+  "dependencies": {
+    "ink": "^7.0.6",
+    "react": "^19.2.7"
+  },
+  "devDependencies": {
+    "ink-testing-library": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}