@decoopus/chatgpt-setup 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 decoopus
+
+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,3 +1,94 @@
-# Temporary Holding Version
+# chatgpt-desktop-setup
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Automated one-command setup for **ChatGPT Desktop** & **Codex CLI** with custom 3P inference gateway, model selection (`gpt-6-astra`), and OpenAI emerald mascot theme.
+
+Easily configure ChatGPT Desktop and Codex CLI to route requests through custom third-party inference gateways (such as `https://api.vokes.in/v1`, LiteLLM, or custom proxies) without manual TOML editing.
+
+---
+
+## ⚡ Quick Start
+
+Users can simply open **PowerShell** (Windows) or **Terminal** (macOS/Linux) and run:
+
+```bash
+npx chatgpt-desktop-setup
+```
+
+*(or `npx codex-setup`)*
+
+It will display the OpenAI pixel mascot and prompt for your API key:
+```text
+   ▟███▙ ▟█▙   ChatGPT & Codex Setup v1.0.0
+  ▐█▛ ▜█▛ ▀█▌  ChatGPT Pro 5x · API Usage Billing
+  ▐█▄ ▟█▛ ▄█▌  https://api.vokes.in/v1
+   ▜█▛ ▜███▛
+  ──────────────────────────────────────────────────────────
+
+  ✳ Enter your API Key:
+  API Key (e.g. sk-...): sk-ant-api03-...
+```
+
+Or pass your API key directly on the command line:
+
+```bash
+npx chatgpt-desktop-setup sk-your-api-key
+```
+
+To launch the **Codex CLI** after setup instead of Desktop:
+
+```bash
+npx codex-setup sk-your-api-key --cli
+```
+
+---
+
+## 🚀 Features
+
+- **OpenAI Pixel Rosette Mascot**: Features the iconic knot rosette in emerald green (`#10a37f`).
+- **Terminal Connection Animation**: Live terminal bridge animating the connection from your API Key to the OpenAI Gateway.
+- **Auto-Configures Both Desktop & CLI**: Writes the exact provider, auth command, and desktop tuning to `~/.codex/config.toml`.
+- **Pre-Configured Models & Settings**:
+  - **Provider**: `chatgpt_pro_5x` (*ChatGPT Pro 5x*)
+  - **Model**: `gpt-6-astra`
+  - **Reasoning Effort**: `ultra`
+  - **Wire API**: `responses`
+  - **Desktop Tuning**: Pre-configures smooth font sizes, prose conversation mode, and steer follow-ups.
+- **Cross-Platform Dynamic Auth**:
+  - Windows: Auto-configures `powershell` with `-NoProfile -Command Write-Output '<KEY>'`
+  - macOS / Linux: Auto-configures standard POSIX `echo`
+- **Config Preserving**: Updates `~/.codex/config.toml` while keeping all your existing plugins, marketplaces, and MCP servers intact.
+- **Process Management**: Gracefully terminates running `ChatGPT.exe` or `codex.exe` so the new configuration applies cleanly without locking issues.
+- **Auto Launcher**: Automatically detects and restarts ChatGPT Desktop (via Windows MSIX / macOS Application bundles) or launches Codex CLI.
+- **Zero Dependencies**: Pure Node.js standard library with no external dependencies. Runs in milliseconds.
+
+---
+
+## 📖 CLI Usage
+
+```text
+Usage:
+  npx chatgpt-desktop-setup [apiKey] [options]
+  npx codex-setup [apiKey] [options]
+
+Arguments:
+  apiKey                   Your gateway API key (prompted interactively if omitted)
+
+Options:
+  -k, --key <key>          Specify API key
+  -u, --url <url>          Gateway base URL (default: https://api.vokes.in/v1)
+  -m, --model <model>      Active model ID (default: gpt-6-astra)
+  -p, --provider <id>      Model provider ID (default: chatgpt_pro_5x)
+  --provider-name <name>   Model provider display name (default: ChatGPT Pro 5x)
+  --reasoning <effort>     Model reasoning effort: low, medium, high, ultra (default: ultra)
+  --cli                    Launch Codex CLI instead of ChatGPT Desktop app after setup
+  --no-launch              Configure settings only; do not auto-launch ChatGPT or Codex
+  -s, --status             Display current ~/.codex/config.toml configuration
+  -r, --revert             Remove custom gateway configuration and restore OpenAI defaults
+  -h, --help               Show this help message
+```
+
+---
+
+## 📄 License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,631 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * ChatGPT Desktop & Codex CLI Auto-Configurator
+ * Automates configuring ChatGPT Desktop and Codex CLI with custom third-party inference gateway.
+ *
+ * Base URL: https://api.vokes.in/v1
+ * Provider: chatgpt_pro_5x ("ChatGPT Pro 5x")
+ * Model: gpt-6-astra (Reasoning: ultra)
+ *
+ * Cross-platform: Windows, macOS, Linux
+ * Zero dependencies (Pure Node.js standard library)
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const { spawn, spawnSync, execSync } = require('child_process');
+
+const pkg = require('../package.json');
+
+// Default Configurations
+const DEFAULT_GATEWAY_URL = 'https://api.vokes.in/v1';
+const DEFAULT_PROVIDER = 'chatgpt_pro_5x';
+const DEFAULT_PROVIDER_NAME = 'ChatGPT Pro 5x';
+const DEFAULT_MODEL = 'gpt-6-astra';
+const DEFAULT_REASONING = 'ultra';
+const DEFAULT_WIRE_API = 'responses';
+
+const isWin = process.platform === 'win32';
+const isMac = process.platform === 'darwin';
+
+// OpenAI / ChatGPT Aesthetic Color Palette
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[38;2;142;142;160m',
+  green: '\x1b[38;2;16;163;127m',
+  greenBold: '\x1b[1m\x1b[38;2;16;163;127m',
+  white: '\x1b[38;2;236;236;241m',
+  whiteBold: '\x1b[1m\x1b[38;2;236;236;241m',
+  gray: '\x1b[38;2;180;180;190m',
+  amber: '\x1b[38;2;245;158;11m',
+  amberBold: '\x1b[1m\x1b[38;2;245;158;11m',
+  red: '\x1b[38;2;239;68;68m',
+  cyan: '\x1b[38;2;6;182;212m'
+};
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function printBanner() {
+  const g = c.greenBold;
+  const r = c.reset;
+  const w = c.whiteBold;
+  const d = c.dim;
+  const lines = [
+    '',
+    `  ${g} ▟███▙ ▟█▙${r}   ${w}ChatGPT & Codex Setup${r} ${d}v${pkg.version}${r}`,
+    `  ${g}▐█▛ ▜█▛ ▀█▌${r}  ${w}${DEFAULT_PROVIDER_NAME}${r} ${d}· API Usage Billing${r}`,
+    `  ${g}▐█▄ ▟█▛ ▄█▌${r}  ${d}${DEFAULT_GATEWAY_URL}${r}`,
+    `  ${g} ▜█▛ ▜███▛${r}`,
+    `  ${d}${'─'.repeat(58)}${r}`,
+    ''
+  ];
+  console.log(lines.join('\n'));
+}
+
+function printHelp() {
+  printBanner();
+  console.log(`${c.whiteBold}Usage:${c.reset}
+  npx chatgpt-desktop-setup [apiKey] [options]
+  npx codex-setup [apiKey] [options]
+
+${c.whiteBold}Arguments:${c.reset}
+  apiKey                   Your gateway API key (prompted interactively if omitted)
+
+${c.whiteBold}Options:${c.reset}
+  -k, --key <key>          Specify API key
+  -u, --url <url>          Gateway base URL (default: ${DEFAULT_GATEWAY_URL})
+  -m, --model <model>      Active model ID (default: ${DEFAULT_MODEL})
+  -p, --provider <id>      Model provider ID (default: ${DEFAULT_PROVIDER})
+  --provider-name <name>   Model provider display name (default: ${DEFAULT_PROVIDER_NAME})
+  --reasoning <effort>     Model reasoning effort: low, medium, high, ultra (default: ${DEFAULT_REASONING})
+  --cli                    Launch Codex CLI instead of ChatGPT Desktop app after setup
+  --no-launch              Configure settings only; do not auto-launch ChatGPT or Codex
+  -s, --status             Display current ~/.codex/config.toml configuration
+  -r, --revert             Remove custom gateway configuration and restore OpenAI defaults
+  -h, --help               Show this help message
+
+${c.whiteBold}Examples:${c.reset}
+  npx chatgpt-desktop-setup
+  npx chatgpt-desktop-setup sk-your-api-key
+  npx codex-setup sk-your-api-key --cli
+  npx chatgpt-desktop-setup --status
+  npx chatgpt-desktop-setup --revert
+`);
+}
+
+function askQuestion(promptText) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(promptText, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// -------------------------------------------------------------
+// Terminal Connection Animation
+// -------------------------------------------------------------
+
+async function runConnectionAnimation(key, gatewayUrl, width = 28) {
+  const isTTY = Boolean(process.stdout.isTTY);
+  const masked = key && key.length > 12 ? `${key.slice(0, 7)}...${key.slice(-4)}` : 'API Key';
+  const src = `${c.whiteBold}${masked}${c.reset}`;
+  const tgt = `${c.greenBold}ChatGPT & Codex${c.reset}`;
+
+  console.log(`\n  ${c.greenBold}✳${c.reset} ${c.whiteBold}Connecting API Key to OpenAI Gateway...${c.reset}\n`);
+
+  if (isTTY) {
+    const frames = 16;
+    for (let i = 0; i <= frames; i++) {
+      const pos = Math.floor((i / frames) * width);
+      let beam = '';
+      for (let j = 0; j < width; j++) {
+        if (j === pos) {
+          beam += `${c.greenBold}●${c.reset}`;
+        } else if (j < pos) {
+          beam += `${c.green}━${c.reset}`;
+        } else {
+          beam += `${c.dim}─${c.reset}`;
+        }
+      }
+
+      process.stdout.write(`\r\x1b[K  ${src} ${beam}► ${tgt}`);
+      await sleep(40);
+    }
+
+    const fullBeam = `${c.greenBold}${'═'.repeat(width)}►${c.reset}`;
+    process.stdout.write(`\r\x1b[K  ${src} ${fullBeam} ${tgt}  ${c.greenBold}✔ CONNECTED${c.reset}\n`);
+  } else {
+    console.log(`  ${src} ════════════════════════════► ${tgt}  ${c.greenBold}✔ CONNECTED${c.reset}`);
+  }
+
+  console.log(`  ${c.dim}↳ Gateway connected to ${gatewayUrl} (${DEFAULT_PROVIDER_NAME} · ${DEFAULT_MODEL}).${c.reset}\n`);
+}
+
+// -------------------------------------------------------------
+// Process Management (Close running ChatGPT Desktop / Codex CLI)
+// -------------------------------------------------------------
+
+function killRunningProcesses() {
+  try {
+    if (isWin) {
+      execSync('taskkill /F /IM ChatGPT.exe /IM codex.exe /T 2>nul', { stdio: 'ignore' });
+    } else if (isMac) {
+      execSync('killall ChatGPT Codex 2>/dev/null', { stdio: 'ignore' });
+    } else {
+      execSync("pkill -f 'ChatGPT|codex' 2>/dev/null", { stdio: 'ignore' });
+    }
+  } catch (_) {
+    // Process may not be running, ignore
+  }
+}
+
+// -------------------------------------------------------------
+// TOML Parser & Updater (Zero external dependencies)
+// -------------------------------------------------------------
+
+function getCodexConfigPath() {
+  const customHome = process.env.CODEX_HOME;
+  if (customHome) {
+    return path.join(customHome, 'config.toml');
+  }
+  return path.join(os.homedir(), '.codex', 'config.toml');
+}
+
+function splitTomlSections(content) {
+  const lines = (content || '').split(/\r?\n/);
+  const sections = [];
+  let currentHeader = '';
+  let currentLines = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const headerMatch = line.match(/^\[([^\]]+)\]/);
+    if (headerMatch) {
+      sections.push({ header: currentHeader, lines: currentLines });
+      currentHeader = headerMatch[1].trim();
+      currentLines = [line];
+    } else {
+      currentLines.push(line);
+    }
+  }
+  sections.push({ header: currentHeader, lines: currentLines });
+  return sections;
+}
+
+function updateCodexConfig(existingToml, opts) {
+  const model = opts.model || DEFAULT_MODEL;
+  const provider = opts.provider || DEFAULT_PROVIDER;
+  const providerName = opts.providerName || DEFAULT_PROVIDER_NAME;
+  const reasoning = opts.reasoning || DEFAULT_REASONING;
+  const baseUrl = opts.baseUrl || DEFAULT_GATEWAY_URL;
+  const wireApi = opts.wireApi || DEFAULT_WIRE_API;
+  const apiKey = opts.apiKey || '';
+
+  const sections = splitTomlSections(existingToml);
+
+  // 1. Process or create Root Section
+  let root = sections.find((s) => s.header === '');
+  if (!root) {
+    root = { header: '', lines: [] };
+    sections.unshift(root);
+  }
+
+  function setRootKey(key, value) {
+    const reg = new RegExp('^\\s*' + key + '\\s*=');
+    const idx = root.lines.findIndex((l) => reg.test(l));
+    const lineVal = `${key} = ${JSON.stringify(value)}`;
+    if (idx >= 0) {
+      root.lines[idx] = lineVal;
+    } else {
+      // Find where to place: put near top
+      root.lines.unshift(lineVal);
+    }
+  }
+
+  setRootKey('model_reasoning_effort', reasoning);
+  setRootKey('model_provider', provider);
+  setRootKey('model', model);
+
+  // 2. Ensure [desktop] Section exists and has optimal settings
+  let desktop = sections.find((s) => s.header === 'desktop');
+  if (!desktop) {
+    desktop = {
+      header: 'desktop',
+      lines: [
+        '[desktop]',
+        'followUpQueueMode = "steer"',
+        'conversationDetailMode = "STEPS_PROSE"',
+        'sansFontSize = 14',
+        'codeFontSize = 13',
+        'ambient-suggestions-enabled = true'
+      ]
+    };
+    // Insert immediately after root
+    const rootIdx = sections.indexOf(root);
+    sections.splice(rootIdx + 1, 0, desktop);
+  } else {
+    // Ensure standard keys exist
+    const ensureDesktopKey = (key, rawVal) => {
+      const reg = new RegExp('^\\s*' + key + '\\s*=');
+      if (!desktop.lines.some((l) => reg.test(l))) {
+        desktop.lines.push(`${key} = ${rawVal}`);
+      }
+    };
+    ensureDesktopKey('followUpQueueMode', '"steer"');
+    ensureDesktopKey('conversationDetailMode', '"STEPS_PROSE"');
+    ensureDesktopKey('sansFontSize', '14');
+    ensureDesktopKey('codeFontSize', '13');
+    ensureDesktopKey('ambient-suggestions-enabled', 'true');
+  }
+
+  // 3. Remove existing provider sections for this provider ID
+  const filtered = sections.filter((s) => {
+    return s.header !== `model_providers.${provider}` &&
+           !s.header.startsWith(`model_providers.${provider}.`);
+  });
+
+  // 4. Construct Provider & Auth Configuration
+  const winPlatform = opts.isWin !== undefined ? opts.isWin : isWin;
+  const authCommand = winPlatform ? 'powershell' : 'echo';
+  let authArgs;
+  if (winPlatform) {
+    const escapedKey = apiKey.replace(/'/g, "''");
+    authArgs = ['-NoProfile', '-Command', `Write-Output '${escapedKey}'`];
+  } else {
+    authArgs = [apiKey];
+  }
+
+  const providerSection = {
+    header: `model_providers.${provider}`,
+    lines: [
+      `[model_providers.${provider}]`,
+      `name = ${JSON.stringify(providerName)}`,
+      `base_url = ${JSON.stringify(baseUrl)}`,
+      `wire_api = ${JSON.stringify(wireApi)}`
+    ]
+  };
+
+  const authArgsFormatted = JSON.stringify(authArgs).replace(/,/g, ', ');
+  const authSection = {
+    header: `model_providers.${provider}.auth`,
+    lines: [
+      `[model_providers.${provider}.auth]`,
+      `command = ${JSON.stringify(authCommand)}`,
+      `args = ${authArgsFormatted}`
+    ]
+  };
+
+  // Locate insertion point: right before [windows] if present, else at end
+  const winIdx = filtered.findIndex((s) => s.header === 'windows');
+  if (winIdx >= 0) {
+    filtered.splice(winIdx, 0, providerSection, authSection);
+  } else {
+    filtered.push(providerSection);
+    filtered.push(authSection);
+  }
+
+  // 5. Serialize back to TOML
+  const outputChunks = [];
+  for (const s of filtered) {
+    const cleanLines = s.lines.filter((l) => l.trim().length > 0);
+    if (cleanLines.length > 0) {
+      outputChunks.push(cleanLines.join('\n'));
+    }
+  }
+
+  return outputChunks.join('\n\n') + '\n';
+}
+
+function revertCodexConfig(existingToml, provider = DEFAULT_PROVIDER) {
+  const sections = splitTomlSections(existingToml);
+
+  // 1. Reset root keys
+  const root = sections.find((s) => s.header === '');
+  if (root) {
+    root.lines = root.lines.filter((line) => {
+      return !line.match(/^\s*model_provider\s*=/) &&
+             !line.match(/^\s*model_reasoning_effort\s*=/);
+    });
+    // Set default model
+    const mIdx = root.lines.findIndex((l) => /^\s*model\s*=/.test(l));
+    if (mIdx >= 0) {
+      root.lines[mIdx] = 'model = "gpt-5"';
+    }
+  }
+
+  // 2. Remove provider sections
+  const filtered = sections.filter((s) => {
+    return s.header !== `model_providers.${provider}` &&
+           !s.header.startsWith(`model_providers.${provider}.`);
+  });
+
+  const outputChunks = [];
+  for (const s of filtered) {
+    const cleanLines = s.lines.filter((l) => l.trim().length > 0);
+    if (cleanLines.length > 0) {
+      outputChunks.push(cleanLines.join('\n'));
+    }
+  }
+  return outputChunks.join('\n\n') + '\n';
+}
+
+// -------------------------------------------------------------
+// Launch Helpers
+// -------------------------------------------------------------
+
+function findCodexCli() {
+  // 1. Check PATH
+  const finder = isWin ? 'where.exe' : 'which';
+  try {
+    const res = spawnSync(finder, ['codex'], { encoding: 'utf8', shell: false });
+    if (res.status === 0 && res.stdout) {
+      const first = res.stdout.split(/\r?\n/)[0]?.trim();
+      if (first && fs.existsSync(first)) return first;
+    }
+  } catch (_) {}
+
+  // 2. Windows specific locations
+  if (isWin) {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    const binDir = path.join(localAppData, 'OpenAI', 'Codex', 'bin');
+    if (fs.existsSync(binDir)) {
+      try {
+        const subdirs = fs.readdirSync(binDir);
+        for (const sub of subdirs) {
+          const exePath = path.join(binDir, sub, 'codex.exe');
+          if (fs.existsSync(exePath)) return exePath;
+        }
+      } catch (_) {}
+    }
+  }
+
+  // 3. Check ~/.codex/config.toml CODEX_CLI_PATH
+  try {
+    const confPath = getCodexConfigPath();
+    if (fs.existsSync(confPath)) {
+      const content = fs.readFileSync(confPath, 'utf8');
+      const match = content.match(/CODEX_CLI_PATH\s*=\s*['"]([^'"]+)['"]/);
+      if (match && fs.existsSync(match[1])) return match[1];
+    }
+  } catch (_) {}
+
+  return null;
+}
+
+function launchChatGPTDesktop() {
+  if (isWin) {
+    try {
+      // 1. Try launching via Windows Apps AUMID
+      const psScript = `
+        $pkg = Get-AppxPackage -Name "*Codex*" -ErrorAction SilentlyContinue
+        if (-not $pkg) { $pkg = Get-AppxPackage -Name "*ChatGPT*" -ErrorAction SilentlyContinue }
+        if ($pkg) {
+          Start-Process "shell:AppsFolder\\$($pkg.PackageFamilyName)!App"
+        } else {
+          Start-Process "shell:AppsFolder\\OpenAI.Codex_2p2nqsd0c76g0!App"
+        }
+      `;
+      spawnSync('powershell', ['-NoProfile', '-Command', psScript], { stdio: 'ignore' });
+      return true;
+    } catch (_) {
+      try {
+        execSync('start explorer.exe shell:AppsFolder\\OpenAI.Codex_2p2nqsd0c76g0!App', { stdio: 'ignore' });
+        return true;
+      } catch (_) {}
+    }
+  } else if (isMac) {
+    try {
+      execSync('open -a "ChatGPT" || open -a "Codex"', { stdio: 'ignore' });
+      return true;
+    } catch (_) {}
+  } else {
+    try {
+      const child = spawn('chatgpt', [], { detached: true, stdio: 'ignore' });
+      child.unref();
+      return true;
+    } catch (_) {}
+  }
+  return false;
+}
+
+function launchCodexCli() {
+  const exe = findCodexCli();
+  if (exe) {
+    console.log(`\n  ${c.greenBold}Starting Codex CLI...${c.reset}\n`);
+    spawn(exe, [], { stdio: 'inherit' });
+    return true;
+  }
+  return false;
+}
+
+// -------------------------------------------------------------
+// Status Display
+// -------------------------------------------------------------
+
+function showStatus() {
+  printBanner();
+  const confPath = getCodexConfigPath();
+  if (!fs.existsSync(confPath)) {
+    console.log(`  ${c.amber}⚠${c.reset} No config found at: ${confPath}\n`);
+    return;
+  }
+
+  const content = fs.readFileSync(confPath, 'utf8');
+  const modelMatch = content.match(/model\s*=\s*["']([^"']+)["']/);
+  const providerMatch = content.match(/model_provider\s*=\s*["']([^"']+)["']/);
+  const reasoningMatch = content.match(/model_reasoning_effort\s*=\s*["']([^"']+)["']/);
+  const urlMatch = content.match(/base_url\s*=\s*["']([^"']+)["']/);
+
+  console.log(`  ${c.whiteBold}Current Configuration:${c.reset} ${c.dim}(${confPath})${c.reset}`);
+  console.log(`  ${c.gray}Model${c.reset}            : ${c.whiteBold}${modelMatch ? modelMatch[1] : 'default'}${c.reset}`);
+  console.log(`  ${c.gray}Provider${c.reset}         : ${c.whiteBold}${providerMatch ? providerMatch[1] : 'default'}${c.reset}`);
+  console.log(`  ${c.gray}Reasoning Effort${c.reset} : ${c.whiteBold}${reasoningMatch ? reasoningMatch[1] : 'standard'}${c.reset}`);
+  console.log(`  ${c.gray}Gateway Base URL${c.reset} : ${c.whiteBold}${urlMatch ? urlMatch[1] : 'https://api.openai.com/v1'}${c.reset}`);
+
+  const cliPath = findCodexCli();
+  console.log(`  ${c.gray}Codex CLI Binary${c.reset} : ${cliPath ? `${c.greenBold}✔ Found${c.reset} ${c.dim}(${cliPath})${c.reset}` : `${c.amber}Not found on PATH${c.reset}`}`);
+  console.log('');
+}
+
+// -------------------------------------------------------------
+// Main CLI Execution
+// -------------------------------------------------------------
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('-h') || args.includes('--help')) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (args.includes('-s') || args.includes('--status')) {
+    showStatus();
+    process.exit(0);
+  }
+
+  const confPath = getCodexConfigPath();
+
+  if (args.includes('-r') || args.includes('--revert')) {
+    printBanner();
+    if (!fs.existsSync(confPath)) {
+      console.log(`  ${c.amber}⚠${c.reset} No configuration file found to revert.\n`);
+      process.exit(0);
+    }
+    const current = fs.readFileSync(confPath, 'utf8');
+    const reverted = revertCodexConfig(current);
+    fs.writeFileSync(confPath, reverted, 'utf8');
+    console.log(`  ${c.greenBold}✔ Configuration reverted to standard OpenAI defaults in:${c.reset}`);
+    console.log(`    ${c.dim}${confPath}${c.reset}\n`);
+    process.exit(0);
+  }
+
+  let apiKey = '';
+  let gatewayUrl = DEFAULT_GATEWAY_URL;
+  let model = DEFAULT_MODEL;
+  let provider = DEFAULT_PROVIDER;
+  let providerName = DEFAULT_PROVIDER_NAME;
+  let reasoning = DEFAULT_REASONING;
+  let launchMode = 'desktop';
+  let shouldLaunch = true;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '-k' || arg === '--key') {
+      apiKey = args[++i];
+    } else if (arg === '-u' || arg === '--url') {
+      gatewayUrl = args[++i];
+    } else if (arg === '-m' || arg === '--model') {
+      model = args[++i];
+    } else if (arg === '-p' || arg === '--provider') {
+      provider = args[++i];
+    } else if (arg === '--provider-name') {
+      providerName = args[++i];
+    } else if (arg === '--reasoning') {
+      reasoning = args[++i];
+    } else if (arg === '--cli') {
+      launchMode = 'cli';
+    } else if (arg === '--no-launch') {
+      shouldLaunch = false;
+    } else if (!arg.startsWith('-') && !apiKey) {
+      apiKey = arg;
+    }
+  }
+
+  printBanner();
+
+  // If no API key provided, prompt interactively
+  if (!apiKey) {
+    console.log(`  ${c.greenBold}✳ Enter your API Key:${c.reset}`);
+    const entered = await askQuestion(`  ${c.gray}API Key (e.g. sk-...):${c.reset} `);
+    if (!entered) {
+      console.log(`\n  ${c.red}✖ No API key provided. Aborting.${c.reset}\n`);
+      process.exit(1);
+    }
+    apiKey = entered;
+  }
+
+  // Gracefully terminate existing instances before writing config
+  killRunningProcesses();
+
+  // Run visual connection animation
+  await runConnectionAnimation(apiKey, gatewayUrl);
+
+  // Ensure ~/.codex directory exists
+  const codexDir = path.dirname(confPath);
+  if (!fs.existsSync(codexDir)) {
+    fs.mkdirSync(codexDir, { recursive: true });
+  }
+
+  // Read existing TOML or initialize empty
+  let existingToml = '';
+  if (fs.existsSync(confPath)) {
+    existingToml = fs.readFileSync(confPath, 'utf8');
+  }
+
+  // Generate updated TOML
+  const updatedToml = updateCodexConfig(existingToml, {
+    apiKey,
+    baseUrl: gatewayUrl,
+    model,
+    provider,
+    providerName,
+    reasoning,
+    wireApi: DEFAULT_WIRE_API
+  });
+
+  fs.writeFileSync(confPath, updatedToml, 'utf8');
+
+  console.log(`  ${c.greenBold}✔ Configured settings & provider in ~/.codex/config.toml${c.reset}`);
+  console.log(`  ${c.greenBold}✔ ChatGPT Desktop & Codex CLI successfully configured!${c.reset}\n`);
+
+  if (shouldLaunch) {
+    if (launchMode === 'cli') {
+      const launched = launchCodexCli();
+      if (!launched) {
+        console.log(`  ${c.amber}Codex CLI binary not found on PATH. Open terminal and run 'codex' to start.${c.reset}\n`);
+      }
+    } else {
+      console.log(`  ${c.whiteBold}Starting ChatGPT Desktop...${c.reset}\n`);
+      const launched = launchChatGPTDesktop();
+      if (!launched) {
+        // Fallback to Codex CLI if desktop failed
+        const cliLaunched = launchCodexCli();
+        if (!cliLaunched) {
+          console.log(`  ${c.greenBold}Configuration complete! Open ChatGPT Desktop or run 'codex' to start.${c.reset}\n`);
+        }
+      }
+    }
+  } else {
+    console.log(`  ${c.dim}Auto-launch skipped (--no-launch specified).${c.reset}\n`);
+  }
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(`\n  ${c.red}✖ Setup error: ${err.message}${c.reset}\n`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  updateCodexConfig,
+  revertCodexConfig,
+  getCodexConfigPath,
+  splitTomlSections,
+  findCodexCli,
+  launchChatGPTDesktop,
+  launchCodexCli
+};

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@decoopus/chatgpt-setup",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "One-command setup for ChatGPT Desktop & Codex CLI with custom 3P inference gateway",
+  "main": "bin/cli.js",
+  "bin": {
+    "chatgpt-setup": "bin/cli.js",
+    "codex-setup": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node ./bin/cli.js"
+  },
+  "keywords": [
+    "chatgpt",
+    "chatgpt-desktop",
+    "codex",
+    "codex-cli",
+    "openai",
+    "setup",
+    "gateway",
+    "gpt-6-astra",
+    "3p-inference"
+  ],
+  "author": "decoopus",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}