@galaxy-yearn/codex-deepseek-gateway 0.1.4 → 0.1.6

package/README.md

@@ -1,64 +1,54 @@
 # Codex DeepSeek Gateway
 
-A small local gateway for using DeepSeek models from Codex.
+A lightweight local gateway for using DeepSeek models in Codex.
 
-Codex keeps sending OpenAI `Responses API` requests to a local endpoint. The gateway converts those requests to DeepSeek-compatible `Chat Completions`, calls DeepSeek, then converts the result back to Responses JSON or streaming `response.*` events.
+Codex keeps using the OpenAI `Responses API` wire format. The gateway translates requests to DeepSeek-compatible `Chat Completions`, calls DeepSeek, then translates the result back to Responses JSON or `response.*` SSE events.
 
-NPM package: [@galaxy-yearn/codex-deepseek-gateway](https://www.npmjs.com/package/@galaxy-yearn/codex-deepseek-gateway)
-
-The runtime uses only the Node.js standard library. It installs under `~/.codex/deepseek-gateway`, runs as a detached background process, and does not edit your existing Codex config.
-
-Use this when you want Codex to stay on its normal Responses API path while the actual model is DeepSeek, including DeepSeek thinking output, function calls, local session resume help, and optional web search emulation through Tavily and Firecrawl.
+Package: [@galaxy-yearn/codex-deepseek-gateway](https://www.npmjs.com/package/@galaxy-yearn/codex-deepseek-gateway)
 
 ## Requirements
 
-- Node.js 20 or newer
+- Node.js 22 or newer
 - A DeepSeek API key
-- Codex configured from `~/.codex/config.toml`
+- Codex CLI 0.142.0 or newer is recommended
 
 ## Install
 
-Run:
-
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway install
-```
-
-This copies the runtime to:
-
-```text
-~/.codex/deepseek-gateway
+npm install -g @galaxy-yearn/codex-deepseek-gateway
+codex-deepseek-gateway --version
+codex-deepseek-gateway install
 ```
 
-It creates two local config files:
+The runtime is copied to `~/.codex/deepseek-gateway`. Put your DeepSeek API key in:
 
 ```text
 ~/.codex/deepseek-gateway/config/gateway.local.json
-~/.codex/deepseek-gateway/config/model-aliases.json
 ```
 
-Put your DeepSeek API key in `gateway.local.json`:
-
 ```json
-"upstreamApiKey": "sk-..."
+{
+  "upstreamApiKey": "sk-..."
+}
 ```
 
-`model-aliases.json` controls the gateway-facing model IDs exposed on `GET /v1/models` and used by the `new` and `sessions` pickers. Edit it only if you want to add or rename model aliases.
-
-If the key is already configured, `install` also starts the gateway. If this is your first install, add the key and then run:
+`install` preserves an existing `gateway.local.json`. If this is your first install, add the key and start the gateway:
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway start
+codex-deepseek-gateway start
+codex-deepseek-gateway status
 ```
 
-## Configure Codex
+`status` should show `"reachable": true`.
+
+## Codex Config
 
-Edit `~/.codex/config.toml`:
+Add this provider to `~/.codex/config.toml`:
 
 ```toml
 model_provider = "deepseek-gateway"
-model = "deepseek-v4-flash"
-model_reasoning_effort = "low"
+model = "deepseek-v4-pro"
+model_reasoning_effort = "xhigh"
 model_supports_reasoning_summaries = true
 model_reasoning_summary = "auto"
 
@@ -68,225 +58,121 @@ base_url = "http://127.0.0.1:3000/v1"
 wire_api = "responses"
 ```
 
-Use `deepseek-v4-pro` instead of `deepseek-v4-flash` if you want the pro model.
-
-Restart Codex after changing `config.toml`.
+Restart Codex after editing `config.toml`.
 
-## Start And Verify
+## Usage
 
-Start, stop, and inspect the local background process:
+Start a new Codex conversation with gateway overrides:
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway start
-npx @galaxy-yearn/codex-deepseek-gateway stop
-npx @galaxy-yearn/codex-deepseek-gateway status
+codex-deepseek-gateway new
 ```
 
-`status` should show `"reachable": true`.
-
-Run `doctor` to check the active Codex config and the DeepSeek request shape the gateway will send:
+Resume a Codex session from the current project:
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway doctor
+codex-deepseek-gateway sessions
 ```
 
-Important fields:
-
-- `codexConfigUsingGateway` should be `true`
-- `codexModel` should be your gateway model, for example `deepseek-v4-pro`
-- `codexReasoningEffort` should match `model_reasoning_effort`
-- `deepseekThinking` shows the DeepSeek `thinking` payload
-- `deepseekReasoningEffort` shows the DeepSeek effort sent upstream
-- `reasoningDisplayMode` shows whether reasoning is shown as `summary`, `hidden`, or `disabled`
-- `tavilyWebSearchReady` and `firecrawlWebFetchReady` show whether optional web search backends are usable
+When using the gateway, prefer these `new` / `sessions` commands over plain `codex` / `codex resume`. The launcher adds the gateway provider, model catalog, model, and reasoning overrides.
 
-Avoid running Codex through a proxy while using the local gateway. Some proxy clients intercept `http://127.0.0.1:3000` and can break local gateway requests.
+In the interactive session picker, use Up/Down to move through a scrolling window of sessions. Press `n` to start a new conversation instead of resuming an existing session.
 
-## Models
-
-The installed `config/model-aliases.json` starts with:
-
-```json
-{
-  "deepseek-v4-flash": {
-    "model": "deepseek-v4-flash",
-    "thinking": "auto"
-  },
-  "deepseek-v4-pro": {
-    "model": "deepseek-v4-pro",
-    "thinking": "auto"
-  }
-}
-```
-
-The gateway serves these aliases directly on `GET /v1/models`. If you also want to merge DeepSeek's upstream `/models` list, set this in `gateway.local.json`:
-
-```json
-"fetchUpstreamModels": true
-```
-
-Whether Codex TUI `/model` shows custom provider models depends on the Codex client build. `config.toml`, `new`, and `sessions` remain the reliable ways to choose a model.
-
-## Reasoning
-
-Codex reasoning effort maps to DeepSeek V4 thinking mode:
-
-| Codex `model_reasoning_effort` | DeepSeek request |
-| --- | --- |
-| `low` | `thinking.type = disabled` |
-| `medium` | `thinking.type = enabled`, `reasoning_effort = high` |
-| `high` | `thinking.type = enabled`, `reasoning_effort = high` |
-| `xhigh` | `thinking.type = enabled`, `reasoning_effort = max` |
-
-`model_supports_reasoning_summaries = true` and `model_reasoning_summary = "auto"` tell Codex to use its normal thinking UI path. When DeepSeek returns `reasoning_content`, the gateway keeps the raw text as `reasoning_text` and mirrors it into `summary_text` with a `Reasoning` heading for Codex TUI compatibility.
-
-When thinking is enabled, the gateway intentionally buffers visible assistant text and tool-call output until the upstream response completes, then emits reasoning first. This improves thinking order in Codex at the cost of higher first-token latency.
-
-## Web Search
-
-Web search is off by default. To let Codex's native `web_search` or `web_search_preview` tool work while DeepSeek is active, configure the optional backends in `gateway.local.json`.
-
-Tavily provides search results:
-
-```json
-"tavilyApiKey": "tvly-...",
-"tavilyWebSearchEnabled": true
-```
-
-Firecrawl provides opened-page reading and focused page lookup:
-
-```json
-"firecrawlApiKey": "fc-...",
-"firecrawlWebFetchEnabled": true,
-"firecrawlAutoScrapeTopResults": 3
-```
-
-Codex does not need MCP, a different tool name, or prompt changes. The gateway converts Codex web search requests into internal Chat Completions tools:
-
-- `tavily_search` searches the web and returns citation-ready snippets.
-- `firecrawl_open_page` reads a specific public page.
-- `firecrawl_find_in_page` reads a page with a focused query.
-
-DeepSeek receives compact text context containing the search query, sources, snippets, and optional opened-page excerpts. Codex receives Responses-compatible `web_search_call` items, final assistant messages, and URL citation annotations when the final text cites a matching source marker.
-
-The web payload is intentionally text-focused. Tavily is called with `include_raw_content: false`; Firecrawl defaults to main content, removes base64 images, rejects local/private URLs, and truncates page text before it reaches the model.
-
-## New Conversations
-
-Start a new Codex conversation with a temporary gateway model override:
+Useful non-interactive forms:
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway new
+codex-deepseek-gateway new --model deepseek-v4-flash --reasoning-effort low  # start with explicit model and effort
+codex-deepseek-gateway sessions --print                                      # list resume commands
+codex-deepseek-gateway sessions --all                                        # include sessions from all projects
+codex-deepseek-gateway sessions --exec <id-or-row>                           # resume directly by row or session id
 ```
 
-The command first lets you choose a model from `~/.codex/deepseek-gateway/config/model-aliases.json`, then choose Codex reasoning effort, then runs:
+`new` chooses a model, then Codex reasoning effort. `sessions` chooses a session first, then model and reasoning effort. Both launch Codex with:
 
 ```sh
-codex -c model_provider=deepseek-gateway -c model=<model> -c model_reasoning_effort=<effort>
+codex -c model_provider=deepseek-gateway -c model=<model> -c model_reasoning_effort=<effort> -c model_supports_reasoning_summaries=true -c model_reasoning_summary=auto
 ```
 
-This does not edit `~/.codex/config.toml`; the `model_providers.deepseek-gateway` provider entry still needs to exist there.
+The installed launcher also passes `model_catalog_json` pointing at the packaged gateway Codex catalog, so Codex-native multi-agent validation accepts the DeepSeek model aliases and `low|medium|high|xhigh` reasoning efforts. This Codex setting replaces the default model catalog for that Codex process; it is not merged into it.
 
-You can skip the picker:
+Inside a launcher-started Codex TUI, `/model` can switch between the packaged DeepSeek models and reasoning efforts.
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway new --model deepseek-v4-flash --reasoning-effort low
-```
+Model aliases are read from:
 
-Print the generated launch command instead of running Codex:
-
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway new --print
+```text
+~/.codex/deepseek-gateway/config/model-aliases.json
 ```
 
-## Sessions
-
-Open a cross-provider session picker from a project:
+`model-aliases.json` is managed by this package and is refreshed on install. The packaged Codex catalog currently allows the default aliases `deepseek-v4-flash` and `deepseek-v4-pro` for Codex-native sub-agent validation.
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions
-```
-
-The picker is read-only. It scans Codex local transcript files, lists sessions for the current project across providers, then runs:
+## Commands
 
 ```sh
-codex resume <session-id> -c model_provider=deepseek-gateway -c model=<model> -c model_reasoning_effort=<effort>
+codex-deepseek-gateway install    # copy runtime into ~/.codex/deepseek-gateway
+codex-deepseek-gateway start      # start the local gateway
+codex-deepseek-gateway stop       # stop the local gateway
+codex-deepseek-gateway status     # show process and endpoint status
+codex-deepseek-gateway doctor     # inspect config and request mapping
+codex-deepseek-gateway new        # start a Codex conversation through the launcher
+codex-deepseek-gateway sessions   # pick and resume a Codex session through the launcher
+codex-deepseek-gateway uninstall  # remove the local runtime
 ```
 
-Flow:
-
-- choose a model from `~/.codex/deepseek-gateway/config/model-aliases.json`
-- choose Codex reasoning effort
-- choose `[New conversation]` or the session to resume
-- use `↑/↓` to select, `Enter` to confirm, `←` to go back, and `Esc` to quit
-
-Print copyable resume commands instead of opening the picker:
+`doctor` checks the active Codex config, DeepSeek request shape, reasoning mode, and optional web-search backend readiness.
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions --print
-```
-
-Include sessions outside the current project:
+To remove the local runtime and then uninstall the global package:
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions --all
+codex-deepseek-gateway uninstall
+npm uninstall -g @galaxy-yearn/codex-deepseek-gateway
 ```
 
-Resume a matching session directly by row number or unique session id prefix:
+## Reasoning
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions --exec <id-or-row>
-```
+Codex effort maps to DeepSeek V4 thinking mode:
 
-Limit how many session rows are shown or offered in the picker:
+| Codex effort | DeepSeek request |
+| --- | --- |
+| `low` | `thinking.type = disabled` |
+| `medium` | `thinking.type = enabled`, `reasoning_effort = high` |
+| `high` | `thinking.type = enabled`, `reasoning_effort = high` |
+| `xhigh` | `thinking.type = enabled`, `reasoning_effort = max` |
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions --limit 50
-```
+When DeepSeek returns `reasoning_content`, the gateway preserves the raw text for DeepSeek history and sends a display-only Markdown-cleaned copy through Codex's reasoning summary UI. The raw reasoning is not duplicated into visible message content.
 
-The command does not edit session files, change provider ownership, or change Codex's native resume picker filters. It only helps you find the hidden session id and resume it with explicit config overrides.
+## Web Search
 
-## Commands
+Web search is optional and off by default. Configure Tavily for search:
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway install
-npx @galaxy-yearn/codex-deepseek-gateway start
-npx @galaxy-yearn/codex-deepseek-gateway stop
-npx @galaxy-yearn/codex-deepseek-gateway status
-npx @galaxy-yearn/codex-deepseek-gateway doctor
-npx @galaxy-yearn/codex-deepseek-gateway new
-npx @galaxy-yearn/codex-deepseek-gateway sessions
-npx @galaxy-yearn/codex-deepseek-gateway uninstall
+```json
+{
+  "tavilyApiKey": "tvly-...",
+  "tavilyWebSearchEnabled": true
+}
 ```
 
-`start` launches a headless background Node.js process. `stop` stops it. `uninstall` stops the gateway and removes `~/.codex/deepseek-gateway`, but it does not edit `~/.codex/config.toml`.
+Configure Firecrawl if you also want opened-page reading:
 
-If `start` returns without visible output on your terminal, run `status`; `"reachable": true` is the source of truth.
+```json
+{
+  "firecrawlApiKey": "fc-...",
+  "firecrawlWebFetchEnabled": true
+}
+```
 
-## What Works
+Codex can keep requesting `web_search` / `web_search_preview`. The gateway exposes compact internal web tools to DeepSeek, executes Tavily/Firecrawl calls itself, feeds tool results back to the model, and returns Codex-compatible `web_search_call` items. `TAVILY_MAX_SEARCH_ROUNDS` defaults to `10` and is only a runaway/cost guardrail; when reached, the gateway disables web tools for one final-answer turn.
 
-- Codex `POST /v1/responses`
-- streaming and non-streaming responses
-- text input and output
-- image, file, and audio content parts when DeepSeek accepts the corresponding Chat Completions shape
-- function tools and tool-call history
-- DeepSeek thinking mode and `reasoning_content`
-- lightweight local `previous_response_id` / `conversation` history while the gateway process is running
-- `GET /v1/models` with local model aliases and optional upstream discovery
-- optional Tavily/Firecrawl-backed `web_search` emulation
-- new-conversation launcher with per-run Codex config overrides
-- read-only cross-provider session picker
+Final answers should include useful source titles and URLs directly.
 
 ## Limits
 
-Chat Completions is not a full Responses API replacement. Some Responses features have no equivalent upstream field.
+Chat Completions is not a full Responses API replacement.
 
-- Hosted tools such as file search, computer use, image generation, and code interpreter are represented as function-tool shims unless Codex executes matching tools locally. Web search is the only hosted tool the gateway can emulate directly.
-- Tavily and Firecrawl web emulation is text-focused. It does not expose raw HTML, screenshots, browser actions, crawl/map jobs, cookies, private network access, or provider-specific payloads through Codex `web_search`.
-- URL citations are returned in the Responses metadata path. Whether they appear as clickable links in the terminal depends on the Codex client build and how it renders custom-provider citation annotations.
+- Hosted tools without a local Codex executor are represented as function shims. Web search is the only hosted tool the gateway emulates directly.
+- Tavily/Firecrawl web emulation is text-focused; it does not provide browser control, screenshots, raw HTML, cookies, crawl jobs, or private-network access.
 - OpenAI `file_id` values are passed through; the gateway cannot fetch private OpenAI-hosted files.
-- In-memory conversation history is lost when the gateway restarts.
-- The gateway exposes model aliases on `/v1/models`, including aliases from `config/model-aliases.json`. Whether Codex TUI `/model` actually shows custom provider models depends on the Codex build. `config.toml`, `new`, and `sessions` remain the reliable ways to choose a model.
+- In-memory `previous_response_id` / `conversation` history is lost when the gateway process restarts.
+- Plain `codex` commands do not automatically load the packaged model catalog. Use the launcher when you want TUI `/model` and sub-agent validation to use the DeepSeek catalog.
 
 ## License
 

package/bin/codex-deepseek-gateway.js

@@ -14,7 +14,7 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadConfig } from '../src/config.js';
 import { newConversation } from '../src/codex-launch.js';
-import { sessions } from '../src/codex-sessions.js';
+import { DEFAULT_SESSION_LIMIT, sessions } from '../src/codex-sessions.js';
 import { toProviderChatCompletionsRequest } from '../src/protocol.js';
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
@@ -39,6 +39,7 @@ Usage:
   codex-deepseek-gateway uninstall
 
 Options:
+  -v, --version   Print package version
   --dir <path>     Install directory, defaults to ~/.codex/deepseek-gateway
   --no-edit        Do not open the local config file after install
   --all            With sessions, include sessions outside the current project
@@ -47,9 +48,8 @@ Options:
   --reasoning-effort <level>
                   With new/sessions, target Codex reasoning effort
   --exec <id>      With sessions, run the generated codex resume command
-  --limit <n>      With sessions, max rows to print, defaults to 20
-  --print          With new, print the launch command. With sessions, print
-                  copyable resume commands instead of picker
+  --limit <n>      With sessions, max rows to print or show, defaults to ${DEFAULT_SESSION_LIMIT}
+  --print          With sessions, print resume commands instead of picker
 `);
 }
 
@@ -58,7 +58,9 @@ function parseArgs(argv) {
   const rest = [];
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
-    if (arg === '--dir' || arg === '-d' || arg === '-InstallDir') {
+    if (arg === '--version' || arg === '-v') {
+      options.version = true;
+    } else if (arg === '--dir' || arg === '-d' || arg === '-InstallDir') {
       const value = argv[index + 1];
       if (!value) throw new Error(`${arg} requires a path`);
       options.dir = resolve(value);
@@ -118,6 +120,12 @@ function serverPath(installDir) {
   return join(installDir, 'src', 'server.js');
 }
 
+function hasRuntimeMarkers(installDir) {
+  return existsSync(join(installDir, 'package.json')) &&
+    existsSync(join(installDir, 'bin', 'codex-deepseek-gateway.js')) &&
+    existsSync(join(installDir, 'src', 'server.js'));
+}
+
 function loadInstalledConfig(installDir) {
   return loadConfig({ ...process.env, GATEWAY_CONFIG_FILE: configPath(installDir) });
 }
@@ -215,10 +223,9 @@ function copyRuntime(installDir) {
   rmSync(join(installDir, 'src'), { recursive: true, force: true });
   cpSync(join(ROOT, 'bin'), join(installDir, 'bin'), { recursive: true });
   cpSync(join(ROOT, 'src'), join(installDir, 'src'), { recursive: true });
-  const modelAliasesConfig = join(installDir, 'config', 'model-aliases.json');
-  if (!existsSync(modelAliasesConfig)) {
-    copyFileSync(join(ROOT, 'config', 'model-aliases.example.json'), modelAliasesConfig);
-  }
+  copyFileSync(join(ROOT, 'config', 'codex-model-catalog.json'), join(installDir, 'config', 'codex-model-catalog.json'));
+  rmSync(join(installDir, 'config', 'codex-model-catalog.base.json'), { force: true });
+  copyFileSync(join(ROOT, 'config', 'model-aliases.example.json'), join(installDir, 'config', 'model-aliases.json'));
   const localConfig = configPath(installDir);
   if (!existsSync(localConfig)) {
     copyFileSync(join(ROOT, 'config', 'gateway.example.json'), localConfig);
@@ -253,6 +260,10 @@ async function install(options) {
 }
 
 async function start(options) {
+  if (!existsSync(options.dir)) {
+    throw new Error(`Missing runtime at ${options.dir}. Run install first.`);
+  }
+  copyRuntime(options.dir);
   if (!existsSync(serverPath(options.dir))) {
     throw new Error(`Missing runtime at ${options.dir}. Run install first.`);
   }
@@ -361,10 +372,19 @@ async function doctor(options) {
   const summaryMode = String(config.codexReasoningSummary || '').toLowerCase();
   const hideAgentReasoning = String(config.codexHideAgentReasoning).toLowerCase() === 'true';
   const thinkingEnabled = upstreamRequest.thinking?.type === 'enabled';
+  const summaryEnabled = Boolean(summaryMode) &&
+    summaryMode !== 'none' &&
+    summaryMode !== 'disabled' &&
+    summaryMode !== 'off' &&
+    summaryMode !== 'false';
+  const codexReasoningSummaryEnabled = supportsReasoningSummaries && summaryEnabled;
+  const gatewayStreamingReasoningSummary = !hideAgentReasoning && thinkingEnabled;
   const reasoningDisplayMode = hideAgentReasoning
     ? 'hidden'
-    : thinkingEnabled
+    : thinkingEnabled && codexReasoningSummaryEnabled
     ? 'summary'
+    : thinkingEnabled
+    ? 'upstream-only'
     : 'disabled';
   print(JSON.stringify({
     packageVersion: packageJson.version,
@@ -381,25 +401,45 @@ async function doctor(options) {
     upstreamModel: upstreamRequest.model,
     deepseekThinking: upstreamRequest.thinking || null,
     deepseekReasoningEffort: upstreamRequest.reasoning_effort || null,
+    codexReasoningSummaryEnabled,
+    gatewayStreamingReasoningSummary,
     reasoningDisplayMode,
     tavilyWebSearchEnabled: Boolean(config.tavilyWebSearchEnabled),
     tavilyWebSearchReady: Boolean(config.tavilyWebSearchEnabled && config.tavilyApiKey),
     firecrawlWebFetchEnabled: Boolean(config.firecrawlWebFetchEnabled),
     firecrawlWebFetchReady: Boolean(config.firecrawlWebFetchEnabled && config.firecrawlApiKey),
     firecrawlAutoScrapeTopResults: config.firecrawlAutoScrapeTopResults,
-    hint: 'The gateway exposes model aliases on /v1/models. Whether Codex TUI /model shows them depends on the Codex build.',
+    hint: 'The gateway exposes model aliases on /v1/models. The launcher passes model_catalog_json for Codex multi-agent validation; plain codex commands must pass that override themselves.',
   }, null, 2));
   print('\n');
 }
 
 async function uninstall(options) {
-  await stop(options);
+  if (!existsSync(options.dir)) {
+    print(`No install found at ${options.dir}\n`);
+    return;
+  }
+  if (resolve(options.dir) === ROOT) {
+    throw new Error(`Refusing to remove source checkout ${options.dir}`);
+  }
+  if (!hasRuntimeMarkers(options.dir)) {
+    throw new Error(`Refusing to remove ${options.dir}: it does not look like a codex-deepseek-gateway install directory.`);
+  }
+  try {
+    await stop(options);
+  } catch (error) {
+    process.stderr.write(`Warning: could not stop gateway before uninstall: ${error.message || error}\n`);
+  }
   rmSync(options.dir, { recursive: true, force: true });
   print(`Removed ${options.dir}\n`);
 }
 
 async function main() {
   const { command, options } = parseArgs(process.argv.slice(2));
+  if (options.version) {
+    print(`${packageJson.version}\n`);
+    return;
+  }
   if (!command || command === '-h' || command === '--help' || command === 'help') {
     usage();
     return;