@jcanizalez7/clauxy 0.1.9 → 0.2.1

package/README.md

@@ -29,14 +29,19 @@ No API keys needed. Just authenticate once with OAuth and you're ready to go.
 npm install -g @jcanizalez7/clauxy
 ```
 
+Also requires [Claude Code](https://docs.anthropic.com/en/docs/claude-code):
+```bash
+npm install -g @anthropic-ai/claude-code
+```
+
 ---
 
 ## Quick Start
 
-### 1. Start the proxy
+Just run:
 
 ```bash
-clauxy run
+clauxy
 ```
 
 First time? Select your provider and authenticate:
@@ -51,35 +56,45 @@ First time? Select your provider and authenticate:
 └
 ```
 
-### 2. Run Claude Code
-
-In a new terminal:
-
-```bash
-export ANTHROPIC_BASE_URL="http://localhost:3000"
-export ANTHROPIC_API_KEY="clauxy"
-claude
-```
-
-That's it! Claude Code now uses your selected provider.
-
-> **Tip:** Add the exports to your `~/.zshrc` or `~/.bashrc` to make them permanent.
+That's it! Clauxy starts the proxy and launches Claude Code automatically with the correct environment variables.
 
 ---
 
 ## Commands
 
 ```bash
-clauxy run                  # Start the proxy
-clauxy run -p copilot       # Start with a specific provider
-clauxy run -c               # Switch provider or re-authenticate
-clauxy run -p copilot -c    # Re-authenticate with a specific provider
-clauxy run --port 3001      # Use a different port
+# Default: Start proxy + launch Claude Code
+clauxy                      # Just works!
+clauxy "fix the bug"        # Pass arguments to Claude
+clauxy -p copilot           # Use specific provider
+clauxy -c                   # Re-authenticate before starting
+clauxy --port 3000          # Use specific port (reuses existing proxy if running)
+
+# Proxy-only mode (for advanced users)
+clauxy run                  # Start proxy without launching Claude
+clauxy run --port 3001      # Proxy on specific port
+clauxy run -p chatgpt       # Proxy with specific provider
+
+# Configuration
 clauxy model                # Configure model mappings
 clauxy auth list            # Show configured providers
 ```
 
-**Provider flag:** Use `-p` or `--provider` to start directly with a specific provider (`copilot`, `chatgpt`, or `google`). If credentials exist, it starts immediately. Otherwise, it authenticates with that provider.
+### Port Reuse
+
+When you specify `--port`, Clauxy checks if a proxy is already running on that port:
+- If yes, it reuses the existing proxy (no new instance started)
+- If no, it starts a new proxy on that port
+
+This lets you run multiple Claude Code sessions sharing a single proxy:
+
+```bash
+# Terminal 1
+clauxy --port 3000          # Starts proxy + Claude
+
+# Terminal 2
+clauxy --port 3000          # Reuses proxy, launches another Claude
+```
 
 ---
 
@@ -96,7 +111,7 @@ Claude Code requests are automatically mapped to your provider's models:
 Customize with `clauxy model` or environment variables:
 
 ```bash
-CLAUXY_MODEL_BIG=gpt-4o CLAUXY_MODEL_MID=gpt-4o clauxy run
+CLAUXY_MODEL_BIG=gpt-4o CLAUXY_MODEL_MID=gpt-4o clauxy
 ```
 
 ---
@@ -123,14 +138,13 @@ Credentials are stored locally in `~/.clauxy/` with restricted permissions.
 
 **"Token refresh failed"** or **"Not authenticated"**
 ```bash
-clauxy run -c
+clauxy -c
 ```
 
 **Port already in use**
 ```bash
-clauxy run --port 3001
+clauxy --port 3001
 ```
-Then update `ANTHROPIC_BASE_URL`.
 
 **Reset everything**
 ```bash

package/dist/cli.js

@@ -2041,84 +2041,18 @@ var init_converter_gemini = __esm(() => {
 
 // proxy.ts
 var exports_proxy = {};
-async function isPortAvailable(port) {
-  try {
-    const server = Bun.serve({ port, fetch: () => new Response("") });
-    server.stop();
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findAvailablePort() {
-  if (process.env.PORT) {
-    const port = parseInt(process.env.PORT, 10);
-    if (await isPortAvailable(port)) {
-      return port;
-    }
-    log.error(`Port ${port} is in use. Try a different port with --port <port>`);
-    process.exit(1);
-  }
-  for (const port of PORT_RANGE) {
-    if (await isPortAvailable(port)) {
-      return port;
-    }
-  }
-  log.error(`All ports (${PORT_RANGE.join(", ")}) are in use.`);
-  log.error(`Try: clauxy run --port <port>`);
-  process.exit(1);
-}
-async function loadProvider() {
-  const providerId = process.env.CLAUXY_PROVIDER || await Config.getActiveProvider();
-  if (!providerId) {
-    log.error("No provider configured. Run 'clauxy run' to set up.");
-    process.exit(1);
-  }
-  return await getProvider(providerId);
-}
-function convertAnthropicToOpenAI(anthropicReq) {
-  if (currentLogLevel === "debug") {
-    for (let i = 0;i < anthropicReq.messages.length; i++) {
-      const msg = anthropicReq.messages[i];
-      if (Array.isArray(msg.content)) {
-        const toolUses = msg.content.filter((b) => b.type === "tool_use").map((b) => b.id);
-        const toolResults = msg.content.filter((b) => b.type === "tool_result").map((b) => b.tool_use_id);
-        if (toolUses.length > 0)
-          log.debug(`msg[${i}] ${msg.role}: tool_use ids: ${toolUses.join(", ")}`);
-        if (toolResults.length > 0)
-          log.debug(`msg[${i}] ${msg.role}: tool_result ids: ${toolResults.join(", ")}`);
-      }
-    }
-  }
-  const messages = convertMessages(anthropicReq.messages, anthropicReq.system);
-  const tools = convertTools(anthropicReq.tools);
-  const mappedModel = provider.mapModel(anthropicReq.model);
-  log.info(`Model: ${anthropicReq.model} -> ${mappedModel}`);
+__export(exports_proxy, {
+  startProxy: () => startProxy
+});
+function createLogger(level) {
   return {
-    model: mappedModel,
-    messages,
-    max_tokens: anthropicReq.max_tokens,
-    temperature: anthropicReq.temperature,
-    stream: anthropicReq.stream ?? false,
-    ...tools && { tools }
-  };
-}
-var LOG_LEVELS, currentLogLevel, log, DEFAULT_PORT, PORT_RANGE, provider, convertOpenAIToAnthropic, token, models, PORT, server, c, wireApi, wireApiLabel;
-var init_proxy = __esm(async () => {
-  init_providers();
-  init_config();
-  init_converter();
-  init_converter_gemini();
-  LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
-  currentLogLevel = process.env.CLAUXY_LOG_LEVEL || "info";
-  log = {
-    _shouldLog(level) {
-      return LOG_LEVELS[level] >= LOG_LEVELS[currentLogLevel];
+    _shouldLog(checkLevel) {
+      return LOG_LEVELS[checkLevel] >= LOG_LEVELS[level];
     },
-    _format(level, msg) {
+    _format(levelStr, msg) {
       const now = new Date;
       const ts = now.toISOString().replace("T", " ").substring(0, 19);
-      return `${ts} ${level.padEnd(5)} ${msg}`;
+      return `${ts} ${levelStr.padEnd(5)} ${msg}`;
     },
     info(msg) {
       if (this._shouldLog("info")) {
@@ -2146,12 +2080,73 @@ var init_proxy = __esm(async () => {
       }
     }
   };
-  DEFAULT_PORT = parseInt(process.env.PORT || "3000", 10);
-  PORT_RANGE = [3000, 3001, 3002, 3003, 3004, 3005];
-  provider = await loadProvider();
-  convertOpenAIToAnthropic = convertResponse;
+}
+async function isPortAvailable(port) {
+  try {
+    const server = Bun.serve({ port, fetch: () => new Response("") });
+    server.stop();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findAvailablePort(requestedPort) {
+  if (requestedPort) {
+    if (await isPortAvailable(requestedPort)) {
+      return requestedPort;
+    }
+  }
+  for (const port2 of PORT_RANGE) {
+    if (await isPortAvailable(port2)) {
+      return port2;
+    }
+  }
+  const server = Bun.serve({ port: 0, fetch: () => new Response("") });
+  const port = server.port;
+  server.stop();
+  return port;
+}
+async function loadProvider(providerId) {
+  const id = providerId || process.env.CLAUXY_PROVIDER || await Config.getActiveProvider();
+  if (!id) {
+    throw new Error("No provider configured. Run 'clauxy' to set up.");
+  }
+  return await getProvider(id);
+}
+async function startProxy(options = {}) {
+  const { port: requestedPort, logLevel = "info", providerId, quiet = false } = options;
+  const log = createLogger(logLevel);
+  const provider = await loadProvider(providerId);
+  function convertAnthropicToOpenAI(anthropicReq) {
+    if (logLevel === "debug") {
+      for (let i = 0;i < anthropicReq.messages.length; i++) {
+        const msg = anthropicReq.messages[i];
+        if (Array.isArray(msg.content)) {
+          const toolUses = msg.content.filter((b) => b.type === "tool_use").map((b) => b.id);
+          const toolResults = msg.content.filter((b) => b.type === "tool_result").map((b) => b.tool_use_id);
+          if (toolUses.length > 0)
+            log.debug(`msg[${i}] ${msg.role}: tool_use ids: ${toolUses.join(", ")}`);
+          if (toolResults.length > 0)
+            log.debug(`msg[${i}] ${msg.role}: tool_result ids: ${toolResults.join(", ")}`);
+        }
+      }
+    }
+    const messages = convertMessages(anthropicReq.messages, anthropicReq.system);
+    const tools = convertTools(anthropicReq.tools);
+    const mappedModel = provider.mapModel(anthropicReq.model);
+    log.info(`Model: ${anthropicReq.model} -> ${mappedModel}`);
+    return {
+      model: mappedModel,
+      messages,
+      max_tokens: anthropicReq.max_tokens,
+      temperature: anthropicReq.temperature,
+      stream: anthropicReq.stream ?? false,
+      ...tools && { tools }
+    };
+  }
+  const convertOpenAIToAnthropic = convertResponse;
   log.info(`Authenticating with ${provider.info.name}...`);
-  token = await provider.getToken();
+  const token = await provider.getToken();
   log.info("\x1B[32m+\x1B[0m Authentication successful");
   if (provider.loadCodeAssist) {
     log.info("Initializing Cloud Code session...");
@@ -2162,15 +2157,17 @@ var init_proxy = __esm(async () => {
       log.warn("\x1B[33m!\x1B[0m Could not get Cloud Code project ID - requests may fail");
     }
   }
-  models = { big: "default", mid: "default", small: "default" };
+  let models = { big: "default", mid: "default", small: "default" };
   if (provider.loadModels) {
     models = await provider.loadModels();
   }
-  PORT = await findAvailablePort();
-  if (PORT !== DEFAULT_PORT && !process.env.PORT) {
+  const PORT = await findAvailablePort(requestedPort);
+  if (requestedPort && PORT !== requestedPort) {
+    log.warn(`Port ${requestedPort} in use, using port ${PORT} instead`);
+  } else if (!requestedPort && PORT !== DEFAULT_PORT) {
     log.warn(`Port 3000 in use, using port ${PORT} instead`);
   }
-  server = Bun.serve({
+  const server = Bun.serve({
     port: PORT,
     async fetch(req) {
       const url = new URL(req.url);
@@ -2365,6 +2362,47 @@ var init_proxy = __esm(async () => {
       }
     }
   });
+  if (!quiet) {
+    const wireApi = provider.info.wireApi || "chat";
+    const wireApiLabel = wireApi === "gemini" ? "Gemini API" : wireApi === "responses" ? "Responses API" : "Chat Completions";
+    log.raw(c.dim("=".repeat(60)));
+    log.raw(`${c.green(">")} ${c.bold("Clauxy")} proxy ready on ${c.cyan(`http://localhost:${PORT}`)}`);
+    log.raw(`${c.green(">")} Provider: ${c.cyan(provider.info.name)}`);
+    log.raw(`${c.green(">")} Wire API: ${c.cyan(wireApiLabel)}`);
+    log.raw(c.dim("=".repeat(60)));
+    log.raw(`
+${c.yellow("Model Mapping")} (Claude -> Provider):`);
+    log.raw(`   opus/big    -> ${c.cyan(models.big)}`);
+    log.raw(`   sonnet/mid  -> ${c.cyan(models.mid)}`);
+    log.raw(`   haiku/small -> ${c.cyan(models.small)}`);
+    log.raw(`
+${c.yellow("To change models:")}`);
+    log.raw(c.dim("   CLAUXY_MODEL_BIG=<model> CLAUXY_MODEL_MID=<model> CLAUXY_MODEL_SMALL=<model>"));
+    log.raw(c.dim("   Or run: clauxy model"));
+    log.raw(c.dim("=".repeat(60)));
+    log.raw(`
+${c.yellow("Run in a NEW terminal:")}
+`);
+    log.raw(`   ${c.green("export")} ANTHROPIC_BASE_URL=${c.cyan(`"http://localhost:${PORT}"`)}`);
+    log.raw(`   ${c.green("export")} ANTHROPIC_API_KEY=${c.cyan('"clauxy"')}`);
+    log.raw(`   ${c.bold("claude")}
+`);
+    log.raw(c.dim("=".repeat(60)));
+  }
+  return {
+    server,
+    port: PORT,
+    stop: () => server.stop()
+  };
+}
+var LOG_LEVELS, DEFAULT_PORT = 3000, PORT_RANGE, c;
+var init_proxy = __esm(async () => {
+  init_providers();
+  init_config();
+  init_converter();
+  init_converter_gemini();
+  LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+  PORT_RANGE = [3000, 3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009];
   c = {
     green: (s) => `\x1B[32m${s}\x1B[0m`,
     cyan: (s) => `\x1B[36m${s}\x1B[0m`,
@@ -2372,31 +2410,7 @@ var init_proxy = __esm(async () => {
     dim: (s) => `\x1B[2m${s}\x1B[0m`,
     bold: (s) => `\x1B[1m${s}\x1B[0m`
   };
-  wireApi = provider.info.wireApi || "chat";
-  wireApiLabel = wireApi === "gemini" ? "Gemini API" : wireApi === "responses" ? "Responses API" : "Chat Completions";
-  log.raw(c.dim("=".repeat(60)));
-  log.raw(`${c.green(">")} ${c.bold("Clauxy")} proxy ready on ${c.cyan(`http://localhost:${PORT}`)}`);
-  log.raw(`${c.green(">")} Provider: ${c.cyan(provider.info.name)}`);
-  log.raw(`${c.green(">")} Wire API: ${c.cyan(wireApiLabel)}`);
-  log.raw(c.dim("=".repeat(60)));
-  log.raw(`
-${c.yellow("Model Mapping")} (Claude -> Provider):`);
-  log.raw(`   opus/big    -> ${c.cyan(models.big)}`);
-  log.raw(`   sonnet/mid  -> ${c.cyan(models.mid)}`);
-  log.raw(`   haiku/small -> ${c.cyan(models.small)}`);
-  log.raw(`
-${c.yellow("To change models:")}`);
-  log.raw(c.dim("   CLAUXY_MODEL_BIG=<model> CLAUXY_MODEL_MID=<model> CLAUXY_MODEL_SMALL=<model>"));
-  log.raw(c.dim("   Or run: clauxy model"));
-  log.raw(c.dim("=".repeat(60)));
-  log.raw(`
-${c.yellow("Run in a NEW terminal:")}
-`);
-  log.raw(`   ${c.green("export")} ANTHROPIC_BASE_URL=${c.cyan(`"http://localhost:${PORT}"`)}`);
-  log.raw(`   ${c.green("export")} ANTHROPIC_API_KEY=${c.cyan('"clauxy"')}`);
-  log.raw(`   ${c.bold("claude")}
-`);
-  log.raw(c.dim("=".repeat(60)));
+  if (false) {}
 });
 
 // cli/index.ts
@@ -2441,23 +2455,21 @@ async function selectAndAuthenticate() {
   return authenticateProvider(providerId);
 }
 async function authenticateProvider(providerId) {
-  const provider2 = await getProvider(providerId);
-  prompts2.intro(`Clauxy - Connecting to ${provider2.info.name}`);
-  const result = await provider2.authenticate();
+  const provider = await getProvider(providerId);
+  prompts2.intro(`Clauxy - Connecting to ${provider.info.name}`);
+  const result = await provider.authenticate();
   if (result.type === "failed") {
     prompts2.cancel(`Authentication failed: ${result.error}`);
     process.exit(1);
   }
   await Config.setActiveProvider(providerId);
-  prompts2.outro(`Connected to ${provider2.info.name}`);
+  prompts2.outro(`Connected to ${provider.info.name}`);
   return providerId;
 }
 async function runCommand(options) {
-  const { port, logLevel, connect, provider: provider2 } = options;
-  process.env.PORT = port.toString();
-  process.env.CLAUXY_LOG_LEVEL = logLevel;
+  const { port, logLevel, connect, provider } = options;
   const availableProviders = getProviderList().map((item) => item.id);
-  const providerOverride = provider2?.toLowerCase();
+  const providerOverride = provider?.toLowerCase();
   if (providerOverride && !availableProviders.includes(providerOverride)) {
     console.error(`Invalid provider: "${providerOverride}". Valid values: ${availableProviders.join(" | ")}.`);
     process.exit(1);
@@ -2482,8 +2494,158 @@ async function runCommand(options) {
     }
   }
   await Config.setActiveProvider(activeProvider);
-  process.env.CLAUXY_PROVIDER = activeProvider;
-  await init_proxy().then(() => exports_proxy);
+  const { startProxy: startProxy2 } = await init_proxy().then(() => exports_proxy);
+  await startProxy2({
+    port,
+    logLevel,
+    providerId: activeProvider
+  });
+  await new Promise(() => {});
+}
+
+// cli/commands/wrapper.ts
+init_auth();
+init_config();
+init_providers();
+import * as prompts3 from "@clack/prompts";
+var c2 = {
+  green: (s) => `\x1B[32m${s}\x1B[0m`,
+  cyan: (s) => `\x1B[36m${s}\x1B[0m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[0m`,
+  dim: (s) => `\x1B[2m${s}\x1B[0m`,
+  bold: (s) => `\x1B[1m${s}\x1B[0m`,
+  red: (s) => `\x1B[31m${s}\x1B[0m`
+};
+async function findClaudeCli() {
+  try {
+    const proc = Bun.spawn(["which", "claude"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode === 0) {
+      const output = await new Response(proc.stdout).text();
+      return output.trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function selectAndAuthenticate2() {
+  prompts3.intro("Clauxy - Connect to AI Provider");
+  const providers = getProviderList();
+  const providerChoice = await prompts3.select({
+    message: "Select your AI provider",
+    options: providers.map((p) => ({
+      label: p.name,
+      value: p.id,
+      hint: p.description
+    }))
+  });
+  const providerId = handleCancel(providerChoice, "Setup cancelled");
+  return authenticateProvider2(providerId);
+}
+async function authenticateProvider2(providerId) {
+  const provider = await getProvider(providerId);
+  prompts3.intro(`Clauxy - Connecting to ${provider.info.name}`);
+  const result = await provider.authenticate();
+  if (result.type === "failed") {
+    prompts3.cancel(`Authentication failed: ${result.error}`);
+    process.exit(1);
+  }
+  await Config.setActiveProvider(providerId);
+  prompts3.outro(`Connected to ${provider.info.name}`);
+  return providerId;
+}
+async function isClauxyRunning(port) {
+  try {
+    const response = await fetch(`http://localhost:${port}/health`, {
+      signal: AbortSignal.timeout(1000)
+    });
+    return response.ok && await response.text() === "OK";
+  } catch {
+    return false;
+  }
+}
+async function wrapperCommand(options) {
+  const { logLevel = "warn", connect = false, provider, port: requestedPort, claudeArgs = [] } = options;
+  const claudePath = await findClaudeCli();
+  if (!claudePath) {
+    console.error(c2.red("Error: Claude CLI not found."));
+    console.error(`
+Install it with: ${c2.cyan("npm i -g @anthropic-ai/claude-code")}`);
+    console.error(`Or visit: ${c2.cyan("https://docs.anthropic.com/en/docs/claude-code")}`);
+    process.exit(1);
+  }
+  const availableProviders = getProviderList().map((item) => item.id);
+  const providerOverride = provider?.toLowerCase();
+  if (providerOverride && !availableProviders.includes(providerOverride)) {
+    console.error(`Invalid provider: "${providerOverride}". Valid values: ${availableProviders.join(" | ")}.`);
+    process.exit(1);
+  }
+  let activeProvider;
+  if (providerOverride) {
+    const credentials = await Auth.get(providerOverride);
+    if (credentials && !connect) {
+      activeProvider = providerOverride;
+    } else {
+      activeProvider = await authenticateProvider2(providerOverride);
+    }
+  } else {
+    activeProvider = await Config.getActiveProvider();
+    if (!activeProvider || connect) {
+      activeProvider = await selectAndAuthenticate2();
+    } else {
+      const credentials = await Auth.get(activeProvider);
+      if (!credentials) {
+        activeProvider = await selectAndAuthenticate2();
+      }
+    }
+  }
+  await Config.setActiveProvider(activeProvider);
+  let proxyPort;
+  let proxyServer = null;
+  if (requestedPort && await isClauxyRunning(requestedPort)) {
+    proxyPort = requestedPort;
+    console.log(`${c2.green(">")} ${c2.bold("Clauxy")} reusing proxy on ${c2.cyan(`localhost:${proxyPort}`)}`);
+  } else {
+    const { startProxy: startProxy2 } = await init_proxy().then(() => exports_proxy);
+    const server = await startProxy2({
+      port: requestedPort,
+      logLevel,
+      providerId: activeProvider,
+      quiet: true
+    });
+    proxyServer = server;
+    proxyPort = server.port;
+    const providerInfo = await getProvider(activeProvider);
+    console.log(`${c2.green(">")} ${c2.bold("Clauxy")} proxy on ${c2.cyan(`localhost:${proxyPort}`)} ${c2.dim(`(${providerInfo.info.name})`)}`);
+  }
+  const claude = Bun.spawn(["claude", ...claudeArgs], {
+    env: {
+      ...process.env,
+      ANTHROPIC_BASE_URL: `http://localhost:${proxyPort}`,
+      ANTHROPIC_API_KEY: "clauxy"
+    },
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  let isCleaningUp = false;
+  const cleanup = () => {
+    if (isCleaningUp)
+      return;
+    isCleaningUp = true;
+    proxyServer?.stop();
+    claude.kill();
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  process.on("SIGHUP", cleanup);
+  const exitCode = await claude.exited;
+  proxyServer?.stop();
+  process.exit(exitCode);
 }
 
 // cli/commands/auth.ts
@@ -2503,14 +2665,14 @@ Configured Providers:
 `);
     return;
   }
-  for (const provider2 of providers) {
-    const auth = allAuth[provider2.id];
+  for (const provider of providers) {
+    const auth = allAuth[provider.id];
     if (auth) {
-      const isActive = provider2.id === activeProvider;
+      const isActive = provider.id === activeProvider;
       const marker = isActive ? colors.green("*") : " ";
       const authType = auth.type === "oauth" ? "OAuth" : "API Key";
       const activeLabel = isActive ? ` ${colors.green("[active]")}` : "";
-      console.log(`  ${marker} ${provider2.name} (${authType})${activeLabel}`);
+      console.log(`  ${marker} ${provider.name} (${authType})${activeLabel}`);
     }
   }
   console.log("");
@@ -2520,7 +2682,7 @@ Configured Providers:
 init_config();
 init_providers();
 init_models();
-import * as prompts3 from "@clack/prompts";
+import * as prompts4 from "@clack/prompts";
 
 // cli/constants.ts
 var CUSTOM_MODEL_VALUE = "__custom__";
@@ -2544,21 +2706,21 @@ async function selectModel(tier, providerId, currentValue) {
     })),
     { label: "Enter custom model", value: CUSTOM_MODEL_VALUE, hint: "Type model name" }
   ];
-  const choice = await prompts3.select({
+  const choice = await prompts4.select({
     message: `Select ${tier} model`,
     options,
     initialValue: currentValue
   });
-  if (prompts3.isCancel(choice)) {
+  if (prompts4.isCancel(choice)) {
     return null;
   }
   if (choice === CUSTOM_MODEL_VALUE) {
-    const custom = await prompts3.text({
+    const custom = await prompts4.text({
       message: `Enter custom ${tier} model name`,
       placeholder: currentValue,
       defaultValue: currentValue
     });
-    if (prompts3.isCancel(custom)) {
+    if (prompts4.isCancel(custom)) {
       return null;
     }
     return custom;
@@ -2567,9 +2729,9 @@ async function selectModel(tier, providerId, currentValue) {
 }
 async function configureModels() {
   const activeProvider = await Config.getActiveProvider();
-  prompts3.intro("Clauxy - Model Configuration");
+  prompts4.intro("Clauxy - Model Configuration");
   const providers = getProviderList();
-  const providerChoice = await prompts3.select({
+  const providerChoice = await prompts4.select({
     message: "Select provider to configure models for",
     options: providers.map((p) => ({
       label: p.name,
@@ -2587,7 +2749,7 @@ Current models for ${PROVIDERS[providerId].name}:`);
   console.log(`   Mid:   ${currentModels.mid}`);
   console.log(`   Small: ${currentModels.small}
 `);
-  const action = await prompts3.select({
+  const action = await prompts4.select({
     message: "What would you like to do?",
     options: [
       { label: "Configure all models", value: "all" },
@@ -2605,36 +2767,36 @@ Models reset to defaults:`);
     console.log(`   Big:   ${defaults.big}`);
     console.log(`   Mid:   ${defaults.mid}`);
     console.log(`   Small: ${defaults.small}`);
-    prompts3.outro("Done");
+    prompts4.outro("Done");
     return;
   }
-  const models2 = {
+  const models = {
     big: currentModels.big,
     mid: currentModels.mid,
     small: currentModels.small
   };
   for (const tier of MODEL_TIERS) {
     if (action === "all" || action === tier.key) {
-      const result = await selectModel(tier.label, providerId, models2[tier.key]);
+      const result = await selectModel(tier.label, providerId, models[tier.key]);
       if (result === null) {
-        prompts3.cancel("Cancelled");
+        prompts4.cancel("Cancelled");
         process.exit(0);
       }
-      models2[tier.key] = result;
+      models[tier.key] = result;
     }
   }
-  await saveModels(models2);
+  await saveModels(models);
   console.log(`
 Models configured:`);
-  console.log(`   opus/big    -> ${models2.big}`);
-  console.log(`   sonnet/mid  -> ${models2.mid}`);
-  console.log(`   haiku/small -> ${models2.small}`);
-  prompts3.outro("Model configuration saved");
+  console.log(`   opus/big    -> ${models.big}`);
+  console.log(`   sonnet/mid  -> ${models.mid}`);
+  console.log(`   haiku/small -> ${models.small}`);
+  prompts4.outro("Model configuration saved");
 }
 // package.json
 var package_default = {
   name: "@jcanizalez7/clauxy",
-  version: "0.1.9",
+  version: "0.2.1",
   description: "Multi-provider AI proxy for Claude Code (GitHub Copilot, ChatGPT Plus, Google Gemini)",
   type: "module",
   bin: {
@@ -2679,7 +2841,7 @@ var package_default = {
 var run = defineCommand({
   meta: {
     name: "run",
-    description: "Start the proxy server"
+    description: "Start the proxy server (without launching Claude)"
   },
   args: {
     port: {
@@ -2715,12 +2877,12 @@ var run = defineCommand({
     if (!LOG_LEVELS2.includes(logLevel)) {
       console.error(`Invalid log level: "${args["log-level"]}". Valid values: ${LOG_LEVELS2.join(" | ")}. Using "${DEFAULT_LOG_LEVEL}".`);
     }
-    const provider2 = args.provider ? String(args.provider).toLowerCase() : undefined;
+    const provider = args.provider ? String(args.provider).toLowerCase() : undefined;
     await runCommand({
       port,
       logLevel: LOG_LEVELS2.includes(logLevel) ? logLevel : DEFAULT_LOG_LEVEL,
       connect: args.connect,
-      provider: provider2
+      provider
     });
   }
 });
@@ -2756,13 +2918,50 @@ var main = defineCommand({
   meta: {
     name: "clauxy",
     version: package_default.version,
-    description: "Multi-Provider AI Proxy for Claude Code"
+    description: "Multi-Provider AI Proxy for Claude Code. Run without arguments to start proxy and launch Claude automatically."
+  },
+  args: {
+    "log-level": {
+      type: "string",
+      alias: "l",
+      description: "Log level: debug, info, warn, error",
+      default: "warn"
+    },
+    connect: {
+      type: "boolean",
+      alias: "c",
+      description: "Re-authenticate before starting",
+      default: false
+    },
+    provider: {
+      type: "string",
+      alias: "p",
+      description: "Provider to use (copilot, chatgpt, google)"
+    },
+    port: {
+      type: "string",
+      description: "Port to use (reuses existing proxy if running)"
+    }
   },
   subCommands: {
     run,
     auth,
     model,
     models: model
+  },
+  async run({ args, rawArgs }) {
+    const port = args.port ? parseInt(args.port, 10) : undefined;
+    if (args.port && isNaN(port)) {
+      console.error(`Invalid port number: "${args.port}". Use --port <number> (e.g., --port 3000).`);
+      process.exit(1);
+    }
+    await wrapperCommand({
+      logLevel: args["log-level"],
+      connect: args.connect,
+      provider: args.provider,
+      port,
+      claudeArgs: rawArgs
+    });
   }
 });
 function cli() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcanizalez7/clauxy",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "Multi-provider AI proxy for Claude Code (GitHub Copilot, ChatGPT Plus, Google Gemini)",
   "type": "module",
   "bin": {