@chrisjowen/wheelhouse 0.1.1 → 0.2.1

package/build/server/chunks/chunks/settings.js-C_6kvzhM.js

@@ -0,0 +1,862 @@
+import { stat, readFile, mkdir, writeFile, rename } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { P as PREVIEW_HOSTS } from './preview.js-hrimfbCG.js';
+import { e as extractUrls } from './urls.js-BrlC6XZ8.js';
+
+const EMPTY_CONFIG = { plugins: {} };
+function defaultConfigDir(env) {
+  if (env.WHEELHOUSE_CONFIG_DIR) return path.resolve(env.WHEELHOUSE_CONFIG_DIR);
+  if (env.XDG_CONFIG_HOME) return path.join(env.XDG_CONFIG_HOME, "wheelhouse");
+  return path.join(homedir(), ".config", "wheelhouse");
+}
+const PLUGINS_FILE = "plugins.json";
+const isRecord$2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function parsePluginConfig(text2) {
+  let raw;
+  try {
+    raw = JSON.parse(text2);
+  } catch (e) {
+    return { ok: false, error: `not valid JSON: ${e.message}` };
+  }
+  if (!isRecord$2(raw)) return { ok: false, error: "expected a JSON object" };
+  for (const k of Object.keys(raw)) {
+    if (k !== "plugins") return { ok: false, error: `unknown field "${k}"` };
+  }
+  const plugins = {};
+  if (raw.plugins !== void 0) {
+    if (!isRecord$2(raw.plugins)) return { ok: false, error: '"plugins" must be an object' };
+    for (const [id, s] of Object.entries(raw.plugins)) {
+      if (!isRecord$2(s)) return { ok: false, error: `plugins.${id} must be an object` };
+      const setting = {};
+      for (const [k, v] of Object.entries(s)) {
+        if (k === "enabled") {
+          if (typeof v !== "boolean") {
+            return { ok: false, error: `plugins.${id}.enabled must be true or false` };
+          }
+          setting.enabled = v;
+        } else if (k === "projects") {
+          if (!isRecord$2(v)) return { ok: false, error: `plugins.${id}.projects must be an object` };
+          for (const [p, on] of Object.entries(v)) {
+            if (typeof on !== "boolean") {
+              return { ok: false, error: `plugins.${id}.projects.${p} must be true or false` };
+            }
+          }
+          setting.projects = v;
+        } else if (k === "settings") {
+          if (!isRecord$2(v)) return { ok: false, error: `plugins.${id}.settings must be an object` };
+          setting.settings = v;
+        } else {
+          return { ok: false, error: `unknown field "plugins.${id}.${k}"` };
+        }
+      }
+      plugins[id] = setting;
+    }
+  }
+  return { ok: true, config: { plugins } };
+}
+function isEnabled(config, plugin, projectId, defaultOn = plugin.enabledByDefault ?? false) {
+  const s = config.plugins[plugin.id];
+  return s?.projects?.[projectId] ?? s?.enabled ?? defaultOn;
+}
+class PluginConfigFile {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  mtimeMs = null;
+  cached = {
+    config: EMPTY_CONFIG,
+    error: null
+  };
+  /** A read in progress, shared by calls that arrive meanwhile, so none sees the defaults early. */
+  reading = null;
+  async current() {
+    let mtimeMs;
+    try {
+      mtimeMs = (await stat(this.file)).mtimeMs;
+    } catch (e) {
+      this.mtimeMs = null;
+      const code = e.code;
+      this.cached = {
+        config: EMPTY_CONFIG,
+        error: code === "ENOENT" ? null : `could not read ${this.file}: ${e.message}`
+      };
+      return this.cached;
+    }
+    if (mtimeMs === this.mtimeMs) return this.cached;
+    if (this.reading?.mtimeMs === mtimeMs) return this.reading.done;
+    const done = this.read().then((r) => {
+      if (this.reading?.done === done) {
+        this.cached = r;
+        this.mtimeMs = mtimeMs;
+        this.reading = null;
+      }
+      return r;
+    });
+    this.reading = { mtimeMs, done };
+    return done;
+  }
+  async read() {
+    try {
+      const parsed = parsePluginConfig(await readFile(this.file, "utf8"));
+      return parsed.ok ? { config: parsed.config, error: null } : { config: EMPTY_CONFIG, error: `${this.file}: ${parsed.error}` };
+    } catch (e) {
+      return {
+        config: EMPTY_CONFIG,
+        error: `could not read ${this.file}: ${e.message}`
+      };
+    }
+  }
+}
+async function readRaw(file) {
+  let text2;
+  try {
+    text2 = await readFile(file, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") return { ok: true, raw: null };
+    return { ok: false, error: `could not read ${file}: ${e.message}` };
+  }
+  const parsed = parsePluginConfig(text2);
+  if (!parsed.ok) return { ok: false, error: `${file} is not valid: ${parsed.error}` };
+  return { ok: true, raw: JSON.parse(text2) };
+}
+async function readPluginSettings(dir, id) {
+  const r = await readRaw(path.join(dir, PLUGINS_FILE));
+  if (!r.ok) return r;
+  const plugins = r.raw?.plugins ?? {};
+  return { ok: true, settings: { ...plugins[id]?.settings ?? {} } };
+}
+let editing = Promise.resolve();
+function editPlugin(dir, id, change) {
+  const run = editing.then(async () => {
+    const file = path.join(dir, PLUGINS_FILE);
+    const r = await readRaw(file);
+    if (!r.ok) return r;
+    const raw = r.raw ?? {};
+    const plugins = isRecord$2(raw.plugins) ? raw.plugins : {};
+    const entry2 = isRecord$2(plugins[id]) ? { ...plugins[id] } : {};
+    change(entry2);
+    if (Object.keys(entry2).length) plugins[id] = entry2;
+    else delete plugins[id];
+    raw.plugins = plugins;
+    try {
+      await mkdir(dir, { recursive: true });
+      const tmp = `${file}.${process.pid}.tmp`;
+      await writeFile(tmp, `${JSON.stringify(raw, null, "	")}
+`);
+      await rename(tmp, file);
+    } catch (e) {
+      return { ok: false, error: `could not write ${file}: ${e.message}` };
+    }
+    return { ok: true };
+  });
+  editing = run.catch(() => {
+  });
+  return run;
+}
+function writePluginSettings(dir, id, settings2) {
+  return editPlugin(dir, id, (entry2) => {
+    entry2.settings = settings2;
+  });
+}
+function changePlugin(dir, id, c) {
+  return editPlugin(dir, id, (entry2) => {
+    if ("settings" in c) {
+      const settings2 = isRecord$2(entry2.settings) ? { ...entry2.settings } : {};
+      for (const [k, v] of Object.entries(c.settings)) {
+        if (v === void 0) delete settings2[k];
+        else settings2[k] = v;
+      }
+      entry2.settings = settings2;
+    } else if ("project" in c) {
+      const projects = isRecord$2(entry2.projects) ? { ...entry2.projects } : {};
+      if (c.enabled === null) delete projects[c.project];
+      else projects[c.project] = c.enabled;
+      if (Object.keys(projects).length) entry2.projects = projects;
+      else delete entry2.projects;
+    } else if (c.enabled === null) delete entry2.enabled;
+    else {
+      entry2.enabled = c.enabled;
+      delete entry2.projects;
+    }
+  });
+}
+const INSTALLED_FILE = "installed.json";
+const SCHEMA = "wheelhouse-installed-plugins.v1";
+const EMPTY_INSTALLED = () => ({ schema: SCHEMA, plugins: {} });
+function defaultPluginsDir(env) {
+  if (env.WHEELHOUSE_PLUGINS_DIR) return path.resolve(env.WHEELHOUSE_PLUGINS_DIR);
+  return path.join(homedir(), ".wheelhouse", "plugins");
+}
+const isRecord$1 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function record(v) {
+  if (!isRecord$1(v)) return null;
+  const { repository, ref, commit, version, installedAt, enabled } = v;
+  if (typeof repository !== "string" || ref !== null && typeof ref !== "string" || typeof commit !== "string" || typeof version !== "string" || typeof installedAt !== "string" || typeof enabled !== "boolean") {
+    return null;
+  }
+  return { repository, ref, commit, version, installedAt, enabled };
+}
+async function readInstalled(dir) {
+  const file = path.join(dir, INSTALLED_FILE);
+  let text2;
+  try {
+    text2 = await readFile(file, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return { ok: true, installed: EMPTY_INSTALLED() };
+    return { ok: false, error: `could not read ${file}: ${e.message}` };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text2);
+  } catch (e) {
+    return { ok: false, error: `${file} is not valid JSON: ${e.message}` };
+  }
+  if (!isRecord$1(raw) || raw.schema !== SCHEMA || !isRecord$1(raw.plugins)) {
+    return { ok: false, error: `${file} is not a ${SCHEMA} record` };
+  }
+  const installed = EMPTY_INSTALLED();
+  for (const [id, v] of Object.entries(raw.plugins)) {
+    const r = record(v);
+    if (!r) return { ok: false, error: `${file}: the entry for "${id}" is not a valid record` };
+    installed.plugins[id] = r;
+  }
+  return { ok: true, installed };
+}
+async function writeInstalled(dir, installed) {
+  await mkdir(dir, { recursive: true });
+  const file = path.join(dir, INSTALLED_FILE);
+  const tmp = `${file}.${process.pid}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(installed, null, "	")}
+`);
+  await rename(tmp, file);
+}
+const TEMPLATE = /^[a-z0-9-]*\{port\}[a-z0-9-]*(?:\.[a-z0-9-]+)*\.localhost$/;
+function validHostTemplate(v) {
+  return typeof v === "string" && v.length <= 100 && TEMPLATE.test(v);
+}
+const validPort = (n) => Number.isInteger(n) && n >= 1 && n <= 65535;
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
+function matchHost(template, hostname) {
+  const [before, after] = template.split("{port}");
+  const m = new RegExp(`^${escape(before)}([1-9]\\d{0,4})${escape(after)}$`).exec(
+    hostname.toLowerCase()
+  );
+  const port = m ? Number(m[1]) : NaN;
+  return validPort(port) ? port : null;
+}
+function localhostName(host) {
+  const m = /^((?:[a-z0-9-]+\.)+localhost)(?::\d{1,5})?$/i.exec(host ?? "");
+  return m ? m[1].toLowerCase() : null;
+}
+function loopbackAddresses(text2) {
+  const found = /* @__PURE__ */ new Set();
+  for (const url of extractUrls(text2)) {
+    const u = URL.parse(url);
+    if (u && (u.protocol === "http:" || u.protocol === "https:")) {
+      if (PREVIEW_HOSTS.has(u.hostname.toLowerCase()) && !u.username && !u.password) {
+        found.add(url);
+      }
+    }
+  }
+  return [...found];
+}
+const SLOTS = [
+  "project.tab",
+  "harbour.card",
+  "task.section",
+  "step.evidence",
+  "bridge.card",
+  "home.card",
+  "header.indicator",
+  "nav.page"
+];
+const SLOT_SCOPE = {
+  "project.tab": "project",
+  "harbour.card": "project",
+  "task.section": "task",
+  "step.evidence": "task",
+  "bridge.card": "fleet",
+  "home.card": "fleet",
+  "header.indicator": "fleet",
+  "nav.page": "fleet"
+};
+const PLUGIN_API_VERSION = 1;
+const SUPPORTED_API_VERSIONS = [PLUGIN_API_VERSION, PLUGIN_API_VERSION - 1].filter(
+  (v) => v >= 1
+);
+const MANIFEST_DIR = ".wheelhouse-plugin";
+const MANIFEST_FILE = "plugin.json";
+const manifestPath = (pluginDir) => path.join(pluginDir, MANIFEST_DIR, MANIFEST_FILE);
+const MANIFEST_FIELDS = [
+  "$schema",
+  "name",
+  "displayName",
+  "version",
+  "description",
+  "author",
+  "repository",
+  "homepage",
+  "license",
+  "keywords",
+  "wheelhouse"
+];
+const WHEELHOUSE_FIELDS = [
+  "apiVersion",
+  "server",
+  "ui",
+  "enabledByDefault",
+  "enabledWhenFile",
+  "enabledWhenHomeFile",
+  "contributions",
+  "services",
+  "settings",
+  "mcpServers",
+  "addressRewrites",
+  "hostRoutes"
+];
+const SETTING_FIELDS = [
+  "title",
+  "description",
+  "type",
+  "required",
+  "default",
+  "options"
+];
+const SETTING_TYPES = ["text", "number", "boolean", "list"];
+const ID = /^[a-z][a-z0-9-]{0,39}$/;
+const SETTING_KEY = /^[A-Za-z][A-Za-z0-9_]{0,39}$/;
+const MAX_SETTINGS = 20;
+const MAX_OPTIONS = 20;
+const MAX_LIST = 50;
+const SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const MAX_TEXT = 400;
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function insidePath(f) {
+  return typeof f === "string" && f.length > 0 && !path.isAbsolute(f) && !f.split(/[\\/]/).some((part) => part === ".." || part === "" || part === ".");
+}
+class Invalid extends Error {
+}
+function text(v, where, optional = false) {
+  if (v === void 0 && optional) return null;
+  if (typeof v !== "string" || !v.trim()) throw new Invalid(`${where} must be text`);
+  if (v.length > MAX_TEXT) throw new Invalid(`${where} is longer than ${MAX_TEXT} characters`);
+  return v;
+}
+function only(o, where, keys) {
+  for (const k of Object.keys(o)) {
+    if (!keys.includes(k)) throw new Invalid(`unknown field "${where ? `${where}.` : ""}${k}"`);
+  }
+}
+function entry(v, where) {
+  if (!insidePath(v)) throw new Invalid(`${where} must be a plain path inside the plugin`);
+  if (!/\.m?js$/.test(v)) throw new Invalid(`${where} must be a JavaScript module (.js or .mjs)`);
+  return v;
+}
+function author(v) {
+  if (v === void 0) return null;
+  if (typeof v === "string") return { name: text(v, "author") };
+  if (!isRecord(v)) throw new Invalid("author must be text or an object");
+  only(v, "author", ["name", "email", "url"]);
+  const a = { name: text(v.name, "author.name") };
+  const email = text(v.email, "author.email", true);
+  const url = text(v.url, "author.url", true);
+  if (email) a.email = email;
+  if (url) a.url = url;
+  return a;
+}
+function wheelhouse(v) {
+  if (!isRecord(v)) throw new Invalid('"wheelhouse" must be an object');
+  only(v, "wheelhouse", WHEELHOUSE_FIELDS);
+  if (typeof v.apiVersion !== "number" || !Number.isInteger(v.apiVersion)) {
+    throw new Invalid("wheelhouse.apiVersion must be a whole number");
+  }
+  if (!SUPPORTED_API_VERSIONS.includes(v.apiVersion)) {
+    throw new Invalid(
+      `it was written for plugin contract ${v.apiVersion}; this Wheelhouse supports ${SUPPORTED_API_VERSIONS.join(" and ")}`
+    );
+  }
+  const w = {
+    apiVersion: v.apiVersion,
+    server: entry(v.server, "wheelhouse.server"),
+    ui: v.ui === void 0 ? null : entry(v.ui, "wheelhouse.ui"),
+    contributions: [],
+    services: [],
+    settings: settings(v.settings),
+    mcpServers: [],
+    addressRewrites: hosts(v.addressRewrites, "addressRewrites", "to"),
+    hostRoutes: hosts(v.hostRoutes, "hostRoutes", "host")
+  };
+  if (v.enabledByDefault !== void 0) {
+    if (typeof v.enabledByDefault !== "boolean") {
+      throw new Invalid("wheelhouse.enabledByDefault must be true or false");
+    }
+    w.enabledByDefault = v.enabledByDefault;
+  }
+  for (const k of ["enabledWhenFile", "enabledWhenHomeFile"]) {
+    if (v[k] === void 0) continue;
+    if (!insidePath(v[k])) throw new Invalid(`wheelhouse.${k} must be a plain relative path`);
+    w[k] = v[k];
+  }
+  if (!Array.isArray(v.contributions)) {
+    throw new Invalid("wheelhouse.contributions must be a list");
+  }
+  for (const [i, c] of v.contributions.entries()) {
+    const where = `wheelhouse.contributions[${i}]`;
+    if (!isRecord(c)) throw new Invalid(`${where} must be an object`);
+    only(c, where, ["id", "slot"]);
+    if (typeof c.id !== "string" || !ID.test(c.id)) {
+      throw new Invalid(`${where}.id must be lower-case letters, digits and dashes`);
+    }
+    if (!SLOTS.includes(c.slot)) {
+      throw new Invalid(`${where}.slot must be one of ${SLOTS.join(", ")}`);
+    }
+    if (w.contributions.some((x) => x.id === c.id)) {
+      throw new Invalid(`it declares contribution "${c.id}" twice`);
+    }
+    w.contributions.push({ id: c.id, slot: c.slot });
+  }
+  if (v.services !== void 0) {
+    if (!Array.isArray(v.services)) throw new Invalid("wheelhouse.services must be a list");
+    for (const [i, s] of v.services.entries()) {
+      const where = `wheelhouse.services[${i}]`;
+      if (!isRecord(s)) throw new Invalid(`${where} must be an object`);
+      only(s, where, ["id", "scope"]);
+      if (typeof s.id !== "string" || !ID.test(s.id)) {
+        throw new Invalid(`${where}.id must be lower-case letters, digits and dashes`);
+      }
+      if (s.scope !== "fleet" && s.scope !== "project") {
+        throw new Invalid(`${where}.scope must be "fleet" or "project"`);
+      }
+      if (w.services.some((x) => x.id === s.id)) {
+        throw new Invalid(`it declares service "${s.id}" twice`);
+      }
+      w.services.push({ id: s.id, scope: s.scope });
+    }
+  }
+  if (v.mcpServers !== void 0) {
+    if (!Array.isArray(v.mcpServers)) throw new Invalid("wheelhouse.mcpServers must be a list");
+    for (const [i, s] of v.mcpServers.entries()) {
+      const where = `wheelhouse.mcpServers[${i}]`;
+      if (!isRecord(s)) throw new Invalid(`${where} must be an object`);
+      only(s, where, ["id", "service"]);
+      if (typeof s.id !== "string" || !ID.test(s.id)) {
+        throw new Invalid(`${where}.id must be lower-case letters, digits and dashes`);
+      }
+      if (typeof s.service !== "string" || !w.services.some((x) => x.id === s.service)) {
+        throw new Invalid(`${where}.service must be one of the services it declares`);
+      }
+      if (w.mcpServers.some((x) => x.id === s.id)) {
+        throw new Invalid(`it declares MCP server "${s.id}" twice`);
+      }
+      w.mcpServers.push({ id: s.id, service: s.service });
+    }
+  }
+  return w;
+}
+function hosts(v, field, key) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v)) throw new Invalid(`wheelhouse.${field} must be a list`);
+  const out = [];
+  for (const [i, h] of v.entries()) {
+    const where = `wheelhouse.${field}[${i}]`;
+    if (!isRecord(h)) throw new Invalid(`${where} must be an object`);
+    only(h, where, ["id", key]);
+    if (typeof h.id !== "string" || !ID.test(h.id)) {
+      throw new Invalid(`${where}.id must be lower-case letters, digits and dashes`);
+    }
+    if (!validHostTemplate(h[key])) {
+      throw new Invalid(
+        `${where}.${key} must be a host name ending in .localhost with {port} in its first label, such as {port}.localhost`
+      );
+    }
+    if (out.some((x) => x.id === h.id)) throw new Invalid(`it declares ${field} "${h.id}" twice`);
+    out.push({ id: h.id, [key]: h[key] });
+  }
+  return out;
+}
+function settings(v) {
+  if (v === void 0) return [];
+  if (!isRecord(v)) throw new Invalid("wheelhouse.settings must be an object of settings by key");
+  const keys = Object.keys(v);
+  if (keys.length > MAX_SETTINGS) {
+    throw new Invalid(`wheelhouse.settings declares more than ${MAX_SETTINGS} settings`);
+  }
+  return keys.map((key) => {
+    const where = `wheelhouse.settings.${key}`;
+    if (!SETTING_KEY.test(key)) {
+      throw new Invalid(
+        `wheelhouse.settings key "${key}" must start with a letter and hold only letters, digits and underscores`
+      );
+    }
+    const s = v[key];
+    if (!isRecord(s)) throw new Invalid(`${where} must be an object`);
+    only(s, where, SETTING_FIELDS);
+    const type = s.type === void 0 ? "text" : s.type;
+    if (!SETTING_TYPES.includes(type)) {
+      throw new Invalid(`${where}.type must be one of ${SETTING_TYPES.join(", ")}`);
+    }
+    if (s.required !== void 0 && typeof s.required !== "boolean") {
+      throw new Invalid(`${where}.required must be true or false`);
+    }
+    const spec = {
+      key,
+      title: text(s.title, `${where}.title`, true) ?? key,
+      description: text(s.description, `${where}.description`, true),
+      type,
+      required: s.required ?? false
+    };
+    if (s.options !== void 0) {
+      if (type !== "text") throw new Invalid(`${where}.options are for a text setting only`);
+      spec.options = options(s.options, `${where}.options`);
+    }
+    if (s.default !== void 0) {
+      const ok = type === "number" ? typeof s.default === "number" && Number.isFinite(s.default) : type === "boolean" ? typeof s.default === "boolean" : type === "list" ? Array.isArray(s.default) && s.default.length <= MAX_LIST && s.default.every((x) => typeof x === "string" && x.trim() && x.length <= MAX_TEXT) : typeof s.default === "string" && s.default.length <= MAX_TEXT && (!spec.options || spec.options.some((o) => o.value === s.default));
+      if (!ok) {
+        const want = {
+          text: spec.options ? "one of its options" : "text",
+          number: "a number",
+          boolean: "true or false",
+          list: "a list of texts"
+        }[type];
+        throw new Invalid(`${where}.default must be ${want}`);
+      }
+      spec.default = s.default;
+    }
+    return spec;
+  });
+}
+function options(v, where) {
+  if (!Array.isArray(v) || !v.length || v.length > MAX_OPTIONS) {
+    throw new Invalid(`${where} must be a list of 1 to ${MAX_OPTIONS} options`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return v.map((o, i) => {
+    if (!isRecord(o)) throw new Invalid(`${where}[${i}] must be an object`);
+    only(o, `${where}[${i}]`, ["value", "label"]);
+    const value = text(o.value, `${where}[${i}].value`);
+    if (seen.has(value)) throw new Invalid(`${where} has "${value}" twice`);
+    seen.add(value);
+    return { value, label: text(o.label, `${where}[${i}].label`, true) ?? value };
+  });
+}
+function parseManifest(text_) {
+  let raw;
+  try {
+    raw = JSON.parse(text_);
+  } catch (e) {
+    return { ok: false, error: `not valid JSON: ${e.message}` };
+  }
+  try {
+    if (!isRecord(raw)) throw new Invalid("expected a JSON object");
+    only(raw, "", MANIFEST_FIELDS);
+    if (typeof raw.name !== "string" || !ID.test(raw.name)) {
+      throw new Invalid("name must be lower-case letters, digits and dashes (at most 40)");
+    }
+    if (typeof raw.version !== "string" || !SEMVER.test(raw.version)) {
+      throw new Invalid("version must be a semantic version, such as 0.1.0");
+    }
+    if (raw.wheelhouse === void 0) {
+      throw new Invalid('"wheelhouse" is missing, so this is not a Wheelhouse plugin');
+    }
+    const keywords = raw.keywords === void 0 ? [] : raw.keywords;
+    if (!Array.isArray(keywords) || keywords.some((k) => typeof k !== "string")) {
+      throw new Invalid("keywords must be a list of text");
+    }
+    return {
+      ok: true,
+      manifest: {
+        name: raw.name,
+        displayName: text(raw.displayName, "displayName", true) ?? raw.name,
+        version: raw.version,
+        description: text(raw.description, "description", true),
+        author: author(raw.author),
+        repository: text(raw.repository, "repository", true),
+        homepage: text(raw.homepage, "homepage", true),
+        license: text(raw.license, "license", true),
+        keywords,
+        wheelhouse: wheelhouse(raw.wheelhouse)
+      }
+    };
+  } catch (e) {
+    if (e instanceof Invalid) return { ok: false, error: e.message };
+    throw e;
+  }
+}
+function fromExport(m, exported, o = {}) {
+  const bad = (error) => ({ ok: false, error });
+  const x = isRecord(exported) ? exported.default : void 0;
+  if (!isRecord(x)) return bad("its server entry does not default-export a plugin object.");
+  for (const [k, want2] of [
+    ["id", m.name],
+    ["version", m.version],
+    ["apiVersion", m.wheelhouse.apiVersion]
+  ]) {
+    if (x[k] !== void 0 && x[k] !== want2) {
+      return bad(
+        `its server entry says ${k} ${JSON.stringify(x[k])}, but its manifest says ${JSON.stringify(want2)}.`
+      );
+    }
+  }
+  if (!Array.isArray(x.providers) || !Array.isArray(x.contributions)) {
+    return bad("its server entry has no providers and contributions lists.");
+  }
+  for (const p of x.providers) {
+    if (!isRecord(p) || typeof p.id !== "string" || typeof p.fetch !== "function") {
+      return bad("every provider needs an id and a fetch function.");
+    }
+    if (typeof p.ttlMs !== "number" || !(p.ttlMs >= 0)) {
+      return bad(`provider "${p.id}" needs a ttlMs of zero or more.`);
+    }
+  }
+  for (const c of x.contributions) {
+    if (!isRecord(c) || typeof c.id !== "string" || !isRecord(c.render)) {
+      return bad("every contribution needs an id and a render.");
+    }
+    if (typeof c.title !== "string" || typeof c.provider !== "string") {
+      return bad(`contribution "${c.id}" needs a title and a provider.`);
+    }
+    if ("component" in c.render && !o.panels) {
+      return bad(
+        `contribution "${c.id}" names a compiled-in panel; an installed plugin draws with blocks or a custom element.`
+      );
+    }
+    if ("element" in c.render && !m.wheelhouse.ui) {
+      return bad(
+        `contribution "${c.id}" is drawn by a custom element, but the manifest names no ui bundle.`
+      );
+    }
+    if (c.badge !== void 0 && typeof c.badge !== "function") {
+      return bad(`contribution "${c.id}" has a badge that is not a function.`);
+    }
+  }
+  const services = x.services ?? [];
+  if (!Array.isArray(services))
+    return bad("its server entry has a services value that is not a list.");
+  for (const s of services) {
+    if (!isRecord(s) || typeof s.id !== "string" || typeof s.resolve !== "function") {
+      return bad("every service needs an id and a resolve function.");
+    }
+    if (typeof s.title !== "string") return bad(`service "${s.id}" needs a title.`);
+  }
+  const mcpServers = x.mcpServers ?? [];
+  if (!Array.isArray(mcpServers)) {
+    return bad("its server entry has an mcpServers value that is not a list.");
+  }
+  for (const s of mcpServers) {
+    if (!isRecord(s) || typeof s.id !== "string" || typeof s.service !== "string") {
+      return bad("every MCP server needs an id and the service it is served by.");
+    }
+    if (typeof s.title !== "string" || typeof s.path !== "string") {
+      return bad(`MCP server "${s.id}" needs a title and a path.`);
+    }
+  }
+  const hostRoutes = x.hostRoutes ?? [];
+  if (!Array.isArray(hostRoutes)) {
+    return bad("its server entry has a hostRoutes value that is not a list.");
+  }
+  for (const r of hostRoutes) {
+    if (!isRecord(r) || typeof r.id !== "string" || typeof r.request !== "function") {
+      return bad("every host route needs an id and a request function.");
+    }
+    if (r.upgrade !== void 0 && typeof r.upgrade !== "function") {
+      return bad(`host route "${r.id}" has an upgrade that is not a function.`);
+    }
+    const want2 = m.wheelhouse.hostRoutes.find((h) => h.id === r.id)?.host;
+    if (r.host !== void 0 && r.host !== want2) {
+      return bad(
+        `its server entry says host route "${r.id}" answers ${JSON.stringify(r.host)}, but its manifest says ${JSON.stringify(want2 ?? null)}.`
+      );
+    }
+  }
+  const declared = (list) => list.map((c) => `${c.id}:${c.slot ?? c.scope ?? c.service}`).sort();
+  const got = declared(x.contributions);
+  const want = declared(m.wheelhouse.contributions);
+  if (got.join() !== want.join()) {
+    return bad(
+      `its server entry contributes ${got.join(", ") || "nothing"}, but its manifest declares ${want.join(", ") || "nothing"}.`
+    );
+  }
+  const gotS = declared(services);
+  const wantS = declared(m.wheelhouse.services);
+  if (gotS.join() !== wantS.join()) {
+    return bad(
+      `its server entry has services ${gotS.join(", ") || "none"}, but its manifest declares ${wantS.join(", ") || "none"}.`
+    );
+  }
+  const gotM = declared(mcpServers);
+  const wantM = declared(m.wheelhouse.mcpServers);
+  if (gotM.join() !== wantM.join()) {
+    return bad(
+      `its server entry has MCP servers ${gotM.join(", ") || "none"}, but its manifest declares ${wantM.join(", ") || "none"}.`
+    );
+  }
+  const gotH = hostRoutes.map((r) => r.id).sort();
+  const wantH = m.wheelhouse.hostRoutes.map((r) => r.id).sort();
+  if (gotH.join() !== wantH.join()) {
+    return bad(
+      `its server entry has host routes ${gotH.join(", ") || "none"}, but its manifest declares ${wantH.join(", ") || "none"}.`
+    );
+  }
+  const plugin = {
+    ...x,
+    apiVersion: m.wheelhouse.apiVersion,
+    id: m.name,
+    name: m.displayName,
+    version: m.version,
+    services,
+    mcpServers,
+    // Each route's host, and every address rewrite, is the manifest's: what the captain agreed to.
+    hostRoutes: hostRoutes.map((r) => ({
+      ...r,
+      host: m.wheelhouse.hostRoutes.find((h) => h.id === r.id).host
+    })),
+    addressRewrites: m.wheelhouse.addressRewrites.map((r) => ({ ...r }))
+  };
+  delete plugin.enabledByDefault;
+  delete plugin.enabledWhenFile;
+  delete plugin.enabledWhenHomeFile;
+  if (m.wheelhouse.enabledByDefault !== void 0) {
+    plugin.enabledByDefault = m.wheelhouse.enabledByDefault;
+  }
+  if (m.wheelhouse.enabledWhenFile !== void 0) {
+    plugin.enabledWhenFile = m.wheelhouse.enabledWhenFile;
+  }
+  if (m.wheelhouse.enabledWhenHomeFile !== void 0) {
+    plugin.enabledWhenHomeFile = m.wheelhouse.enabledWhenHomeFile;
+  }
+  return { ok: true, plugin };
+}
+const ATTEMPTS = 3;
+const has = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+function parseGiven(pairs) {
+  const given = {};
+  for (const p of pairs) {
+    const at = p.indexOf("=");
+    if (at < 1) return { ok: false, error: `--setting "${p}" is not key=value` };
+    given[p.slice(0, at).trim()] = p.slice(at + 1);
+  }
+  return { ok: true, given };
+}
+function parseValue(spec, text2) {
+  const t = text2.trim();
+  if (spec.type === "list") {
+    const items = [
+      ...new Set(
+        t.split(",").map((x) => x.trim()).filter(Boolean)
+      )
+    ];
+    return items.length || !spec.required ? { ok: true, value: items } : { ok: false, error: `${spec.title} needs at least one` };
+  }
+  if (spec.options) {
+    const o = spec.options.find((x) => x.value === t || x.label.toLowerCase() === t.toLowerCase());
+    return o ? { ok: true, value: o.value } : {
+      ok: false,
+      error: `${spec.title} must be one of ${spec.options.map((x) => x.label).join(", ")}`
+    };
+  }
+  if (spec.type === "number") {
+    const n = Number(t);
+    return t !== "" && Number.isFinite(n) ? { ok: true, value: n } : { ok: false, error: `${spec.title} must be a number` };
+  }
+  if (spec.type === "boolean") {
+    if (/^(y|yes|true|on)$/i.test(t)) return { ok: true, value: true };
+    if (/^(n|no|false|off)$/i.test(t)) return { ok: true, value: false };
+    return { ok: false, error: `${spec.title} must be yes or no` };
+  }
+  return t ? { ok: true, value: t } : { ok: false, error: `${spec.title} must not be empty` };
+}
+function showValue(spec, v) {
+  if (v === true) return "yes";
+  if (v === false) return "no";
+  if (Array.isArray(v)) return v.join(", ");
+  return spec.options?.find((o) => o.value === v)?.label ?? String(v);
+}
+function question(spec, offered) {
+  const optional = spec.required ? "" : " (optional)";
+  const kind = spec.type === "boolean" ? " (y/n)" : spec.type === "list" ? " (separate with commas)" : spec.options ? ` (${spec.options.map((o) => o.label).join(" / ")})` : "";
+  const def = offered === void 0 ? "" : ` [${showValue(spec, offered)}]`;
+  return `${spec.title}${optional}${kind}${def}: `;
+}
+async function gatherSettings(id, specs, o) {
+  for (const k of Object.keys(o.given)) {
+    if (!specs.some((s) => s.key === k)) {
+      return { ok: false, error: `${id} has no setting "${k}"` };
+    }
+  }
+  const settings2 = { ...o.current };
+  let introduced = false;
+  for (const spec of specs) {
+    if (has(o.given, spec.key)) {
+      const v = parseValue(spec, o.given[spec.key]);
+      if (!v.ok) return { ok: false, error: `--setting ${spec.key}: ${v.error}` };
+      settings2[spec.key] = v.value;
+      continue;
+    }
+    if (has(o.current, spec.key)) continue;
+    const offered = spec.default;
+    if (!o.ask) {
+      if (offered !== void 0) settings2[spec.key] = offered;
+      else if (spec.required) {
+        return {
+          ok: false,
+          error: `${id} needs ${spec.title}; pass --setting ${spec.key}=<value>`
+        };
+      }
+      continue;
+    }
+    if (!introduced) {
+      o.log(o.intro);
+      introduced = true;
+    }
+    if (spec.description) o.log(`  ${spec.description}`);
+    let answered = false;
+    for (let i = 0; i < ATTEMPTS && !answered; i++) {
+      const a = await o.ask(question(spec, offered));
+      if (a === null) return { ok: false, error: `stopped before ${spec.title} was answered` };
+      if (!a.trim()) {
+        if (offered !== void 0) {
+          settings2[spec.key] = offered;
+          answered = true;
+        } else if (!spec.required) answered = true;
+        else o.log(`  ${spec.title} is needed.`);
+        continue;
+      }
+      const v = parseValue(spec, a);
+      if (v.ok) {
+        settings2[spec.key] = v.value;
+        answered = true;
+      } else o.log(`  ${v.error}.`);
+    }
+    if (!answered) return { ok: false, error: `${id} needs ${spec.title}` };
+  }
+  return { ok: true, settings: settings2 };
+}
+function settingViews(specs, have) {
+  return specs.map((x) => {
+    const v = have[x.key];
+    const fits = x.type === "list" ? Array.isArray(v) && v.every((i) => typeof i === "string") : x.type === "number" ? typeof v === "number" : x.type === "boolean" ? typeof v === "boolean" : typeof v === "string";
+    return fits ? { ...x, current: v } : { ...x };
+  });
+}
+function readAnswers(specs, answers) {
+  const settings2 = {};
+  for (const [key, text2] of Object.entries(answers)) {
+    const spec = specs.find((s) => s.key === key);
+    if (!spec) return { ok: false, error: `there is no setting "${key}"` };
+    if (!text2.trim()) {
+      if (spec.required) return { ok: false, error: `${spec.title} is needed` };
+      settings2[key] = spec.type === "list" ? [] : spec.type === "text" && !spec.options ? "" : void 0;
+      continue;
+    }
+    const v = parseValue(spec, text2);
+    if (!v.ok) return v;
+    settings2[key] = v.value;
+  }
+  return { ok: true, settings: settings2 };
+}
+
+export { EMPTY_CONFIG as E, PluginConfigFile as P, SUPPORTED_API_VERSIONS as S, PLUGINS_FILE as a, defaultPluginsDir as b, SLOT_SCOPE as c, defaultConfigDir as d, loopbackAddresses as e, manifestPath as f, fromExport as g, SLOTS as h, isEnabled as i, changePlugin as j, readPluginSettings as k, localhostName as l, matchHost as m, parseGiven as n, gatherSettings as o, parseManifest as p, writePluginSettings as q, readInstalled as r, settingViews as s, readAnswers as t, validHostTemplate as v, writeInstalled as w };
+//# sourceMappingURL=settings.js-C_6kvzhM.js.map