codelark 0.1.0

package/scripts/hot-update-bridge.sh

@@ -0,0 +1,298 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PROJECT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CODELARK_HOME="${CODELARK_HOME:-$HOME/.codelark}"
+LOG_DIR="$CODELARK_HOME/logs"
+BRIDGE_LOG="$LOG_DIR/bridge.log"
+
+usage() {
+  cat <<'USAGE'
+Usage: bash scripts/hot-update-bridge.sh [--pull] [--skip-tests] [--dry-run] [--run]
+
+Dispatch a detached CodeLark hot update so the current bridge-hosted
+Codex session can survive the bridge stop/start sequence.
+
+Options:
+  --pull         Run git pull before build/test/restart.
+  --skip-tests   Skip npm test during this hot update.
+  --dry-run      Validate environment and print the planned detached update
+                 without dispatching a worker, building, testing, or restarting.
+  --run          Internal worker mode. Do not call directly from a bridge session.
+USAGE
+}
+
+USE_PULL=0
+SKIP_TESTS=0
+RUN_WORKER=0
+DRY_RUN=0
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --pull)
+      USE_PULL=1
+      ;;
+    --skip-tests)
+      SKIP_TESTS=1
+      ;;
+    --run)
+      RUN_WORKER=1
+      ;;
+    --dry-run)
+      DRY_RUN=1
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      usage >&2
+      exit 2
+      ;;
+  esac
+  shift
+done
+
+validate_project_dir() {
+  if [ ! -f "$PROJECT_DIR/package.json" ] || [ ! -f "$PROJECT_DIR/scripts/hot-update-bridge.sh" ]; then
+    echo "[hot-update] refusing to run outside a CodeLark/codelark project directory" >&2
+    exit 1
+  fi
+
+  local package_name
+  package_name="$(env -u NODE_OPTIONS node -e "const fs = require('fs'); const pkg = JSON.parse(fs.readFileSync(process.argv[1], 'utf8')); process.stdout.write(String(pkg.name || ''));" "$PROJECT_DIR/package.json" 2>/dev/null || true)"
+  if [ "$package_name" != "codelark" ]; then
+    echo "[hot-update] refusing to run outside a CodeLark/codelark project directory" >&2
+    exit 1
+  fi
+}
+
+bridge_cli_display() {
+  if [ -f "$PROJECT_DIR/dist/cli.mjs" ]; then
+    echo "node $PROJECT_DIR/dist/cli.mjs"
+    return
+  fi
+  if command -v codelark >/dev/null 2>&1; then
+    echo "codelark"
+    return
+  fi
+  echo "codelark"
+}
+
+run_bridge_cli() {
+  if [ -f "$PROJECT_DIR/dist/cli.mjs" ]; then
+    node "$PROJECT_DIR/dist/cli.mjs" "$@"
+    return
+  fi
+  if command -v codelark >/dev/null 2>&1; then
+    codelark "$@"
+    return
+  fi
+  echo "[hot-update] codelark CLI not found" >&2
+  return 127
+}
+
+ensure_node24() {
+  # npm test can export npm_config_prefix, which makes nvm refuse to run.
+  # Hot update owns its Node runtime selection, so clear the incompatible prefix.
+  unset npm_config_prefix NPM_CONFIG_PREFIX
+
+  # Check if Node 24 is already available in the current environment.
+  # This handles CI environments (GitHub Actions, etc.) where Node is installed
+  # via setup-node rather than nvm.
+  if command -v node >/dev/null 2>&1; then
+    local current_major
+    current_major="$(node -p "process.versions.node.split('.')[0]" 2>/dev/null || true)"
+    if [ "$current_major" = "24" ]; then
+      return
+    fi
+  fi
+
+  # Try to switch to Node 24 via nvm if available.
+  local nvm_root="${NVM_DIR:-$HOME/.nvm}"
+  if [ -s "$nvm_root/nvm.sh" ]; then
+    # shellcheck source=/dev/null
+    source "$nvm_root/nvm.sh"
+    # Allow nvm use to fail gracefully if Node 24 is not installed via nvm.
+    # We'll check again below and search for a manually-installed Node 24.
+    nvm use 24 >/dev/null 2>&1 || true
+  fi
+
+  # Check again after attempting nvm use.
+  if command -v node >/dev/null 2>&1; then
+    local current_major
+    current_major="$(node -p "process.versions.node.split('.')[0]" 2>/dev/null || true)"
+    if [ "$current_major" = "24" ]; then
+      return
+    fi
+  fi
+
+  # Search for Node 24 in common nvm installation directories.
+  local node24=""
+  local root
+  for root in \
+    "${NVM_DIR:-}" \
+    "$HOME/.nvm" \
+    "/home/${USER:-}/.nvm" \
+    "/data00/home/${USER:-}/.nvm"
+  do
+    [ -n "$root" ] || continue
+    [ -d "$root/versions/node" ] || continue
+    local candidate
+    for candidate in "$root"/versions/node/v24.*/bin/node; do
+      [ -x "$candidate" ] || continue
+      node24="$candidate"
+    done
+  done
+  if [ -n "$node24" ]; then
+    PATH="$(dirname "$node24"):$PATH"
+    export PATH
+  fi
+
+  # Final check: ensure Node 24 is now available.
+  if ! command -v node >/dev/null 2>&1; then
+    echo "[hot-update] node is not available in PATH" >&2
+    exit 1
+  fi
+
+  local major
+  major="$(node -p "process.versions.node.split('.')[0]")"
+  if [ "$major" != "24" ]; then
+    echo "[hot-update] Node.js 24 is required, found $(node -v)" >&2
+    exit 1
+  fi
+}
+
+node_supports_env_proxy() {
+  node --help 2>/dev/null | grep -F -- --use-env-proxy >/dev/null 2>&1
+}
+
+run_logged() {
+  echo "[hot-update] $*"
+  "$@"
+}
+
+run_worker() {
+  cd "$PROJECT_DIR"
+  mkdir -p "$LOG_DIR"
+
+  echo "[hot-update] started $(date -Is)"
+  echo "[hot-update] project: $PROJECT_DIR"
+  echo "[hot-update] bridge log: $BRIDGE_LOG"
+
+  validate_project_dir
+
+  ensure_node24
+  echo "[hot-update] node: $(node -v)"
+
+  local proxy_supported=0
+  if node_supports_env_proxy; then
+    proxy_supported=1
+    echo "[hot-update] --use-env-proxy: supported"
+  else
+    echo "[hot-update] --use-env-proxy: not supported"
+  fi
+
+  if [ "$USE_PULL" = "1" ]; then
+    run_logged git pull
+  else
+    echo "[hot-update] git pull: skipped"
+  fi
+
+  run_logged npm run build
+  if [ "$SKIP_TESTS" = "1" ]; then
+    echo "[hot-update] npm test: skipped by --skip-tests"
+  else
+    run_logged npm test
+  fi
+
+  local cli
+  cli="$(bridge_cli_display)"
+  if [ "$proxy_supported" = "1" ]; then
+    echo "[hot-update] restart command: NODE_OPTIONS=--use-env-proxy LITELLM_KEY=sk-local-dev $cli stop && NODE_OPTIONS=--use-env-proxy LITELLM_KEY=sk-local-dev $cli start"
+    NODE_OPTIONS=--use-env-proxy LITELLM_KEY="sk-local-dev" run_bridge_cli stop
+    NODE_OPTIONS=--use-env-proxy LITELLM_KEY="sk-local-dev" run_bridge_cli start
+  else
+    echo "[hot-update] restart command: LITELLM_KEY=sk-local-dev $cli stop && LITELLM_KEY=sk-local-dev $cli start"
+    LITELLM_KEY="sk-local-dev" run_bridge_cli stop
+    LITELLM_KEY="sk-local-dev" run_bridge_cli start
+  fi
+
+  echo "[hot-update] completed $(date -Is)"
+}
+
+run_dry_run() {
+  cd "$PROJECT_DIR"
+  validate_project_dir
+  ensure_node24
+
+  local args=(--run)
+  if [ "$USE_PULL" = "1" ]; then
+    args+=(--pull)
+  fi
+  if [ "$SKIP_TESTS" = "1" ]; then
+    args+=(--skip-tests)
+  fi
+
+  echo "[hot-update] dry-run: yes"
+  echo "[hot-update] project: $PROJECT_DIR"
+  echo "[hot-update] pwd: $(pwd)"
+  echo "[hot-update] script: $PROJECT_DIR/scripts/hot-update-bridge.sh"
+  echo "[hot-update] CODELARK_HOME: $CODELARK_HOME"
+  echo "[hot-update] log dir: $LOG_DIR"
+  echo "[hot-update] bridge log: $BRIDGE_LOG"
+  echo "[hot-update] node: $(node -v)"
+  if node_supports_env_proxy; then
+    echo "[hot-update] --use-env-proxy: supported"
+  else
+    echo "[hot-update] --use-env-proxy: not supported"
+  fi
+  echo "[hot-update] worker args: ${args[*]}"
+  echo "[hot-update] dispatch command: bash scripts/hot-update-bridge.sh ${args[*]}"
+  echo "[hot-update] git pull: $([ "$USE_PULL" = "1" ] && echo planned || echo skipped)"
+  echo "[hot-update] npm run build: planned"
+  echo "[hot-update] npm test: $([ "$SKIP_TESTS" = "1" ] && echo skipped || echo planned)"
+  echo "[hot-update] restart cli: $(bridge_cli_display)"
+  echo "[hot-update] restart: planned"
+}
+
+dispatch_worker() {
+  local log_stamp
+  log_stamp="$(date +%Y%m%d-%H%M%S)"
+  local log_file="$LOG_DIR/hot-update-$log_stamp.log"
+  if ! { mkdir -p "$LOG_DIR" && : >"$log_file"; } 2>/dev/null; then
+    local fallback_log_dir="${TMPDIR:-/tmp}/codelark-logs"
+    mkdir -p "$fallback_log_dir"
+    log_file="$fallback_log_dir/hot-update-$log_stamp.log"
+    : >"$log_file"
+  fi
+  local args=(--run)
+  if [ "$USE_PULL" = "1" ]; then
+    args+=(--pull)
+  fi
+  if [ "$SKIP_TESTS" = "1" ]; then
+    args+=(--skip-tests)
+  fi
+
+  if command -v setsid >/dev/null 2>&1; then
+    nohup setsid bash "$0" "${args[@]}" >"$log_file" 2>&1 </dev/null &
+  else
+    nohup bash "$0" "${args[@]}" >"$log_file" 2>&1 </dev/null &
+  fi
+
+  echo "Dispatched CodeLark hot update."
+  echo "PID: $!"
+  echo "Hot update log: $log_file"
+  echo "Bridge log: $BRIDGE_LOG"
+  echo "Pull requested: $([ "$USE_PULL" = "1" ] && echo yes || echo no)"
+  echo "Tests skipped: $([ "$SKIP_TESTS" = "1" ] && echo yes || echo no)"
+}
+
+if [ "$DRY_RUN" = "1" ]; then
+  run_dry_run
+elif [ "$RUN_WORKER" = "1" ]; then
+  run_worker
+else
+  dispatch_worker
+fi

package/scripts/install-codex-skills.sh

@@ -0,0 +1,127 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Install bundled CodeLark skills and the official Lark lark-doc skill.
+# Usage:
+#   bash scripts/install-codex-skills.sh [--link] [skill ...]
+#
+# If no skill name is provided, all default skills are installed. Supported names:
+#   codelark              IM attachment send-back skill
+#   codelark-question     explicit question-card skill
+#   codelark-auto         /auto-script helper skill
+#   lark-doc              official Lark document skill from larksuite/cli
+#
+# --link only symlinks the primary package skill for local development.
+
+CODEX_SKILLS_DIR="$HOME/.codex/skills"
+SOURCE_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+LINK_PRIMARY=0
+REQUESTED_SKILLS=()
+
+for arg in "$@"; do
+  case "$arg" in
+    --link)
+      LINK_PRIMARY=1
+      ;;
+    -h|--help)
+      sed -n '3,18p' "$0"
+      exit 0
+      ;;
+    *)
+      REQUESTED_SKILLS+=("$arg")
+      ;;
+  esac
+done
+
+if [ "${#REQUESTED_SKILLS[@]}" -eq 0 ]; then
+  REQUESTED_SKILLS=(codelark codelark-question codelark-auto lark-doc)
+fi
+
+echo "Installing CodeLark skills..."
+echo "Target: $CODEX_SKILLS_DIR"
+echo "Note: lark-doc is installed through the official larksuite/cli skills package."
+echo ""
+
+mkdir -p "$CODEX_SKILLS_DIR"
+
+skill_source_dir() {
+  case "$1" in
+    codelark|codelark-auto|codelark-question)
+      printf '%s\n' "$SOURCE_DIR/skills/$1"
+      ;;
+    lark-doc)
+      printf '%s\n' ""
+      ;;
+    *)
+      echo "Error: unknown skill '$1'" >&2
+      echo "Supported skills: codelark codelark-question codelark-auto lark-doc" >&2
+      exit 1
+      ;;
+  esac
+}
+
+install_skill_dir() {
+  local name="$1"
+  local source_dir="$2"
+  local target_dir="$CODEX_SKILLS_DIR/$name"
+  if [ ! -f "$source_dir/SKILL.md" ]; then
+    echo "Error: SKILL.md not found in $source_dir"
+    exit 1
+  fi
+  if [ -e "$target_dir" ]; then
+    if [ -L "$target_dir" ]; then
+      local existing
+      existing=$(readlink "$target_dir")
+      echo "Already installed: $name -> $existing"
+    else
+      echo "Already installed: $target_dir"
+    fi
+    return
+  fi
+  cp -R "$source_dir" "$target_dir"
+  echo "Copied $name to: $target_dir"
+}
+
+for skill in "${REQUESTED_SKILLS[@]}"; do
+  if [ "$skill" = "lark-doc" ]; then
+    echo "Installing official lark-doc skill..."
+    npx skills add larksuite/cli -s lark-doc -y -g -a claude-code
+    continue
+  fi
+  source_dir="$(skill_source_dir "$skill")"
+  target_dir="$CODEX_SKILLS_DIR/$skill"
+  if [ "$skill" = "codelark" ] && [ "$LINK_PRIMARY" -eq 1 ]; then
+    if [ -e "$target_dir" ]; then
+      echo "Already installed: $target_dir"
+    else
+      ln -s "$source_dir" "$target_dir"
+      echo "Symlinked: $target_dir -> $source_dir"
+    fi
+  else
+    install_skill_dir "$skill" "$source_dir"
+  fi
+done
+
+TARGET_DIR="$CODEX_SKILLS_DIR/codelark"
+if [[ " ${REQUESTED_SKILLS[*]} " == *" codelark "* ]] && [ "$LINK_PRIMARY" -eq 0 ]; then
+  if [ ! -d "$TARGET_DIR/node_modules" ] || [ ! -d "$TARGET_DIR/node_modules/@openai/codex-sdk" ]; then
+    echo "Installing dependencies for codelark..."
+    (cd "$TARGET_DIR" && npm install)
+  fi
+
+  if [ ! -f "$TARGET_DIR/dist/daemon.mjs" ]; then
+    echo "Building daemon bundle for codelark..."
+    (cd "$TARGET_DIR" && npm run build)
+  fi
+
+  echo "Pruning dev dependencies for codelark..."
+  (cd "$TARGET_DIR" && npm prune --production)
+fi
+
+if [ "$LINK_PRIMARY" -eq 1 ]; then
+  echo ""
+  echo "Development mode: no install/build/prune steps were run against the source repo."
+fi
+
+echo ""
+echo "Done. Start a new Codex session for newly installed skills to be discoverable."

package/scripts/install-codex.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+echo "scripts/install-codex.sh is kept for compatibility."
+echo "Use scripts/install-codex-skills.sh for the clearer manual CodeLark skill installer."
+echo ""
+
+exec "$SCRIPT_DIR/install-codex-skills.sh" "$@"

package/scripts/migrate-bindings-to-channel-chats.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function usage() {
+  return [
+    'Usage: node scripts/migrate-bindings-to-channel-chats.js [--codelark-home <path>] [--clk-home <path>] [--dry-run]',
+    '',
+    'Migrates data/bindings.json to data/channel-chats.json.',
+    'For each channel/chat pair, keeps the newest active legacy record where active=true and drops inactive records.',
+    'Moves binding workingDirectory/model/mode/chatDisplayName into the linked session when session fields are empty.',
+  ].join('\n');
+}
+
+function parseArgs(argv) {
+  const out = {
+    codelarkHome: process.env.CODELARK_HOME || path.join(os.homedir(), '.codelark'),
+    dryRun: false,
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--dry-run') {
+      out.dryRun = true;
+    } else if (arg === '--codelark-home' || arg === '--clk-home') {
+      const value = argv[++i];
+      if (!value) throw new Error(`${arg} requires a path`);
+      out.codelarkHome = value;
+    } else if (arg === '-h' || arg === '--help') {
+      console.log(usage());
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return out;
+}
+
+function readJsonObject(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`${filePath} must contain a JSON object`);
+  }
+  return parsed;
+}
+
+function atomicWriteJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, 'utf-8');
+  fs.renameSync(tmp, filePath);
+}
+
+function readString(record, key) {
+  const value = record?.[key];
+  return typeof value === 'string' ? value : '';
+}
+
+function readBoolean(record, key) {
+  const value = record?.[key];
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+function normalizeChatKind(value) {
+  if (value === 'p2p' || value === 'group') return value;
+  return undefined;
+}
+
+function updatedTime(record) {
+  const parsed = Date.parse(readString(record, 'updatedAt') || readString(record, 'createdAt'));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function normalizeMode(value) {
+  return value === 'yolo' ? 'yolo' : 'normal';
+}
+
+function ensureRecord(parent, key) {
+  if (!parent[key] || typeof parent[key] !== 'object' || Array.isArray(parent[key])) {
+    parent[key] = {};
+  }
+  return parent[key];
+}
+
+function chooseActiveBinding(records) {
+  return records
+    .filter((record) => readBoolean(record, 'active') === true)
+    .sort((a, b) => updatedTime(b) - updatedTime(a))[0];
+}
+
+function toChannelChat(binding) {
+  return {
+    id: readString(binding, 'id'),
+    channelType: readString(binding, 'channelType'),
+    ...(readString(binding, 'channelProvider') ? { channelProvider: readString(binding, 'channelProvider') } : {}),
+    ...(readString(binding, 'channelAlias') ? { channelAlias: readString(binding, 'channelAlias') } : {}),
+    chatId: readString(binding, 'chatId'),
+    ...(normalizeChatKind(binding.chatKind) ? { chatKind: normalizeChatKind(binding.chatKind) } : {}),
+    ...(readString(binding, 'chatUserId') ? { chatUserId: readString(binding, 'chatUserId') } : {}),
+    bridgeSessionId: readString(binding, 'bridgeSessionId'),
+    createdAt: readString(binding, 'createdAt') || new Date().toISOString(),
+    updatedAt: readString(binding, 'updatedAt') || new Date().toISOString(),
+  };
+}
+
+function migrateSessionFromBinding(session, binding) {
+  let changed = false;
+  const workingDirectory = readString(binding, 'workingDirectory');
+  const model = readString(binding, 'model');
+  const chatDisplayName = readString(binding, 'chatDisplayName');
+  const mode = normalizeMode(binding?.mode);
+  const runtime = ensureRecord(session, 'runtime');
+  const codex = ensureRecord(runtime, 'codex');
+  const existingModel = readString(session, 'model');
+  const existingMode = readString(session, 'preferred_mode');
+
+  if (existingModel && !readString(codex, 'model')) {
+    codex.model = existingModel;
+    changed = true;
+  }
+  if (existingMode && !readString(codex, 'mode')) {
+    codex.mode = normalizeMode(existingMode);
+    changed = true;
+  }
+  if ('model' in session) {
+    delete session.model;
+    changed = true;
+  }
+  if ('preferred_mode' in session) {
+    delete session.preferred_mode;
+    changed = true;
+  }
+
+  if (workingDirectory && !readString(session, 'working_directory')) {
+    session.working_directory = workingDirectory;
+    changed = true;
+  }
+  if (model && !readString(codex, 'model')) {
+    codex.model = model;
+    changed = true;
+  }
+  if (mode && !readString(codex, 'mode')) {
+    codex.mode = mode;
+    changed = true;
+  }
+  if (chatDisplayName && !readString(session, 'name')) {
+    session.name = chatDisplayName;
+    changed = true;
+  }
+  if (changed) {
+    session.updated_at = readString(session, 'updated_at') || new Date().toISOString();
+  }
+  return changed;
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const dataDir = path.join(options.codelarkHome, 'data');
+  const bindingsPath = path.join(dataDir, 'bindings.json');
+  const channelChatsPath = path.join(dataDir, 'channel-chats.json');
+  const sessionsPath = path.join(dataDir, 'sessions.json');
+
+  const bindings = readJsonObject(bindingsPath);
+  const sessions = readJsonObject(sessionsPath);
+  const byChat = new Map();
+  for (const [key, binding] of Object.entries(bindings)) {
+    if (!binding || typeof binding !== 'object') continue;
+    const id = readString(binding, 'id') || key;
+    const normalized = { ...binding, id };
+    const channelType = readString(normalized, 'channelType');
+    const chatId = readString(normalized, 'chatId');
+    const bridgeSessionId = readString(normalized, 'bridgeSessionId');
+    if (!channelType || !chatId || !bridgeSessionId) continue;
+    const chatKey = `${channelType}:${chatId}`;
+    byChat.set(chatKey, [...(byChat.get(chatKey) || []), normalized]);
+  }
+
+  const channelChats = {};
+  let sessionsChanged = 0;
+  let droppedBindings = 0;
+  let skippedInactiveBindings = 0;
+  for (const records of byChat.values()) {
+    const kept = chooseActiveBinding(records);
+    if (!kept) {
+      skippedInactiveBindings += records.length;
+      droppedBindings += records.length;
+      continue;
+    }
+    const inactiveCount = records.filter((record) => readBoolean(record, 'active') !== true).length;
+    skippedInactiveBindings += inactiveCount;
+    droppedBindings += records.length - 1;
+    const chat = toChannelChat(kept);
+    channelChats[chat.id] = chat;
+    const session = sessions[chat.bridgeSessionId];
+    if (session && typeof session === 'object' && migrateSessionFromBinding(session, kept)) {
+      sessionsChanged += 1;
+    }
+  }
+
+  const summary = {
+    codelarkHome: options.codelarkHome,
+    inputBindings: Object.keys(bindings).length,
+    outputChannelChats: Object.keys(channelChats).length,
+    droppedBindings,
+    skippedInactiveBindings,
+    sessionsChanged,
+    dryRun: options.dryRun,
+  };
+
+  if (!options.dryRun) {
+    atomicWriteJson(channelChatsPath, channelChats);
+    atomicWriteJson(sessionsPath, sessions);
+    fs.rmSync(bindingsPath, { force: true });
+  }
+
+  console.log(JSON.stringify(summary, null, 2));
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  console.error('');
+  console.error(usage());
+  process.exit(1);
+}