@chrisjowen/wheelhouse 0.1.1 → 0.2.1

package/build/server/chunks/chunks/service.js-DZR6CoEI.js

@@ -0,0 +1,914 @@
+import { d as defaultConfigDir, b as defaultPluginsDir, r as readInstalled, w as writeInstalled, f as manifestPath, p as parseManifest, k as readPluginSettings, s as settingViews, n as parseGiven, o as gatherSettings, q as writePluginSettings, a as PLUGINS_FILE } from './settings.js-C_6kvzhM.js';
+import { execFile } from 'node:child_process';
+import { readFile, realpath, rename, mkdtemp, rm, stat, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { a as addressWords } from './words.js-Cte4wOB4.js';
+import { tmpdir } from 'node:os';
+import { c as canRestart, r as restartSoon } from './restart.js-Dv1_ODgZ.js';
+
+const NAME = /^[A-Za-z0-9_.-]+$/;
+const SHA$1 = /^[0-9a-f]{7,40}$/;
+function parseSource(spec) {
+  const m = /^([^/@\s]+)\/([^/@\s]+?)(?:\.git)?(?:@(\S+))?$/.exec(spec.trim());
+  if (!m || !NAME.test(m[1]) || !NAME.test(m[2]) || m[1].startsWith("-") || m[2].startsWith(".")) {
+    return null;
+  }
+  const ref = m[3] ?? null;
+  if (ref !== null && (ref.startsWith("-") || !/^[A-Za-z0-9_./-]+$/.test(ref))) return null;
+  return { org: m[1], repo: m[2], ref };
+}
+const runGit = (args, cwd) => new Promise((resolve) => {
+  execFile(
+    "git",
+    args,
+    {
+      cwd,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+      maxBuffer: 4 * 1024 * 1024
+    },
+    (err, stdout, stderr) => resolve({
+      code: err ? typeof err.code === "number" ? err.code : 1 : 0,
+      stdout: String(stdout),
+      stderr: String(stderr)
+    })
+  );
+});
+const githubUrl$1 = (s) => `https://github.com/${s.org}/${s.repo}.git`;
+const short = (commit) => commit.slice(0, 12);
+const label = (r) => `${r.repository}${r.ref ? `@${r.ref}` : ""}`;
+class Refused extends Error {
+}
+async function fetchSource(source, into, deps) {
+  const git = deps.git ?? runGit;
+  const url = (deps.gitUrl ?? githubUrl$1)(source);
+  const step = async (args) => {
+    const r = await git(args, into);
+    if (r.code !== 0)
+      throw new Refused(r.stderr.trim().split("\n").pop() || `git ${args[0]} failed`);
+    return r.stdout.trim();
+  };
+  await step(["init", "-q"]);
+  const want = source.ref ?? "HEAD";
+  const shallow = await git(["fetch", "-q", "--depth", "1", url, want], into);
+  if (shallow.code !== 0) {
+    if (!source.ref || !SHA$1.test(source.ref)) {
+      throw new Refused(
+        `could not fetch ${source.org}/${source.repo}${source.ref ? ` at ${source.ref}` : ""}: ${shallow.stderr.trim().split("\n").pop() ?? ""}`
+      );
+    }
+    await step(["fetch", "-q", url]);
+    await step(["checkout", "-q", "--detach", source.ref]);
+  } else {
+    await step(["checkout", "-q", "--detach", "FETCH_HEAD"]);
+  }
+  const commit = await step(["rev-parse", "HEAD"]);
+  await rm(path.join(into, ".git"), { recursive: true, force: true });
+  return commit;
+}
+async function checkCopy(dir) {
+  let text;
+  try {
+    text = await readFile(manifestPath(dir), "utf8");
+  } catch {
+    throw new Refused("it has no .wheelhouse-plugin/plugin.json, so it is not a Wheelhouse plugin");
+  }
+  const parsed = parseManifest(text);
+  if (!parsed.ok) throw new Refused(`its manifest is not valid: ${parsed.error}`);
+  const m = parsed.manifest;
+  const base = await realpath(dir);
+  for (const [what, rel] of [
+    ["server entry", m.wheelhouse.server],
+    ["ui bundle", m.wheelhouse.ui]
+  ]) {
+    if (!rel) continue;
+    let file;
+    try {
+      file = await realpath(path.join(base, rel));
+      if (!(await stat(file)).isFile()) throw new Error();
+    } catch {
+      throw new Refused(`its ${what} ${rel} is missing`);
+    }
+    if (!file.startsWith(base + path.sep))
+      throw new Refused(`its ${what} leads outside the plugin`);
+  }
+  return m;
+}
+function enabledText(m) {
+  const w = m.wheelhouse;
+  return w.enabledWhenHomeFile ? `while the Firstmate home has ${w.enabledWhenHomeFile}` : w.enabledWhenFile ? `for projects whose clone has ${w.enabledWhenFile}` : w.enabledByDefault ? "for every project" : "only where your plugins file turns it on";
+}
+function describeManifest(m, from, commit) {
+  const w = m.wheelhouse;
+  const enabled = enabledText(m);
+  return [
+    `${m.displayName} (${m.name}) ${m.version}`,
+    ...m.description ? [`  ${m.description}`] : [],
+    `  From:      ${from}`,
+    `  Commit:    ${commit}`,
+    ...m.author ? [`  Author:    ${m.author.name}${m.author.url ? ` <${m.author.url}>` : ""}`] : [],
+    ...m.repository ? [`  Homepage:  ${m.repository}`] : [],
+    `  Contract:  plugin API ${w.apiVersion}`,
+    `  Slots:     ${w.contributions.map((c) => `${c.slot} (${c.id})`).join(", ") || "none"}`,
+    `  Services:  ${w.services.map((s) => `${s.id} (${s.scope})`).join(", ") || "none"}`,
+    `  Settings:  ${w.settings.map((s) => `${s.key}${s.required ? " (required)" : ""}`).join(", ") || "none"}`,
+    ...w.mcpServers.length ? [
+      `  MCP apps:  ${w.mcpServers.map((s) => `${s.id} (on ${s.service})`).join(", ")}, drawn in a sandboxed frame`
+    ] : [],
+    ...w.hostRoutes.length ? [
+      `  Answers:   ${w.hostRoutes.map((r) => r.host).join(", ")} on Wheelhouse’s port, with its own code`
+    ] : [],
+    ...w.addressRewrites.length ? [
+      `  Addresses: opens addresses on this computer at ${w.addressRewrites.map((r) => r.to).join(", ")}`
+    ] : [],
+    `  UI bundle: ${w.ui ?? "none"}`,
+    `  On:        ${enabled}`,
+    "",
+    "Its code runs with your permissions: its server entry inside Wheelhouse, and",
+    "its UI bundle in Wheelhouse’s pages. Wheelhouse gives it read-only helpers, but",
+    "does not sandbox it. Install only plugins you trust."
+  ];
+}
+async function withStaging(dir, work) {
+  await mkdir(dir, { recursive: true });
+  const staging = await mkdtemp(path.join(dir, ".staging-"));
+  try {
+    return await work(staging);
+  } finally {
+    await rm(staging, { recursive: true, force: true });
+  }
+}
+async function guarded(work) {
+  try {
+    return await work();
+  } catch (e) {
+    if (e instanceof Refused) return { ok: false, error: e.message };
+    throw e;
+  }
+}
+function given(pairs2) {
+  const g2 = parseGiven(pairs2 ?? []);
+  if (!g2.ok) throw new Refused(g2.error);
+  return g2.given;
+}
+async function settle(m, deps, o) {
+  if (!m.wheelhouse.settings.length && !Object.keys(o.given).length) return null;
+  const current = await readPluginSettings(deps.configDir, m.name);
+  if (!current.ok) throw new Refused(current.error);
+  const r = await gatherSettings(m.name, m.wheelhouse.settings, {
+    current: current.settings,
+    given: o.given,
+    ask: o.yes ? null : deps.ask ?? null,
+    intro: `${m.displayName} needs some settings (Enter keeps the one in brackets):`,
+    log: deps.log
+  });
+  if (!r.ok) throw new Refused(r.error);
+  return r.settings;
+}
+async function keepSettings(id, settings, deps) {
+  const w = await writePluginSettings(deps.configDir, id, settings);
+  if (!w.ok) throw new Refused(`could not keep ${id}'s settings: ${w.error}`);
+  deps.log(`Kept ${id}'s settings in ${path.join(deps.configDir, PLUGINS_FILE)}.`);
+}
+async function reload(deps, what, yes) {
+  const r = await deps.restart(async (url, busy) => {
+    deps.log(`Restarting Wheelhouse at ${url} stops what it is running:`);
+    for (const b of busy) deps.log(`  - ${b}`);
+    return yes || deps.confirm("Restart it now?");
+  });
+  for (const url of r.restarted) deps.log(`Restarting Wheelhouse at ${url} to ${what}.`);
+  for (const url of r.kept) deps.log(`Left Wheelhouse at ${url} running; restart it to ${what}.`);
+  for (const f of r.failed) {
+    deps.log(`Could not restart Wheelhouse at ${f.url} (${f.reason}); restart it to ${what}.`);
+  }
+  if (!r.restarted.length && !r.kept.length && !r.failed.length) {
+    deps.log(`Wheelhouse is not running; it will ${what} when it next starts.`);
+  }
+}
+async function record(deps) {
+  const r = await readInstalled(deps.dir);
+  if (!r.ok) throw new Refused(r.error);
+  return r.installed;
+}
+function expected(commit, expect, repository) {
+  if (expect !== void 0 && commit !== expect) {
+    throw new Refused(
+      `${repository} is at ${short(commit)} now, not ${short(expect)} as when you looked; look it up again`
+    );
+  }
+}
+async function preview(m, at, deps, installed) {
+  const current = await readPluginSettings(deps.configDir, m.name);
+  const have = current.ok ? current.settings : {};
+  const w = m.wheelhouse;
+  return {
+    id: m.name,
+    name: m.displayName,
+    version: m.version,
+    description: m.description,
+    ...at,
+    author: m.author?.name ?? null,
+    homepage: m.repository,
+    apiVersion: w.apiVersion,
+    slots: w.contributions.map((c) => c.slot),
+    services: w.services.map((x) => `${x.id} (${x.scope})`),
+    addresses: addressWords(
+      w.hostRoutes.map((r) => r.host),
+      w.addressRewrites.map((r) => r.to)
+    ),
+    ui: w.ui,
+    on: enabledText(m),
+    settings: settingViews(w.settings, have),
+    installed
+  };
+}
+function inspect(spec, deps) {
+  return guardedInspect(async () => {
+    const source = parseSource(spec);
+    if (!source) throw new Refused(`"${spec}" is not org/repo or org/repo@ref`);
+    const installed = await record(deps);
+    const repository = `${source.org}/${source.repo}`;
+    return withStaging(deps.dir, async (staging) => {
+      const commit = await fetchSource(source, staging, deps);
+      const m = await checkCopy(staging);
+      if (installed.plugins[m.name]) {
+        throw new Refused(
+          `${m.name} is already installed from ${label(installed.plugins[m.name])}; update it from its row instead`
+        );
+      }
+      if (await exists(path.join(deps.dir, m.name))) {
+        throw new Refused(`${path.join(deps.dir, m.name)} already exists; remove it first`);
+      }
+      return preview(m, { repository, ref: source.ref, commit }, deps, null);
+    });
+  });
+}
+function inspectUpdate(id, deps, o = {}) {
+  return guardedInspect(async () => {
+    const installed = await record(deps);
+    const was = installed.plugins[id];
+    if (!was) throw new Refused(`${id} is not installed`);
+    const [org, repo] = was.repository.split("/");
+    const ref = o.ref === void 0 ? was.ref : o.ref;
+    const source = { org, repo, ref };
+    if (!parseSource(`${org}/${repo}${ref ? `@${ref}` : ""}`)) {
+      throw new Refused(`"${ref}" is not a ref`);
+    }
+    return withStaging(deps.dir, async (staging) => {
+      const commit = await fetchSource(source, staging, deps);
+      if (commit === was.commit) throw new Refused(`${id} is already at ${short(commit)}`);
+      const m = await checkCopy(staging);
+      if (m.name !== id) {
+        throw new Refused(`${was.repository} now names its plugin "${m.name}", not "${id}"`);
+      }
+      return preview(m, { repository: was.repository, ref, commit }, deps, {
+        version: was.version,
+        commit: was.commit,
+        ref: was.ref
+      });
+    });
+  });
+}
+async function guardedInspect(work) {
+  try {
+    return { ok: true, preview: await work() };
+  } catch (e) {
+    if (e instanceof Refused) return { ok: false, error: e.message };
+    throw e;
+  }
+}
+function install(spec, deps, o = {}) {
+  return guarded(async () => {
+    const source = parseSource(spec);
+    if (!source) throw new Refused(`"${spec}" is not org/repo or org/repo@ref`);
+    const answers = given(o.settings);
+    const installed = await record(deps);
+    const repository = `${source.org}/${source.repo}`;
+    return withStaging(deps.dir, async (staging) => {
+      deps.log(`Fetching ${repository}${source.ref ? ` at ${source.ref}` : ""}…`);
+      const commit = await fetchSource(source, staging, deps);
+      expected(commit, o.expect, repository);
+      const m = await checkCopy(staging);
+      const target = path.join(deps.dir, m.name);
+      if (installed.plugins[m.name]) {
+        throw new Refused(
+          `${m.name} is already installed from ${label(installed.plugins[m.name])}; use \`wheelhouse plugin update ${m.name}\``
+        );
+      }
+      if (await exists(target)) {
+        throw new Refused(`${target} already exists; remove it first`);
+      }
+      for (const line of describeManifest(
+        m,
+        `${repository}${source.ref ? ` (${source.ref})` : ""}`,
+        commit
+      ))
+        deps.log(line);
+      if (!o.yes && !await deps.confirm(`Install ${m.name}?`)) {
+        throw new Refused("not installed");
+      }
+      const settings = await settle(m, deps, { yes: o.yes, given: answers });
+      if (settings) await keepSettings(m.name, settings, deps);
+      await rename(staging, target);
+      installed.plugins[m.name] = {
+        repository,
+        ref: source.ref,
+        commit,
+        version: m.version,
+        installedAt: (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+        enabled: true
+      };
+      await writeInstalled(deps.dir, installed);
+      deps.log(`Installed ${m.name} ${m.version} at ${short(commit)}.`);
+      await reload(deps, `load ${m.name}`, o.yes);
+      return { ok: true };
+    });
+  });
+}
+function update(id, deps, o = {}) {
+  return guarded(async () => {
+    const answers = given(o.settings);
+    const installed = await record(deps);
+    const was = installed.plugins[id];
+    if (!was) throw new Refused(`${id} is not installed`);
+    const [org, repo] = was.repository.split("/");
+    const source = { org, repo, ref: o.ref ?? was.ref };
+    if (!parseSource(`${org}/${repo}${source.ref ? `@${source.ref}` : ""}`)) {
+      throw new Refused(`"${source.ref}" is not a ref`);
+    }
+    return withStaging(deps.dir, async (staging) => {
+      deps.log(`Fetching ${was.repository}${source.ref ? ` at ${source.ref}` : ""}…`);
+      const commit = await fetchSource(source, staging, deps);
+      expected(commit, o.expect, was.repository);
+      if (commit === was.commit) {
+        if (source.ref !== was.ref) {
+          installed.plugins[id] = { ...was, ref: source.ref };
+          await writeInstalled(deps.dir, installed);
+        }
+        deps.log(`${id} is already at ${short(commit)}.`);
+        return { ok: true };
+      }
+      const m = await checkCopy(staging);
+      if (m.name !== id) {
+        throw new Refused(`${was.repository} now names its plugin "${m.name}", not "${id}"`);
+      }
+      deps.log(
+        `Update ${id} from ${was.version} (${short(was.commit)}) to ${m.version} (${short(commit)}):`
+      );
+      for (const line of describeManifest(
+        m,
+        `${was.repository}${source.ref ? ` (${source.ref})` : ""}`,
+        commit
+      ))
+        deps.log(line);
+      if (!o.yes && !await deps.confirm(`Update ${id}?`)) throw new Refused("not updated");
+      const settings = await settle(m, deps, { yes: o.yes, given: answers });
+      if (settings) await keepSettings(id, settings, deps);
+      const target = path.join(deps.dir, id);
+      const old = await mkdtemp(path.join(deps.dir, ".old-"));
+      const parked = path.join(old, id);
+      if (await exists(target)) await rename(target, parked);
+      try {
+        await rename(staging, target);
+      } catch (e) {
+        if (await exists(parked)) await rename(parked, target);
+        throw e;
+      } finally {
+        await rm(old, { recursive: true, force: true });
+      }
+      installed.plugins[id] = {
+        ...was,
+        ref: source.ref,
+        commit,
+        version: m.version,
+        installedAt: (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeInstalled(deps.dir, installed);
+      deps.log(`Updated ${id} to ${m.version} at ${short(commit)}.`);
+      await reload(deps, `load ${id} ${m.version}`, o.yes);
+      return { ok: true };
+    });
+  });
+}
+function setEnabled(id, enabled, deps, o = {}) {
+  return guarded(async () => {
+    const installed = await record(deps);
+    const r = installed.plugins[id];
+    if (!r) throw new Refused(`${id} is not installed`);
+    installed.plugins[id] = { ...r, enabled };
+    await writeInstalled(deps.dir, installed);
+    deps.log(`${id} is ${enabled ? "on" : "off"}.`);
+    await reload(deps, `${enabled ? "load" : "unload"} ${id}`, o.yes);
+    return { ok: true };
+  });
+}
+async function exists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const SEMVER = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(s) {
+  const m = SEMVER.exec(s.trim());
+  if (!m) return null;
+  return { major: +m[1], minor: +m[2], patch: +m[3], pre: m[4] ?? null };
+}
+function comparePre(a, b) {
+  if (a === b) return 0;
+  if (a === null) return 1;
+  if (b === null) return -1;
+  const pa = a.split(".");
+  const pb = b.split(".");
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if (pa[i] === void 0) return -1;
+    if (pb[i] === void 0) return 1;
+    const na = /^\d+$/.test(pa[i]) ? Number(pa[i]) : null;
+    const nb = /^\d+$/.test(pb[i]) ? Number(pb[i]) : null;
+    if (na !== null && nb !== null) {
+      if (na !== nb) return na < nb ? -1 : 1;
+    } else if (na !== null) return -1;
+    else if (nb !== null) return 1;
+    else if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
+  }
+  return 0;
+}
+function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return null;
+  for (const k of ["major", "minor", "patch"]) {
+    if (va[k] !== vb[k]) return va[k] < vb[k] ? -1 : 1;
+  }
+  return comparePre(va.pre, vb.pre);
+}
+function newerTag(current, tags) {
+  const cur = parseVersion(current);
+  if (!cur) return null;
+  let best = null;
+  for (const t of tags) {
+    const v = parseVersion(t);
+    if (!v || v.pre !== null && cur.pre === null) continue;
+    if ((compareVersions(t, current) ?? 0) <= 0) continue;
+    if (best === null || (compareVersions(t, best) ?? 0) > 0) best = t;
+  }
+  return best;
+}
+function parseLsRemote(text) {
+  const out = { head: null, heads: /* @__PURE__ */ new Map(), tags: /* @__PURE__ */ new Map() };
+  const peeled = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    const [sha, ref] = line.trim().split(/\s+/);
+    if (!sha || !ref || !/^[0-9a-f]{40}$/.test(sha)) continue;
+    if (ref === "HEAD") out.head = sha;
+    else if (ref.startsWith("refs/heads/")) out.heads.set(ref.slice(11), sha);
+    else if (ref.startsWith("refs/tags/")) {
+      const name = ref.slice(10);
+      if (name.endsWith("^{}")) peeled.set(name.slice(0, -3), sha);
+      else out.tags.set(name, sha);
+    }
+  }
+  for (const [name, sha] of peeled) out.tags.set(name, sha);
+  return out;
+}
+const githubUrl = (s) => `https://github.com/${s.org}/${s.repo}.git`;
+const SHA = /^[0-9a-f]{7,40}$/;
+async function checkPlugin(id, r, deps = {}) {
+  const base = {
+    id,
+    repository: r.repository,
+    ref: r.ref,
+    commit: r.commit,
+    version: r.version,
+    latest: null,
+    reason: null
+  };
+  const [org, repo] = r.repository.split("/");
+  const url = (deps.gitUrl ?? githubUrl)({ org, repo, ref: r.ref });
+  const res = await (deps.git ?? runGit)(["ls-remote", url], tmpdir());
+  if (res.code !== 0) {
+    const why = res.stderr.trim().split("\n").pop() || "git ls-remote failed";
+    return { ...base, state: "error", reason: `could not reach ${r.repository}: ${why}` };
+  }
+  const refs = parseLsRemote(res.stdout);
+  const moved = (commit, ref) => commit && commit !== r.commit ? { ...base, state: "available", latest: { ref, commit } } : { ...base, state: "current" };
+  if (r.ref === null) return moved(refs.head, null);
+  if (refs.tags.has(r.ref)) {
+    const tag = newerTag(r.ref, [...refs.tags.keys()]);
+    if (tag) {
+      return {
+        ...base,
+        state: "newer-tag",
+        latest: { ref: tag, commit: refs.tags.get(tag) }
+      };
+    }
+    return moved(refs.tags.get(r.ref), r.ref);
+  }
+  if (refs.heads.has(r.ref)) return moved(refs.heads.get(r.ref), r.ref);
+  if (SHA.test(r.ref)) return { ...base, state: "pinned" };
+  return {
+    ...base,
+    state: "error",
+    reason: `${r.repository} has no branch or tag ${r.ref} any more`
+  };
+}
+async function checkPlugins(dir, deps = {}) {
+  const checkedAt = (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const installed = await readInstalled(dir);
+  if (!installed.ok) {
+    return {
+      schema: "wheelhouse-plugin-updates.v1",
+      checkedAt,
+      plugins: [],
+      error: installed.error
+    };
+  }
+  const rows = Object.entries(installed.installed.plugins).sort(([a], [b]) => a.localeCompare(b));
+  return {
+    schema: "wheelhouse-plugin-updates.v1",
+    checkedAt,
+    plugins: await Promise.all(rows.map(([id, r]) => checkPlugin(id, r, deps))),
+    error: null
+  };
+}
+const COMMITS_SHOWN = 20;
+const runCommand = (cmd, args, cwd) => new Promise((resolve) => {
+  execFile(cmd, args, { cwd, maxBuffer: 64 * 1024 * 1024 }, (err, stdout, stderr) => {
+    const output = `${String(stdout)}${String(stderr)}`;
+    resolve({
+      code: err ? typeof err.code === "number" ? err.code : 1 : 0,
+      output: output.slice(-6e4)
+    });
+  });
+});
+function githubRepository(url) {
+  const m = /^(?:https?:\/\/(?:[^@/]+@)?github\.com\/|(?:ssh:\/\/)?git@github\.com[:/])([^/]+)\/([^/]+?)(?:\.git)?\/?$/.exec(
+    url.trim()
+  );
+  return m ? `${m[1]}/${m[2]}` : null;
+}
+function packageVersion(text) {
+  if (text === null) return null;
+  try {
+    const v = JSON.parse(text).version;
+    return typeof v === "string" ? v : null;
+  } catch {
+    return null;
+  }
+}
+const lastLine = (s) => s.trim().split("\n").pop() ?? "";
+async function checkClone(deps) {
+  const git = deps.git ?? runGit;
+  const g2 = async (...args) => git(args, deps.dir);
+  const out = {
+    schema: "wheelhouse-update.v1",
+    checkedAt: (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+    state: "unsupported",
+    reason: null,
+    dir: deps.dir,
+    repository: null,
+    branch: null,
+    current: { commit: null, version: null },
+    latest: null,
+    commits: [],
+    behind: 0,
+    changes: []
+  };
+  out.current.version = packageVersion(
+    await readFile(path.join(deps.dir, "package.json"), "utf8").catch(() => null)
+  );
+  const top = await g2("rev-parse", "--show-toplevel");
+  const here = await realpath(deps.dir).catch(() => deps.dir);
+  if (top.code !== 0 || await realpath(top.stdout.trim()).catch(() => "") !== here) {
+    out.reason = `${deps.dir} is not a git clone, so Wheelhouse cannot upgrade it; update it the way it was installed (for npm, \`npm install -g @chrisjowen/wheelhouse\`)`;
+    return out;
+  }
+  const head = await g2("rev-parse", "HEAD");
+  out.current.commit = head.code === 0 ? head.stdout.trim() : null;
+  const origin = await g2("remote", "get-url", "origin");
+  if (origin.code !== 0) {
+    out.reason = `${deps.dir} has no origin remote to upgrade from`;
+    return out;
+  }
+  out.repository = githubRepository(origin.stdout);
+  const symref = await g2("ls-remote", "--symref", "origin", "HEAD");
+  const branch = /^ref: refs\/heads\/(\S+)\s+HEAD$/m.exec(symref.stdout)?.[1] ?? null;
+  if (symref.code !== 0 || !branch) {
+    out.state = "error";
+    out.reason = `could not reach origin: ${lastLine(symref.stderr) || "it named no default branch"}`;
+    return out;
+  }
+  out.branch = branch;
+  const fetched = await g2("fetch", "--quiet", "--no-tags", "origin", `refs/heads/${branch}`);
+  if (fetched.code !== 0) {
+    out.state = "error";
+    out.reason = `could not fetch ${branch}: ${lastLine(fetched.stderr)}`;
+    return out;
+  }
+  const latest = (await g2("rev-parse", "FETCH_HEAD")).stdout.trim();
+  const remotePkg = await g2("show", `${latest}:package.json`);
+  out.latest = {
+    commit: latest,
+    version: packageVersion(remotePkg.code === 0 ? remotePkg.stdout : null)
+  };
+  const counts = (await g2("rev-list", "--left-right", "--count", `HEAD...${latest}`)).stdout.trim().split(/\s+/).map(Number);
+  const ahead = counts[0] || 0;
+  out.behind = counts[1] || 0;
+  if (out.behind === 0) {
+    out.state = "current";
+    return out;
+  }
+  const log = await g2("log", "--format=%H%x1f%s%x1f%cI", `-n${COMMITS_SHOWN}`, `HEAD..${latest}`);
+  out.commits = log.stdout.split("\n").filter(Boolean).map((l) => {
+    const [sha, subject, date] = l.split("");
+    return { sha, subject, date };
+  });
+  const on = await g2("symbolic-ref", "--quiet", "--short", "HEAD");
+  const status = await g2("status", "--porcelain", "--untracked-files=no");
+  const changes = status.stdout.split("\n").filter((l) => l.trim());
+  out.state = "refused";
+  if (on.code !== 0) {
+    out.reason = `${deps.dir} is not on a branch (detached HEAD), so it cannot fast-forward to ${branch}`;
+  } else if (on.stdout.trim() !== branch) {
+    out.reason = `${deps.dir} is on ${on.stdout.trim()}, not ${branch}, so it cannot fast-forward`;
+  } else if (changes.length) {
+    out.reason = `${deps.dir} has local changes; commit or discard them, then check again`;
+    out.changes = changes;
+  } else if (ahead > 0) {
+    out.reason = `${deps.dir} has ${ahead} commit${ahead === 1 ? "" : "s"} that ${branch} does not, so it cannot fast-forward`;
+  } else {
+    out.state = "available";
+  }
+  return out;
+}
+async function upgradeClone(deps, onStep = () => {
+}) {
+  const git = deps.git ?? runGit;
+  const run = deps.run ?? runCommand;
+  onStep("fetch");
+  const check = await checkClone(deps);
+  if (check.state !== "available" || !check.latest) {
+    const error = check.state === "current" ? `Wheelhouse is already up to date with ${check.branch}` : check.reason ?? "there is nothing to upgrade to";
+    return { ok: false, step: "fetch", error, output: "", check };
+  }
+  onStep("fast-forward");
+  const ff = await git(["merge", "--ff-only", "--quiet", check.latest.commit], deps.dir);
+  if (ff.code !== 0) {
+    return {
+      ok: false,
+      step: "fast-forward",
+      error: `could not fast-forward: ${lastLine(ff.stderr)}`,
+      output: ff.stderr,
+      check
+    };
+  }
+  for (const [step, args] of [
+    ["install", ["ci"]],
+    ["build", ["run", "build"]]
+  ]) {
+    onStep(step);
+    const r = await run("npm", [...args], deps.dir);
+    if (r.code !== 0) {
+      return {
+        ok: false,
+        step,
+        error: `npm ${args.join(" ")} failed (exit ${r.code}); the clone is at ${check.latest.commit.slice(0, 7)} but its build is incomplete, so rebuild it (npm ci && npm run build) before Wheelhouse restarts`,
+        output: r.output,
+        check
+      };
+    }
+  }
+  return { ok: true, check, from: check.current.commit, to: check.latest.commit };
+}
+const CHECK_EVERY_MS = 6 * 60 * 60 * 1e3;
+const fresh = () => ({
+  check: null,
+  checking: null,
+  job: null,
+  plugins: null,
+  pluginsChecking: null,
+  changing: null
+});
+class UpdateService {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  s = fresh();
+  now = () => this.deps.now?.() ?? Date.now();
+  log = (line) => (this.deps.log ?? console.log)(line);
+  stale = (at) => !at || this.now() - Date.parse(at) >= CHECK_EVERY_MS;
+  /** The directory Wheelhouse runs from, as `wheelhouse open` names it. */
+  installDir() {
+    return this.deps.env.WHEELHOUSE_INSTALL_DIR || null;
+  }
+  cloneDeps(dir) {
+    return { now: () => new Date(this.now()), ...this.deps.clone, dir };
+  }
+  pluginDeps() {
+    return {
+      dir: defaultPluginsDir(this.deps.env),
+      configDir: defaultConfigDir(this.deps.env),
+      ...this.deps.plugins,
+      confirm: async () => true,
+      // The page restarts this Wheelhouse itself once the change is kept.
+      restart: async () => ({ restarted: [], failed: [], kept: [] }),
+      log: () => {
+      }
+    };
+  }
+  /** Check Wheelhouse now; a check already under way is shared. */
+  checkWheelhouse() {
+    if (this.s.checking) return this.s.checking;
+    const dir = this.installDir();
+    const run = dir ? checkClone(this.cloneDeps(dir)) : Promise.resolve({
+      schema: "wheelhouse-update.v1",
+      checkedAt: new Date(this.now()).toISOString(),
+      state: "unsupported",
+      reason: "this Wheelhouse was not started by `wheelhouse open`, so it does not know where it is installed",
+      dir: "",
+      repository: null,
+      branch: null,
+      current: { commit: null, version: null },
+      latest: null,
+      commits: [],
+      behind: 0,
+      changes: []
+    });
+    this.s.checking = run.then((c) => this.s.check = c).finally(() => this.s.checking = null);
+    return this.s.checking;
+  }
+  /** The captain asked to check again: that also puts a failed upgrade behind them. */
+  checkWheelhouseNow() {
+    if (this.s.job?.state === "failed") this.s.job = null;
+    return this.checkWheelhouse();
+  }
+  /** Wheelhouse's state; starts a check in the background when the last one is stale. */
+  async wheelhouse() {
+    if (!this.s.checking && !this.s.changing && this.stale(this.s.check?.checkedAt)) {
+      void this.checkWheelhouse().catch(() => {
+      });
+    }
+    return {
+      schema: "wheelhouse-self-update.v1",
+      check: this.s.check,
+      checking: this.s.checking !== null,
+      job: this.s.job,
+      canRestart: canRestart(),
+      busy: await this.deps.busy?.() ?? []
+    };
+  }
+  /** Why a change cannot start now, or null. */
+  refuseChange() {
+    if (this.s.changing) return `Wait for ${this.s.changing} to finish.`;
+    if (!canRestart()) {
+      return "This Wheelhouse was not started by `wheelhouse open`, so it cannot restart itself to load a change.";
+    }
+    return null;
+  }
+  /**
+   * Start upgrading Wheelhouse: returns at once (or why it cannot start), and
+   * the job's progress shows in `wheelhouse()`. Ends by restarting.
+   */
+  startUpgrade() {
+    const refused = this.refuseChange();
+    if (refused) return { ok: false, error: refused };
+    const dir = this.installDir();
+    if (!dir) return { ok: false, error: "This Wheelhouse does not know where it is installed." };
+    this.s.changing = "the Wheelhouse upgrade";
+    const job = {
+      state: "running",
+      step: "fetch",
+      to: null,
+      error: null,
+      output: null,
+      startedAt: new Date(this.now()).toISOString()
+    };
+    this.s.job = job;
+    this.log("Upgrading Wheelhouse…");
+    void upgradeClone(this.cloneDeps(dir), (step) => {
+      job.step = step;
+    }).then((r) => {
+      if (r.check) this.s.check = r.check;
+      if (!r.ok) {
+        job.state = "failed";
+        job.error = r.error;
+        job.output = r.output.slice(-4e3) || null;
+        this.log(`Wheelhouse was not upgraded: ${r.error}.`);
+        return;
+      }
+      job.to = r.to;
+      job.step = "restart";
+      job.state = "restarting";
+      this.log(`Upgraded Wheelhouse to ${r.to.slice(0, 7)}; restarting.`);
+      restartSoon();
+    }).catch((e) => {
+      job.state = "failed";
+      job.error = e.message;
+    }).finally(() => {
+      if (job.state === "failed") this.s.changing = null;
+    });
+    return { ok: true };
+  }
+  /** Check every installed plugin now; a check under way is shared. */
+  checkPlugins() {
+    if (this.s.pluginsChecking) return this.s.pluginsChecking;
+    this.s.pluginsChecking = checkPlugins(defaultPluginsDir(this.deps.env), {
+      ...this.deps.plugins,
+      now: () => new Date(this.now())
+    }).then((v) => this.s.plugins = v).finally(() => this.s.pluginsChecking = null);
+    return this.s.pluginsChecking;
+  }
+  /** The installed plugins' update state; checks in the background when stale. */
+  async plugins() {
+    if (!this.s.pluginsChecking && this.stale(this.s.plugins?.checkedAt)) {
+      void this.checkPlugins().catch(() => {
+      });
+    }
+    return {
+      ...this.s.plugins ?? {
+        schema: "wheelhouse-plugin-updates.v1",
+        checkedAt: null,
+        plugins: [],
+        error: null
+      },
+      checking: this.s.pluginsChecking !== null,
+      busy: await this.deps.busy?.() ?? []
+    };
+  }
+  inspectInstall(repo, ref) {
+    return inspect(ref ? `${repo}@${ref}` : repo, this.pluginDeps());
+  }
+  /** `ref` moves it to that tag, branch or commit; null keeps the one it was installed from. */
+  inspectUpdate(id, ref) {
+    return inspectUpdate(id, this.pluginDeps(), ref ? { ref } : {});
+  }
+  /** Install what a look-up showed (exactly that commit), keep its settings, then restart. */
+  installPlugin(o) {
+    return this.change(
+      `installing ${o.repo}`,
+      () => install(o.ref ? `${o.repo}@${o.ref}` : o.repo, this.pluginDeps(), {
+        yes: true,
+        expect: o.commit,
+        settings: pairs(o.settings)
+      })
+    );
+  }
+  /** Update `id` to what a look-up showed (exactly that commit), keep new settings, then restart. */
+  updatePlugin(id, o) {
+    return this.change(
+      `updating ${id}`,
+      () => update(id, this.pluginDeps(), {
+        yes: true,
+        expect: o.commit,
+        ...o.ref ? { ref: o.ref } : {},
+        settings: pairs(o.settings)
+      })
+    );
+  }
+  /** Turn an installed plugin that is off back on (as `wheelhouse plugin enable`), then restart to load it. */
+  loadPlugin(id) {
+    return this.change(
+      `turning on ${id}`,
+      () => setEnabled(id, true, this.pluginDeps(), { yes: true })
+    );
+  }
+  async change(what, work) {
+    const refused = this.refuseChange();
+    if (refused) return { ok: false, error: refused };
+    this.s.changing = what;
+    let r;
+    try {
+      r = await work();
+    } catch (e) {
+      this.s.changing = null;
+      throw e;
+    }
+    if (!r.ok) {
+      this.s.changing = null;
+      return r;
+    }
+    this.s.plugins = null;
+    this.log(`Wheelhouse is restarting after ${what}.`);
+    restartSoon();
+    return { ok: true, restarting: true };
+  }
+  /** Forget everything (tests). */
+  reset() {
+    this.s = fresh();
+  }
+}
+const pairs = (settings) => Object.entries(settings).map(([k, v]) => `${k}=${v}`);
+const KEY = /* @__PURE__ */ Symbol.for("wheelhouse.updates");
+const g = globalThis;
+function updateService() {
+  g[KEY] ??= new UpdateService({
+    env: process.env,
+    busy: async () => (await import('./runtime.js-4msnOWzY.js').then((n) => n.T)).busyRuntime()
+  });
+  return g[KEY];
+}
+
+export { updateService as u };
+//# sourceMappingURL=service.js-DZR6CoEI.js.map