lopebase 0.1.0 → 0.3.0

package/dist/lopebase.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 var __create = Object.create;
 var { getPrototypeOf: __getProtoOf, defineProperty: __defProp, getOwnPropertyNames: __getOwnPropNames } = Object;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
@@ -13,7 +14,7 @@ var __toESMCache_node, __toESMCache_esm, __toESM = (mod, isNodeMode, target) =>
       return cached;
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
-  let to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target;
+  let to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target;
   if (mod && typeof mod === "object" || typeof mod === "function") {
     for (let key of __getOwnPropNames(mod))
       if (!__hasOwnProp.call(to, key))
@@ -27,6 +28,7 @@ var __toESMCache_node, __toESMCache_esm, __toESM = (mod, isNodeMode, target) =>
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/.bun/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
 var require_src = __commonJS(function(exports, module) {
@@ -143,8 +145,364 @@ var require_picocolors = __commonJS(function(exports, module) {
   module.exports.createColors = createColors;
 });
 
+// ../../node_modules/.bun/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS(function(exports, module) {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function checkPathExt(path, options) {
+    var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+    if (!pathext)
+      return !0;
+    if (pathext = pathext.split(";"), pathext.indexOf("") !== -1)
+      return !0;
+    for (var i = 0;i < pathext.length; i++) {
+      var p2 = pathext[i].toLowerCase();
+      if (p2 && path.substr(-p2.length).toLowerCase() === p2)
+        return !0;
+    }
+    return !1;
+  }
+  function checkStat(stat, path, options) {
+    if (!stat.isSymbolicLink() && !stat.isFile())
+      return !1;
+    return checkPathExt(path, options);
+  }
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? !1 : checkStat(stat, path, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), path, options);
+  }
+});
+
+// ../../node_modules/.bun/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = __commonJS(function(exports, module) {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? !1 : checkStat(stat, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), options);
+  }
+  function checkStat(stat, options) {
+    return stat.isFile() && checkMode(stat, options);
+  }
+  function checkMode(stat, options) {
+    var { mode: mod, uid, gid } = stat, myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid(), myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid(), u2 = parseInt("100", 8), g2 = parseInt("010", 8), o2 = parseInt("001", 8), ug = u2 | g2, ret = mod & o2 || mod & g2 && gid === myGid || mod & u2 && uid === myUid || mod & ug && myUid === 0;
+    return ret;
+  }
+});
+
+// ../../node_modules/.bun/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS(function(exports, module) {
+  var fs = __require("fs"), core;
+  if (process.platform === "win32" || global.TESTING_WINDOWS)
+    core = require_windows();
+  else
+    core = require_mode();
+  module.exports = isexe;
+  isexe.sync = sync;
+  function isexe(path, options, cb) {
+    if (typeof options === "function")
+      cb = options, options = {};
+    if (!cb) {
+      if (typeof Promise !== "function")
+        throw TypeError("callback not provided");
+      return new Promise(function(resolve, reject) {
+        isexe(path, options || {}, function(er, is) {
+          if (er)
+            reject(er);
+          else
+            resolve(is);
+        });
+      });
+    }
+    core(path, options || {}, function(er, is) {
+      if (er) {
+        if (er.code === "EACCES" || options && options.ignoreErrors)
+          er = null, is = !1;
+      }
+      cb(er, is);
+    });
+  }
+  function sync(path, options) {
+    try {
+      return core.sync(path, options || {});
+    } catch (er) {
+      if (options && options.ignoreErrors || er.code === "EACCES")
+        return !1;
+      else
+        throw er;
+    }
+  }
+});
+
+// ../../node_modules/.bun/which@2.0.2/node_modules/which/which.js
+var require_which = __commonJS(function(exports, module) {
+  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys", path = __require("path"), COLON = isWindows ? ";" : ":", isexe = require_isexe(), getNotFoundError = (cmd) => Object.assign(Error(`not found: ${cmd}`), { code: "ENOENT" }), getPathInfo = (cmd, opt) => {
+    let colon = opt.colon || COLON, pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+      ...isWindows ? [process.cwd()] : [],
+      ...(opt.path || process.env.PATH || "").split(colon)
+    ], pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "", pathExt = isWindows ? pathExtExe.split(colon) : [""];
+    if (isWindows) {
+      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+        pathExt.unshift("");
+    }
+    return {
+      pathEnv,
+      pathExt,
+      pathExtExe
+    };
+  }, which = (cmd, opt, cb) => {
+    if (typeof opt === "function")
+      cb = opt, opt = {};
+    if (!opt)
+      opt = {};
+    let { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt), found = [], step = (i) => new Promise((resolve, reject) => {
+      if (i === pathEnv.length)
+        return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+      let ppRaw = pathEnv[i], pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw, pCmd = path.join(pathPart, cmd), p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      resolve(subStep(p2, i, 0));
+    }), subStep = (p2, i, ii) => new Promise((resolve, reject) => {
+      if (ii === pathExt.length)
+        return resolve(step(i + 1));
+      let ext = pathExt[ii];
+      isexe(p2 + ext, { pathExt: pathExtExe }, (er, is) => {
+        if (!er && is)
+          if (opt.all)
+            found.push(p2 + ext);
+          else
+            return resolve(p2 + ext);
+        return resolve(subStep(p2, i, ii + 1));
+      });
+    });
+    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+  }, whichSync = (cmd, opt) => {
+    opt = opt || {};
+    let { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt), found = [];
+    for (let i = 0;i < pathEnv.length; i++) {
+      let ppRaw = pathEnv[i], pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw, pCmd = path.join(pathPart, cmd), p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      for (let j2 = 0;j2 < pathExt.length; j2++) {
+        let cur = p2 + pathExt[j2];
+        try {
+          if (isexe.sync(cur, { pathExt: pathExtExe }))
+            if (opt.all)
+              found.push(cur);
+            else
+              return cur;
+        } catch (ex) {}
+      }
+    }
+    if (opt.all && found.length)
+      return found;
+    if (opt.nothrow)
+      return null;
+    throw getNotFoundError(cmd);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// ../../node_modules/.bun/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = __commonJS(function(exports, module) {
+  var pathKey = (options = {}) => {
+    let environment = options.env || process.env;
+    if ((options.platform || process.platform) !== "win32")
+      return "PATH";
+    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  };
+  module.exports = pathKey;
+  module.exports.default = pathKey;
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS(function(exports, module) {
+  var path = __require("path"), which = require_which(), getPathKey = require_path_key();
+  function resolveCommandAttempt(parsed, withoutPathExt) {
+    let env = parsed.options.env || process.env, cwd = process.cwd(), hasCustomCwd = parsed.options.cwd != null, shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+    if (shouldSwitchCwd)
+      try {
+        process.chdir(parsed.options.cwd);
+      } catch (err) {}
+    let resolved;
+    try {
+      resolved = which.sync(parsed.command, {
+        path: env[getPathKey({ env })],
+        pathExt: withoutPathExt ? path.delimiter : void 0
+      });
+    } catch (e2) {} finally {
+      if (shouldSwitchCwd)
+        process.chdir(cwd);
+    }
+    if (resolved)
+      resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, !0);
+  }
+  module.exports = resolveCommand;
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS(function(exports, module) {
+  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+  function escapeCommand(arg) {
+    return arg = arg.replace(metaCharsRegExp, "^$1"), arg;
+  }
+  function escapeArgument(arg, doubleEscapeMetaChars) {
+    if (arg = `${arg}`, arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\""), arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1"), arg = `"${arg}"`, arg = arg.replace(metaCharsRegExp, "^$1"), doubleEscapeMetaChars)
+      arg = arg.replace(metaCharsRegExp, "^$1");
+    return arg;
+  }
+  exports.command = escapeCommand;
+  exports.argument = escapeArgument;
+});
+
+// ../../node_modules/.bun/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS(function(exports, module) {
+  module.exports = /^#!(.*)/;
+});
+
+// ../../node_modules/.bun/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS(function(exports, module) {
+  var shebangRegex = require_shebang_regex();
+  module.exports = (string = "") => {
+    let match = string.match(shebangRegex);
+    if (!match)
+      return null;
+    let [path, argument] = match[0].replace(/#! ?/, "").split(" "), binary = path.split("/").pop();
+    if (binary === "env")
+      return argument;
+    return argument ? `${binary} ${argument}` : binary;
+  };
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS(function(exports, module) {
+  var fs = __require("fs"), shebangCommand = require_shebang_command();
+  function readShebang(command) {
+    let buffer = Buffer.alloc(150), fd;
+    try {
+      fd = fs.openSync(command, "r"), fs.readSync(fd, buffer, 0, 150, 0), fs.closeSync(fd);
+    } catch (e2) {}
+    return shebangCommand(buffer.toString());
+  }
+  module.exports = readShebang;
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS(function(exports, module) {
+  var path = __require("path"), resolveCommand = require_resolveCommand(), escape = require_escape(), readShebang = require_readShebang(), isWin = process.platform === "win32", isExecutableRegExp = /\.(?:com|exe)$/i, isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    let shebang = parsed.file && readShebang(parsed.file);
+    if (shebang)
+      return parsed.args.unshift(parsed.file), parsed.command = shebang, resolveCommand(parsed);
+    return parsed.file;
+  }
+  function parseNonShell(parsed) {
+    if (!isWin)
+      return parsed;
+    let commandFile = detectShebang(parsed), needsShell = !isExecutableRegExp.test(commandFile);
+    if (parsed.options.forceShell || needsShell) {
+      let needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+      parsed.command = path.normalize(parsed.command), parsed.command = escape.command(parsed.command), parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+      let shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`], parsed.command = process.env.comspec || "cmd.exe", parsed.options.windowsVerbatimArguments = !0;
+    }
+    return parsed;
+  }
+  function parse(command, args, options) {
+    if (args && !Array.isArray(args))
+      options = args, args = null;
+    args = args ? args.slice(0) : [], options = Object.assign({}, options);
+    let parsed = {
+      command,
+      args,
+      options,
+      file: void 0,
+      original: {
+        command,
+        args
+      }
+    };
+    return options.shell ? parsed : parseNonShell(parsed);
+  }
+  module.exports = parse;
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS(function(exports, module) {
+  var isWin = process.platform === "win32";
+  function notFoundError(original, syscall) {
+    return Object.assign(Error(`${syscall} ${original.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${syscall} ${original.command}`,
+      path: original.command,
+      spawnargs: original.args
+    });
+  }
+  function hookChildProcess(cp, parsed) {
+    if (!isWin)
+      return;
+    let originalEmit = cp.emit;
+    cp.emit = function(name, arg1) {
+      if (name === "exit") {
+        let err = verifyENOENT(arg1, parsed);
+        if (err)
+          return originalEmit.call(cp, "error", err);
+      }
+      return originalEmit.apply(cp, arguments);
+    };
+  }
+  function verifyENOENT(status, parsed) {
+    if (isWin && status === 1 && !parsed.file)
+      return notFoundError(parsed.original, "spawn");
+    return null;
+  }
+  function verifyENOENTSync(status, parsed) {
+    if (isWin && status === 1 && !parsed.file)
+      return notFoundError(parsed.original, "spawnSync");
+    return null;
+  }
+  module.exports = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+  };
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS(function(exports, module) {
+  var cp = __require("child_process"), parse = require_parse(), enoent = require_enoent();
+  function spawn(command, args, options) {
+    let parsed = parse(command, args, options), spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    return enoent.hookChildProcess(spawned, parsed), spawned;
+  }
+  function spawnSync(command, args, options) {
+    let parsed = parse(command, args, options), result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    return result.error = result.error || enoent.verifyENOENTSync(result.status, parsed), result;
+  }
+  module.exports = spawn;
+  module.exports.spawn = spawn;
+  module.exports.sync = spawnSync;
+  module.exports._parse = parse;
+  module.exports._enoent = enoent;
+});
+
 // bin/lopebase.ts
-import { spawn, spawnSync as spawnSync2 } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
+import { readFileSync as readFileSync3 } from "node:fs";
 
 // ../../node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/dist/index.mjs
 import { stripVTControlCharacters as S2 } from "node:util";
@@ -592,17 +950,17 @@ var V2 = ce(), u = (t, n) => V2 ? t : n, le = u("◆", "*"), L2 = u("■", "x"),
       return import_picocolors2.default.green(C);
   }
 }, G2 = (t) => {
-  let { cursor: n, options: r, style: i } = t, s = t.maxItems ?? Number.POSITIVE_INFINITY, c = Math.max(process.stdout.rows - 4, 0), a = Math.min(c, Math.max(s, 5)), l = 0;
-  n >= l + a - 3 ? l = Math.max(Math.min(n - a + 3, r.length - a), 0) : n < l + 2 && (l = Math.max(n - 2, 0));
-  let $ = a < r.length && l > 0, g = a < r.length && l + a < r.length;
-  return r.slice(l, l + a).map((p, v, f) => {
-    let j = v === 0 && $, E = v === f.length - 1 && g;
-    return j || E ? import_picocolors2.default.dim("...") : i(p, v + l === n);
+  let { cursor: n, options: r2, style: i } = t, s = t.maxItems ?? Number.POSITIVE_INFINITY, c = Math.max(process.stdout.rows - 4, 0), a = Math.min(c, Math.max(s, 5)), l2 = 0;
+  n >= l2 + a - 3 ? l2 = Math.max(Math.min(n - a + 3, r2.length - a), 0) : n < l2 + 2 && (l2 = Math.max(n - 2, 0));
+  let $2 = a < r2.length && l2 > 0, g2 = a < r2.length && l2 + a < r2.length;
+  return r2.slice(l2, l2 + a).map((p2, v2, f) => {
+    let j2 = v2 === 0 && $2, E = v2 === f.length - 1 && g2;
+    return j2 || E ? import_picocolors2.default.dim("...") : i(p2, v2 + l2 === n);
   });
 }, he = (t) => new RD({ validate: t.validate, placeholder: t.placeholder, defaultValue: t.defaultValue, initialValue: t.initialValue, render() {
   let n = `${import_picocolors2.default.gray(o)}
 ${b2(this.state)}  ${t.message}
-`, r = t.placeholder ? import_picocolors2.default.inverse(t.placeholder[0]) + import_picocolors2.default.dim(t.placeholder.slice(1)) : import_picocolors2.default.inverse(import_picocolors2.default.hidden("_")), i = this.value ? this.valueWithCursor : r;
+`, r2 = t.placeholder ? import_picocolors2.default.inverse(t.placeholder[0]) + import_picocolors2.default.dim(t.placeholder.slice(1)) : import_picocolors2.default.inverse(import_picocolors2.default.hidden("_")), i = this.value ? this.valueWithCursor : r2;
   switch (this.state) {
     case "error":
       return `${n.trim()}
@@ -622,7 +980,7 @@ ${import_picocolors2.default.cyan(d2)}
 } }).prompt(), ge = (t) => new MD({ validate: t.validate, mask: t.mask ?? $e, render() {
   let n = `${import_picocolors2.default.gray(o)}
 ${b2(this.state)}  ${t.message}
-`, r = this.valueWithCursor, i = this.masked;
+`, r2 = this.valueWithCursor, i = this.masked;
   switch (this.state) {
     case "error":
       return `${n.trim()}
@@ -635,19 +993,19 @@ ${import_picocolors2.default.yellow(d2)}  ${import_picocolors2.default.yellow(th
       return `${n}${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(i ?? ""))}${i ? `
 ${import_picocolors2.default.gray(o)}` : ""}`;
     default:
-      return `${n}${import_picocolors2.default.cyan(o)}  ${r}
+      return `${n}${import_picocolors2.default.cyan(o)}  ${r2}
 ${import_picocolors2.default.cyan(d2)}
 `;
   }
 } }).prompt();
 var ve = (t) => {
-  let n = (r, i) => {
-    let s = r.label ?? String(r.value);
+  let n = (r2, i) => {
+    let s = r2.label ?? String(r2.value);
     switch (i) {
       case "selected":
         return `${import_picocolors2.default.dim(s)}`;
       case "active":
-        return `${import_picocolors2.default.green(k2)} ${s} ${r.hint ? import_picocolors2.default.dim(`(${r.hint})`) : ""}`;
+        return `${import_picocolors2.default.green(k2)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}`;
       case "cancelled":
         return `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}`;
       default:
@@ -655,17 +1013,17 @@ var ve = (t) => {
     }
   };
   return new LD({ options: t.options, initialValue: t.initialValue, render() {
-    let r = `${import_picocolors2.default.gray(o)}
+    let r2 = `${import_picocolors2.default.gray(o)}
 ${b2(this.state)}  ${t.message}
 `;
     switch (this.state) {
       case "submit":
-        return `${r}${import_picocolors2.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
+        return `${r2}${import_picocolors2.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
       case "cancel":
-        return `${r}${import_picocolors2.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
+        return `${r2}${import_picocolors2.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
 ${import_picocolors2.default.gray(o)}`;
       default:
-        return `${r}${import_picocolors2.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i, s) => n(i, s ? "active" : "inactive") }).join(`
+        return `${r2}${import_picocolors2.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i, s) => n(i, s ? "active" : "inactive") }).join(`
 ${import_picocolors2.default.cyan(o)}  `)}
 ${import_picocolors2.default.cyan(d2)}
 `;
@@ -673,16 +1031,16 @@ ${import_picocolors2.default.cyan(d2)}
   } }).prompt();
 };
 var fe = (t) => {
-  let n = (r, i) => {
-    let s = r.label ?? String(r.value);
-    return i === "active" ? `${import_picocolors2.default.cyan(A2)} ${s} ${r.hint ? import_picocolors2.default.dim(`(${r.hint})`) : ""}` : i === "selected" ? `${import_picocolors2.default.green(T)} ${import_picocolors2.default.dim(s)} ${r.hint ? import_picocolors2.default.dim(`(${r.hint})`) : ""}` : i === "cancelled" ? `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}` : i === "active-selected" ? `${import_picocolors2.default.green(T)} ${s} ${r.hint ? import_picocolors2.default.dim(`(${r.hint})`) : ""}` : i === "submitted" ? `${import_picocolors2.default.dim(s)}` : `${import_picocolors2.default.dim(F)} ${import_picocolors2.default.dim(s)}`;
+  let n = (r2, i) => {
+    let s = r2.label ?? String(r2.value);
+    return i === "active" ? `${import_picocolors2.default.cyan(A2)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}` : i === "selected" ? `${import_picocolors2.default.green(T)} ${import_picocolors2.default.dim(s)} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}` : i === "cancelled" ? `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}` : i === "active-selected" ? `${import_picocolors2.default.green(T)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}` : i === "submitted" ? `${import_picocolors2.default.dim(s)}` : `${import_picocolors2.default.dim(F)} ${import_picocolors2.default.dim(s)}`;
   };
-  return new SD({ options: t.options, initialValues: t.initialValues, required: t.required ?? !0, cursorAt: t.cursorAt, validate(r) {
-    if (this.required && r.length === 0)
+  return new SD({ options: t.options, initialValues: t.initialValues, required: t.required ?? !0, cursorAt: t.cursorAt, validate(r2) {
+    if (this.required && r2.length === 0)
       return `Please select at least one option.
 ${import_picocolors2.default.reset(import_picocolors2.default.dim(`Press ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" space ")))} to select, ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" enter ")))} to submit`))}`;
   }, render() {
-    let r = `${import_picocolors2.default.gray(o)}
+    let r2 = `${import_picocolors2.default.gray(o)}
 ${b2(this.state)}  ${t.message}
 `, i = (s, c) => {
       let a = this.value.includes(s.value);
@@ -690,23 +1048,23 @@ ${b2(this.state)}  ${t.message}
     };
     switch (this.state) {
       case "submit":
-        return `${r}${import_picocolors2.default.gray(o)}  ${this.options.filter(({ value: s }) => this.value.includes(s)).map((s) => n(s, "submitted")).join(import_picocolors2.default.dim(", ")) || import_picocolors2.default.dim("none")}`;
+        return `${r2}${import_picocolors2.default.gray(o)}  ${this.options.filter(({ value: s }) => this.value.includes(s)).map((s) => n(s, "submitted")).join(import_picocolors2.default.dim(", ")) || import_picocolors2.default.dim("none")}`;
       case "cancel": {
         let s = this.options.filter(({ value: c }) => this.value.includes(c)).map((c) => n(c, "cancelled")).join(import_picocolors2.default.dim(", "));
-        return `${r}${import_picocolors2.default.gray(o)}  ${s.trim() ? `${s}
+        return `${r2}${import_picocolors2.default.gray(o)}  ${s.trim() ? `${s}
 ${import_picocolors2.default.gray(o)}` : ""}`;
       }
       case "error": {
         let s = this.error.split(`
 `).map((c, a) => a === 0 ? `${import_picocolors2.default.yellow(d2)}  ${import_picocolors2.default.yellow(c)}` : `   ${c}`).join(`
 `);
-        return `${r + import_picocolors2.default.yellow(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
+        return `${r2 + import_picocolors2.default.yellow(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
 ${import_picocolors2.default.yellow(o)}  `)}
 ${s}
 `;
       }
       default:
-        return `${r}${import_picocolors2.default.cyan(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
+        return `${r2}${import_picocolors2.default.cyan(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
 ${import_picocolors2.default.cyan(o)}  `)}
 ${import_picocolors2.default.cyan(d2)}
 `;
@@ -714,13 +1072,13 @@ ${import_picocolors2.default.cyan(d2)}
   } }).prompt();
 };
 var Me = (t = "", n = "") => {
-  let r = `
+  let r2 = `
 ${t}
 `.split(`
-`), i = S2(n).length, s = Math.max(r.reduce((a, l) => {
-    let $ = S2(l);
-    return $.length > a ? $.length : a;
-  }, 0), i) + 2, c = r.map((a) => `${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors2.default.gray(o)}`).join(`
+`), i = S2(n).length, s = Math.max(r2.reduce((a, l2) => {
+    let $2 = S2(l2);
+    return $2.length > a ? $2.length : a;
+  }, 0), i) + 2, c = r2.map((a) => `${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors2.default.gray(o)}`).join(`
 `);
   process.stdout.write(`${import_picocolors2.default.gray(o)}
 ${import_picocolors2.default.green(C)}  ${import_picocolors2.default.reset(n)} ${import_picocolors2.default.gray(_2.repeat(Math.max(s - i - 1, 1)) + me)}
@@ -740,13 +1098,13 @@ ${import_picocolors2.default.gray(d2)}  ${t}
 
 `);
 }, M2 = { message: (t = "", { symbol: n = import_picocolors2.default.gray(o) } = {}) => {
-  let r = [`${import_picocolors2.default.gray(o)}`];
+  let r2 = [`${import_picocolors2.default.gray(o)}`];
   if (t) {
     let [i, ...s] = t.split(`
 `);
-    r.push(`${n}  ${i}`, ...s.map((c) => `${import_picocolors2.default.gray(o)}  ${c}`));
+    r2.push(`${n}  ${i}`, ...s.map((c) => `${import_picocolors2.default.gray(o)}  ${c}`));
   }
-  process.stdout.write(`${r.join(`
+  process.stdout.write(`${r2.join(`
 `)}
 `);
 }, info: (t) => {
@@ -763,66 +1121,341 @@ ${import_picocolors2.default.gray(d2)}  ${t}
   M2.message(t, { symbol: import_picocolors2.default.red(K2) });
 } }, J2 = `${import_picocolors2.default.gray(o)}  `;
 var Y2 = ({ indicator: t = "dots" } = {}) => {
-  let n = V2 ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"], r = V2 ? 80 : 120, i = process.env.CI === "true", s, c, a = !1, l = "", $, g = performance.now(), p = (m) => {
-    let h = m > 1 ? "Something went wrong" : "Canceled";
-    a && N(h, m);
-  }, v = () => p(2), f = () => p(1), j = () => {
-    process.on("uncaughtExceptionMonitor", v), process.on("unhandledRejection", v), process.on("SIGINT", f), process.on("SIGTERM", f), process.on("exit", p);
+  let n = V2 ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"], r2 = V2 ? 80 : 120, i = process.env.CI === "true", s, c, a = !1, l2 = "", $2, g2 = performance.now(), p2 = (m2) => {
+    let h2 = m2 > 1 ? "Something went wrong" : "Canceled";
+    a && N2(h2, m2);
+  }, v2 = () => p2(2), f = () => p2(1), j2 = () => {
+    process.on("uncaughtExceptionMonitor", v2), process.on("unhandledRejection", v2), process.on("SIGINT", f), process.on("SIGTERM", f), process.on("exit", p2);
   }, E = () => {
-    process.removeListener("uncaughtExceptionMonitor", v), process.removeListener("unhandledRejection", v), process.removeListener("SIGINT", f), process.removeListener("SIGTERM", f), process.removeListener("exit", p);
-  }, B = () => {
-    if ($ === void 0)
+    process.removeListener("uncaughtExceptionMonitor", v2), process.removeListener("unhandledRejection", v2), process.removeListener("SIGINT", f), process.removeListener("SIGTERM", f), process.removeListener("exit", p2);
+  }, B2 = () => {
+    if ($2 === void 0)
       return;
     i && process.stdout.write(`
 `);
-    let m = $.split(`
+    let m2 = $2.split(`
 `);
-    process.stdout.write(import_sisteransi2.cursor.move(-999, m.length - 1)), process.stdout.write(import_sisteransi2.erase.down(m.length));
-  }, R = (m) => m.replace(/\.+$/, ""), O = (m) => {
-    let h = (performance.now() - m) / 1000, w = Math.floor(h / 60), I = Math.floor(h % 60);
-    return w > 0 ? `[${w}m ${I}s]` : `[${I}s]`;
-  }, H = (m = "") => {
-    a = !0, s = fD(), l = R(m), g = performance.now(), process.stdout.write(`${import_picocolors2.default.gray(o)}
+    process.stdout.write(import_sisteransi2.cursor.move(-999, m2.length - 1)), process.stdout.write(import_sisteransi2.erase.down(m2.length));
+  }, R2 = (m2) => m2.replace(/\.+$/, ""), O2 = (m2) => {
+    let h2 = (performance.now() - m2) / 1000, w2 = Math.floor(h2 / 60), I2 = Math.floor(h2 % 60);
+    return w2 > 0 ? `[${w2}m ${I2}s]` : `[${I2}s]`;
+  }, H2 = (m2 = "") => {
+    a = !0, s = fD(), l2 = R2(m2), g2 = performance.now(), process.stdout.write(`${import_picocolors2.default.gray(o)}
 `);
-    let h = 0, w = 0;
-    j(), c = setInterval(() => {
-      if (i && l === $)
+    let h2 = 0, w2 = 0;
+    j2(), c = setInterval(() => {
+      if (i && l2 === $2)
         return;
-      B(), $ = l;
-      let I = import_picocolors2.default.magenta(n[h]);
+      B2(), $2 = l2;
+      let I2 = import_picocolors2.default.magenta(n[h2]);
       if (i)
-        process.stdout.write(`${I}  ${l}...`);
+        process.stdout.write(`${I2}  ${l2}...`);
       else if (t === "timer")
-        process.stdout.write(`${I}  ${l} ${O(g)}`);
+        process.stdout.write(`${I2}  ${l2} ${O2(g2)}`);
       else {
-        let z = ".".repeat(Math.floor(w)).slice(0, 3);
-        process.stdout.write(`${I}  ${l}${z}`);
+        let z2 = ".".repeat(Math.floor(w2)).slice(0, 3);
+        process.stdout.write(`${I2}  ${l2}${z2}`);
       }
-      h = h + 1 < n.length ? h + 1 : 0, w = w < n.length ? w + 0.125 : 0;
-    }, r);
-  }, N = (m = "", h = 0) => {
-    a = !1, clearInterval(c), B();
-    let w = h === 0 ? import_picocolors2.default.green(C) : h === 1 ? import_picocolors2.default.red(L2) : import_picocolors2.default.red(W2);
-    l = R(m ?? l), t === "timer" ? process.stdout.write(`${w}  ${l} ${O(g)}
-`) : process.stdout.write(`${w}  ${l}
+      h2 = h2 + 1 < n.length ? h2 + 1 : 0, w2 = w2 < n.length ? w2 + 0.125 : 0;
+    }, r2);
+  }, N2 = (m2 = "", h2 = 0) => {
+    a = !1, clearInterval(c), B2();
+    let w2 = h2 === 0 ? import_picocolors2.default.green(C) : h2 === 1 ? import_picocolors2.default.red(L2) : import_picocolors2.default.red(W2);
+    l2 = R2(m2 ?? l2), t === "timer" ? process.stdout.write(`${w2}  ${l2} ${O2(g2)}
+`) : process.stdout.write(`${w2}  ${l2}
 `), E(), s();
   };
-  return { start: H, stop: N, message: (m = "") => {
-    l = R(m ?? l);
+  return { start: H2, stop: N2, message: (m2 = "") => {
+    l2 = R2(m2 ?? l2);
   } };
 };
 
+// ../admin-adapter/src/security.ts
+var SIGNATURE_HEADER = "lopebase-signature";
+var enc = /* @__PURE__ */ new TextEncoder;
+function hex(bytes) {
+  return [...new Uint8Array(bytes)].map((b3) => b3.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Hex(data) {
+  return hex(await crypto.subtle.digest("SHA-256", data));
+}
+async function hmacHex(secret, message) {
+  let key = await crypto.subtle.importKey("raw", enc.encode(secret), { name: "HMAC", hash: "SHA-256" }, !1, ["sign"]);
+  return hex(await crypto.subtle.sign("HMAC", key, enc.encode(message)));
+}
+function newSigningSecret() {
+  let bytes = crypto.getRandomValues(new Uint8Array(32)), bin = "";
+  for (let b3 of bytes)
+    bin += String.fromCharCode(b3);
+  return "lbs_" + btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function payload(t, method, pathAndQuery, bodyHash) {
+  return `${t}.${method.toUpperCase()}.${pathAndQuery}.${bodyHash}`;
+}
+async function signRequest(input) {
+  let t = input.timestamp ?? Math.floor(Date.now() / 1000), body = typeof input.body === "string" ? enc.encode(input.body) : input.body ?? new Uint8Array, sig = await hmacHex(input.secret, payload(t, input.method, input.pathAndQuery, await sha256Hex(body)));
+  return `t=${t},v1=${sig}`;
+}
+var SENSITIVE_PARTS = /* @__PURE__ */ new Set([
+  "password",
+  "passwd",
+  "passcode",
+  "pwd",
+  "hash",
+  "hashed",
+  "salt",
+  "secret",
+  "secrets",
+  "token",
+  "tokens",
+  "credential",
+  "credentials",
+  "ssn",
+  "card",
+  "cvv",
+  "cvc",
+  "iban",
+  "otp",
+  "mfa",
+  "totp",
+  "session",
+  "cookie"
+]), SENSITIVE_JOINED = /apikey|privatekey|secretkey|accesskey|accountnumber|routingnumber|stripecustomer|paymentmethod|recoverycode/;
+function isSensitiveFieldName(name) {
+  let parts = name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  if (parts.some((p2) => SENSITIVE_PARTS.has(p2)))
+    return !0;
+  return SENSITIVE_JOINED.test(parts.join(""));
+}
+var PERSON_WORDS = "user|customer|client|member|contact|person|people|owner|author|sender|recipient|requester|assignee|reporter|buyer|guest|subscriber|lead|employee|student|patient|attendee|signer|holder", PERSON_NAME = new RegExp(`(${PERSON_WORDS})s?name$`), PEOPLE_RESOURCE = new RegExp(`^(${PERSON_WORDS})s?$`);
+
+// ../admin-adapter/src/adapter.ts
+var DEFAULT_BASE_PATH = "/api/lopebase";
+// ../admin-adapter/src/conformance.ts
+import { strict as assert } from "node:assert";
+async function body(res) {
+  return await res.json();
+}
+function conformanceChecks(opts) {
+  if (!opts.adapter && !opts.baseUrl)
+    throw Error("conformanceChecks needs an adapter or a baseUrl");
+  let remote = !opts.adapter, base = opts.baseUrl ? opts.baseUrl.replace(/\/$/, "") : `${opts.origin ?? "https://property.test"}${(opts.basePath ?? opts.adapter?.config.basePath ?? DEFAULT_BASE_PATH).replace(/\/$/, "")}`, send = (req) => opts.adapter ? opts.adapter.handle(req) : fetch(req);
+  async function signedHeaders(url, method, bodyText, timestamp) {
+    if (opts.secret) {
+      let u2 = new URL(url);
+      return {
+        [SIGNATURE_HEADER]: await signRequest({
+          secret: opts.secret,
+          method,
+          pathAndQuery: u2.pathname + u2.search,
+          body: bodyText,
+          timestamp
+        })
+      };
+    }
+    return opts.token ? { authorization: `Bearer ${opts.token}` } : {};
+  }
+  let authed = async (path, init) => {
+    let url = base + path, method = init?.method ?? "GET", bodyText = typeof init?.body === "string" ? init.body : void 0;
+    return send(new Request(url, {
+      ...init,
+      headers: {
+        "content-type": "application/json",
+        ...await signedHeaders(url, method, bodyText),
+        ...init?.headers
+      }
+    }));
+  }, resources = () => authed("/resources").then((r2) => body(r2)), checks = [
+    {
+      name: "GET /health returns { ok } without auth",
+      async run() {
+        let res = await send(new Request(`${base}/health`));
+        assert.equal(res.status, 200);
+        let b3 = await body(res);
+        assert.equal(typeof b3.ok, "boolean");
+      }
+    },
+    {
+      name: "requests without a valid token get 401",
+      async run() {
+        let res = await send(new Request(`${base}/resources`));
+        assert.equal(res.status, 401);
+      }
+    },
+    {
+      name: "GET /resources returns a catalog with field metadata",
+      async run() {
+        let res = await authed("/resources");
+        assert.equal(res.status, 200);
+        let b3 = await body(res);
+        assert.ok(Array.isArray(b3.resources));
+        for (let r2 of b3.resources)
+          assert.ok(r2.name && r2.label && r2.readCapability), assert.ok(Array.isArray(r2.fields));
+      }
+    },
+    {
+      name: "GET /actions returns a catalog with param specs",
+      async run() {
+        let res = await authed("/actions");
+        assert.equal(res.status, 200);
+        let b3 = await body(res);
+        assert.ok(Array.isArray(b3.actions));
+        for (let a of b3.actions)
+          assert.ok(a.name && a.label && a.capability), assert.ok(Array.isArray(a.params));
+      }
+    },
+    {
+      name: "GET /resources/:name paginates ({ rows, total? })",
+      async run() {
+        let cat = await resources(), name = opts.sampleResource ?? cat.resources[0]?.name;
+        if (!name)
+          return;
+        let res = await authed(`/resources/${name}?limit=5`);
+        assert.equal(res.status, 200);
+        let page = await body(res);
+        assert.ok(Array.isArray(page.rows));
+      }
+    },
+    {
+      name: "GET /resources/:name/:id returns a row or 404-null",
+      async run() {
+        let cat = await resources(), meta = opts.sampleResource ? cat.resources.find((r2) => r2.name === opts.sampleResource) : cat.resources[0];
+        if (!meta)
+          return;
+        let first = (await body(await authed(`/resources/${meta.name}?limit=1`))).rows[0];
+        if (!first)
+          return;
+        let idField = meta.fields[0]?.name ?? "id", res = await authed(`/resources/${meta.name}/${encodeURIComponent(String(first[idField]))}`);
+        assert.ok(res.status === 200 || res.status === 404);
+      }
+    },
+    {
+      name: "GET /audit returns { rows: AuditEvent[] }",
+      async run() {
+        let res = await authed("/audit");
+        assert.equal(res.status, 200);
+        let b3 = await body(res);
+        assert.ok(Array.isArray(b3.rows));
+      }
+    },
+    {
+      name: "an unknown route returns 404",
+      async run() {
+        let res = await authed("/does-not-exist");
+        assert.equal(res.status, 404);
+      }
+    },
+    {
+      name: "no field in the catalog looks like a secret unless marked safe",
+      async run() {
+        let cat = await resources();
+        for (let r2 of cat.resources)
+          for (let f of r2.fields)
+            assert.ok(!isSensitiveFieldName(f.name) || f.sensitive === "allow", `${r2.name}.${f.name} looks sensitive`);
+      }
+    },
+    {
+      name: "rows contain only declared fields, and a page is at most 100",
+      async run() {
+        let cat = await resources();
+        for (let r2 of cat.resources) {
+          let res = await authed(`/resources/${r2.name}?limit=1000`);
+          assert.equal(res.status, 200);
+          let page = await body(res);
+          assert.ok(page.rows.length <= 100, `${r2.name} returned ${page.rows.length} rows`);
+          let declared = /* @__PURE__ */ new Set(["id", ...r2.fields.map((f) => f.name)]);
+          for (let row of page.rows)
+            for (let k3 of Object.keys(row))
+              assert.ok(declared.has(k3), `${r2.name} returned undeclared field ${k3}`);
+        }
+      }
+    },
+    ...opts.secret ? [
+      {
+        name: "a stale or tampered signature gets 401",
+        async run() {
+          let url = `${base}/resources`, stale = await signedHeaders(url, "GET", void 0, Math.floor(Date.now() / 1000) - 3600);
+          assert.equal((await send(new Request(url, { headers: stale }))).status, 401);
+          let good = await signedHeaders(url, "GET", void 0), tampered = `${url}?limit=1`;
+          assert.equal((await send(new Request(tampered, { headers: good }))).status, 401);
+        }
+      }
+    ] : [],
+    {
+      name: "a mutation writes an audit row (PATCH round-trips into /audit)",
+      async run() {
+        let writable = (await resources()).resources.find((r2) => r2.writeCapability && r2.fields.some((f) => f.editable));
+        if (!writable || remote)
+          return;
+        let row = (await body(await authed(`/resources/${writable.name}?limit=1`))).rows[0];
+        if (!row)
+          return;
+        let idField = writable.fields[0]?.name ?? "id", editField = writable.fields.find((f) => f.editable)?.name;
+        if (!editField)
+          return;
+        let before = await body(await authed("/audit")), res = await authed(`/resources/${writable.name}/${encodeURIComponent(String(row[idField]))}`, {
+          method: "PATCH",
+          body: JSON.stringify({ patch: { [editField]: row[editField] } })
+        });
+        assert.equal(res.status, 200);
+        let after = await body(await authed("/audit"));
+        assert.ok(after.rows.length > before.rows.length, "expected a new audit row");
+      }
+    }
+  ];
+  return remote ? checks.filter((c) => !c.name.startsWith("a mutation writes")) : checks;
+}
 // bin/lopebase.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+
+// src/adapter-check.ts
+async function checkAdapter(input) {
+  let log = input.log ?? (() => {}), failed = [], passed = 0, base = input.baseUrl.replace(/\/$/, ""), url = new URL(`${base}/resources`), status;
+  try {
+    let headers = input.secret ? {
+      [SIGNATURE_HEADER]: await signRequest({
+        secret: input.secret,
+        method: "GET",
+        pathAndQuery: url.pathname + url.search
+      })
+    } : { authorization: `Bearer ${input.token ?? ""}` };
+    status = (await fetch(url, { headers })).status;
+  } catch (e2) {
+    let error = `Could not reach ${base} (${e2 instanceof Error ? e2.message : String(e2)}).`;
+    return log(`FAIL  ${error}`), { passed, failed: [{ name: "reachable", error }] };
+  }
+  if (status === 401) {
+    let error = input.secret ? "The adapter refused the signature. The secret here does not match the app's LOPEBASE_SIGNING_SECRET, or the two clocks are more than 5 minutes apart." : "The adapter refused the token.";
+    return log(`FAIL  ${error}`), { passed, failed: [{ name: "authenticated", error }] };
+  }
+  if (status === 404) {
+    let error = `Nothing at ${base}/resources. Check the base URL, usually https://your-app/api/lopebase.`;
+    return log(`FAIL  ${error}`), { passed, failed: [{ name: "found", error }] };
+  }
+  for (let c of conformanceChecks({
+    baseUrl: input.baseUrl,
+    secret: input.secret,
+    token: input.token
+  }))
+    try {
+      await c.run(), passed++, log(`pass  ${c.name}`);
+    } catch (e2) {
+      let error = e2 instanceof Error ? e2.message.split(`
+`)[0] : String(e2);
+      failed.push({ name: c.name, error }), log(`FAIL  ${c.name}: ${error}`);
+    }
+  return { passed, failed };
+}
 
 // src/agents.ts
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 import { spawnSync } from "node:child_process";
 var AGENTS = [
   {
     id: "claude",
     label: "Claude Code",
     bin: "claude",
-    args: (p) => [p],
+    args: (p2) => [p2],
     mcpAdd: (argv) => [
       "mcp",
       "add",
@@ -837,32 +1470,48 @@ var AGENTS = [
     id: "codex",
     label: "Codex",
     bin: "codex",
-    args: (p) => [p],
+    args: (p2) => [p2],
     mcpAdd: (argv) => ["mcp", "add", "lopebase", "--", ...argv]
   },
   {
     id: "gemini",
     label: "Gemini CLI",
     bin: "gemini",
-    args: (p) => ["-i", p],
+    args: (p2) => ["-i", p2],
     mcpAdd: (argv) => ["mcp", "add", "lopebase", ...argv]
   },
   {
     id: "opencode",
     label: "opencode",
     bin: "opencode",
-    args: (p) => ["--prompt", p]
+    args: (p2) => ["--prompt", p2]
   },
   {
     id: "cursor-agent",
     label: "Cursor Agent",
     bin: "cursor-agent",
-    args: (p) => [p]
+    args: (p2) => [p2]
   }
 ];
 function isInstalled(bin) {
-  let probe = process.platform === "win32" ? "where" : "which";
-  return spawnSync(probe, [bin], { stdio: "ignore" }).status === 0;
+  return whereIs(bin) !== null;
+}
+function whereIs(bin) {
+  let probe = process.platform === "win32" ? "where" : "which", res = spawnSync(probe, [bin], { encoding: "utf8" });
+  if (res.status !== 0)
+    return null;
+  return res.stdout.split(/\r?\n/)[0]?.trim() || null;
+}
+function portableArgs(bin, args, platform = process.platform, resolved = platform === "win32" ? whereIs(bin) : null) {
+  if (platform !== "win32" || !resolved || !/\.(cmd|bat)$/i.test(resolved))
+    return args;
+  return args.map((a) => a.replace(/[ \t]*\r?\n\s*/g, " "));
+}
+function spawnAgent(bin, args, options) {
+  return import_cross_spawn.default(bin, portableArgs(bin, args), options);
+}
+function spawnAgentSync(bin, args, options) {
+  return import_cross_spawn.default.sync(bin, portableArgs(bin, args), options);
 }
 function installedAgents() {
   return AGENTS.filter((a) => isInstalled(a.bin));
@@ -879,6 +1528,22 @@ import {
 import os from "node:os";
 import path from "node:path";
 var DEFAULT_URL = "https://app.lopebase.com";
+function workspaceUrl(input) {
+  let v2 = input.trim().replace(/\/+$/, "");
+  if (!v2)
+    return null;
+  if (/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(v2))
+    return `https://${v2.toLowerCase()}.lopebase.com`;
+  let withScheme = /^https?:\/\//i.test(v2) ? v2 : `https://${v2}`;
+  try {
+    let u2 = new URL(withScheme);
+    if (!u2.hostname.includes(".") && u2.hostname !== "localhost")
+      return null;
+    return `${u2.origin}${u2.pathname.replace(/\/+$/, "")}`;
+  } catch {
+    return null;
+  }
+}
 function configDir() {
   let base = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
   return path.join(base, "lopebase");
@@ -908,21 +1573,21 @@ function saveAuth(auth) {
 var mcpEndpoint = (url) => `${url.replace(/\/+$/, "")}/api/mcp`;
 
 // src/detect.ts
-var APP_SIDE_ENV = /^(NEXT_PUBLIC_|PUBLIC_|VITE_|NUXT_PUBLIC_|EXPO_PUBLIC_)|_DSN$/;
+var APP_SIDE_ENV = /^(NEXT_PUBLIC_|PUBLIC_|VITE_|NUXT_PUBLIC_|EXPO_PUBLIC_|REACT_APP_|GATSBY_)|_DSN$/, file = (name) => new RegExp(`(^|/)${name.replace(/[.]/g, "\\.")}$`);
 function evidenceFor(facts, rule) {
   let out = [], weak = [];
   for (let re of rule.deps ?? []) {
-    let hit = facts.dependencies.find((d) => re.test(d));
+    let hit = facts.dependencies.find((d3) => re.test(d3));
     if (hit)
-      out.push(`uses ${hit}`);
+      out.push(`uses ${hit.replace(/^(py|gem|composer|go|cargo):/, "")}`);
   }
   for (let re of rule.files ?? []) {
     let hit = facts.files.find((f) => re.test(f));
     if (hit)
-      out.push(`has ${hit}`);
+      out.push(`has ${hit.replace(/#.*$/, "")}`);
   }
   for (let re of rule.env ?? []) {
-    let hit = facts.envKeys.find((k) => re.test(k));
+    let hit = facts.envKeys.find((k3) => re.test(k3));
     if (hit)
       (APP_SIDE_ENV.test(hit) ? out : weak).push(`env ${hit}`);
   }
@@ -931,15 +1596,31 @@ function evidenceFor(facts, rule) {
 var SOURCE_RULES = {
   posthog: {
     label: "PostHog",
-    rule: { deps: [/^posthog-(js|node)$/], env: [/POSTHOG/] },
+    rule: {
+      deps: [
+        /^posthog-(js|node|react-native)$/,
+        /^py:posthog$/,
+        /^gem:posthog-ruby$/,
+        /^composer:posthog\//,
+        /^go:github\.com\/posthog\//
+      ],
+      env: [/POSTHOG/]
+    },
     why: "Signups, active users, and funnels on your dashboard."
   },
   ga4: {
     label: "Google Analytics",
     rule: {
-      deps: [/^@next\/third-parties$/, /^react-ga4$/, /^vue-gtag/],
+      deps: [
+        /^@next\/third-parties$/,
+        /^react-ga4$/,
+        /^vue-gtag/,
+        /^nuxt-gtag$/,
+        /^gatsby-plugin-google-(gtag|analytics)$/,
+        /^@analytics\/google-analytics$/
+      ],
       env: [
-        /^(NEXT_PUBLIC_|PUBLIC_|VITE_)?GA(4)?_(MEASUREMENT_)?ID$/,
+        /^(NEXT_PUBLIC_|PUBLIC_|VITE_|GATSBY_|REACT_APP_)?GA(4)?_(MEASUREMENT_|TRACKING_)?ID$/,
         /GTM_ID/
       ]
     },
@@ -948,7 +1629,14 @@ var SOURCE_RULES = {
   sentry: {
     label: "Sentry",
     rule: {
-      deps: [/^@sentry\//],
+      deps: [
+        /^@sentry\//,
+        /^py:sentry-sdk$/,
+        /^gem:sentry-(ruby|rails)$/,
+        /^composer:sentry\//,
+        /^go:github\.com\/getsentry\//,
+        /^cargo:sentry$/
+      ],
       files: [/sentry\.(client|server|edge)\.config/],
       env: [/SENTRY_DSN/]
     },
@@ -956,80 +1644,392 @@ var SOURCE_RULES = {
   },
   stripe: {
     label: "Stripe",
-    rule: { deps: [/^stripe$/, /^@stripe\//], env: [/^STRIPE_/] },
+    rule: {
+      deps: [
+        /^stripe$/,
+        /^@stripe\//,
+        /^py:stripe$/,
+        /^gem:stripe$/,
+        /^composer:stripe\//,
+        /^go:github\.com\/stripe\//
+      ],
+      env: [/^STRIPE_/, /^(NEXT_PUBLIC_|PUBLIC_|VITE_)STRIPE_/]
+    },
     why: "Revenue, new customers, and churn per product."
+  },
+  polar: {
+    label: "Polar",
+    rule: { deps: [/^@polar-sh\//, /^py:polar-sdk$/], env: [/^POLAR_/] },
+    why: "Revenue and subscriptions from Polar per product."
+  },
+  supabase: {
+    label: "Supabase",
+    rule: {
+      deps: [/^@supabase\//, /^py:supabase$/, /^composer:supabase\//],
+      files: [file("supabase/config.toml")],
+      env: [/SUPABASE_URL$/]
+    },
+    why: "Database health, security warnings, disk, and backups next to everything else."
+  },
+  resend: {
+    label: "Resend",
+    rule: {
+      deps: [/^resend$/, /^py:resend$/, /^gem:resend$/, /^composer:resend\//],
+      env: [/^RESEND_/]
+    },
+    why: "Bounce and complaint rates, so you know your emails land."
+  },
+  sequenzy: {
+    label: "Sequenzy",
+    rule: { deps: [/^@?sequenzy/], env: [/SEQUENZY/] },
+    why: "Your audience and running email sequences at a glance."
   }
 }, STACK_RULES = [
-  { kind: "framework", name: "Next.js", rule: { deps: [/^next$/] } },
-  { kind: "framework", name: "Astro", rule: { deps: [/^astro$/] } },
+  {
+    kind: "framework",
+    name: "Next.js",
+    rule: { deps: [/^next$/], files: [/(^|\/)next\.config\./] }
+  },
+  {
+    kind: "framework",
+    name: "Astro",
+    rule: { deps: [/^astro$/], files: [/(^|\/)astro\.config\./] }
+  },
   {
     kind: "framework",
     name: "SvelteKit",
     rule: { deps: [/^@sveltejs\/kit$/] }
   },
+  { kind: "framework", name: "Remix", rule: { deps: [/^@remix-run\//] } },
+  {
+    kind: "framework",
+    name: "React Router",
+    rule: { deps: [/^@react-router\/dev$/] }
+  },
+  {
+    kind: "framework",
+    name: "Nuxt",
+    rule: { deps: [/^nuxt$/], files: [/(^|\/)nuxt\.config\./] }
+  },
+  { kind: "framework", name: "Gatsby", rule: { deps: [/^gatsby$/] } },
+  {
+    kind: "framework",
+    name: "Docusaurus",
+    rule: { deps: [/^@docusaurus\/core$/] }
+  },
+  {
+    kind: "framework",
+    name: "Eleventy",
+    rule: {
+      deps: [/^@11ty\/eleventy$/],
+      files: [/(^|\/)(\.eleventy\.js|eleventy\.config\.)/]
+    }
+  },
+  {
+    kind: "framework",
+    name: "Hugo",
+    rule: { files: [/(^|\/)hugo\.(toml|ya?ml|json)$/] }
+  },
+  { kind: "framework", name: "Jekyll", rule: { deps: [/^gem:jekyll$/] } },
+  { kind: "framework", name: "Angular", rule: { deps: [/^@angular\/core$/] } },
+  {
+    kind: "framework",
+    name: "SolidStart",
+    rule: { deps: [/^@solidjs\/start$/] }
+  },
   {
     kind: "framework",
-    name: "Remix",
-    rule: { deps: [/^@remix-run\//, /^react-router$/] }
+    name: "Qwik",
+    rule: { deps: [/^@builder\.io\/qwik-city$/] }
   },
-  { kind: "framework", name: "Nuxt", rule: { deps: [/^nuxt$/] } },
+  {
+    kind: "framework",
+    name: "TanStack Start",
+    rule: { deps: [/^@tanstack\/(react-)?start$/] }
+  },
+  { kind: "framework", name: "Expo", rule: { deps: [/^expo$/] } },
+  { kind: "framework", name: "Electron", rule: { deps: [/^electron$/] } },
   { kind: "framework", name: "Hono", rule: { deps: [/^hono$/] } },
+  { kind: "framework", name: "Express", rule: { deps: [/^express$/] } },
+  { kind: "framework", name: "Fastify", rule: { deps: [/^fastify$/] } },
+  { kind: "framework", name: "NestJS", rule: { deps: [/^@nestjs\/core$/] } },
+  {
+    kind: "framework",
+    name: "Django",
+    rule: { deps: [/^py:django$/], files: [/(^|\/)manage\.py$/] }
+  },
+  { kind: "framework", name: "Flask", rule: { deps: [/^py:flask$/] } },
+  { kind: "framework", name: "FastAPI", rule: { deps: [/^py:fastapi$/] } },
+  { kind: "framework", name: "Rails", rule: { deps: [/^gem:rails$/] } },
+  {
+    kind: "framework",
+    name: "Laravel",
+    rule: {
+      deps: [/^composer:laravel\/framework$/],
+      files: [/(^|\/)artisan$/]
+    }
+  },
+  {
+    kind: "framework",
+    name: "WordPress",
+    rule: { files: [/(^|\/)wp-config(-sample)?\.php$/, /(^|\/)wp-content$/] }
+  },
+  {
+    kind: "framework",
+    name: "Shopify app",
+    rule: { files: [/(^|\/)shopify\.app\.toml$/] }
+  },
+  { kind: "framework", name: "Vue", rule: { deps: [/^vue$/] } },
+  { kind: "framework", name: "React", rule: { deps: [/^react$/] } },
+  { kind: "framework", name: "Vite", rule: { deps: [/^vite$/] } },
+  { kind: "language", name: "TypeScript", rule: { deps: [/^typescript$/] } },
+  {
+    kind: "language",
+    name: "Python",
+    rule: { files: [/(^|\/)(requirements\.txt|pyproject\.toml|Pipfile)$/] }
+  },
+  { kind: "language", name: "Ruby", rule: { files: [/(^|\/)Gemfile$/] } },
+  { kind: "language", name: "PHP", rule: { files: [/(^|\/)composer\.json$/] } },
+  { kind: "language", name: "Go", rule: { files: [/(^|\/)go\.mod$/] } },
+  { kind: "language", name: "Rust", rule: { files: [/(^|\/)Cargo\.toml$/] } },
   {
     kind: "hosting",
     name: "Cloudflare Workers",
     rule: {
       files: [/(^|\/)wrangler\.(toml|jsonc?)$/],
-      deps: [/^@opennextjs\/cloudflare$/]
+      deps: [
+        /^@opennextjs\/cloudflare$/,
+        /^@astrojs\/cloudflare$/,
+        /^@sveltejs\/adapter-cloudflare/
+      ]
+    }
+  },
+  {
+    kind: "hosting",
+    name: "Vercel",
+    rule: {
+      files: [file("vercel.json")],
+      deps: [
+        /^@vercel\/(analytics|speed-insights|og)$/,
+        /^@astrojs\/vercel$/,
+        /^@sveltejs\/adapter-vercel$/
+      ]
     }
   },
-  { kind: "hosting", name: "Vercel", rule: { files: [/(^|\/)vercel\.json$/] } },
   {
     kind: "hosting",
     name: "Netlify",
-    rule: { files: [/(^|\/)netlify\.toml$/] }
+    rule: {
+      files: [file("netlify.toml")],
+      deps: [/^@netlify\//, /^@astrojs\/netlify$/]
+    }
   },
-  { kind: "hosting", name: "Fly.io", rule: { files: [/(^|\/)fly\.toml$/] } },
+  { kind: "hosting", name: "Fly.io", rule: { files: [file("fly.toml")] } },
   {
-    kind: "database",
-    name: "Supabase",
-    rule: { deps: [/^@supabase\//], files: [/(^|\/)supabase\/config\.toml$/] }
+    kind: "hosting",
+    name: "Render",
+    rule: { files: [/(^|\/)render\.ya?ml$/] }
   },
+  {
+    kind: "hosting",
+    name: "Railway",
+    rule: { files: [/(^|\/)railway\.(json|toml)$/] }
+  },
+  {
+    kind: "hosting",
+    name: "Firebase Hosting",
+    rule: { files: [file("firebase.json")] }
+  },
+  {
+    kind: "hosting",
+    name: "AWS Amplify",
+    rule: { files: [/(^|\/)amplify\.ya?ml$/] }
+  },
+  { kind: "hosting", name: "Heroku", rule: { files: [file("Procfile")] } },
+  { kind: "hosting", name: "GitHub Pages", rule: { files: [file("CNAME")] } },
+  {
+    kind: "hosting",
+    name: "Docker",
+    rule: { files: [file("Dockerfile"), /(^|\/)(docker-)?compose\.ya?ml$/] }
+  },
+  { kind: "database", name: "Supabase", rule: SOURCE_RULES.supabase.rule },
   {
     kind: "database",
     name: "Convex",
-    rule: { deps: [/^convex$/], files: [/(^|\/)convex\/schema\.ts$/] }
+    rule: { deps: [/^convex$/], files: [file("convex/schema.ts")] }
   },
+  { kind: "database", name: "Neon", rule: { deps: [/^@neondatabase\//] } },
   {
     kind: "database",
-    name: "Neon",
-    rule: { deps: [/^@neondatabase\//, /^@neon\/(env|config)$/] }
+    name: "Postgres",
+    rule: {
+      deps: [
+        /^postgres$/,
+        /^pg$/,
+        /^py:psycopg2?(-binary)?$/,
+        /^py:asyncpg$/,
+        /^gem:pg$/
+      ]
+    }
   },
   {
     kind: "database",
-    name: "Postgres",
-    rule: { deps: [/^postgres$/, /^pg$/] }
+    name: "MySQL",
+    rule: { deps: [/^mysql2?$/, /^py:(mysqlclient|pymysql)$/, /^gem:mysql2$/] }
+  },
+  {
+    kind: "database",
+    name: "SQLite",
+    rule: { deps: [/^better-sqlite3$/, /^gem:sqlite3$/] }
+  },
+  {
+    kind: "database",
+    name: "MongoDB",
+    rule: { deps: [/^mongodb$/, /^mongoose$/, /^py:pymongo$/, /^py:motor$/] }
+  },
+  {
+    kind: "database",
+    name: "Firebase",
+    rule: { deps: [/^firebase(-admin)?$/, /^py:firebase-admin$/] }
+  },
+  {
+    kind: "database",
+    name: "PlanetScale",
+    rule: { deps: [/^@planetscale\/database$/] }
+  },
+  { kind: "database", name: "Turso", rule: { deps: [/^@libsql\/client$/] } },
+  {
+    kind: "database",
+    name: "Redis",
+    rule: { deps: [/^@upstash\/redis$/, /^ioredis$/, /^redis$/, /^py:redis$/] }
+  },
+  {
+    kind: "database",
+    name: "Prisma",
+    rule: {
+      deps: [/^@prisma\/client$/],
+      files: [file("prisma/schema.prisma")]
+    }
   },
-  { kind: "database", name: "Prisma", rule: { deps: [/^@prisma\/client$/] } },
   { kind: "database", name: "Drizzle", rule: { deps: [/^drizzle-orm$/] } },
   {
     kind: "database",
     name: "Cloudflare D1",
     rule: { files: [/(^|\/)wrangler\.(toml|jsonc?)#d1$/] }
   },
+  { kind: "email", name: "Resend", rule: SOURCE_RULES.resend.rule },
+  { kind: "email", name: "Sequenzy", rule: SOURCE_RULES.sequenzy.rule },
+  {
+    kind: "email",
+    name: "SendGrid",
+    rule: { deps: [/^@sendgrid\/mail$/, /^py:sendgrid$/], env: [/^SENDGRID_/] }
+  },
+  {
+    kind: "email",
+    name: "Postmark",
+    rule: { deps: [/^postmark$/, /^py:postmarker$/], env: [/^POSTMARK_/] }
+  },
   {
     kind: "email",
-    name: "Resend",
-    rule: { deps: [/^resend$/], env: [/^RESEND_/] }
+    name: "Mailgun",
+    rule: { deps: [/^mailgun\.js$/], env: [/^MAILGUN_/] }
+  },
+  {
+    kind: "email",
+    name: "Loops",
+    rule: { deps: [/^loops$/], env: [/^LOOPS_/] }
+  },
+  {
+    kind: "email",
+    name: "Amazon SES",
+    rule: { deps: [/^@aws-sdk\/client-sesv?2?$/] }
+  },
+  { kind: "email", name: "Nodemailer", rule: { deps: [/^nodemailer$/] } },
+  { kind: "billing", name: "Stripe", rule: SOURCE_RULES.stripe.rule },
+  { kind: "billing", name: "Polar", rule: SOURCE_RULES.polar.rule },
+  {
+    kind: "billing",
+    name: "Lemon Squeezy",
+    rule: { deps: [/^@lemonsqueezy\//], env: [/^LEMON_?SQUEEZY_/] }
   },
   {
     kind: "billing",
-    name: "Polar",
-    rule: { deps: [/^@polar-sh\//], env: [/^POLAR_/] }
+    name: "Paddle",
+    rule: { deps: [/^@paddle\//], env: [/^PADDLE_/] }
   },
   { kind: "auth", name: "Clerk", rule: { deps: [/^@clerk\//] } },
-  { kind: "auth", name: "WorkOS", rule: { deps: [/^@workos-inc\//] } },
-  { kind: "auth", name: "Better Auth", rule: { deps: [/^better-auth$/] } }
-];
+  {
+    kind: "auth",
+    name: "WorkOS",
+    rule: { deps: [/^@workos-inc\//, /^py:workos$/] }
+  },
+  { kind: "auth", name: "Better Auth", rule: { deps: [/^better-auth$/] } },
+  {
+    kind: "auth",
+    name: "Auth.js",
+    rule: { deps: [/^next-auth$/, /^@auth\/core$/] }
+  },
+  { kind: "auth", name: "Auth0", rule: { deps: [/^@auth0\//] } },
+  { kind: "auth", name: "Kinde", rule: { deps: [/^@kinde-oss\//] } },
+  { kind: "auth", name: "Lucia", rule: { deps: [/^lucia$/] } },
+  { kind: "auth", name: "Devise", rule: { deps: [/^gem:devise$/] } },
+  {
+    kind: "analytics",
+    name: "Vercel Analytics",
+    rule: { deps: [/^@vercel\/analytics$/] }
+  },
+  {
+    kind: "analytics",
+    name: "Plausible",
+    rule: { deps: [/plausible/], env: [/PLAUSIBLE/] }
+  },
+  { kind: "analytics", name: "Umami", rule: { env: [/UMAMI/] } },
+  { kind: "analytics", name: "Fathom", rule: { deps: [/^fathom-client$/] } },
+  {
+    kind: "analytics",
+    name: "Mixpanel",
+    rule: { deps: [/^mixpanel(-browser)?$/] }
+  },
+  { kind: "analytics", name: "Amplitude", rule: { deps: [/^@amplitude\//] } },
+  {
+    kind: "cms",
+    name: "Sanity",
+    rule: { deps: [/^(next-)?sanity$/, /^@sanity\/client$/] }
+  },
+  { kind: "cms", name: "Contentful", rule: { deps: [/^contentful$/] } },
+  { kind: "cms", name: "Payload", rule: { deps: [/^payload$/] } },
+  { kind: "cms", name: "Strapi", rule: { deps: [/^@strapi\/strapi$/] } },
+  { kind: "cms", name: "Keystatic", rule: { deps: [/^@keystatic\/core$/] } },
+  {
+    kind: "cms",
+    name: "MDX",
+    rule: { deps: [/^@next\/mdx$/, /^@astrojs\/mdx$/, /^@mdx-js\//] }
+  }
+], WEB_FRAMEWORKS = /* @__PURE__ */ new Set([
+  "Next.js",
+  "Astro",
+  "SvelteKit",
+  "Remix",
+  "React Router",
+  "Nuxt",
+  "Gatsby",
+  "Docusaurus",
+  "Eleventy",
+  "Hugo",
+  "Jekyll",
+  "Angular",
+  "SolidStart",
+  "Qwik",
+  "TanStack Start",
+  "Django",
+  "Flask",
+  "Rails",
+  "Laravel",
+  "WordPress",
+  "Vue",
+  "React",
+  "Vite"
+]);
 function detectStack(facts) {
   let stack = [];
   for (let s of STACK_RULES) {
@@ -1037,7 +2037,13 @@ function detectStack(facts) {
     if (ev.length)
       stack.push({ kind: s.kind, name: s.name, evidence: ev[0] });
   }
-  let sources = [];
+  if (!stack.some((s) => s.kind === "framework") && facts.files.some((f) => /(^|\/)index\.html$/.test(f)))
+    stack.unshift({
+      kind: "framework",
+      name: "Static site",
+      evidence: "has index.html"
+    });
+  let tidy = stack.filter((s) => s.kind === "framework" && !["React", "Vite", "Vue"].includes(s.name)).length ? stack.filter((s) => !["React", "Vite", "Vue"].includes(s.name)) : stack, sources = [];
   for (let [id, s] of Object.entries(SOURCE_RULES)) {
     let { strong, weak } = evidenceFor(facts, s.rule);
     if (strong.length || weak.length)
@@ -1049,7 +2055,15 @@ function detectStack(facts) {
         why: s.why
       });
   }
-  let has = (id) => sources.some((s) => s.source === id && s.status === "found"), listed = (id) => sources.some((s) => s.source === id), isWebsite = stack.some((s) => s.kind === "framework") || !!facts.siteUrl, gaps = [];
+  if (facts.repo)
+    sources.push({
+      source: "github",
+      label: "GitHub",
+      status: "found",
+      evidence: [`repo ${facts.repo}`],
+      why: "Open pull requests, issues, and failing Actions runs."
+    });
+  let has = (id) => sources.some((s) => s.source === id && s.status === "found"), listed = (id) => sources.some((s) => s.source === id), isWebsite = tidy.some((s) => s.kind === "framework" && (WEB_FRAMEWORKS.has(s.name) || s.name === "Static site")) || !!facts.siteUrl, gaps = [];
   if (isWebsite)
     sources.push({
       source: "gsc",
@@ -1063,8 +2077,14 @@ function detectStack(facts) {
       status: "suggested",
       evidence: [],
       why: "Bing and ChatGPT search traffic. Imports from Search Console in one click."
+    }, {
+      source: "uptime",
+      label: "Uptime check",
+      status: "suggested",
+      evidence: [],
+      why: "Know the moment the site goes down. Nothing to install."
     });
-  if (!has("posthog") && !has("ga4")) {
+  if (isWebsite && !has("posthog") && !has("ga4")) {
     if (gaps.push("No product analytics found. Add PostHog (free tier, one snippet) so LopeBase can show signups and active users."), !listed("posthog"))
       sources.push({
         source: "posthog",
@@ -1084,7 +2104,7 @@ function detectStack(facts) {
         why: SOURCE_RULES.sentry.why
       });
   }
-  return { stack, sources, gaps };
+  return { stack: tidy, sources, gaps };
 }
 
 // src/device-login.ts
@@ -1101,27 +2121,27 @@ async function startDeviceLogin(url, opts = {}) {
     });
     if (!res.ok)
       return null;
-    let b = await res.json();
-    if (typeof b.device_code !== "string" || typeof b.user_code !== "string")
+    let b3 = await res.json();
+    if (typeof b3.device_code !== "string" || typeof b3.user_code !== "string")
       return null;
     return {
-      deviceCode: b.device_code,
-      userCode: b.user_code,
-      verifyUrl: String(b.verification_uri_complete ?? b.verification_uri),
-      interval: Number(b.interval) || 5,
-      expiresIn: Number(b.expires_in) || 600
+      deviceCode: b3.device_code,
+      userCode: b3.user_code,
+      verifyUrl: String(b3.verification_uri_complete ?? b3.verification_uri),
+      interval: Number(b3.interval) || 5,
+      expiresIn: Number(b3.expires_in) || 600
     };
   } catch {
     return null;
   }
 }
 async function pollDeviceLogin(url, start, opts = {}) {
-  let f = opts.fetchImpl ?? fetch, sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))), interval = start.interval, deadline = Date.now() + start.expiresIn * 1000;
+  let f = opts.fetchImpl ?? fetch, sleep = opts.sleep ?? ((ms) => new Promise((r2) => setTimeout(r2, ms))), interval = start.interval, deadline = Date.now() + start.expiresIn * 1000;
   while (Date.now() < deadline) {
     await sleep(interval * 1000);
-    let body;
+    let body2;
     try {
-      body = await (await f(`${url}/api/oauth/token`, {
+      body2 = await (await f(`${url}/api/oauth/token`, {
         method: "POST",
         headers: { "content-type": "application/x-www-form-urlencoded" },
         body: new URLSearchParams({
@@ -1132,14 +2152,14 @@ async function pollDeviceLogin(url, start, opts = {}) {
     } catch {
       continue;
     }
-    if (typeof body.access_token === "string")
+    if (typeof body2.access_token === "string")
       return {
         ok: !0,
-        token: body.access_token,
-        url: typeof body.workspace_url === "string" ? body.workspace_url : url,
-        scope: String(body.scope ?? "")
+        token: body2.access_token,
+        url: typeof body2.workspace_url === "string" ? body2.workspace_url : url,
+        scope: String(body2.scope ?? "")
       };
-    switch (body.error) {
+    switch (body2.error) {
       case "authorization_pending":
         continue;
       case "slow_down":
@@ -1161,7 +2181,7 @@ async function pollDeviceLogin(url, start, opts = {}) {
         return {
           ok: !1,
           reason: "error",
-          message: String(body.error_description ?? body.error ?? "Sign-in failed.")
+          message: String(body2.error_description ?? body2.error ?? "Sign-in failed.")
         };
     }
   }
@@ -1230,7 +2250,7 @@ async function runMcpProxy(auth, fetchImpl = fetch) {
       }
       process.stdout.write(`${text}
 `);
-    } catch (e) {
+    } catch (e2) {
       if (id === null)
         return;
       write({
@@ -1238,7 +2258,7 @@ async function runMcpProxy(auth, fetchImpl = fetch) {
         id,
         error: {
           code: -32000,
-          message: `Could not reach LopeBase at ${endpoint}: ${String(e)}`
+          message: `Could not reach LopeBase at ${endpoint}: ${String(e2)}`
         }
       });
     }
@@ -1270,116 +2290,499 @@ function onboardingPrompt(input) {
 }
 
 // src/scan.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
 import path2 from "node:path";
-var MONOREPO_DIRS = ["apps", "packages", "services", "web", "site"], MARKER_FILES = [
-  "wrangler.toml",
-  "wrangler.json",
-  "wrangler.jsonc",
-  "vercel.json",
-  "netlify.toml",
-  "fly.toml",
+var MONOREPO_DIRS = ["apps", "packages", "services", "sites", "web", "site"], SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".turbo",
+  ".vercel",
+  ".wrangler",
+  "dist",
+  "build",
+  "out",
+  "vendor",
+  "venv",
+  ".venv",
+  "target"
+]), MAX_PACKAGES = 200, MARKERS = [
+  /^wrangler\.(toml|jsonc?)$/,
+  /^vercel\.json$/,
+  /^netlify\.toml$/,
+  /^fly\.toml$/,
+  /^render\.ya?ml$/,
+  /^railway\.(json|toml)$/,
+  /^firebase\.json$/,
+  /^amplify\.ya?ml$/,
+  /^app\.ya?ml$/,
+  /^Dockerfile$/,
+  /^docker-compose\.ya?ml$/,
+  /^compose\.ya?ml$/,
+  /^Procfile$/,
+  /^CNAME$/,
+  /^index\.html$/,
+  /^(next|astro|nuxt|svelte|vite|remix|gatsby|docusaurus|tailwind|drizzle|sentry\.(client|server|edge))\.config\.(js|cjs|mjs|ts|mts)$/,
+  /^gatsby-config\.(js|ts)$/,
+  /^(\.eleventy\.js|eleventy\.config\.(js|cjs|mjs))$/,
+  /^hugo\.(toml|ya?ml|json)$/,
+  /^_config\.ya?ml$/,
+  /^instrumentation(-client)?\.(ts|js)$/,
+  /^manage\.py$/,
+  /^artisan$/,
+  /^wp-config(-sample)?\.php$/,
+  /^shopify\.app\.toml$/,
+  /^app\.json$/,
+  /^(requirements\.txt|pyproject\.toml|Pipfile|Gemfile|composer\.json|go\.mod|Cargo\.toml)$/,
+  /^(bun\.lockb?|pnpm-lock\.yaml|yarn\.lock|package-lock\.json)$/
+], NESTED_MARKERS = [
   "supabase/config.toml",
   "convex/schema.ts",
-  "sentry.client.config.ts",
-  "sentry.server.config.ts",
-  "sentry.edge.config.ts",
-  "instrumentation.ts"
-], EXAMPLE_ENV = [
-  ".env.example",
-  ".env.sample",
-  ".env.template",
-  ".dev.vars.example"
-];
-function readJson(file) {
+  "prisma/schema.prisma",
+  "src/instrumentation.ts",
+  "wp-content",
+  ".github/workflows",
+  "content/config.ts"
+], EXAMPLE_ENV = /^(\.env\.(example|sample|template|dist|local\.example|development\.example|production\.example)|example\.env|\.dev\.vars\.example)$/;
+function readText(file2) {
   try {
-    return JSON.parse(readFileSync2(file, "utf8"));
+    return readFileSync2(file2, "utf8");
   } catch {
     return null;
   }
 }
+function readJson(file2) {
+  let text = readText(file2);
+  if (text === null)
+    return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function isDir(p2) {
+  try {
+    return statSync(p2).isDirectory();
+  } catch {
+    return !1;
+  }
+}
+function listDir(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function isPackage(dir) {
+  return [
+    "package.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "Gemfile",
+    "composer.json",
+    "go.mod",
+    "Cargo.toml"
+  ].some((f) => existsSync2(path2.join(dir, f)));
+}
+function workspaceGlobs(root) {
+  let globs = [], ws = readJson(path2.join(root, "package.json"))?.workspaces, list = Array.isArray(ws) ? ws : ws && typeof ws === "object" && Array.isArray(ws.packages) ? ws.packages : [];
+  for (let g2 of list)
+    if (typeof g2 === "string")
+      globs.push(g2);
+  let pnpm = readText(path2.join(root, "pnpm-workspace.yaml"));
+  if (pnpm)
+    for (let m2 of pnpm.matchAll(/^\s*-\s*["']?([^"'\s#]+)["']?/gm))
+      globs.push(m2[1]);
+  return globs.filter((g2) => !g2.startsWith("!"));
+}
+function expandGlob(root, glob) {
+  let clean = glob.replace(/\/\*\*$/, "/*").replace(/\/$/, "");
+  if (!clean.includes("*")) {
+    let dir = path2.join(root, clean);
+    return isDir(dir) ? [dir] : [];
+  }
+  let [base] = clean.split("*"), parent = path2.join(root, base);
+  return listDir(parent).filter((e2) => !SKIP_DIRS.has(e2) && !e2.startsWith(".")).map((e2) => path2.join(parent, e2)).filter(isDir);
+}
 function packageDirs(root) {
-  let dirs = [root];
+  let dirs = /* @__PURE__ */ new Set([root]);
+  for (let g2 of workspaceGlobs(root))
+    for (let d3 of expandGlob(root, g2))
+      if (isPackage(d3))
+        dirs.add(d3);
   for (let group of MONOREPO_DIRS) {
-    let g = path2.join(root, group);
-    if (!existsSync2(g))
+    let g2 = path2.join(root, group);
+    if (!isDir(g2))
       continue;
-    if (existsSync2(path2.join(g, "package.json")))
-      dirs.push(g);
-    try {
-      for (let entry of readdirSync(g, { withFileTypes: !0 }))
-        if (entry.isDirectory() && existsSync2(path2.join(g, entry.name, "package.json")))
-          dirs.push(path2.join(g, entry.name));
-    } catch {}
+    if (isPackage(g2))
+      dirs.add(g2);
+    for (let entry of listDir(g2)) {
+      let d3 = path2.join(g2, entry);
+      if (!SKIP_DIRS.has(entry) && isDir(d3) && isPackage(d3))
+        dirs.add(d3);
+    }
   }
-  return dirs;
+  return [...dirs].slice(0, MAX_PACKAGES);
+}
+function pythonRequirements(text) {
+  let out = [];
+  for (let line of text.split(/\r?\n/)) {
+    let m2 = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/.exec(line.replace(/#.*/, ""));
+    if (m2 && !line.trim().startsWith("-"))
+      out.push(m2[1].toLowerCase());
+  }
+  return out;
+}
+function pythonProjectDeps(text) {
+  let out = /* @__PURE__ */ new Set;
+  for (let block of text.matchAll(/(?:^|\n)\s*dependencies\s*=\s*\[([\s\S]*?)\]/g))
+    for (let m2 of block[1].matchAll(/["']([A-Za-z0-9][A-Za-z0-9._-]*)/g))
+      out.add(m2[1].toLowerCase());
+  for (let table of text.matchAll(/\[(?:tool\.poetry\.(?:group\.[a-z]+\.)?dependencies|(?:dev-)?packages)\]([\s\S]*?)(?=\n\[|$)/g))
+    for (let m2 of table[1].matchAll(/^\s*([A-Za-z0-9][A-Za-z0-9._-]*)\s*=/gm))
+      out.add(m2[1].toLowerCase());
+  return out.delete("python"), [...out];
+}
+function gemfileDeps(text) {
+  return [...text.matchAll(/^\s*gem\s+["']([^"']+)["']/gm)].map((m2) => m2[1]);
+}
+function goModDeps(text) {
+  let out = [];
+  for (let m2 of text.matchAll(/^\s*(?:require\s+)?([a-z0-9.-]+\.[a-z]+\/[^\s]+)\s+v[0-9]/gm))
+    out.push(m2[1]);
+  return out;
+}
+function cargoDeps(text) {
+  let out = [];
+  for (let table of text.matchAll(/\[(?:dev-|build-)?dependencies\]([\s\S]*?)(?=\n\[|$)/g))
+    for (let m2 of table[1].matchAll(/^\s*([A-Za-z0-9_-]+)\s*=/gm))
+      out.push(m2[1]);
+  return out;
+}
+function manifestDeps(dir) {
+  let deps = [], add = (prefix, names) => {
+    for (let n of names)
+      deps.push(`${prefix}:${n}`);
+  }, req = readText(path2.join(dir, "requirements.txt"));
+  if (req)
+    add("py", pythonRequirements(req));
+  for (let f of ["pyproject.toml", "Pipfile"]) {
+    let t = readText(path2.join(dir, f));
+    if (t)
+      add("py", pythonProjectDeps(t));
+  }
+  let gem = readText(path2.join(dir, "Gemfile"));
+  if (gem)
+    add("gem", gemfileDeps(gem));
+  let composer = readJson(path2.join(dir, "composer.json"));
+  for (let k3 of ["require", "require-dev"]) {
+    let d3 = composer?.[k3];
+    if (d3 && typeof d3 === "object")
+      add("composer", Object.keys(d3));
+  }
+  let gomod = readText(path2.join(dir, "go.mod"));
+  if (gomod)
+    add("go", goModDeps(gomod));
+  let cargo = readText(path2.join(dir, "Cargo.toml"));
+  if (cargo)
+    add("cargo", cargoDeps(cargo));
+  return deps;
 }
 function siteFromWrangler(text) {
   let first = [
     ...text.matchAll(/(?:pattern|route)["']?\s*[:=]\s*["']([^"'*/\s]+)/g),
     ...text.matchAll(/custom_domain["']?\s*[:=]\s*["']([^"'*/\s]+)/g)
-  ].map((m) => m[1].toLowerCase()).filter((h) => h.includes(".") && !h.endsWith("workers.dev"))[0];
+  ].map((m2) => m2[1].toLowerCase()).filter((h2) => h2.includes(".") && !h2.endsWith("workers.dev"))[0];
   if (!first)
     return;
   return `https://${first.replace(/^(app|www|api|console)\./, "")}`;
 }
+var NOT_A_SITE = /(^|\.)(localhost|example\.(com|org)|your-?(site|domain)\.[a-z]+|vercel\.app|netlify\.app|pages\.dev|workers\.dev|github\.com|gitlab\.com|npmjs\.com)$/;
+function publicSite(url) {
+  try {
+    let u2 = new URL(url.startsWith("http") ? url : `https://${url}`);
+    if (!u2.hostname.includes(".") || NOT_A_SITE.test(u2.hostname))
+      return;
+    return `https://${u2.hostname.replace(/^www\./, "")}`;
+  } catch {
+    return;
+  }
+}
+function siteFromConfig(text) {
+  let m2 = /\b(?:site|siteUrl|baseURL|baseUrl|url)\s*[:=]\s*["'`](https?:\/\/[^"'`\s]+)["'`]/.exec(text);
+  return m2 ? publicSite(m2[1]) : void 0;
+}
+function githubRepo(gitConfig) {
+  let remotes = [
+    ...gitConfig.matchAll(/\[remote "([^"]+)"\][^[]*?url\s*=\s*(\S+)/g)
+  ].sort((a, b3) => Number(b3[1] === "origin") - Number(a[1] === "origin"));
+  for (let [, , url] of remotes) {
+    let m2 = /github\.com[:/]([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/.exec(url);
+    if (m2)
+      return `${m2[1]}/${m2[2]}`;
+  }
+  return;
+}
+function readGitConfig(root) {
+  let dotGit = path2.join(root, ".git");
+  if (isDir(dotGit))
+    return readText(path2.join(dotGit, "config"));
+  let pointer = /gitdir:\s*(.+)/.exec(readText(dotGit) ?? "")?.[1]?.trim();
+  if (!pointer)
+    return null;
+  let gitDir = path2.resolve(root, pointer);
+  return readText(path2.join(gitDir, "config")) ?? readText(path2.join(gitDir, "..", "..", "config"));
+}
+function siteFromHtml(html) {
+  let m2 = /<link[^>]+rel=["']canonical["'][^>]+href=["'](https?:\/\/[^"']+)/i.exec(html) ?? /<link[^>]+href=["'](https?:\/\/[^"']+)["'][^>]+rel=["']canonical["']/i.exec(html) ?? /<meta[^>]+property=["']og:url["'][^>]+content=["'](https?:\/\/[^"']+)/i.exec(html);
+  return m2 ? publicSite(m2[1]) : void 0;
+}
 function envKeyNames(text) {
   let out = [];
   for (let line of text.split(/\r?\n/)) {
-    let m = /^\s*(?:#\s*)?(?:export\s+)?([A-Z][A-Z0-9_]*)\s*=/.exec(line);
-    if (m)
-      out.push(m[1]);
+    let m2 = /^\s*(?:#\s*)?(?:export\s+)?([A-Z][A-Z0-9_]*)\s*=/.exec(line);
+    if (m2)
+      out.push(m2[1]);
   }
   return out;
 }
-function scanProject(root) {
-  let deps = /* @__PURE__ */ new Set, files = /* @__PURE__ */ new Set, envKeys = /* @__PURE__ */ new Set, name, siteUrl;
-  for (let dir of packageDirs(root)) {
-    let rel = (f) => path2.relative(root, path2.join(dir, f)) || f, pkg = readJson(path2.join(dir, "package.json"));
+var SITE_CONFIGS = /^(astro\.config\.\w+|next-sitemap\.config\.\w+|gatsby-config\.\w+|docusaurus\.config\.\w+|hugo\.toml|config\.toml|_config\.ya?ml|nuxt\.config\.\w+)$/;
+function scanProject(root, onProgress) {
+  let deps = /* @__PURE__ */ new Set, files = /* @__PURE__ */ new Set, envKeys = /* @__PURE__ */ new Set, name, siteUrl, dirs = packageDirs(root), relDir = (d3) => path2.relative(root, d3).split(path2.sep).join("/") || ".";
+  onProgress?.({
+    label: `Found ${dirs.length} ${dirs.length === 1 ? "package" : "packages"}`,
+    detail: dirs.length > 1 ? dirs.map(relDir).join(", ") : void 0
+  });
+  let envFiles = 0;
+  for (let dir of dirs) {
+    let rel = (f) => (path2.relative(root, path2.join(dir, f)) || f).split(path2.sep).join("/"), pkg = readJson(path2.join(dir, "package.json"));
     if (pkg) {
       if (dir === root && typeof pkg.name === "string")
         name = pkg.name;
       if (!siteUrl && typeof pkg.homepage === "string")
-        siteUrl = pkg.homepage;
-      for (let k of ["dependencies", "devDependencies"]) {
-        let d = pkg[k];
-        if (d && typeof d === "object")
-          for (let n of Object.keys(d))
+        siteUrl = publicSite(pkg.homepage);
+      for (let k3 of ["dependencies", "devDependencies"]) {
+        let d3 = pkg[k3];
+        if (d3 && typeof d3 === "object")
+          for (let n of Object.keys(d3))
             deps.add(n);
       }
     }
-    for (let f of MARKER_FILES) {
-      if (!existsSync2(path2.join(dir, f)))
+    for (let d3 of manifestDeps(dir))
+      deps.add(d3);
+    for (let entry of listDir(dir)) {
+      if (EXAMPLE_ENV.test(entry)) {
+        let text = readText(path2.join(dir, entry));
+        if (text) {
+          envFiles++;
+          for (let k3 of envKeyNames(text))
+            envKeys.add(k3);
+        }
+      }
+      if (!MARKERS.some((re) => re.test(entry)))
         continue;
-      if (files.add(rel(f)), f.startsWith("wrangler."))
-        try {
-          let text = readFileSync2(path2.join(dir, f), "utf8");
-          if (/d1_databases/.test(text))
-            files.add(`${rel(f)}#d1`);
-          if (!siteUrl)
-            siteUrl = siteFromWrangler(text);
-        } catch {}
+      if (files.add(rel(entry)), entry.startsWith("wrangler.")) {
+        let text = readText(path2.join(dir, entry)) ?? "";
+        if (/d1_databases/.test(text))
+          files.add(`${rel(entry)}#d1`);
+        if (!siteUrl)
+          siteUrl = siteFromWrangler(text);
+      } else if (entry === "CNAME" && !siteUrl)
+        siteUrl = publicSite((readText(path2.join(dir, entry)) ?? "").trim());
+    }
+    for (let f of NESTED_MARKERS)
+      if (existsSync2(path2.join(dir, f)))
+        files.add(rel(f));
+    if (!siteUrl)
+      for (let entry of listDir(dir)) {
+        if (!SITE_CONFIGS.test(entry))
+          continue;
+        if (siteUrl = siteFromConfig(readText(path2.join(dir, entry)) ?? ""), siteUrl)
+          break;
+      }
+    if (!siteUrl) {
+      for (let f of ["index.html", "public/index.html", "src/index.html"])
+        if (siteUrl = siteFromHtml(readText(path2.join(dir, f)) ?? ""), siteUrl)
+          break;
     }
-    for (let f of EXAMPLE_ENV)
-      try {
-        for (let k of envKeyNames(readFileSync2(path2.join(dir, f), "utf8")))
-          envKeys.add(k);
-      } catch {}
   }
+  onProgress?.({
+    label: `Read ${deps.size} ${deps.size === 1 ? "dependency" : "dependencies"}`
+  }), onProgress?.({
+    label: `Found ${files.size} config ${files.size === 1 ? "file" : "files"}`,
+    detail: [...files].filter((f) => !f.includes("#")).slice(0, 8).join(", ") || void 0
+  }), onProgress?.({
+    label: envFiles ? `Read ${envKeys.size} variable names from ${envFiles} example env ${envFiles === 1 ? "file" : "files"}` : "No example env files to read",
+    detail: "Names only. Your real .env files are never opened."
+  });
+  let gitConfig = readGitConfig(root), repo = gitConfig ? githubRepo(gitConfig) : void 0;
+  if (repo)
+    onProgress?.({ label: `GitHub repo ${repo}` });
   return {
     name,
     siteUrl,
+    repo,
     dependencies: [...deps].sort(),
     files: [...files].sort(),
     envKeys: [...envKeys].sort()
   };
 }
 
+// src/ui.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1), MARK = [
+  "   ▗▖  ▗▖   ",
+  "   ▐▌  ▐▌   ",
+  "   ▐█▖▗█▌   ",
+  "    ▜██▛    ",
+  "    ▟██▙    ",
+  "   ▟████▙   ",
+  "  ▟██████▙  ",
+  "            ",
+  " ▀▀▀▀▀▀▀▀▀▀ ",
+  "   ▀▀▀▀▀▀   "
+], HORIZON = /* @__PURE__ */ new Set([8, 9]);
+function motionAllowed(argv = process.argv, env = process.env, isTTY = Boolean(process.stdout.isTTY)) {
+  return isTTY && !env.CI && !env.LOPEBASE_NO_MOTION && env.TERM !== "dumb" && !argv.includes("--no-motion");
+}
+var sleep = (ms) => new Promise((r2) => setTimeout(r2, ms));
+function logoLines(opts) {
+  let right = {
+    4: `${import_picocolors3.default.bold("Lope")}${import_picocolors3.default.dim("Base")}${opts.version ? import_picocolors3.default.dim(`  v${opts.version}`) : ""}`,
+    5: import_picocolors3.default.dim(opts.tagline)
+  };
+  return MARK.map((row, i) => {
+    let mark = HORIZON.has(i) ? import_picocolors3.default.yellow(import_picocolors3.default.dim(row)) : import_picocolors3.default.yellow(row);
+    return right[i] ? `${mark}   ${right[i]}` : mark;
+  });
+}
+async function showLogo(opts) {
+  let write = opts.write ?? ((s) => process.stdout.write(s)), lines = logoLines(opts);
+  if (!opts.motion) {
+    write(`
+${lines.join(`
+`)}
+
+`);
+    return;
+  }
+  let blank = MARK.map((r2) => " ".repeat(r2.length)), frame = (shown) => MARK.map((row, i) => shown.has(i) ? HORIZON.has(i) ? import_picocolors3.default.yellow(import_picocolors3.default.dim(row)) : import_picocolors3.default.yellow(row) : blank[i]), up = `\x1B[${MARK.length}A`, onInterrupt = () => {
+    write(`\x1B[?25h
+`), process.exit(130);
+  };
+  process.once("SIGINT", onInterrupt), write(`
+\x1B[?25l`);
+  try {
+    let shown = /* @__PURE__ */ new Set;
+    write(`${frame(shown).join(`
+`)}
+`);
+    for (let i = MARK.length - 1;i >= 0; i--)
+      shown.add(i), write(`${up}\r${frame(shown).join(`
+`)}
+`), await sleep(i >= 8 ? 70 : 35);
+    write(`${up}\r${lines.join(`
+`)}
+
+`);
+  } finally {
+    process.off("SIGINT", onInterrupt), write("\x1B[?25h");
+  }
+}
+async function pace(motion, ms = 90) {
+  if (motion)
+    await sleep(ms);
+}
+var KIND_LABEL = {
+  framework: "Framework",
+  language: "Language",
+  hosting: "Hosting",
+  database: "Data",
+  email: "Email",
+  billing: "Billing",
+  auth: "Sign-in",
+  analytics: "Analytics",
+  cms: "Content"
+};
+function stackRows(detection, facts) {
+  let byKind = /* @__PURE__ */ new Map;
+  for (let s of detection.stack)
+    byKind.set(s.kind, [...byKind.get(s.kind) ?? [], s.name]);
+  let rows = [];
+  for (let kind of Object.keys(KIND_LABEL)) {
+    let names = byKind.get(kind);
+    if (names)
+      rows.push([KIND_LABEL[kind], names.join(", ")]);
+  }
+  if (facts.siteUrl)
+    rows.push(["Site", facts.siteUrl]);
+  if (facts.repo)
+    rows.push(["Repo", facts.repo]);
+  if (!rows.length)
+    return [import_picocolors3.default.dim("Nothing recognized yet. Your agent will look closer.")];
+  let width = Math.max(...rows.map(([k3]) => k3.length));
+  return rows.map(([k3, v2]) => `${import_picocolors3.default.dim(k3.padEnd(width))}  ${v2}`);
+}
+var PLAN = [
+  {
+    title: "Scan this folder",
+    detail: "Reads dependency and file names only. Never your .env or code."
+  },
+  {
+    title: "Connect this computer",
+    detail: "Sign in in the browser and confirm a short code."
+  },
+  {
+    title: "Choose what to connect",
+    detail: "What your code already uses is ticked. New things are optional."
+  },
+  {
+    title: "Hand over to your coding agent",
+    detail: "It does the setup and asks you when it needs a key or a yes."
+  }
+];
+function planLines() {
+  return PLAN.map((s, i) => `${import_picocolors3.default.yellow(String(i + 1))}  ${import_picocolors3.default.bold(s.title)}
+   ${import_picocolors3.default.dim(s.detail)}`);
+}
+function stepTitle(n) {
+  return `${import_picocolors3.default.dim(`Step ${n} of ${PLAN.length}`)}  ${import_picocolors3.default.bold(PLAN[n - 1].title)}`;
+}
+
 // bin/lopebase.ts
-var [command = "init", ...rest] = process.argv.slice(2), flag = (name) => rest.includes(`--${name}`), option = (name) => {
+var [command = "init", ...rest] = process.argv.slice(2), HELP = `
+${import_picocolors4.default.bgYellow(import_picocolors4.default.black(" LopeBase "))}  Set up LopeBase from this project's folder.
+
+${import_picocolors4.default.bold("Usage")}
+  npx lopebase                      scan, connect, and hand over to your agent
+  npx lopebase login                connect this computer (--paste for a token)
+  npx lopebase scan [--json]        show what the scan found
+  npx lopebase prompt               print the setup prompt instead
+  npx lopebase mcp                  run the LopeBase tools as a stdio MCP server
+  npx lopebase adapter secret       print a new @lopebase/adapter signing secret
+  npx lopebase adapter check <url>  test a running adapter (reads LOPEBASE_SIGNING_SECRET)
+
+${import_picocolors4.default.bold("Options")}
+  --print                           print the agent prompt instead of starting an agent
+  --no-motion                       no animation (also LOPEBASE_NO_MOTION=1)
+
+${import_picocolors4.default.bold("Learn more")}
+  ${import_picocolors4.default.cyan("https://lopebase.com")}
+  Help: contact@jackalope.digital
+`, flag = (name) => rest.includes(`--${name}`), option = (name) => {
   let i = rest.indexOf(`--${name}`);
   return i >= 0 ? rest[i + 1] : rest.find((a) => a.startsWith(`--${name}=`))?.split("=")[1];
-}, cwd = process.cwd();
+}, cwd = process.cwd(), motion = motionAllowed(), TAGLINE = "Every product, one place.";
+function version() {
+  try {
+    return JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf8")).version;
+  } catch {
+    return;
+  }
+}
 function bail(message) {
   xe(message), process.exit(1);
 }
@@ -1389,8 +2792,11 @@ function guard(value) {
   return value;
 }
 function openBrowser(url) {
-  let cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  spawn(cmd, [url], { stdio: "ignore", detached: !0 }).unref();
+  let [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+  try {
+    let child = spawn2(cmd, args, { stdio: "ignore", detached: !0 });
+    child.on("error", () => {}), child.unref();
+  } catch {}
 }
 async function checkToken(auth) {
   try {
@@ -1409,40 +2815,40 @@ async function checkToken(auth) {
     });
     if (res.status === 401)
       return { ok: !1, message: "That token is not valid or has expired." };
-    let body = await res.json();
-    return { ok: !0, products: JSON.parse(body.result?.content?.[0]?.text ?? "[]").length };
-  } catch (e) {
+    let body2 = await res.json();
+    return { ok: !0, products: JSON.parse(body2.result?.content?.[0]?.text ?? "[]").length };
+  } catch (e2) {
     return {
       ok: !1,
-      message: `Could not reach ${auth.url} (${String(e)}).`
+      message: `Could not reach ${auth.url} (${String(e2)}).`
     };
   }
 }
 async function login() {
-  let url = guard(await he({
-    message: "Your LopeBase workspace address",
-    placeholder: "https://yourteam.lopebase.com",
-    initialValue: option("url") ?? loadAuth()?.url ?? DEFAULT_URL,
-    validate: (v) => /^https?:\/\/\S+$/.test(v ?? "") ? void 0 : "Starts with https://"
-  })).replace(/\/+$/, "");
+  let known = option("url") ?? loadAuth()?.url, url = workspaceUrl(guard(await he({
+    message: "Your LopeBase workspace (name or address)",
+    placeholder: "yourteam  or  https://yourteam.lopebase.com",
+    initialValue: known ?? "",
+    validate: (v2) => workspaceUrl(v2 ?? "") ? void 0 : "Type your workspace name, like yourteam, or its full address"
+  })));
   if (!flag("paste")) {
     let device = await startDeviceLogin(url);
     if (device) {
       Me([
-        `Your code: ${import_picocolors3.default.bold(import_picocolors3.default.yellow(device.userCode))}`,
+        `Your code: ${import_picocolors4.default.bold(import_picocolors4.default.yellow(device.userCode))}`,
         "",
         "We opened your workspace in the browser. Sign in if asked,",
         "check the code matches, and press Connect."
       ].join(`
-`), "Connect this computer"), openBrowser(device.verifyUrl), M2.info(import_picocolors3.default.dim(device.verifyUrl));
+`), "Connect this computer"), openBrowser(device.verifyUrl), M2.info(import_picocolors4.default.dim(device.verifyUrl));
       let s = Y2();
       s.start("Waiting for you to approve in the browser");
       let res = await pollDeviceLogin(url, device);
       if (res.ok) {
-        let file = saveAuth({ url: res.url, token: res.token });
-        return s.stop(`Connected (${res.scope}). Saved to ${import_picocolors3.default.dim(file)}`), { url: res.url, token: res.token };
+        let file2 = saveAuth({ url: res.url, token: res.token });
+        return s.stop(`Connected (${res.scope}). Saved to ${import_picocolors4.default.dim(file2)}`), { url: res.url, token: res.token };
       }
-      if (s.stop(import_picocolors3.default.red(res.message)), res.reason === "denied")
+      if (s.stop(import_picocolors4.default.red(res.message)), res.reason === "denied")
         bail("Nothing was connected.");
       M2.warn("Falling back to pasting a token.");
     }
@@ -1453,47 +2859,59 @@ async function pasteLogin(url) {
   let settings = `${url}/settings#agent-access`;
   Me([
     "1. Sign in (or sign up) in the browser tab we open.",
-    `2. Under Settings, Agent access, press ${import_picocolors3.default.bold("Create agent access")}.`,
+    `2. Under Settings, Agent access, press ${import_picocolors4.default.bold("Create agent access")}.`,
     "3. Copy the token and paste it here. It is saved on this computer only."
   ].join(`
-`), "Get an agent token"), openBrowser(settings), M2.info(import_picocolors3.default.dim(settings));
+`), "Get an agent token"), openBrowser(settings), M2.info(import_picocolors4.default.dim(settings));
   for (;; ) {
     let token = guard(await ge({
       message: "Paste the agent token",
-      validate: (v) => v?.startsWith("lb_agent_") ? void 0 : "Tokens start with lb_agent_"
+      validate: (v2) => v2?.startsWith("lb_agent_") ? void 0 : "Tokens start with lb_agent_"
     })).trim(), s = Y2();
     s.start("Checking the token");
     let check = await checkToken({ url, token });
     if (check.ok) {
-      let file = saveAuth({ url, token });
-      return s.stop(`Signed in. ${check.products} product(s) in this workspace. Saved to ${import_picocolors3.default.dim(file)}`), { url, token };
+      let file2 = saveAuth({ url, token });
+      return s.stop(`Signed in. ${check.products} product(s) in this workspace. Saved to ${import_picocolors4.default.dim(file2)}`), { url, token };
     }
-    s.stop(import_picocolors3.default.red(check.message ?? "That did not work."));
+    s.stop(import_picocolors4.default.red(check.message ?? "That did not work."));
   }
 }
-function printDetection(d) {
-  let stack = d.stack.map((s) => `${import_picocolors3.default.bold(s.name)} ${import_picocolors3.default.dim(s.kind)}`).join(`
-`) || import_picocolors3.default.dim("Nothing recognised");
-  Me(stack, "Your stack");
-  let found = d.sources.filter((s) => s.status === "found");
+async function printDetection(d3, facts) {
+  Me(stackRows(d3, facts).join(`
+`), "Your stack"), await pace(motion, 150);
+  let found = d3.sources.filter((s) => s.status === "found");
   if (found.length)
-    Me(found.map((s) => `${import_picocolors3.default.green("●")} ${import_picocolors3.default.bold(s.label)}  ${import_picocolors3.default.dim(s.evidence.join(", "))}`).join(`
-`), "Already in your code, ready to connect");
-  let possible = d.sources.filter((s) => s.status === "possible");
+    Me(found.map((s) => `${import_picocolors4.default.green("●")} ${import_picocolors4.default.bold(s.label)}  ${import_picocolors4.default.dim(s.evidence.join(", "))}`).join(`
+`), "Already in your code, ready to connect"), await pace(motion, 150);
+  let possible = d3.sources.filter((s) => s.status === "possible");
   if (possible.length)
-    Me(possible.map((s) => `${import_picocolors3.default.yellow("?")} ${import_picocolors3.default.bold(s.label)}  ${import_picocolors3.default.dim(`only ${s.evidence.join(", ")}`)}`).join(`
-`), "Maybe in use, your agent will check");
-  for (let gap of d.gaps)
+    Me(possible.map((s) => `${import_picocolors4.default.yellow("?")} ${import_picocolors4.default.bold(s.label)}  ${import_picocolors4.default.dim(`only ${s.evidence.join(", ")}`)}`).join(`
+`), "Maybe in use, your agent will check"), await pace(motion, 150);
+  for (let gap of d3.gaps)
     M2.warn(gap);
 }
+async function scanWithProgress() {
+  let s = Y2();
+  s.start("Reading this folder");
+  let steps = [], facts = scanProject(cwd, (step) => steps.push(step));
+  await pace(motion, 400), s.stop("Read this folder");
+  for (let step of steps)
+    M2.success(step.detail ? `${step.label}
+${import_picocolors4.default.dim(step.detail)}` : step.label), await pace(motion, 120);
+  let detection = detectStack(facts);
+  return { facts, detection };
+}
 function selfCommand() {
   let self = process.argv[1] ?? "";
-  return self.includes("node_modules") || !self ? ["npx", "-y", "lopebase", "mcp"] : [process.execPath, self, "mcp"];
+  if (self && !self.includes("node_modules"))
+    return [process.execPath, self, "mcp"];
+  return process.platform === "win32" ? ["cmd", "/c", "npx", "-y", "lopebase", "mcp"] : ["npx", "-y", "lopebase", "mcp"];
 }
 function registerMcp(agent) {
   if (!agent.mcpAdd)
     return !1;
-  let argv = agent.mcpAdd(selfCommand()), res = spawnSync2(agent.bin, argv, {
+  let argv = agent.mcpAdd(selfCommand()), res = spawnAgentSync(agent.bin, argv, {
     stdio: "pipe",
     cwd,
     encoding: "utf8"
@@ -1501,29 +2919,40 @@ function registerMcp(agent) {
   return res.status === 0 || /already exists/i.test(`${res.stderr}${res.stdout}`);
 }
 async function init() {
-  console.clear(), Ie(`${import_picocolors3.default.bgYellow(import_picocolors3.default.black(" LopeBase "))} set up this project`);
-  let s = Y2();
-  s.start("Scanning this folder");
-  let facts = scanProject(cwd), detection = detectStack(facts);
-  s.stop(`Scanned ${facts.dependencies.length} dependencies and ${facts.files.length} config files`), printDetection(detection);
-  let auth = loadAuth() ?? await login();
-  if (!(await checkToken(auth)).ok)
-    M2.warn("Your saved token no longer works. Let's get a new one."), await login();
+  console.clear(), await showLogo({ tagline: TAGLINE, version: version(), motion }), Ie(`${import_picocolors4.default.bgYellow(import_picocolors4.default.black(" LopeBase "))} set up this project`), Me(planLines().join(`
+`), "Here is what happens"), await pace(motion, 300), M2.step(stepTitle(1));
+  let { facts, detection } = await scanWithProgress();
+  await printDetection(detection, facts), M2.step(stepTitle(2));
+  let auth = loadAuth();
+  if (auth) {
+    let s2 = Y2();
+    s2.start(`Checking your connection to ${auth.url}`);
+    let check = await checkToken(auth);
+    if (check.ok)
+      s2.stop(`Connected to ${import_picocolors4.default.bold(auth.url)}. ${check.products} ${check.products === 1 ? "product" : "products"} so far.`);
+    else
+      s2.stop(import_picocolors4.default.yellow("Your saved connection no longer works.")), auth = null;
+  }
+  auth ??= await login(), M2.step(stepTitle(3));
   let productName = guard(await he({
     message: "What is this product called?",
     initialValue: facts.name?.replace(/^@[^/]+\//, "") ?? ""
   })), chosen = guard(await fe({
-    message: "What should we connect? (space to toggle)",
+    message: "What should we connect? (space to toggle, enter to go on)",
     options: detection.sources.map((src) => ({
       value: src.label,
-      label: src.status === "found" ? src.label : src.status === "possible" ? `${src.label} ${import_picocolors3.default.dim("(maybe in use, we'll check)")}` : `${src.label} ${import_picocolors3.default.dim("(not set up yet, we'll help)")}`,
+      label: src.status === "found" ? src.label : src.status === "possible" ? `${src.label} ${import_picocolors4.default.dim("(maybe in use, we'll check)")}` : `${src.label} ${import_picocolors4.default.dim("(not set up yet, we'll help)")}`,
       hint: src.why
     })),
-    initialValues: detection.sources.filter((src) => src.status === "found" || src.source === "gsc").map((src) => src.label),
+    initialValues: detection.sources.filter((src) => src.status === "found" || src.source === "gsc" || src.source === "uptime").map((src) => src.label),
     required: !1
-  })), prompt = onboardingPrompt({ facts, detection, chosen, productName }), agents = installedAgents();
+  }));
+  M2.step(stepTitle(4));
+  let prompt = onboardingPrompt({ facts, detection, chosen, productName }), agents = installedAgents();
   if (!agents.length || flag("print")) {
-    Me(prompt, "Paste this into your coding agent"), Se(`Add the MCP server first: ${import_picocolors3.default.cyan("npx lopebase mcp")} (stdio)`);
+    if (!agents.length)
+      M2.info("No coding agent found on this computer (Claude Code, Codex, and others). Paste the prompt below into the one you use.");
+    Me(prompt, "Paste this into your coding agent"), Se(`Add the MCP server first: ${import_picocolors4.default.cyan("npx lopebase mcp")} (stdio)`);
     return;
   }
   let agentId = guard(await ve({
@@ -1537,29 +2966,66 @@ async function init() {
     Me(prompt, "Paste this into your coding agent"), Se("Done.");
     return;
   }
-  let agent = agents.find((a) => a.id === agentId);
-  if (registerMcp(agent))
-    M2.success(`Added LopeBase tools to ${agent.label} for this folder.`);
+  let agent = agents.find((a) => a.id === agentId), s = Y2();
+  s.start(`Adding the LopeBase tools to ${agent.label}`);
+  let registered = registerMcp(agent);
+  if (await pace(motion, 300), registered)
+    s.stop(`Added the LopeBase tools to ${agent.label} for this folder.`);
   else
-    M2.warn(`Add an MCP server to ${agent.label} that runs: npx -y lopebase mcp`);
-  Se(`Handing over to ${agent.label}. You stay in the loop for anything that needs you.`), spawn(agent.bin, agent.args(prompt), { stdio: "inherit", cwd }).on("exit", (code) => process.exit(code ?? 0));
+    s.stop(import_picocolors4.default.yellow(`Add an MCP server to ${agent.label} that runs: npx -y lopebase mcp`));
+  Me([
+    `${import_picocolors4.default.bold(agent.label)} will now:`,
+    `  ${import_picocolors4.default.dim("1.")} add ${import_picocolors4.default.bold(productName || "this product")} to your workspace`,
+    `  ${import_picocolors4.default.dim("2.")} connect ${chosen.length ? chosen.join(", ") : "what it recommends"}`,
+    `  ${import_picocolors4.default.dim("3.")} stop and ask you for any sign-in, key, or yes`,
+    "",
+    import_picocolors4.default.dim("You can follow along in your workspace as each one turns green.")
+  ].join(`
+`), "Handing over"), Se(`Starting ${agent.label}. Press Ctrl+C any time to stop.`);
+  let child = spawnAgent(agent.bin, agent.args(prompt), {
+    stdio: "inherit",
+    cwd
+  });
+  child.on("error", (e2) => bail(`Could not start ${agent.label}: ${e2.message}`)), child.on("exit", (code) => process.exit(code ?? 0));
 }
 async function main() {
   switch (command) {
     case "init":
       return init();
     case "login":
-      return Ie(`${import_picocolors3.default.bgYellow(import_picocolors3.default.black(" LopeBase "))} sign in`), await login(), Se("Ready. Run lopebase in any project.");
+      return await showLogo({ tagline: TAGLINE, version: version(), motion }), Ie(`${import_picocolors4.default.bgYellow(import_picocolors4.default.black(" LopeBase "))} sign in`), await login(), Se("Ready. Run lopebase in any project.");
     case "scan": {
       let facts = scanProject(cwd), detection = detectStack(facts);
       if (flag("json"))
         return console.log(JSON.stringify({ facts, detection }, null, 2));
-      return printDetection(detection);
+      return Ie(`${import_picocolors4.default.bgYellow(import_picocolors4.default.black(" LopeBase "))} scan`), await printDetection(detection, facts), Se(`Run ${import_picocolors4.default.cyan("npx lopebase")} to connect what it found.`);
     }
     case "prompt": {
       let facts = scanProject(cwd), detection = detectStack(facts);
       return console.log(onboardingPrompt({ facts, detection, chosen: [] }));
     }
+    case "adapter": {
+      let sub = rest[0];
+      if (sub === "secret")
+        return process.stdout.write(`${newSigningSecret()}
+`);
+      if (sub === "check" && rest[1]) {
+        let envName = option("secret-env") ?? "LOPEBASE_SIGNING_SECRET", secret = process.env[envName]?.trim(), token = process.env.LOPEBASE_ADAPTER_TOKEN?.trim();
+        if (!secret && !token)
+          console.error(`Set ${envName} to the adapter's signing secret (or LOPEBASE_ADAPTER_TOKEN for an older bearer adapter).`), process.exit(1);
+        console.log(`Checking ${rest[1]}`);
+        let res = await checkAdapter({
+          baseUrl: rest[1],
+          secret,
+          token: secret ? void 0 : token,
+          log: (l2) => console.log(l2.startsWith("FAIL") ? import_picocolors4.default.red(l2) : import_picocolors4.default.green(l2))
+        });
+        console.log(res.failed.length ? import_picocolors4.default.red(`${res.failed.length} failed, ${res.passed} passed`) : import_picocolors4.default.green(`All ${res.passed} checks passed. Ready to connect.`)), process.exit(res.failed.length ? 1 : 0);
+      }
+      return console.log(`Usage:
+  lopebase adapter secret              print a new signing secret
+  lopebase adapter check <base-url>    test a running adapter (reads LOPEBASE_SIGNING_SECRET)`), process.exit(sub ? 1 : 0);
+    }
     case "mcp": {
       let auth = loadAuth();
       if (!auth)
@@ -1567,7 +3033,7 @@ async function main() {
       return runMcpProxy(auth);
     }
     default:
-      console.log("Usage: lopebase [init|login|scan|prompt|mcp]"), process.exit(command === "--help" || command === "-h" ? 0 : 1);
+      console.log(HELP), process.exit(command === "--help" || command === "-h" || command === "help" ? 0 : 1);
   }
 }
 main();