xclaude-launcher 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 placeholder
+
+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

@@ -0,0 +1,108 @@
+# Claude Launcher
+
+[English](./README.md) | [中文](./README.zh-CN.md)
+
+`xclaude` solves the problem of switching Claude Code between multiple environment sources.
+
+If you work with more than one Claude setup, such as:
+
+- the default official Claude service
+- a proxy or gateway endpoint
+- different API base URLs for work and personal use
+- different model defaults for different tasks
+- different auth tokens across environments
+
+then repeatedly exporting environment variables by hand is tedious and error-prone.
+
+`xclaude` lets you save each setup as a reusable profile, then launch `claude` with the right environment in one step.
+
+## Install
+
+```bash
+npm install -g xclaude-launcher
+```
+
+## Prerequisites
+
+`xclaude` launches the local `claude` command, so Claude Code must already be installed and available in your `PATH`.
+
+## QuickStart
+
+```bash
+# 1. Add your first profile
+xclaude config add
+```
+
+When creating a profile, you will be prompted for:
+
+- `Profile name`: the label shown in the launcher
+- `ANTHROPIC_AUTH_TOKEN`: your Claude auth token
+- `ANTHROPIC_BASE_URL`: optional custom API base URL
+- `ANTHROPIC_MODEL`: optional default model
+- `ANTHROPIC_DEFAULT_HAIKU_MODEL`: optional Haiku override
+- `ANTHROPIC_DEFAULT_SONNET_MODEL`: optional Sonnet override
+- `ANTHROPIC_DEFAULT_OPUS_MODEL`: optional Opus override
+- `CLAUDE_CODE_SUBAGENT_MODEL`: optional subagent model override
+- Additional custom ENV vars if needed
+
+You can leave optional fields empty and only set the values you actually use.
+
+```bash
+# 2. Launch with the interactive picker
+xclaude
+
+# 3. Or launch a specific profile directly
+xclaude --profile my-profile
+```
+
+If you have not created any profiles yet, start with `xclaude config add`.
+
+## Usage
+
+```bash
+xclaude
+xclaude --profile my-profile
+xclaude --list
+xclaude config
+xclaude config path
+```
+
+## What it does
+
+- `xclaude` opens an interactive profile picker and launches `claude` with the selected profile environment.
+- `xclaude config` opens the interactive profile manager.
+
+## Config file
+
+Profiles are stored in:
+
+```text
+~/.claude-launcher/config.json
+```
+
+## Built-in environment variables
+
+`xclaude config` prompts for these first-class variables:
+
+- `ANTHROPIC_AUTH_TOKEN`
+- `ANTHROPIC_BASE_URL`
+- `ANTHROPIC_MODEL`
+- `ANTHROPIC_DEFAULT_HAIKU_MODEL`
+- `ANTHROPIC_DEFAULT_SONNET_MODEL`
+- `ANTHROPIC_DEFAULT_OPUS_MODEL`
+- `CLAUDE_CODE_SUBAGENT_MODEL`
+
+You can also add any number of custom environment variables to each profile.
+
+## Development
+
+```bash
+npm install
+npm run build
+npm run start -- --help
+```
+
+## Links
+
+- Repository: https://github.com/placeholder/xclaude
+- Issues: https://github.com/placeholder/xclaude/issues

package/README.zh-CN.md

@@ -0,0 +1,117 @@
+# Claude Launcher
+
+[English](./README.md) | [中文](./README.zh-CN.md)
+
+`xclaude` 用来解决 Claude Code 在多个环境源之间切换麻烦的问题。
+
+如果你平时会在多个 Claude 配置之间来回切换，比如：
+
+- 官方默认 Claude 服务
+- 公司或团队内部代理 / 网关
+- 不同的 `ANTHROPIC_BASE_URL`
+- 不同环境下使用不同的 token
+- 不同场景下使用不同的默认模型
+
+那么每次手动切换环境变量会很繁琐，也很容易出错。
+
+`xclaude` 可以把这些配置保存成可复用的 profile，然后在启动 `claude` 时一键带上对应环境变量。
+
+## 安装
+
+```bash
+npm install -g xclaude-launcher
+```
+
+## 前置要求
+
+`xclaude` 本身不会替代 Claude Code，它只是负责按指定 profile 启动本地的 `claude` 命令。
+
+所以在使用前，需要先确保：
+
+- 已经安装 Claude Code
+- `claude` 命令已经在你的 `PATH` 中可用
+
+## QuickStart
+
+```bash
+# 1. 新增第一个 profile
+xclaude config add
+```
+
+创建 profile 时，会依次提示你填写这些信息：
+
+- `Profile name`：这个 profile 在启动器里的显示名称
+- `ANTHROPIC_AUTH_TOKEN`：你的 Claude 鉴权 token
+- `ANTHROPIC_BASE_URL`：可选，自定义 API 地址
+- `ANTHROPIC_MODEL`：可选，默认模型
+- `ANTHROPIC_DEFAULT_HAIKU_MODEL`：可选，Haiku 默认模型覆盖
+- `ANTHROPIC_DEFAULT_SONNET_MODEL`：可选，Sonnet 默认模型覆盖
+- `ANTHROPIC_DEFAULT_OPUS_MODEL`：可选，Opus 默认模型覆盖
+- `CLAUDE_CODE_SUBAGENT_MODEL`：可选，subagent 默认模型覆盖
+- 其他自定义 ENV 变量：按需添加
+
+如果某些字段你暂时不需要，可以直接留空。
+
+```bash
+# 2. 使用交互方式选择 profile 并启动
+xclaude
+
+# 3. 或者直接指定 profile 启动
+xclaude --profile my-profile
+```
+
+如果你还没有创建任何 profile，建议先执行：
+
+```bash
+xclaude config add
+```
+
+## 用法
+
+```bash
+xclaude
+xclaude --profile my-profile
+xclaude --list
+xclaude config
+xclaude config path
+```
+
+## 这个工具会做什么
+
+- `xclaude` 会打开一个交互式 profile 选择器，并使用所选 profile 的环境变量启动 `claude`
+- `xclaude config` 会打开交互式 profile 管理界面
+
+## 配置文件位置
+
+profile 保存在：
+
+```text
+~/.claude-launcher/config.json
+```
+
+## 内置支持的环境变量
+
+执行 `xclaude config` 时，会优先提示这些一等字段：
+
+- `ANTHROPIC_AUTH_TOKEN`
+- `ANTHROPIC_BASE_URL`
+- `ANTHROPIC_MODEL`
+- `ANTHROPIC_DEFAULT_HAIKU_MODEL`
+- `ANTHROPIC_DEFAULT_SONNET_MODEL`
+- `ANTHROPIC_DEFAULT_OPUS_MODEL`
+- `CLAUDE_CODE_SUBAGENT_MODEL`
+
+除此之外，你也可以为每个 profile 添加任意数量的自定义环境变量。
+
+## 开发
+
+```bash
+npm install
+npm run build
+npm run start -- --help
+```
+
+## 链接
+
+- Repository: https://github.com/placeholder/xclaude
+- Issues: https://github.com/placeholder/xclaude/issues

package/dist/adapters/file-config-repo.js

@@ -0,0 +1,31 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { CliError } from '../utils/errors.js';
+import { getConfigDir, getConfigPath } from '../utils/paths.js';
+const DEFAULT_CONFIG = {
+    version: 1,
+    profiles: [],
+};
+export class FileConfigRepository {
+    async load() {
+        const filePath = getConfigPath();
+        try {
+            const content = await readFile(filePath, 'utf8');
+            const parsed = JSON.parse(content);
+            return {
+                version: parsed.version ?? 1,
+                profiles: parsed.profiles ?? [],
+                lastUsedProfileId: parsed.lastUsedProfileId,
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return structuredClone(DEFAULT_CONFIG);
+            }
+            throw new CliError(`Failed to read config: ${filePath}`);
+        }
+    }
+    async save(config) {
+        await mkdir(getConfigDir(), { recursive: true });
+        await writeFile(getConfigPath(), `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    }
+}

package/dist/adapters/process-runner.js

@@ -0,0 +1,15 @@
+import { spawn } from 'node:child_process';
+export class ProcessRunner {
+    run(command, args, env) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                env,
+                stdio: 'inherit',
+            });
+            child.on('error', reject);
+            child.on('exit', (code) => {
+                resolve(code ?? 0);
+            });
+        });
+    }
+}

package/dist/commands/config.js

@@ -0,0 +1,107 @@
+import { ConfigService } from '../services/config-service.js';
+import { PromptService } from '../services/prompt-service.js';
+import { getConfigPath } from '../utils/paths.js';
+import { CliError } from '../utils/errors.js';
+export async function runConfigCommand(action) {
+    const configService = new ConfigService();
+    const promptService = new PromptService();
+    while (true) {
+        const nextAction = normalizeAction(action) ?? (await promptService.chooseConfigAction());
+        action = undefined;
+        if (nextAction === 'path') {
+            console.log(getConfigPath());
+            continue;
+        }
+        if (nextAction === 'exit') {
+            return 0;
+        }
+        if (nextAction === 'list') {
+            while (true) {
+                const config = await configService.getConfig();
+                promptService.printProfiles(config.profiles, config.lastUsedProfileId);
+                if (config.profiles.length === 0) {
+                    break;
+                }
+                const profile = await promptService.chooseProfileOrBackOrExit(config.profiles, config.lastUsedProfileId);
+                if (profile === 'exit') {
+                    return 0;
+                }
+                if (profile === 'back') {
+                    break;
+                }
+                const profileAction = await promptService.chooseProfileAction();
+                if (profileAction === 'exit') {
+                    return 0;
+                }
+                if (profileAction === 'back') {
+                    continue;
+                }
+                if (profileAction === 'edit') {
+                    const input = await promptService.promptProfileInput(profile);
+                    if (input === 'exit') {
+                        return 0;
+                    }
+                    if (input === 'back') {
+                        continue;
+                    }
+                    const updated = await configService.updateProfile(profile.id, input);
+                    console.log(`Updated profile: ${updated.name}`);
+                    continue;
+                }
+                if (await promptService.confirmRemoveProfile(profile)) {
+                    const removed = await configService.removeProfile(profile.id);
+                    console.log(`Removed profile: ${removed.name}`);
+                }
+            }
+            continue;
+        }
+        if (nextAction === 'add') {
+            while (true) {
+                const input = await promptService.promptProfileInput();
+                if (input === 'exit') {
+                    return 0;
+                }
+                if (input === 'back') {
+                    break;
+                }
+                const profile = await configService.addProfile(input);
+                console.log(`Added profile: ${profile.name}`);
+                return 0;
+            }
+            continue;
+        }
+        if (nextAction === 'edit') {
+            while (true) {
+                const config = await configService.getConfig();
+                const profile = await promptService.chooseProfileOrBackOrExit(config.profiles, config.lastUsedProfileId);
+                if (profile === 'exit') {
+                    return 0;
+                }
+                if (profile === 'back') {
+                    break;
+                }
+                const input = await promptService.promptProfileInput(profile);
+                if (input === 'exit') {
+                    return 0;
+                }
+                if (input === 'back') {
+                    continue;
+                }
+                const updated = await configService.updateProfile(profile.id, input);
+                console.log(`Updated profile: ${updated.name}`);
+                continue;
+            }
+            continue;
+        }
+        throw new CliError(`Unsupported config action: ${action}`);
+    }
+}
+function normalizeAction(action) {
+    if (!action) {
+        return undefined;
+    }
+    if (action === 'list' || action === 'add' || action === 'edit' || action === 'path') {
+        return action;
+    }
+    throw new CliError(`Unsupported config action: ${action}`);
+}

package/dist/commands/run-claude.js

@@ -0,0 +1,19 @@
+import { ConfigService } from '../services/config-service.js';
+import { PromptService } from '../services/prompt-service.js';
+export async function runClaudeCommand(options) {
+    const configService = new ConfigService();
+    const promptService = new PromptService();
+    const config = await configService.getConfig();
+    const sortedProfiles = configService.sortProfilesByLastUsed(config.profiles, config.lastUsedProfileId);
+    if (options.list) {
+        promptService.printProfiles(sortedProfiles, config.lastUsedProfileId);
+        return 0;
+    }
+    const profile = options.profile
+        ? await configService.getProfileByIdOrName(options.profile)
+        : await promptService.chooseProfileForLaunch(sortedProfiles, config.lastUsedProfileId);
+    await configService.markLastUsed(profile.id);
+    const { ClaudeLauncherService } = await import('../services/claude-launcher.js');
+    const launcher = new ClaudeLauncherService();
+    return launcher.launch(profile, options.claudeArgs);
+}

package/dist/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { runClaudeCommand } from './commands/run-claude.js';
+import { runConfigCommand } from './commands/config.js';
+import { CliError } from './utils/errors.js';
+async function main() {
+    const args = process.argv.slice(2);
+    const [command, ...rest] = args;
+    if (command === '--help' || command === '-h') {
+        printHelp();
+        return;
+    }
+    if (command === 'config') {
+        const code = await runConfigCommand(rest[0]);
+        process.exitCode = code;
+        return;
+    }
+    const code = await runClaudeCommand(parseRunClaudeOptions(args));
+    process.exitCode = code;
+}
+function parseRunClaudeOptions(args) {
+    const options = {
+        claudeArgs: [],
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (current === '--profile') {
+            const value = args[index + 1];
+            if (!value) {
+                throw new CliError('--profile requires a value');
+            }
+            options.profile = value;
+            index += 1;
+            continue;
+        }
+        if (current === '--list') {
+            options.list = true;
+            continue;
+        }
+        options.claudeArgs.push(current);
+    }
+    return options;
+}
+function printHelp() {
+    console.log(`xclaude - Claude launcher\n\nUsage:\n  xclaude [--profile <name-or-id>] [--list] [claude args...]\n  xclaude config [list|add|edit]\n`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.error(message);
+    process.exitCode = 1;
+});

package/dist/models/config.js

@@ -0,0 +1 @@
+export {};

package/dist/services/claude-launcher.js

@@ -0,0 +1,21 @@
+import { ProcessRunner } from '../adapters/process-runner.js';
+import { mergeEnv } from '../utils/env.js';
+import { CliError } from '../utils/errors.js';
+export class ClaudeLauncherService {
+    processRunner;
+    constructor(processRunner = new ProcessRunner()) {
+        this.processRunner = processRunner;
+    }
+    async launch(profile, extraArgs = []) {
+        try {
+            return await this.processRunner.run(profile.command, [...profile.args, ...extraArgs], mergeEnv(profile.env));
+        }
+        catch (error) {
+            const errno = error;
+            if (errno.code === 'ENOENT') {
+                throw new CliError('Could not find the claude command. Make sure it is installed and available in PATH');
+            }
+            throw error;
+        }
+    }
+}

package/dist/services/config-service.js

@@ -0,0 +1,99 @@
+import { FileConfigRepository } from '../adapters/file-config-repo.js';
+import { buildProfileEnv } from '../utils/env.js';
+import { CliError } from '../utils/errors.js';
+export class ConfigService {
+    repository;
+    constructor(repository = new FileConfigRepository()) {
+        this.repository = repository;
+    }
+    async getConfig() {
+        return this.repository.load();
+    }
+    async listProfiles() {
+        const config = await this.repository.load();
+        return config.profiles;
+    }
+    sortProfilesByLastUsed(profiles, lastUsedProfileId) {
+        if (!lastUsedProfileId) {
+            return [...profiles];
+        }
+        const sortedProfiles = [...profiles];
+        const index = sortedProfiles.findIndex((profile) => profile.id === lastUsedProfileId);
+        if (index <= 0) {
+            return sortedProfiles;
+        }
+        const [lastUsedProfile] = sortedProfiles.splice(index, 1);
+        sortedProfiles.unshift(lastUsedProfile);
+        return sortedProfiles;
+    }
+    async getProfileByIdOrName(idOrName) {
+        const config = await this.repository.load();
+        const profile = config.profiles.find((item) => item.id === idOrName || item.name === idOrName);
+        if (!profile) {
+            throw new CliError(`Profile not found: ${idOrName}`);
+        }
+        return profile;
+    }
+    async addProfile(input) {
+        const config = await this.repository.load();
+        const id = this.createProfileId(input.name);
+        if (config.profiles.some((profile) => profile.id === id || profile.name === input.name)) {
+            throw new CliError(`Profile already exists: ${input.name}`);
+        }
+        const profile = {
+            id,
+            name: input.name,
+            command: 'claude',
+            args: [],
+            env: buildProfileEnv(input),
+        };
+        config.profiles.push(profile);
+        await this.repository.save(config);
+        return profile;
+    }
+    async updateProfile(profileId, input) {
+        const config = await this.repository.load();
+        const profile = config.profiles.find((item) => item.id === profileId);
+        if (!profile) {
+            throw new CliError(`Profile not found: ${profileId}`);
+        }
+        const nextId = this.createProfileId(input.name);
+        const duplicate = config.profiles.find((item) => item.id !== profileId && (item.id === nextId || item.name === input.name));
+        if (duplicate) {
+            throw new CliError(`Profile name conflict: ${input.name}`);
+        }
+        profile.id = nextId;
+        profile.name = input.name;
+        profile.env = buildProfileEnv(input);
+        if (config.lastUsedProfileId === profileId) {
+            config.lastUsedProfileId = nextId;
+        }
+        await this.repository.save(config);
+        return profile;
+    }
+    async markLastUsed(profileId) {
+        const config = await this.repository.load();
+        config.lastUsedProfileId = profileId;
+        await this.repository.save(config);
+    }
+    async removeProfile(profileId) {
+        const config = await this.repository.load();
+        const index = config.profiles.findIndex((item) => item.id === profileId);
+        if (index === -1) {
+            throw new CliError(`Profile not found: ${profileId}`);
+        }
+        const [removedProfile] = config.profiles.splice(index, 1);
+        if (config.lastUsedProfileId === profileId) {
+            config.lastUsedProfileId = config.profiles[0]?.id;
+        }
+        await this.repository.save(config);
+        return removedProfile;
+    }
+    createProfileId(name) {
+        return name
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/(^-|-$)/g, '');
+    }
+}

package/dist/services/prompt-service.js

@@ -0,0 +1,238 @@
+import { confirm, input, select } from '@inquirer/prompts';
+import { maskEnvValue, validateEnvKey } from '../utils/env.js';
+import { CliError } from '../utils/errors.js';
+export class PromptService {
+    async chooseProfile(profiles, lastUsedProfileId) {
+        if (profiles.length === 0) {
+            throw new CliError('No profiles available yet. Run xclaude config add first');
+        }
+        const answer = await select({
+            message: 'Choose a profile',
+            choices: profiles.map((profile) => ({
+                name: this.formatProfileLabel(profile, lastUsedProfileId),
+                value: profile.id,
+                description: this.describeProfile(profile),
+            })),
+        });
+        const profile = profiles.find((item) => item.id === answer);
+        if (!profile) {
+            throw new CliError('Selected profile does not exist');
+        }
+        return profile;
+    }
+    async chooseProfileForLaunch(profiles, lastUsedProfileId) {
+        if (profiles.length === 0) {
+            throw new CliError('No profiles available yet. Run xclaude config add first');
+        }
+        const answer = await select({
+            message: 'Launch profile',
+            choices: [
+                ...profiles.map((profile) => ({
+                    name: this.formatProfileLabel(profile, lastUsedProfileId),
+                    value: profile.id,
+                })),
+                {
+                    name: 'Exit',
+                    value: '__exit__',
+                    description: 'Exit without launching Claude',
+                },
+            ],
+        });
+        if (answer === '__exit__') {
+            throw new CliError('Launch cancelled');
+        }
+        const profile = profiles.find((item) => item.id === answer);
+        if (!profile) {
+            throw new CliError('Selected profile does not exist');
+        }
+        return profile;
+    }
+    async chooseConfigAction() {
+        return select({
+            message: 'Choose a config action',
+            choices: [
+                { name: 'List profiles', value: 'list' },
+                { name: 'Add profile', value: 'add' },
+                { name: 'Edit profile', value: 'edit' },
+                { name: 'Show config path', value: 'path' },
+                { name: 'Exit', value: 'exit' },
+            ],
+        });
+    }
+    async confirmLaunchProfile(profile, extraArgs = []) {
+        console.log(`About to launch with profile: ${profile.name} (${profile.id})`);
+        for (const [key, value] of Object.entries(profile.env)) {
+            console.log(`  ${key}=${maskEnvValue(key, value)}`);
+        }
+        console.log(`  Claude args=${extraArgs.length > 0 ? extraArgs.join(' ') : '(none)'}`);
+        return confirm({
+            message: 'Launch Claude?',
+            default: true,
+        });
+    }
+    async chooseProfileOrBackOrExit(profiles, lastUsedProfileId) {
+        if (profiles.length === 0) {
+            return 'back';
+        }
+        const answer = await select({
+            message: 'Choose a profile',
+            choices: [
+                ...profiles.map((profile) => ({
+                    name: this.formatProfileLabel(profile, lastUsedProfileId),
+                    value: profile.id,
+                    description: this.describeProfile(profile),
+                })),
+                {
+                    name: 'Back',
+                    value: '__back__',
+                    description: 'Return to the previous menu',
+                },
+                {
+                    name: 'Exit',
+                    value: '__exit__',
+                    description: 'Exit config',
+                },
+            ],
+        });
+        if (answer === '__back__') {
+            return 'back';
+        }
+        if (answer === '__exit__') {
+            return 'exit';
+        }
+        return profiles.find((item) => item.id === answer) ?? 'back';
+    }
+    async chooseProfileAction() {
+        return select({
+            message: 'Choose an action',
+            choices: [
+                { name: 'Edit', value: 'edit' },
+                { name: 'Remove', value: 'remove' },
+                { name: 'Back', value: 'back' },
+                { name: 'Exit', value: 'exit' },
+            ],
+        });
+    }
+    async confirmRemoveProfile(profile) {
+        return confirm({
+            message: `Remove profile ${profile.name}?`,
+            default: false,
+        });
+    }
+    async promptProfileInput(existing) {
+        const name = await input({
+            message: 'Profile name',
+            default: existing?.name,
+            validate: (value) => (value.trim() ? true : 'Profile name is required'),
+        });
+        const anthropicAuthToken = await input({
+            message: 'ANTHROPIC_AUTH_TOKEN',
+            default: existing?.env.ANTHROPIC_AUTH_TOKEN,
+        });
+        const anthropicBaseUrl = await input({
+            message: 'ANTHROPIC_BASE_URL',
+            default: existing?.env.ANTHROPIC_BASE_URL,
+        });
+        const anthropicModel = await input({
+            message: 'ANTHROPIC_MODEL',
+            default: existing?.env.ANTHROPIC_MODEL,
+        });
+        const anthropicDefaultHaikuModel = await input({
+            message: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+            default: existing?.env.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+        });
+        const anthropicDefaultSonnetModel = await input({
+            message: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+            default: existing?.env.ANTHROPIC_DEFAULT_SONNET_MODEL,
+        });
+        const anthropicDefaultOpusModel = await input({
+            message: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+            default: existing?.env.ANTHROPIC_DEFAULT_OPUS_MODEL,
+        });
+        const claudeCodeSubagentModel = await input({
+            message: 'CLAUDE_CODE_SUBAGENT_MODEL',
+            default: existing?.env.CLAUDE_CODE_SUBAGENT_MODEL,
+        });
+        const extraEnv = await this.promptExtraEnv(existing?.env ?? {});
+        return {
+            name: name.trim(),
+            anthropicAuthToken: anthropicAuthToken.trim() || undefined,
+            anthropicBaseUrl: anthropicBaseUrl.trim() || undefined,
+            anthropicModel: anthropicModel.trim() || undefined,
+            anthropicDefaultHaikuModel: anthropicDefaultHaikuModel.trim() || undefined,
+            anthropicDefaultSonnetModel: anthropicDefaultSonnetModel.trim() || undefined,
+            anthropicDefaultOpusModel: anthropicDefaultOpusModel.trim() || undefined,
+            claudeCodeSubagentModel: claudeCodeSubagentModel.trim() || undefined,
+            extraEnv,
+        };
+    }
+    printProfiles(profiles, lastUsedProfileId) {
+        if (profiles.length === 0) {
+            console.log('No profiles');
+            return;
+        }
+        for (const profile of profiles) {
+            const markers = [];
+            if (profile.id === lastUsedProfileId) {
+                markers.push('recent');
+            }
+            const marker = markers.length > 0 ? ` [${markers.join(' / ')}]` : '';
+            console.log(`- ${profile.name} (${profile.id})${marker}`);
+            for (const [key, value] of Object.entries(profile.env)) {
+                console.log(`  ${key}=${maskEnvValue(key, value)}`);
+            }
+        }
+    }
+    async promptExtraEnv(existingEnv) {
+        const extraEnv = {};
+        const presetEntries = Object.entries(existingEnv).filter(([key]) => key !== 'ANTHROPIC_AUTH_TOKEN' &&
+            key !== 'ANTHROPIC_BASE_URL' &&
+            key !== 'ANTHROPIC_MODEL' &&
+            key !== 'ANTHROPIC_DEFAULT_HAIKU_MODEL' &&
+            key !== 'ANTHROPIC_DEFAULT_SONNET_MODEL' &&
+            key !== 'ANTHROPIC_DEFAULT_OPUS_MODEL' &&
+            key !== 'CLAUDE_CODE_SUBAGENT_MODEL');
+        for (const [key, value] of presetEntries) {
+            const keep = await confirm({
+                message: `Keep ${key}=${maskEnvValue(key, value)}?`,
+                default: true,
+            });
+            if (keep) {
+                extraEnv[key] = value;
+            }
+        }
+        while (await confirm({
+            message: 'Add a custom ENV?',
+            default: false,
+        })) {
+            const key = (await input({
+                message: 'ENV name',
+                validate: (value) => {
+                    try {
+                        validateEnvKey(value.trim());
+                        return true;
+                    }
+                    catch (error) {
+                        return error.message;
+                    }
+                },
+            })).trim();
+            const value = await input({
+                message: `ENV value (${key})`,
+            });
+            extraEnv[key] = value;
+        }
+        return extraEnv;
+    }
+    formatProfileLabel(profile, lastUsedProfileId) {
+        const markers = [];
+        if (profile.id === lastUsedProfileId) {
+            markers.push('recent');
+        }
+        return markers.length > 0 ? `${profile.name} (${markers.join(', ')})` : profile.name;
+    }
+    describeProfile(profile) {
+        const pairs = Object.entries(profile.env).map(([key, value]) => `${key}=${maskEnvValue(key, value)}`);
+        return pairs.length > 0 ? pairs.join('\n') : 'No ENV';
+    }
+}

package/dist/utils/env.js

@@ -0,0 +1,45 @@
+import { CliError } from './errors.js';
+const ENV_KEY_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+export function validateEnvKey(key) {
+    if (!ENV_KEY_PATTERN.test(key)) {
+        throw new CliError(`Invalid ENV name: ${key}`);
+    }
+}
+export function mergeEnv(profileEnv) {
+    return {
+        ...process.env,
+        ...profileEnv,
+    };
+}
+export function maskEnvValue(_key, value) {
+    return value;
+}
+export function buildProfileEnv(input) {
+    const env = {};
+    if (input.anthropicAuthToken) {
+        env.ANTHROPIC_AUTH_TOKEN = input.anthropicAuthToken;
+    }
+    if (input.anthropicBaseUrl) {
+        env.ANTHROPIC_BASE_URL = input.anthropicBaseUrl;
+    }
+    if (input.anthropicModel) {
+        env.ANTHROPIC_MODEL = input.anthropicModel;
+    }
+    if (input.anthropicDefaultHaikuModel) {
+        env.ANTHROPIC_DEFAULT_HAIKU_MODEL = input.anthropicDefaultHaikuModel;
+    }
+    if (input.anthropicDefaultSonnetModel) {
+        env.ANTHROPIC_DEFAULT_SONNET_MODEL = input.anthropicDefaultSonnetModel;
+    }
+    if (input.anthropicDefaultOpusModel) {
+        env.ANTHROPIC_DEFAULT_OPUS_MODEL = input.anthropicDefaultOpusModel;
+    }
+    if (input.claudeCodeSubagentModel) {
+        env.CLAUDE_CODE_SUBAGENT_MODEL = input.claudeCodeSubagentModel;
+    }
+    for (const [key, value] of Object.entries(input.extraEnv)) {
+        validateEnvKey(key);
+        env[key] = value;
+    }
+    return env;
+}

package/dist/utils/errors.js

@@ -0,0 +1,6 @@
+export class CliError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CliError';
+    }
+}

package/dist/utils/paths.js

@@ -0,0 +1,8 @@
+import os from 'node:os';
+import path from 'node:path';
+export function getConfigDir() {
+    return path.join(os.homedir(), '.claude-launcher');
+}
+export function getConfigPath() {
+    return path.join(getConfigDir(), 'config.json');
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "xclaude-launcher",
+  "version": "0.1.0",
+  "description": "Launch Claude Code with reusable environment profiles.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Jango26/claude-launcher.git"
+  },
+  "homepage": "https://github.com/Jango26/claude-launcher",
+  "bugs": {
+    "url": "https://github.com/Jango26/claude-launcher/issues"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "cli",
+    "launcher",
+    "profiles"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "bin": {
+    "xclaude": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/index.js",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.5.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.1",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  }
+}