claude-code-hub 1.27.2 → 1.29.0

package/README.md

@@ -179,15 +179,19 @@ The shortcuts also work when focus is inside a tool. Kanban keeps <kbd>Ctrl</kbd
 --memory-port <n>       Memory Diagnoser port (default: 3544)
 --pool-size <n>         Config-dir sets kept running after a switch (default: 3)
 --disable-terminal      Turn off the embedded terminal in Kanban
+--no-mods               Load no mod (or "modsEnabled": false in config.json)
 --host <addr>           Bind address (default: 127.0.0.1)
 --allowed-hosts <list>  Extra host names to accept, comma-separated
 --open                  Open the browser on start
+--show-token            Print the URL with its token also when output is not a terminal
 --detached              Keep running when stdin closes (the macOS tray uses it)
 --tray                  Windows, macOS: run the hub from a tray icon
 --autostart             Windows, macOS: same as --tray, and start the tray at logon
 --no-autostart          Windows, macOS: stop starting the tray at logon
 --tray-status           Windows, macOS: show whether autostart is on and the tray and hub are running
 --app-id <id>           Windows, macOS, with --tray or --autostart: the installed app that Open Hub starts
+-v, --version           Print the version
+-h, --help              Print the flags
 ```
 
 If a port is busy, the hub uses a free port and reports it.

package/extensions/xmas/hub.css

@@ -0,0 +1,33 @@
+/* A hairline of holly, pine and gold along the top edge of the window. Drawn once, no animation. */
+body::before {
+  content: "";
+  position: fixed;
+  inset: 0 0 auto 0;
+  height: 2px;
+  z-index: 50;
+  pointer-events: none;
+  opacity: 0.7;
+  background: repeating-linear-gradient(
+    90deg,
+    #b5333c 0 18px,
+    transparent 18px 26px,
+    #3f6b55 26px 44px,
+    transparent 44px 52px,
+    #c9a45c 52px 58px,
+    transparent 58px 66px
+  );
+}
+
+:root[data-hub-mode="light"] body::before {
+  opacity: 0.55;
+}
+
+/* Above the app frames, below the hub's toasts and dialogs. */
+.xmas-snow {
+  position: fixed;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 12;
+  pointer-events: none;
+}

package/extensions/xmas/hub.js

@@ -0,0 +1,199 @@
+// Sparse snow over every tab. A canvas above the app frames that takes no clicks. It draws at
+// 30 fps at most, stops while the window is hidden, and never starts when the OS asks for less motion.
+(() => {
+  const motion = matchMedia('(prefers-reduced-motion: reduce)');
+  const canvas = Object.assign(document.createElement('canvas'), { className: 'xmas-snow', ariaHidden: 'true' });
+  const ctx = canvas.getContext('2d');
+  const rand = (a, b) => a + Math.random() * (b - a);
+
+  // Three depths: far flakes are small, slow and faint; near ones are larger, faster, and some are crystals.
+  const LAYERS = [
+    { share: 0.58, r: [0.5, 1.1], v: [7, 13], a: [0.18, 0.34], wind: 0.45 },
+    { share: 0.32, r: [1.1, 1.9], v: [15, 26], a: [0.32, 0.55], wind: 0.8 },
+    { share: 0.1, r: [2.2, 3.4], v: [30, 44], a: [0.45, 0.7], wind: 1.2, crystal: 0.5 },
+  ];
+
+  let w = 0;
+  let h = 0;
+  let frame = 0;
+  let last = 0;
+  let clock = rand(0, 1000);
+  let light = null;
+  let sprites = null;
+  let flakes = [];
+  let resizing = 0;
+  let base = 0;
+  let target = 0;
+  let level = 0;
+  let pace = 1;
+  const gust = { v: 0, target: 0, next: rand(6, 14) };
+
+  function sprite(size, draw) {
+    const c = document.createElement('canvas');
+    c.width = c.height = size;
+    const g = c.getContext('2d');
+    draw(g, size / 2);
+    return c;
+  }
+
+  function makeSprites() {
+    const ink = light ? '127,147,163' : '238,243,240';
+    const dot = sprite(16, (g, m) => {
+      const grad = g.createRadialGradient(m, m, 0, m, m, m);
+      grad.addColorStop(0, `rgba(${ink},1)`);
+      grad.addColorStop(0.45, `rgba(${ink},0.85)`);
+      grad.addColorStop(1, `rgba(${ink},0)`);
+      g.fillStyle = grad;
+      g.fillRect(0, 0, m * 2, m * 2);
+    });
+    const crystal = sprite(24, (g, m) => {
+      g.strokeStyle = `rgba(${ink},1)`;
+      g.lineWidth = 1;
+      g.lineCap = 'round';
+      g.translate(m, m);
+      for (let i = 0; i < 6; i++) {
+        g.rotate(Math.PI / 3);
+        g.beginPath();
+        g.moveTo(0, 0);
+        g.lineTo(0, -m + 2);
+        g.moveTo(0, -m * 0.5);
+        g.lineTo(-3, -m * 0.5 - 3);
+        g.moveTo(0, -m * 0.5);
+        g.lineTo(3, -m * 0.5 - 3);
+        g.stroke();
+      }
+    });
+    sprites = { dot, crystal };
+  }
+
+  function layerOf() {
+    let x = Math.random();
+    for (const l of LAYERS) if ((x -= l.share) <= 0) return l;
+    return LAYERS[0];
+  }
+
+  function flake(top) {
+    const l = layerOf();
+    return {
+      l,
+      x: rand(-20, w + 20),
+      y: top ? rand(-60, -8) : rand(0, h),
+      r: rand(...l.r),
+      v: rand(...l.v),
+      a: rand(...l.a),
+      crystal: Math.random() < (l.crystal ?? 0),
+      amp: rand(4, 14),
+      f1: rand(0.25, 0.9),
+      f2: rand(1.1, 2.3),
+      p1: rand(0, Math.PI * 2),
+      p2: rand(0, Math.PI * 2),
+      rot: rand(0, Math.PI),
+      spin: rand(-0.6, 0.6),
+    };
+  }
+
+  // The canvas stays at 1x on a HiDPI screen: soft dots look the same, and each frame clears and
+  // composites a quarter of the pixels.
+  function size() {
+    resizing = 0;
+    w = innerWidth;
+    h = innerHeight;
+    canvas.width = w;
+    canvas.height = h;
+    base = Math.round(Math.min(40, Math.max(18, (w * h) / 60000)));
+    while (flakes.length < base) flakes.push(flake(false));
+    retarget();
+  }
+
+  // Busy sessions add up to 80% more flakes. New ones start above the top edge, and spare ones
+  // leave only when they fall out at the bottom, so the change never pops.
+  function retarget() {
+    target = Math.round(base * (1 + level * 0.8));
+  }
+
+  // Wind is two slow waves plus a gust now and then, so the drift never settles into one pattern.
+  function wind(dt) {
+    gust.next -= dt;
+    if (gust.next <= 0) {
+      gust.target = gust.target ? 0 : rand(-22, 22);
+      gust.next = gust.target ? rand(2, 5) : rand(8, 20);
+    }
+    gust.v += (gust.target - gust.v) * Math.min(1, dt * 0.8);
+    return Math.sin(clock * 0.07) * 5 + Math.sin(clock * 0.023 + 1) * 8 + gust.v;
+  }
+
+  function draw(now) {
+    frame = requestAnimationFrame(draw);
+    const dt = Math.min((now - last) / 1000, 0.1);
+    if (dt < 1 / 30) return;
+    last = now;
+    clock += dt;
+    const isLight = document.documentElement.dataset.hubMode === 'light';
+    if (isLight !== light) {
+      light = isLight;
+      makeSprites();
+    }
+    const breeze = wind(dt);
+    pace += (1 + level * 0.45 - pace) * Math.min(1, dt * 0.3);
+    if (flakes.length < target) flakes.push(flake(true));
+    ctx.clearRect(0, 0, w, h);
+    for (let i = flakes.length - 1; i >= 0; i--) {
+      const f = flakes[i];
+      const sway = Math.sin(clock * f.f1 + f.p1) * f.amp + Math.sin(clock * f.f2 + f.p2) * f.amp * 0.3;
+      f.y += f.v * pace * dt;
+      f.x += (breeze * f.l.wind + sway) * dt;
+      if (f.x < -30) f.x += w + 60;
+      else if (f.x > w + 30) f.x -= w + 60;
+      if (f.y > h + 12) {
+        if (flakes.length > target) {
+          flakes.splice(i, 1);
+          continue;
+        }
+        Object.assign(f, flake(true));
+      }
+      ctx.globalAlpha = light ? f.a * 0.85 : f.a;
+      if (f.crystal) {
+        f.rot += f.spin * dt;
+        const s = f.r * 3.4;
+        ctx.save();
+        ctx.translate(f.x, f.y);
+        ctx.rotate(f.rot);
+        ctx.drawImage(sprites.crystal, -s, -s, s * 2, s * 2);
+        ctx.restore();
+      } else {
+        const s = f.r * 2.2;
+        ctx.drawImage(sprites.dot, f.x - s, f.y - s, s * 2, s * 2);
+      }
+    }
+  }
+
+  function start() {
+    if (frame || document.hidden || motion.matches) return;
+    last = performance.now();
+    frame = requestAnimationFrame(draw);
+  }
+
+  function stop() {
+    cancelAnimationFrame(frame);
+    frame = 0;
+  }
+
+  window.ClaudeHub?.mod.on('xmas:activity', ({ data }) => {
+    if (typeof data !== 'number') return;
+    level = Math.min(1, Math.max(0, data));
+    retarget();
+  });
+
+  size();
+  document.body.appendChild(canvas);
+  addEventListener('resize', () => {
+    resizing ||= requestAnimationFrame(size);
+  });
+  document.addEventListener('visibilitychange', () => (document.hidden ? stop() : start()));
+  motion.addEventListener('change', () => {
+    stop();
+    ctx.clearRect(0, 0, w, h);
+    start();
+  });
+  start();
+})();

package/extensions/xmas/kanban.css

@@ -0,0 +1,141 @@
+:root {
+  --xmas-red: #b5333c;
+  --xmas-pine: #3f6b55;
+  --xmas-gold: #c9a45c;
+  --xmas-trim: #f1ede4;
+}
+
+:root[data-hub-mode="light"] {
+  --xmas-trim: #d6cbb4;
+}
+
+/* A snowflake after a finished task's number, in the board's own muted ink. */
+[data-hub-part="task-card"].completed [data-hub-part="task-number"]::after {
+  content: "\2744";
+  margin-left: 6px;
+  color: var(--text-muted);
+  opacity: 0.75;
+  font-size: 11px;
+  line-height: 1;
+}
+
+[data-hub-part="task-card"].completed:hover [data-hub-part="task-number"]::after {
+  color: var(--accent-text);
+  opacity: 1;
+}
+
+/* A small gold star after the Completed title when every task is done. */
+[data-hub-part="board"].xmas-all-done [data-hub-part="done-title"]::after {
+  content: " \2605";
+  color: var(--xmas-gold);
+  letter-spacing: 0;
+}
+
+/* Fairy lights: the header bar is a wire of unlit bulbs, and the fill lights them in turn,
+   cranberry, gold, pine. The fill's width still comes from the board. */
+/* :root lifts it over the board's own two-class rule for the bar. */
+:root [data-hub-part="progress"] {
+  height: 8px;
+  border-radius: 0;
+  overflow: visible;
+  background:
+    radial-gradient(circle at 6px 4px, color-mix(in srgb, var(--text-muted) 35%, transparent) 1.6px, transparent 2.2px) 0 0 / 12px 8px repeat-x,
+    linear-gradient(var(--border), var(--border)) 0 50% / 100% 1px no-repeat;
+}
+
+[data-hub-part="progress"] [data-hub-part="progress-fill"] {
+  overflow: hidden;
+  background:
+    radial-gradient(circle at 6px 4px, #d24c55 2px, transparent 2.6px) 0 0 / 36px 8px repeat-x,
+    radial-gradient(circle at 18px 4px, #ddb865 2px, transparent 2.6px) 0 0 / 36px 8px repeat-x,
+    radial-gradient(circle at 30px 4px, #5c9a7a 2px, transparent 2.6px) 0 0 / 36px 8px repeat-x;
+  filter: drop-shadow(0 0 2px rgba(221, 184, 101, 0.55));
+}
+
+/* A few twinkles when the bar appears, not forever, so an idle board draws no frames. */
+@media (prefers-reduced-motion: no-preference) {
+  [data-hub-part="progress-fill"] {
+    animation: xmas-twinkle 5s ease-in-out 3;
+  }
+}
+
+@keyframes xmas-twinkle {
+  50% {
+    opacity: 0.78;
+  }
+}
+
+/* The open session's border is a thin garland, like the hub's top line. Diagonal stripes masked
+   to a ring put short dashes on all four sides and keep the card's rounded corners. */
+[data-hub-part="session-card"].active {
+  border-color: transparent;
+  box-shadow: 0 0 14px -8px rgba(221, 184, 101, 0.5);
+}
+
+[data-hub-part="session-card"].active::after {
+  content: "";
+  position: absolute;
+  inset: -1px;
+  padding: 1.5px;
+  border-radius: inherit;
+  pointer-events: none;
+  opacity: 0.7;
+  background: repeating-linear-gradient(
+    45deg,
+    var(--xmas-red) 0 9px,
+    transparent 9px 14px,
+    var(--xmas-pine) 14px 23px,
+    transparent 23px 28px,
+    var(--xmas-gold) 28px 37px,
+    transparent 37px 42px
+  );
+  -webkit-mask: linear-gradient(#000 0 0) content-box exclude, linear-gradient(#000 0 0);
+  mask: linear-gradient(#000 0 0) content-box exclude, linear-gradient(#000 0 0);
+}
+
+:root[data-hub-mode="light"] [data-hub-part="session-card"].active::after {
+  opacity: 0.6;
+}
+
+/* Days to Christmas, set by kanban.js. A pseudo-element, because the board rebuilds the footer's children. */
+[data-hub-part="sidebar-footer"] {
+  flex-wrap: wrap;
+  row-gap: 6px;
+}
+
+[data-hub-part="sidebar-footer"]::before {
+  content: var(--xmas-advent, none);
+  order: 1;
+  flex-basis: 100%;
+  color: var(--text-muted);
+  font-size: 10px;
+  white-space: nowrap;
+}
+
+/* The same hat on the footer's Kanbot, 1px per pixel: trim and pompom as gradient layers over
+   the red. CSS, because the board rebuilds the footer on each poll, which would drop added nodes. */
+[data-hub-part="sidebar-footer"] button:has(> [data-hub-part="kanbot"]) {
+  position: relative;
+}
+
+[data-hub-part="sidebar-footer"] button:has(> [data-hub-part="kanbot"])::before {
+  content: "";
+  position: absolute;
+  width: 10px;
+  height: 6px;
+  margin: -6px 0 0 3px;
+  pointer-events: none;
+  background:
+    linear-gradient(var(--xmas-trim) 0 0) 0 5px / 10px 1px,
+    linear-gradient(var(--xmas-trim) 0 0) 8px 0 / 2px 2px,
+    url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 10 6' shape-rendering='crispEdges'%3E%3Cpath fill='%23b5333c' d='M1 4h8v1H1zM2 3h6v1H2zM3 2h5v1H3zM5 1h3v1H5z'/%3E%3C/svg%3E");
+  background-repeat: no-repeat;
+}
+
+[data-hub-part="idle-mascot"] .xmas-hat-red {
+  fill: var(--xmas-red);
+}
+
+[data-hub-part="idle-mascot"] .xmas-hat-trim {
+  fill: var(--xmas-trim);
+}

package/extensions/xmas/kanban.js

@@ -0,0 +1,57 @@
+(() => {
+  const mod = window.ClaudeHub?.mod;
+  if (!mod) return;
+
+  mod.on('board.rendered', () => {
+    const board = document.querySelector('[data-hub-part="board"]');
+    if (!board) return;
+    const card = '[data-hub-part="task-card"]';
+    board.classList.toggle('xmas-all-done', !!board.querySelector(card) && !board.querySelector(`${card}:not(.completed)`));
+  });
+
+  // Santa hat in the mascot's own pixel grid (viewBox units), inside its svg so it floats with it.
+  const HAT = [
+    ['red', 4, -2, 10, 1],
+    ['red', 5, -3, 8, 1],
+    ['red', 7, -4, 6, 1],
+    ['red', 10, -5, 4, 1],
+    ['trim', 3, -1, 12, 1],
+    ['trim', 14, -6, 2, 2],
+  ];
+  const svg = document.querySelector('[data-hub-part="idle-mascot"] svg');
+  if (svg) {
+    const ns = 'http://www.w3.org/2000/svg';
+    const g = document.createElementNS(ns, 'g');
+    for (const [part, x, y, width, height] of HAT) {
+      const r = document.createElementNS(ns, 'rect');
+      for (const [k, v] of Object.entries({ x, y, width, height })) r.setAttribute(k, v);
+      r.setAttribute('class', `xmas-hat-${part}`);
+      g.append(r);
+    }
+    svg.append(g);
+  }
+
+  const footer = document.querySelector('[data-hub-part="sidebar-footer"]');
+  function advent() {
+    const now = new Date();
+    let xmas = new Date(now.getFullYear(), 11, 25);
+    if (now.getMonth() === 11 && now.getDate() > 26) xmas = new Date(now.getFullYear() + 1, 11, 25);
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const days = Math.round((xmas - today) / 86400000);
+    const text = days <= 0 ? '★ Merry Christmas' : `★ ${days} ${days === 1 ? 'day' : 'days'} to Christmas`;
+    footer?.style.setProperty('--xmas-advent', JSON.stringify(text));
+  }
+  advent();
+  setInterval(advent, 3600000);
+
+  // The hub's snow falls a little faster and thicker while sessions work. The level is a number
+  // from 0 to 1 and goes to the hub page only when it changes.
+  let level = -1;
+  mod.on('activity.rendered', (counts) => {
+    if (!counts) return;
+    const next = Math.min(counts.active, 4) / 4;
+    if (next === level) return;
+    level = next;
+    mod.send('xmas:activity', level);
+  });
+})();

package/extensions/xmas/mod.json

@@ -0,0 +1,57 @@
+{
+  "manifest": 1,
+  "kind": "mod",
+  "id": "xmas",
+  "title": "Christmas",
+  "themes": [
+    {
+      "id": "xmas",
+      "label": "Christmas",
+      "extends": "ember",
+      "dark": {
+        "ember": "#c8424a",
+        "emberGlow": "#d9b46a",
+        "emberDim": "rgba(200,66,74,0.22)",
+        "field": "#0f1513",
+        "surface": "#141b18",
+        "elevated": "#1a2320",
+        "hover": "#222d29",
+        "border": "#2a3631"
+      },
+      "light": {
+        "ember": "#a8323a",
+        "emberGlow": "#7d2329",
+        "emberDim": "rgba(168,50,58,0.14)",
+        "field": "#eceee9",
+        "surface": "#f2f3ef",
+        "elevated": "#fbfbf8",
+        "hover": "#d9ddd5",
+        "border": "#cdd3c9"
+      }
+    }
+  ],
+  "targets": {
+    "hub": { "surface": 1, "css": ["hub.css"], "js": ["hub.js"] },
+    "kanban": { "surface": 1, "css": ["kanban.css"], "js": ["kanban.js"] }
+  },
+  "listing": {
+    "tagline": "A quiet Christmas look for the hub and Kanban",
+    "description": "Pine and cranberry colors, light snow that falls faster while sessions work, fairy lights on the progress bar, a garland around the open session, a Santa hat on the mascot and a countdown to Christmas. It runs a little JS, so the install asks you first.",
+    "tags": ["theme", "seasonal", "mod"],
+    "screenshots": [
+      {
+        "url": "https://nikiforovall.blog/claude-code-hub/shots/extensions/xmas-demo.webp",
+        "alt": "Animation: the hub with the Christmas mod in dark mode. Snow falls over the board, a garland of red, green and gold dashes moves to each session the user opens, and the progress bar in the header twinkles as fairy lights. Then the same board in light mode",
+        "title": "Snow, lights and a garland",
+        "caption": "The garland follows the open session, and the snow falls faster while sessions work.",
+        "card": true
+      },
+      {
+        "url": "https://nikiforovall.blog/claude-code-hub/shots/extensions/xmas-hub-light.webp",
+        "alt": "The hub in light mode with the Christmas mod: a garland around the open session card, fairy lights on the header progress bar, a red and green dashed line at the top and grey snowflakes",
+        "title": "Light mode",
+        "caption": "Each part has its own light-mode colors."
+      }
+    ]
+  }
+}

package/lib/apps.js

@@ -311,6 +311,7 @@ function loadApp(app, { flagPort, hubRoot = HUB_ROOT, resolve = require.resolve,
   } catch {}
   return {
     id: app.id,
+    root,
     version,
     plugin: plugin && { id: plugin.id, bundled: plugin.bundled, install: plugin.install },
     entry: path.join(root, manifest.run.entry),

package/lib/cli.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { version: HUB_VERSION } = require('../package.json');
+
+// Every flag the hub reads, and whether it takes a value. `--<app id>-port` is open-ended, because
+// config.json can add apps.
+const FLAGS = {
+  port: true,
+  'hub-dir': true,
+  'pool-size': true,
+  'disable-terminal': false,
+  'no-mods': false,
+  host: true,
+  'allowed-hosts': true,
+  open: false,
+  'show-token': false,
+  detached: false,
+  install: false,
+  uninstall: false,
+  dir: true,
+  tray: false,
+  autostart: false,
+  'no-autostart': false,
+  'tray-status': false,
+  'app-id': true,
+  version: false,
+  help: false,
+};
+const SHORT = { '-v': 'version', '-h': 'help' };
+const APP_PORT_RE = /^[a-z0-9-]+-port$/;
+
+const HELP = `Claude Code Hub ${HUB_VERSION}
+
+Usage:
+  claude-code-hub [options]       Start the hub, or print the URL of the one that runs
+  claude-code-hub ext <command>   Manage extensions (claude-code-hub ext --help)
+
+Options:
+  --port <n>                      Hub port (default 3540)
+  --<app>-port <n>                Port of an app: kanban, marketplace, cost, memory
+  --hub-dir <path>                Hub dir (default ~/.claude-hub)
+  --pool-size <n>                 Config dirs kept running (default 3)
+  --disable-terminal              Turn off the embedded terminal in Kanban
+  --no-mods                       Start without mods
+  --host <addr>                   Bind address (default 127.0.0.1)
+  --allowed-hosts <list>          Extra host names to accept, comma-separated
+  --open                          Open the hub in the browser
+  --show-token                    Print the hub URL with its token also when output is not a terminal
+  --detached                      Keep running when stdin closes
+  --install, --uninstall          Install or remove the hub plugin (--dir <config dir>)
+  --tray, --autostart, --no-autostart, --tray-status, --app-id <id>
+                                  Tray and start at login (Windows and macOS)
+  -v, --version                   Print the version
+  -h, --help                      Print this help`;
+
+// {exit, out} when the command line is answered here: the version, the help, or a usage error.
+// {} when the hub should go on. `ext` keeps its own parser.
+function checkArgs(args) {
+  if (args[0] === 'ext') return {};
+  const bad = (what) => ({ exit: 1, out: `${what}\n\n${HELP}` });
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg.startsWith('-')) return bad(i === 0 ? `Unknown command: ${arg}` : `Unexpected argument: ${arg}`);
+    const [flag, value] = arg.startsWith('--') ? [arg.slice(2).split('=')[0], arg.includes('=')] : [SHORT[arg], false];
+    const takes = FLAGS[flag] ?? (APP_PORT_RE.test(flag ?? '') || undefined);
+    if (takes === undefined) return bad(`Unknown option: ${arg}`);
+    if (flag === 'version') return { exit: 0, out: HUB_VERSION };
+    if (flag === 'help') return { exit: 0, out: HELP };
+    if (takes && !value) i++;
+  }
+  return {};
+}
+
+// The hub URL as printed. Off a terminal (an agent's shell, a pipe, the tray's hub.log) the output is
+// kept or read by others, so the token is hidden unless --show-token asks for it.
+function printedUrl(line, url, { show, tokenFile }) {
+  if (show) return `${line} ${url}`;
+  const hidden = url.replace(/([?&]token=)[^&]*/, '$1<hidden>');
+  return `${line} ${hidden}\n  The token is hidden. Open the hub with --open, print it with --show-token, or read ${tokenFile}`;
+}
+
+module.exports = { HUB_VERSION, FLAGS, HELP, checkArgs, printedUrl };