@chrisjowen/wheelhouse 0.2.0 → 0.2.1

package/build/server/chunks/chunks/service.js-DQK1kj-4.js

@@ -1,914 +0,0 @@
-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-BuGWYyZZ.js').then((n) => n.S)).busyRuntime()
-  });
-  return g[KEY];
-}
-
-export { updateService as u };
-//# sourceMappingURL=service.js-DQK1kj-4.js.map