npm - lazyclaw - Versions diffs - 3.99.4 → 3.99.6 - Mend

lazyclaw 3.99.4 → 3.99.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md CHANGED Viewed

@@ -71,7 +71,7 @@ What you see on launch (TTY only):
   │  | |__ _ _____  _ _          │
   │  | / _` |_ / || | '_|         │
   │  |_\__,_/__\_, |_|            │
-  │  LazyClaw  |__/  3.92.0      │
+  │  LazyClaw  |__/  3.99.6      │
   ╰──────────────────────────────╯
   provider · anthropic

package/cli.mjs CHANGED Viewed

@@ -877,6 +877,8 @@ const SUBCOMMANDS = [
   'rates',
   // OpenClaw-parity subsurfaces (v3.93–v3.98)
   'auth', 'pairing', 'nodes', 'message', 'workspace', 'browse', 'cron',
+  // v3.99.6 — multi-step setup wizard + lazyclaw-only dashboard
+  'setup', 'dashboard',
 ];
 const SUBCOMMAND_SUBS = {
@@ -1107,6 +1109,8 @@ const HELP_SUMMARIES = {
   workspace:  'AGENTS.md / SOUL.md / TOOLS.md system-prompt convention (workspace list|init|show|remove|path)',
   browse:     'Fetch a URL and emit Markdown on stdout (browse <url> [--max-bytes <N>])',
   cron:       'Schedule recurring agent runs via launchd / crontab (cron list|add|remove|show|sync|run)',
+  setup:      'OpenClaw-style multi-step first-run wizard (provider + workspace + skill + webhook + ping)',
+  dashboard:  'Launch the lazyclaw-only web UI (lighter than the full lazyclaude dashboard)',
   inspect:    'Print persisted workflow state without executing',
   clear:      'Delete a persisted workflow state file (idempotent)',
   validate:   'Static-check a workflow file: shape, deps, cycles, parallelism',
@@ -1144,6 +1148,8 @@ const HELP_DETAILS = {
   workspace: 'Usage: lazyclaw workspace <list | init <name> | show <name> [<file>] | remove <name> | path <name>>\n  Workspace = a directory under <configDir>/workspaces/<name>/ containing AGENTS.md, SOUL.md, TOOLS.md.\n  When `chat` or `agent` is invoked with --workspace <name>, the three files are stitched into a single system prompt at the head of the conversation. Missing files are skipped silently.\n  init scaffolds the three files with short stubs you replace.\n  show prints the composed prompt; show <name> AGENTS.md (etc) prints just one file.',
   browse: 'Usage: lazyclaw browse <url> [--max-bytes <N>] [--timeout-ms <N>] [--user-agent <ua>] [--meta]\n  Fetches the URL and emits Markdown on stdout. Pipes cleanly into `agent`:\n      lazyclaw browse https://example.com/docs | lazyclaw agent -\n  Strips <script>/<style>/<svg>/comments, prefers <main>/<article>, falls back to <body>.\n  --max-bytes caps the body read (default 2 MB) so a misconfigured upstream can\'t OOM the process.\n  --meta prints { url, title, bytes, truncated } as JSON to stderr alongside the markdown on stdout.',
   cron: 'Usage: lazyclaw cron <list | add <name> "<cron-spec>" -- <cmd> ... | remove <name> | show <name> | sync | run <name>>\n  Schedule recurring agent runs. macOS uses launchd (~/Library/LaunchAgents/com.lazyclaw.<name>.plist); Linux / WSL uses the user crontab.\n  Cron spec is the standard 5-field form (minute hour dom month dow). Supports *, range a-b, list a,b,c, step */N.\n  add: pass the command after `--`. Typical use:\n      lazyclaw cron add daily-summary "0 9 * * 1-5" -- lazyclaw agent "Summarise today\'s TODOs"\n  list / show: read from cfg.cron[name] (config is the source of truth).\n  sync: re-installs every job in cfg.cron into the system scheduler — handy after a reinstall.\n  run: one-shot in-process execution of the named job; the OS scheduler does the same thing on its trigger.\n  Logs: ~/.lazyclaw/logs/cron-<name>.{out,err}.log (macOS launchd path).',
+  setup: 'Usage: lazyclaw setup [--skip-test]\n  OpenClaw-style multi-step first-run wizard. Walks through:\n    1. Provider + model + api-key (delegates to onboard --pick)\n    2. Optional workspace init  (AGENTS.md / SOUL.md / TOOLS.md)\n    3. Optional skill bundle install from GitHub\n    4. Optional outbound webhook (Slack / Discord)\n    5. Reachability test against the picked provider\n  Each optional step takes Enter or "skip" to bypass. Re-runnable safely.\n  Also fires automatically on first run when `lazyclaw` is invoked with no config.',
+  dashboard: 'Usage: lazyclaw dashboard [--port <N>] [--no-open]\n  Launches the lazyclaw-only web UI on http://127.0.0.1:<port> (default 19600) and opens it in the default browser.\n  Wraps `lazyclaw daemon` + a static HTML; no Python / lazyclaude dashboard required.\n  Tabs: Chat · Sessions · Skills · Workspace · Providers · Status. Each tab calls existing daemon endpoints.\n  --no-open keeps the browser closed (handy for SSH / headless / dev). The bound URL is always printed to stdout.',
 };
 function cmdHelp(name) {
@@ -1394,20 +1400,58 @@ function _attachGhostAutocomplete(rl) {
 // session so users see the active provider/model before they start
 // typing. Plain ANSI; auto-skipped when stdout isn't a TTY (so piped
 // invocations stay clean for tests/scripts).
+// Single source of truth for the LazyClaw banner — used by the chat
+// REPL header, the no-arg launcher, and the first-run welcome panel.
+// Returns an array of pre-formatted lines (with ANSI colour) so the
+// caller can splice in additional rows without re-implementing the
+// alignment.
+//
+// Width-management rule: every inner line is forced through
+// `.padEnd(W)` so a stray width miscount can't punch the right
+// border off the box (which is exactly the bug v3.99.5 shipped:
+// two of the inner lines were 33 cols vs the others' 32, so the
+// ╮ rendered into the next line).
+function _renderBanner(version) {
+  const W = 30;
+  const accent = (s) => `\x1b[38;5;208m${s}\x1b[0m`;
+  const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
+  // Inner content of each banner row — DO NOT pad here, the wrapper
+  // does it. Backslashes are JS-escaped so each `\\` renders as one
+  // literal `\` in the output.
+  const inner = [
+    '   _',
+    '  | |__ _ _____  _ _',
+    "  | / _` |_ / || | '_|",
+    '  |_\\__,_/__\\_, |_|',
+    '  LazyClaw  |__/  ' + String(version || '?.?.?').padEnd(10).slice(0, 10),
+  ];
+  // Sleepy-cat mascot on the right, lined up with the busiest part
+  // of the wordmark. Three rows of ASCII art + "zz" trail. Plain
+  // ASCII (no box-drawing on the cat) so it lands well in any font.
+  const mascot = [
+    '',
+    '',
+    '   /\\_/\\',
+    '  ( -.- )  ' + dim('z z'),
+    '   > ^ <    ' + dim('z'),
+    '',
+    '',
+  ];
+  const banner = [
+    '╭' + '─'.repeat(W) + '╮',
+    ...inner.map((s) => '│' + s.padEnd(W).slice(0, W) + '│'),
+    '╰' + '─'.repeat(W) + '╯',
+  ];
+  return banner.map((l, i) => '  ' + accent(l) + (mascot[i] ? '  ' + mascot[i] : ''));
+}
 function _printChatBanner(activeProvName, activeModel, version) {
   if (!process.stdout.isTTY) return;
   const dim = (s) => `\x1b[2m${s}\x1b[0m`;
-  const accent = (s) => `\x1b[38;5;208m${s}\x1b[0m`;
   const ok = (s) => `\x1b[32m${s}\x1b[0m`;
   const lines = [
     '',
-    accent('  ╭──────────────────────────────╮'),
-    accent('  │   _                          │'),
-    accent('  │  | |__ _ _____  _ _          │'),
-    accent('  │  | / _` |_ / || | \'_|         │'),
-    accent('  │  |_\\__,_/__\\_, |_|            │'),
-    accent('  │  LazyClaw  |__/  ' + (version || '').padEnd(10) + '  │'),
-    accent('  ╰──────────────────────────────╯'),
+    ..._renderBanner(version),
     '',
     `  ${dim('provider ·')} ${ok(activeProvName)}`,
     `  ${dim('model    ·')} ${ok(activeModel || '(default)')}`,
@@ -1457,10 +1501,10 @@ async function _pickProviderInteractive() {
     });
     return { provider: ans || providers[0], model: null };
   }
-  // Default cursor: prefer claude-cli (subscription, no key) so first-
-  // time users with Claude Code already installed don't have to scroll.
-  let idx = items.findIndex(it => it.provider === 'claude-cli');
-  if (idx < 0) idx = 0;
+  // Default cursor: lands on item 0 (= the first row from PROVIDERS
+  // insertion order, which registry.mjs deliberately curates as the
+  // most user-familiar vendor — gemini at the time of writing).
+  let idx = 0;
   const readline = await import('node:readline');
   readline.emitKeypressEvents(process.stdin);
@@ -1855,6 +1899,69 @@ async function cmdChat(flags = {}) {
   }
 }
+// Light wrapper around the daemon — meant for users who installed
+// via npm and don't want to remember `daemon` flags. Boots the
+// daemon on a fixed default port (override with --port), then opens
+// the dashboard URL in the user's default browser.
+//
+// Why a separate command: typing `lazyclaw daemon` works too, but
+// `dashboard` is the discoverable name and it auto-opens the browser
+// (which the bare daemon doesn't, since most daemon callers are
+// scripts).
+async function cmdDashboard(flags = {}) {
+  await ensureRegistry();
+  const sessionsMod = await import('./sessions.mjs');
+  const { startDaemon } = await import('./daemon.mjs');
+  const port = flags.port !== undefined ? parseInt(flags.port, 10) : 19600;
+  const cfgDir = path.dirname(configPath());
+  const d = await startDaemon({
+    port,
+    once: false,
+    readConfig,
+    sessionsDirGetter: () => cfgDir,
+    sessionsMod,
+    version: () => readVersionFromRepo(),
+    workflowStateDir: () => process.env.LAZYCLAW_WORKFLOW_STATE_DIR || '.workflow-state',
+    // No auth token by default — same loopback-only assumption the
+    // bare daemon uses. Users who want to expose the dashboard set
+    // LAZYCLAW_AUTH_TOKEN + --allow-origin via the daemon command.
+    authToken: undefined,
+    allowedOrigins: [],
+    rateLimit: null,
+    responseCache: null,
+    logger: null,
+    costCap: null,
+  });
+  const url = `http://127.0.0.1:${d.port}/dashboard`;
+  process.stdout.write(`🦞 LazyClaw dashboard listening at ${url}\n`);
+  if (!flags['no-open']) {
+    // macOS uses `open`; Linux generally `xdg-open`; Windows
+    // `cmd /c start`. Detect by platform; bail silently if the
+    // helper fails — the URL is already on stdout for fallback.
+    const { spawn } = await import('node:child_process');
+    let cmd, args;
+    if (process.platform === 'darwin')      { cmd = 'open';      args = [url]; }
+    else if (process.platform === 'win32')  { cmd = 'cmd';       args = ['/c', 'start', '""', url]; }
+    else                                    { cmd = 'xdg-open';  args = [url]; }
+    try {
+      spawn(cmd, args, { stdio: 'ignore', detached: true }).unref();
+    } catch (_) { /* user can click the URL above */ }
+  }
+  // Forward SIGINT/SIGTERM to a graceful shutdown so Ctrl-C doesn't
+  // strand a port-bound server. Same shape cmdDaemon uses.
+  const { gracefulShutdown } = await import('./daemon.mjs');
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) return process.exit(1);
+    shuttingDown = true;
+    process.stdout.write('\n  shutting down…\n');
+    const result = await gracefulShutdown(d.server, 5_000);
+    process.exit(result.forced ? 1 : 0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
 async function cmdDaemon(flags) {
   await ensureRegistry();
   const sessionsMod = await import('./sessions.mjs');
@@ -3082,10 +3189,199 @@ function parseArgs(argv) {
 // so chat / agent / etc. behave bit-identically to typing them
 // directly. Non-TTY (piped, scripted) callers still see the
 // classic "Usage: …" line so automation isn't surprised.
-async function cmdLauncher() {
+// Multi-step setup wizard — OpenClaw-style first-run experience.
+// Provider/model/key + optional workspace + optional sample skill
+// + reachability ping. Each step can be skipped (Enter on prompt /
+// "n" on yes-no). Re-runnable safely: existing state is reused, not
+// clobbered, except when the user explicitly opts in.
+//
+// `lazyclaw setup` exposes this directly so users can re-run the
+// wizard any time. The first-run code path also funnels through it
+// so a fresh install sees the same flow whether they typed
+// `lazyclaw` or `lazyclaw setup`.
+async function cmdSetup(_sub, _positional, flags = {}) {
   await ensureRegistry();
+  const accent = (s) => `\x1b[38;5;208m${s}\x1b[0m`;
+  const bold   = (s) => `\x1b[1m${s}\x1b[0m`;
+  const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
+  const ok     = (s) => `\x1b[32m${s}\x1b[0m`;
+  const warn   = (s) => `\x1b[33m${s}\x1b[0m`;
+  // Header.
+  if (process.stdout.isTTY) process.stdout.write('\x1b[2J\x1b[H');
+  _renderBanner(readVersionFromRepo()).forEach((l) => process.stdout.write(l + '\n'));
+  process.stdout.write('\n');
+  process.stdout.write(`  ${bold('🔧 Setup wizard')}\n`);
+  process.stdout.write(`  ${dim('Five short steps. Press Enter to accept the default; type "skip" or "n" to bypass an optional step.')}\n\n`);
   const cfg = readConfig();
-  const provider = cfg.provider || '(unset — pick during onboard)';
+  const cfgDir = path.dirname(configPath());
+  // ── Step 1: Provider + model (mandatory) ────────────────────
+  process.stdout.write(`  ${accent('Step 1/5 ·')} ${bold('Pick a provider + model')}\n`);
+  process.stdout.write(`  ${dim('Opens the arrow-key picker. The list leads with gemini / openai / claude-cli — pick the one you have an account or login for.')}\n\n`);
+  await _quickPrompt('  ▶ press Enter to open the picker ');
+  try {
+    await cmdOnboard({ pick: true });
+  } catch (e) {
+    process.stderr.write(`onboard error: ${e?.message || e}\n`);
+    process.exit(1);
+  }
+  // Re-read config after onboard wrote it. If the user aborted with
+  // no provider set, bail out early — the rest of the wizard depends
+  // on a provider being configured.
+  const cfgAfterOnboard = readConfig();
+  if (!cfgAfterOnboard.provider) {
+    process.stdout.write(`\n  ${warn('Setup aborted — no provider configured. Run `lazyclaw setup` again when ready.')}\n\n`);
+    process.exit(0);
+  }
+  process.stdout.write(`\n  ${ok('✓ provider:')} ${cfgAfterOnboard.provider}  ${dim('model:')} ${cfgAfterOnboard.model || '(default)'}\n\n`);
+  // ── Step 2: Optional workspace ──────────────────────────────
+  process.stdout.write(`  ${accent('Step 2/5 ·')} ${bold('Initialise a workspace?')} ${dim('(optional)')}\n`);
+  process.stdout.write(`  ${dim('A workspace is a folder of AGENTS.md / SOUL.md / TOOLS.md prompt files that auto-inject into chat / agent. Skip if you don\'t need project-specific personas yet.')}\n\n`);
+  const wsName = (await _quickPrompt('  workspace name (Enter to skip): ')).trim();
+  if (wsName && /^[A-Za-z0-9_.-]+$/.test(wsName)) {
+    try {
+      const ws = await import('./workspace.mjs');
+      const dir = ws.initWorkspace(cfgDir, wsName);
+      process.stdout.write(`  ${ok('✓ workspace created:')} ${dir}\n`);
+      process.stdout.write(`  ${dim('Edit AGENTS.md / SOUL.md / TOOLS.md any time. Use with: lazyclaw chat --workspace ' + wsName)}\n\n`);
+    } catch (e) {
+      process.stdout.write(`  ${warn('skipped:')} ${e?.message || e}\n\n`);
+    }
+  } else if (wsName) {
+    process.stdout.write(`  ${warn('skipped:')} workspace name must match [A-Za-z0-9_.-]+\n\n`);
+  } else {
+    process.stdout.write(`  ${dim('— skipped —')}\n\n`);
+  }
+  // ── Step 3: Optional skill bundle install ───────────────────
+  process.stdout.write(`  ${accent('Step 3/5 ·')} ${bold('Install a skill bundle from GitHub?')} ${dim('(optional)')}\n`);
+  process.stdout.write(`  ${dim('Format: <user>/<repo>[@<ref>]. Skills are .md prompt fragments that compose into the system prompt via --skill.')}\n\n`);
+  const skillSpec = (await _quickPrompt('  github spec (Enter to skip): ')).trim();
+  if (skillSpec) {
+    try {
+      const inst = await import('./skills_install.mjs');
+      const r = await inst.installFromGithub(skillSpec, cfgDir, { force: false });
+      process.stdout.write(`  ${ok('✓ installed')} ${r.installed.length} ${dim('skill(s) from')} ${skillSpec}\n`);
+      r.installed.forEach((s) => process.stdout.write(`    · ${s.name} ${dim(`(${s.bytes} bytes)`)}\n`));
+      if (r.skipped.length) {
+        process.stdout.write(`  ${dim('skipped (already installed):')} ${r.skipped.map((s) => s.name).join(', ')}\n`);
+      }
+      process.stdout.write('\n');
+    } catch (e) {
+      process.stdout.write(`  ${warn('skipped:')} ${e?.message || e}\n\n`);
+    }
+  } else {
+    process.stdout.write(`  ${dim('— skipped —')}\n\n`);
+  }
+  // ── Step 4: Optional outbound webhook ───────────────────────
+  process.stdout.write(`  ${accent('Step 4/5 ·')} ${bold('Add an outbound webhook?')} ${dim('(optional)')}\n`);
+  process.stdout.write(`  ${dim('Use with: lazyclaw message send <name> <text>. Slack / Discord Incoming Webhook URLs work as-is.')}\n\n`);
+  const hookName = (await _quickPrompt('  webhook name (Enter to skip): ')).trim();
+  if (hookName) {
+    const hookUrl = (await _quickPrompt('  webhook URL: ')).trim();
+    if (!hookUrl) {
+      process.stdout.write(`  ${warn('skipped:')} URL required\n\n`);
+    } else {
+      try {
+        const cf = await import('./config_features.mjs');
+        const fresh = readConfig();
+        cf.messageAdd(fresh, hookName, hookUrl);
+        writeConfig(fresh);
+        process.stdout.write(`  ${ok('✓ webhook saved:')} ${hookName}\n\n`);
+      } catch (e) {
+        process.stdout.write(`  ${warn('skipped:')} ${e?.message || e}\n\n`);
+      }
+    }
+  } else {
+    process.stdout.write(`  ${dim('— skipped —')}\n\n`);
+  }
+  // ── Step 5: Reachability check ──────────────────────────────
+  process.stdout.write(`  ${accent('Step 5/5 ·')} ${bold('Verify the picked provider responds')}\n`);
+  process.stdout.write(`  ${dim('Sends a 1-token "ping" via `lazyclaw providers test`. Confirms your key / subscription / local daemon is wired up.')}\n\n`);
+  const wantPing = !flags['skip-test'] && (await _quickPrompt('  test now? [Y/n] ')).trim().toLowerCase() !== 'n';
+  if (wantPing) {
+    try {
+      // Reuse the existing providers-test path so behaviour matches
+      // a manual `lazyclaw providers test`.
+      await cmdProviders('test', [cfgAfterOnboard.provider], {});
+    } catch (e) {
+      process.stdout.write(`  ${warn('test errored:')} ${e?.message || e}\n`);
+      process.stdout.write(`  ${dim('Setup still completed; you can retry with:')} lazyclaw providers test ${cfgAfterOnboard.provider}\n`);
+    }
+  } else {
+    process.stdout.write(`  ${dim('— skipped —')}\n`);
+  }
+  // ── Wrap up ─────────────────────────────────────────────────
+  process.stdout.write('\n');
+  process.stdout.write(`  ${ok(bold('🎉 Setup complete.'))}\n`);
+  process.stdout.write(`  ${dim('Run')} ${bold('lazyclaw')} ${dim('any time to open the menu, or jump in directly:')}\n`);
+  process.stdout.write(`    ${dim('•')} lazyclaw chat                ${dim('— REPL with the configured provider')}\n`);
+  process.stdout.write(`    ${dim('•')} lazyclaw agent "..."          ${dim('— one-shot prompt')}\n`);
+  process.stdout.write(`    ${dim('•')} lazyclaw doctor              ${dim('— diagnostic JSON')}\n`);
+  process.stdout.write(`    ${dim('•')} lazyclaw setup               ${dim('— re-run this wizard any time')}\n\n`);
+}
+// First-run welcome panel + delegated onboard. Drawn once before the
+// main launcher menu when the config has no provider yet. Walks the
+// user through the same arrow-key picker that `lazyclaw onboard`
+// uses; on success the launcher continues, on cancel the launcher
+// exits politely instead of dropping into a menu where every option
+// would error.
+async function _runFirstTimeOnboard() {
+  const accent = (s) => `\x1b[38;5;208m${s}\x1b[0m`;
+  const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
+  const bold   = (s) => `\x1b[1m${s}\x1b[0m`;
+  process.stdout.write('\x1b[2J\x1b[H');
+  _renderBanner(readVersionFromRepo()).forEach((l) => process.stdout.write(l + '\n'));
+  process.stdout.write('\n');
+  process.stdout.write(`  ${bold('👋 Welcome — first-time setup')}\n\n`);
+  process.stdout.write(`  ${dim('No provider configured yet at')} ${configPath()}\n`);
+  process.stdout.write(`  ${dim('Pick a provider + model below; LazyClaw stores it in ~/.lazyclaw/config.json.')}\n\n`);
+  process.stdout.write(`  ${dim('Quick rule of thumb:')}\n`);
+  process.stdout.write(`  ${dim('  · gemini / openai / anthropic — need an API key (sk-... / paste during setup)')}\n`);
+  process.stdout.write(`  ${dim('  · claude-cli / ollama          — keyless (use your existing Claude Code login or local Ollama)')}\n`);
+  process.stdout.write(`  ${dim('  · mock                         — offline echo, only useful for testing')}\n\n`);
+  process.stdout.write(`  ${dim('Press Enter to open the picker · Ctrl+C to abort.')}\n`);
+  await _quickPrompt('  ▶ ');
+  // Delegate to the real onboard flow with --pick so the picker UI
+  // fires regardless of how this entry point was reached. cmdOnboard
+  // owns config writing.
+  try {
+    await cmdOnboard({ pick: true });
+  } catch (e) {
+    process.stderr.write(`onboard error: ${e?.message || e}\n`);
+  }
+  process.stdout.write('\n');
+}
+async function cmdLauncher() {
+  await ensureRegistry();
+  let cfg = readConfig();
+  // First-run guard: a fresh install has no `provider` set, so any
+  // menu pick that calls a provider (Chat / Agent / Doctor / etc.)
+  // would error halfway through with a confusing "missing api key"
+  // or "unknown provider". Detect that state up front and walk the
+  // user through onboard before showing the menu — once they've
+  // picked, re-read the config and continue normally.
+  if (!cfg.provider) {
+    // Delegate to the full setup wizard rather than the bare onboard
+    // picker — first-time users benefit from the workspace / skill /
+    // ping steps too. cmdSetup exits the process on abort, so the
+    // re-read below only fires when the wizard completed successfully.
+    await cmdSetup(undefined, [], {});
+    cfg = readConfig();
+    if (!cfg.provider) {
+      process.stdout.write('\n  Setup not completed — exiting.\n  Run `lazyclaw setup` when ready, then try `lazyclaw` again.\n\n');
+      process.exit(0);
+    }
+  }
+  const provider = cfg.provider;
   const model = cfg.model || '(default)';
   const items = [
     { id: 'chat',      label: 'Chat',          desc: 'interactive REPL with the configured provider', argv: ['chat'] },
@@ -3118,16 +3414,7 @@ async function cmdLauncher() {
   const draw = () => {
     process.stdout.write('\x1b[?25l\x1b[2J\x1b[H'); // hide cursor + clear
-    const banner = [
-      accent('  ╭──────────────────────────────╮'),
-      accent('  │   _                          │'),
-      accent('  │  | |__ _ _____  _ _          │'),
-      accent('  │  | / _` |_ / || | \'_|         │'),
-      accent('  │  |_\\__,_/__\\_, |_|            │'),
-      accent('  │  LazyClaw  |__/  ' + (readVersionFromRepo() || '').padEnd(10) + '  │'),
-      accent('  ╰──────────────────────────────╯'),
-    ];
-    banner.forEach((l) => process.stdout.write(l + '\n'));
+    _renderBanner(readVersionFromRepo()).forEach((l) => process.stdout.write(l + '\n'));
     process.stdout.write('\n');
     const provDisplay = provider === '(unset — pick during onboard)'
       ? warn(provider)
@@ -3385,6 +3672,14 @@ async function main() {
       await cmdCron(sub, rest.positional.slice(1), rest.flags);
       break;
     }
+    case 'setup': {
+      await cmdSetup(undefined, rest.positional, rest.flags);
+      break;
+    }
+    case 'dashboard': {
+      await cmdDashboard(rest.flags);
+      break;
+    }
     case 'daemon': {
       await cmdDaemon(rest.flags);
       break;

package/daemon.mjs CHANGED Viewed

@@ -378,6 +378,34 @@ export function makeHandler(ctx) {
       const workflowMatch = url.pathname.match(/^\/workflows\/([^/]+)$/);
       const configKeyMatch = url.pathname.match(/^\/config\/([^/]+)$/);
       switch (true) {
+        case route === 'GET /' || route === 'GET /dashboard': {
+          // Serve the lazyclaw-only web dashboard (a single static
+          // HTML in src/lazyclaw/web/). Co-resident with the JSON
+          // API so a single port handles both — no CORS song and
+          // dance, no separate static server. Falls back to a
+          // helpful text response when the file is missing (someone
+          // ran the daemon out of a partial install).
+          try {
+            const fs = await import('node:fs');
+            const path = await import('node:path');
+            const url = await import('node:url');
+            const here = path.dirname(url.fileURLToPath(import.meta.url));
+            const htmlPath = path.join(here, 'web', 'dashboard.html');
+            const body = fs.readFileSync(htmlPath, 'utf8');
+            res.writeHead(200, {
+              'content-type': 'text/html; charset=utf-8',
+              'cache-control': 'no-cache',
+            });
+            return res.end(body);
+          } catch (e) {
+            res.writeHead(503, { 'content-type': 'text/plain; charset=utf-8' });
+            return res.end(
+              `lazyclaw daemon is up but the dashboard HTML wasn't found.\n` +
+              `Try \`lazyclaw version\` to confirm install integrity, or hit any /api endpoint directly.\n\n` +
+              `error: ${e?.message || e}\n`,
+            );
+          }
+        }
         case route === 'GET /version':
           return writeJson(res, 200, { version: ctx.version(), nodeVersion: process.version, platform: `${process.platform}-${process.arch}` });
         case route === 'GET /health':

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "3.99.4",
+  "version": "3.99.6",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama and orchestrating multi-step LLM workflows. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",

package/providers/registry.mjs CHANGED Viewed

@@ -50,15 +50,20 @@ export const mockProvider = {
 export { anthropicProvider, openaiProvider, ollamaProvider, geminiProvider, claudeCliProvider };
+// Insertion order is the picker order. The list goes first-to-last in
+// rough "user-familiar / popular" order so a first-time onboard lands
+// the cursor on a vendor most users recognise. v3.99.5 reordered per
+// user feedback ("gemini, codex 이런거 먼저 나오게끔").
 export const PROVIDERS = {
-  mock: mockProvider,
-  // claude-cli (subscription-backed, no API key) listed before
-  // anthropic so first-time onboarding surfaces it as the default.
+  // Tier 1 — popular / brand-name vendors users come in looking for.
+  gemini: geminiProvider,
+  openai: openaiProvider,        // surfaces gpt-5-codex / gpt-5 / o3-pro etc.
+  // Tier 2 — Claude. CLI variant first because it's keyless.
   'claude-cli': claudeCliProvider,
   anthropic: anthropicProvider,
-  openai: openaiProvider,
-  gemini: geminiProvider,
+  // Tier 3 — local + dev/test.
   ollama: ollamaProvider,
+  mock: mockProvider,
 };
 // Static metadata for `lazyclaw providers list/info`. Kept next to PROVIDERS

package/web/dashboard.html ADDED Viewed

@@ -0,0 +1,459 @@
+<!doctype html>
+<!--
+  lazyclaw dashboard — a single-file SPA served by `lazyclaw daemon`.
+  Deliberately framework-free: vanilla DOM, vanilla fetch, no build
+  step. The full lazyclaude dashboard is gigantic; this is the
+  lazyclaw-only slice (chat / sessions / skills / providers /
+  status), aimed at users who installed via `npm i -g lazyclaw` and
+  don't want to clone the whole monorepo just to see a UI.
+-->
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>LazyClaw</title>
+  <style>
+    :root {
+      --bg: #0a0a0a;
+      --card: #14141c;
+      --border: #2a2a36;
+      --text: #e8e8ea;
+      --dim: #a8a8b8;
+      --accent: #d97757;
+      --ok: #4ade80;
+      --warn: #f59e0b;
+      --err: #ef4444;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font: 14px/1.5 -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      min-height: 100vh;
+      display: flex;
+      flex-direction: column;
+    }
+    header {
+      padding: 14px 22px;
+      border-bottom: 1px solid var(--border);
+      display: flex;
+      align-items: center;
+      gap: 14px;
+    }
+    .logo { font-weight: 700; font-size: 16px; color: var(--accent); }
+    .ver  { color: var(--dim); font-size: 11px; }
+    nav.tabs {
+      display: flex;
+      gap: 2px;
+      padding: 0 14px;
+      border-bottom: 1px solid var(--border);
+      overflow-x: auto;
+    }
+    nav.tabs button {
+      background: none;
+      border: 0;
+      color: var(--dim);
+      padding: 12px 16px;
+      cursor: pointer;
+      font-size: 13px;
+      border-bottom: 2px solid transparent;
+      white-space: nowrap;
+    }
+    nav.tabs button:hover { color: var(--text); }
+    nav.tabs button.active {
+      color: var(--accent);
+      border-bottom-color: var(--accent);
+    }
+    main {
+      flex: 1;
+      padding: 22px;
+      overflow-y: auto;
+    }
+    section { display: none; }
+    section.active { display: block; }
+    h2 { margin: 0 0 14px; font-size: 18px; }
+    .card {
+      background: var(--card);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 14px 16px;
+      margin-bottom: 12px;
+    }
+    .row { display: flex; align-items: center; gap: 12px; padding: 6px 0; }
+    .row + .row { border-top: 1px solid var(--border); }
+    .name { font-weight: 600; }
+    .dim { color: var(--dim); font-size: 12px; }
+    button.btn {
+      background: var(--accent);
+      color: #fff;
+      border: 0;
+      border-radius: 6px;
+      padding: 8px 14px;
+      cursor: pointer;
+      font-size: 13px;
+      font-weight: 500;
+    }
+    button.btn:hover { filter: brightness(1.1); }
+    button.btn-secondary {
+      background: transparent;
+      border: 1px solid var(--border);
+      color: var(--text);
+    }
+    button.btn-secondary:hover { border-color: var(--accent); color: var(--accent); }
+    .empty { color: var(--dim); padding: 24px; text-align: center; font-style: italic; }
+    pre {
+      background: #06060c;
+      padding: 12px 14px;
+      border-radius: 6px;
+      overflow-x: auto;
+      font-size: 12px;
+      color: #cfcfd6;
+      border: 1px solid var(--border);
+    }
+    /* Chat */
+    #chat-stream {
+      background: var(--card);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 12px;
+      height: 50vh;
+      overflow-y: auto;
+      display: flex;
+      flex-direction: column;
+      gap: 14px;
+    }
+    .msg { padding: 8px 12px; border-radius: 6px; max-width: 90%; white-space: pre-wrap; word-wrap: break-word; }
+    .msg.user { align-self: flex-end; background: rgba(217, 119, 87, 0.15); border: 1px solid rgba(217, 119, 87, 0.3); }
+    .msg.assistant { align-self: flex-start; background: rgba(74, 222, 128, 0.06); border: 1px solid rgba(74, 222, 128, 0.18); }
+    .msg.error { align-self: stretch; background: rgba(239, 68, 68, 0.12); border: 1px solid rgba(239, 68, 68, 0.3); color: #ffd3d3; }
+    .input-row {
+      display: flex;
+      gap: 8px;
+      margin-top: 12px;
+    }
+    .input-row textarea {
+      flex: 1;
+      background: var(--card);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      padding: 10px 12px;
+      color: var(--text);
+      resize: vertical;
+      min-height: 60px;
+      font: inherit;
+    }
+    .pill {
+      display: inline-block;
+      padding: 2px 8px;
+      border-radius: 999px;
+      font-size: 10px;
+      background: var(--border);
+      color: var(--dim);
+      margin-left: 6px;
+    }
+    .pill.ok  { background: rgba(74, 222, 128, 0.15); color: var(--ok); }
+    .pill.warn { background: rgba(245, 158, 11, 0.15); color: var(--warn); }
+    .pill.err  { background: rgba(239, 68, 68, 0.15); color: var(--err); }
+    .toolbar { display: flex; align-items: center; gap: 8px; margin-bottom: 12px; }
+    .toolbar select {
+      background: var(--card);
+      border: 1px solid var(--border);
+      color: var(--text);
+      padding: 6px 10px;
+      border-radius: 6px;
+      font: inherit;
+    }
+    footer {
+      padding: 10px 22px;
+      border-top: 1px solid var(--border);
+      color: var(--dim);
+      font-size: 11px;
+      display: flex;
+      justify-content: space-between;
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div class="logo">🦞 LazyClaw</div>
+    <div class="ver" id="version">…</div>
+  </header>
+  <nav class="tabs">
+    <button data-tab="chat" class="active">Chat</button>
+    <button data-tab="sessions">Sessions</button>
+    <button data-tab="skills">Skills</button>
+    <button data-tab="providers">Providers</button>
+    <button data-tab="status">Status</button>
+  </nav>
+  <main>
+    <section id="tab-chat" class="active">
+      <h2>Chat</h2>
+      <div class="toolbar">
+        <select id="chat-assignee"><option value="">(loading…)</option></select>
+        <button class="btn btn-secondary" onclick="resetChat()">Clear</button>
+        <span class="dim" id="chat-meta"></span>
+      </div>
+      <div id="chat-stream"><div class="empty">Type below to start.</div></div>
+      <div class="input-row">
+        <textarea id="chat-input" placeholder="Send a message — Enter to send, Shift+Enter for newline."></textarea>
+        <button class="btn" onclick="sendChat()">Send</button>
+      </div>
+    </section>
+    <section id="tab-sessions">
+      <h2>Sessions</h2>
+      <div id="sessions-list"><div class="empty">Loading…</div></div>
+    </section>
+    <section id="tab-skills">
+      <h2>Skills</h2>
+      <div id="skills-list"><div class="empty">Loading…</div></div>
+    </section>
+    <section id="tab-providers">
+      <h2>Providers</h2>
+      <div id="providers-list"><div class="empty">Loading…</div></div>
+    </section>
+    <section id="tab-status">
+      <h2>Status</h2>
+      <div id="status-card"><div class="empty">Loading…</div></div>
+    </section>
+  </main>
+  <footer>
+    <span>lazyclaw dashboard</span>
+    <span id="footer-url"></span>
+  </footer>
+  <script>
+    // Tab switching ────────────────────────────────────────────────
+    const tabs = document.querySelectorAll('nav.tabs button');
+    const sections = document.querySelectorAll('main section');
+    tabs.forEach((b) => b.addEventListener('click', () => {
+      tabs.forEach((x) => x.classList.toggle('active', x === b));
+      sections.forEach((s) => s.classList.toggle('active', s.id === 'tab-' + b.dataset.tab));
+      const loader = LOADERS[b.dataset.tab];
+      if (loader) loader();
+    }));
+    document.getElementById('footer-url').textContent = location.href;
+    // Tiny fetch helper that surfaces errors as toasts on the page.
+    async function api(path, opts = {}) {
+      const r = await fetch(path, opts);
+      if (!r.ok && r.status !== 200) {
+        let body = '';
+        try { body = JSON.stringify(await r.json()); } catch {}
+        throw new Error(`${r.status} ${r.statusText}${body ? ' — ' + body : ''}`);
+      }
+      return r.json();
+    }
+    // ── Status / version (always shown in header) ────────────────
+    api('/version').then((v) => {
+      document.getElementById('version').textContent = `v${v.version}`;
+    }).catch(() => {});
+    // ── Loaders per tab ──────────────────────────────────────────
+    const LOADERS = {};
+    LOADERS.chat = async function loadChat() {
+      try {
+        const r = await api('/providers');
+        const sel = document.getElementById('chat-assignee');
+        sel.innerHTML = '';
+        for (const p of r.providers || []) {
+          const ms = (p.suggestedModels || []);
+          if (!ms.length) {
+            const opt = document.createElement('option');
+            opt.value = p.name; opt.textContent = p.name;
+            sel.appendChild(opt);
+            continue;
+          }
+          for (const m of ms.slice(0, 6)) {
+            const opt = document.createElement('option');
+            opt.value = `${p.name}:${m}`;
+            opt.textContent = `${p.name}  ·  ${m}`;
+            sel.appendChild(opt);
+          }
+        }
+      } catch (e) {
+        document.getElementById('chat-meta').textContent = '⚠ ' + e.message;
+      }
+    };
+    LOADERS.sessions = async function loadSessions() {
+      const root = document.getElementById('sessions-list');
+      root.innerHTML = '<div class="empty">Loading…</div>';
+      try {
+        const r = await api('/sessions');
+        const arr = r.sessions || r;
+        if (!Array.isArray(arr) || arr.length === 0) {
+          root.innerHTML = '<div class="empty">No persisted sessions yet. Start one with <code>lazyclaw chat --session &lt;id&gt;</code>.</div>';
+          return;
+        }
+        root.innerHTML = '';
+        arr.forEach((s) => {
+          const div = document.createElement('div');
+          div.className = 'card row';
+          const id = s.id || s.sessionId || s.name || JSON.stringify(s);
+          const turns = s.turns ?? s.turnCount ?? '';
+          const updated = s.updatedAt || s.mtime || '';
+          div.innerHTML = `<div class="name">${id}</div>
+            <div class="dim">${turns ? turns + ' turns' : ''}</div>
+            <div class="dim" style="margin-left:auto;">${updated}</div>`;
+          root.appendChild(div);
+        });
+      } catch (e) {
+        root.innerHTML = `<div class="empty">⚠ ${e.message}</div>`;
+      }
+    };
+    LOADERS.skills = async function loadSkills() {
+      const root = document.getElementById('skills-list');
+      root.innerHTML = '<div class="empty">Loading…</div>';
+      try {
+        const r = await api('/skills');
+        const arr = r.skills || r;
+        if (!Array.isArray(arr) || arr.length === 0) {
+          root.innerHTML = '<div class="empty">No skills yet. Install one: <code>lazyclaw skills install &lt;user&gt;/&lt;repo&gt;</code>.</div>';
+          return;
+        }
+        root.innerHTML = '';
+        arr.forEach((s) => {
+          const div = document.createElement('div');
+          div.className = 'card';
+          div.innerHTML = `<div class="row" style="border:0;padding:0;">
+              <div class="name">${s.name}</div>
+              <div class="dim" style="margin-left:auto;">${(s.bytes ?? '')} bytes</div>
+            </div>
+            <div class="dim" style="margin-top:6px;">${s.summary || ''}</div>`;
+          root.appendChild(div);
+        });
+      } catch (e) {
+        root.innerHTML = `<div class="empty">⚠ ${e.message}</div>`;
+      }
+    };
+    LOADERS.providers = async function loadProviders() {
+      const root = document.getElementById('providers-list');
+      root.innerHTML = '<div class="empty">Loading…</div>';
+      try {
+        const r = await api('/providers');
+        const arr = r.providers || r;
+        root.innerHTML = '';
+        arr.forEach((p) => {
+          const div = document.createElement('div');
+          div.className = 'card';
+          const tag = p.requiresApiKey
+            ? '<span class="pill warn">api key</span>'
+            : '<span class="pill ok">no key</span>';
+          const models = (p.suggestedModels || []).slice(0, 6).join(' · ') || '<span class="dim">(default)</span>';
+          div.innerHTML = `<div class="row" style="border:0;padding:0;">
+              <div class="name">${p.name}</div>${tag}
+              <div class="dim" style="margin-left:auto;">${p.endpoint || ''}</div>
+            </div>
+            <div class="dim" style="margin-top:6px;">${p.docs || ''}</div>
+            <div style="margin-top:8px;font-size:12px;">${models}</div>`;
+          root.appendChild(div);
+        });
+      } catch (e) {
+        root.innerHTML = `<div class="empty">⚠ ${e.message}</div>`;
+      }
+    };
+    LOADERS.status = async function loadStatus() {
+      const root = document.getElementById('status-card');
+      root.innerHTML = '<div class="empty">Loading…</div>';
+      try {
+        const r = await api('/status');
+        root.innerHTML = `<div class="card"><pre>${JSON.stringify(r, null, 2)}</pre></div>`;
+      } catch (e) {
+        root.innerHTML = `<div class="empty">⚠ ${e.message}</div>`;
+      }
+    };
+    // First load = chat tab.
+    LOADERS.chat();
+    // ── Chat send ─────────────────────────────────────────────────
+    let chatHistory = []; // [{role, text}]
+    function resetChat() {
+      chatHistory = [];
+      const stream = document.getElementById('chat-stream');
+      stream.innerHTML = '<div class="empty">Type below to start.</div>';
+      document.getElementById('chat-meta').textContent = '';
+    }
+    function appendMsg(role, text) {
+      const stream = document.getElementById('chat-stream');
+      // First message kicks the empty placeholder.
+      if (stream.querySelector('.empty')) stream.innerHTML = '';
+      const div = document.createElement('div');
+      div.className = 'msg ' + role;
+      div.textContent = text;
+      stream.appendChild(div);
+      stream.scrollTop = stream.scrollHeight;
+      return div;
+    }
+    document.getElementById('chat-input').addEventListener('keydown', (e) => {
+      if (e.key === 'Enter' && !e.shiftKey) {
+        e.preventDefault();
+        sendChat();
+      }
+    });
+    async function sendChat() {
+      const ta = document.getElementById('chat-input');
+      const text = ta.value.trim();
+      if (!text) return;
+      const assignee = document.getElementById('chat-assignee').value;
+      if (!assignee) {
+        appendMsg('error', 'No provider selected. Run `lazyclaw onboard` first.');
+        return;
+      }
+      ta.value = '';
+      appendMsg('user', text);
+      chatHistory.push({ role: 'user', text });
+      const meta = document.getElementById('chat-meta');
+      meta.textContent = '⏳ thinking…';
+      const t0 = Date.now();
+      try {
+        // Daemon's POST /agent: { prompt, provider, model, ... }
+        // Returns { text, provider, model, durationMs, ... }.
+        const [provName, modelName] = assignee.includes(':') ? assignee.split(':', 2) : [assignee, ''];
+        const body = { prompt: buildAgentPrompt(text), provider: provName };
+        if (modelName) body.model = modelName;
+        const r = await api('/agent', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify(body),
+        });
+        const reply = r.text || r.output || '(empty)';
+        appendMsg('assistant', reply);
+        chatHistory.push({ role: 'assistant', text: reply });
+        const dur = ((Date.now() - t0) / 1000).toFixed(1);
+        meta.textContent = `${r.provider || provName} · ${r.model || modelName || '(default)'} · ${dur}s`;
+      } catch (e) {
+        appendMsg('error', '⚠ ' + (e.message || String(e)));
+        meta.textContent = '';
+      }
+    }
+    function buildAgentPrompt(latestUserText) {
+      // Flat conversation prompt: previous turns + the new user message.
+      // The daemon's /agent endpoint is one-shot, so we stuff prior
+      // turns into the prompt body. Keeps the dashboard stateless.
+      if (chatHistory.length <= 1) return latestUserText;
+      const lines = [];
+      for (const m of chatHistory.slice(-12, -1)) {
+        lines.push((m.role === 'user' ? 'User:' : 'Assistant:') + ' ' + m.text);
+      }
+      lines.push('User: ' + latestUserText);
+      lines.push('Assistant:');
+      return lines.join('\n\n');
+    }
+  </script>
+</body>
+</html>