@opencode/browse 0.0.0 → 0.0.6-dev.17

package/dist/runtime-update-0mddkfy5.mjs

@@ -0,0 +1,187 @@
+import {
+  cliCommand,
+  installCommand,
+  runtimeLayout,
+  versionEntry,
+  channelOf,
+  UPDATE_VERSION,
+  compareVersions,
+  readCurrent,
+  writeCurrent,
+  readState,
+  updateState,
+  npmRuntime,
+  autoUpdateOverride,
+  registryUrl,
+  fetchPublished,
+  installVersion,
+  pruneVersions,
+  switchVersion
+} from "./main-g5mke6rn.mjs";
+import {
+  Service,
+  layerFetch,
+  restartRelay,
+  startManagedRelay
+} from "./main-3qpkwaa7.mjs";
+import"./main-y7c1atbf.mjs";
+import"./main-4bht27ry.mjs";
+
+// src/runtime-update.ts
+import { Effect } from "effect";
+import { existsSync } from "node:fs";
+var log = (line) => process.stdout.write(line + `
+`);
+async function switchTo(layout, version, options) {
+  const entry = versionEntry(layout, version);
+  if (!existsSync(entry))
+    return `${version} isn't installed`;
+  const before = readCurrent(layout);
+  let switched = false;
+  const point = Effect.sync(() => {
+    switchVersion(layout, version, options.previous);
+    switched = true;
+  });
+  const program = Effect.gen(function* () {
+    const relay = yield* Service;
+    const running = yield* Effect.result(relay.version);
+    if (running._tag === "Failure") {
+      yield* point;
+      return;
+    }
+    yield* restartRelay({
+      relay,
+      clientKind: "cli",
+      force: options.force,
+      otherBuild: true,
+      onShutdownAccepted: point,
+      start: Effect.suspend(() => switched ? Effect.void : point).pipe(Effect.andThen(startManagedRelay(entry)))
+    });
+    const now = yield* relay.version;
+    return now.version === version ? undefined : `a relay of version ${now.version} started first`;
+  }).pipe(Effect.provide(layerFetch));
+  const refused = await Effect.runPromise(program.pipe(Effect.catch((error) => Effect.succeed(error.message ?? String(error)))));
+  if (refused && switched && before)
+    writeCurrent(layout, before);
+  return refused;
+}
+function npmOnly(command) {
+  const runtime = npmRuntime();
+  if (runtime)
+    return runtime;
+  log(`\`${command}\` is for npm installs (\`${installCommand()}\`); this one isn't.`);
+  process.exitCode = 1;
+  return;
+}
+async function runRollback(args) {
+  const runtime = npmOnly("rollback");
+  if (!runtime)
+    return;
+  const { layout } = runtime;
+  const current = readCurrent(layout);
+  const previous = current.previous;
+  if (!previous || !existsSync(versionEntry(layout, previous))) {
+    log(`Nothing to roll back to: ${current.version} has no previous version installed.`);
+    process.exitCode = 1;
+    return;
+  }
+  const refused = await switchTo(layout, previous, { previous: current.version, force: args.includes("--force") });
+  if (refused) {
+    log(`✗ Not rolled back: the relay didn't restart (${refused}).`);
+    log(`  When no agent is using the browser, run \`${cliCommand("rollback")}\` again (or add --force to end what's blocking it).`);
+    process.exitCode = 1;
+    return;
+  }
+  updateState(layout, ({ pending: _pending, ...state }) => ({ ...state, skipped: current.version, lastUpdate: { from: current.version, to: previous, at: new Date().toISOString() } }));
+  log(`✓ Rolled back ${current.version} → ${previous}. Auto-update skips ${current.version} until a newer version is published.`);
+  log("  Running MCP servers switch to it between requests; restart opencode if a tool still reports the old version.");
+}
+async function runNpmUpdate(args, layout) {
+  const runtime = npmRuntime(layout ? { layout } : {});
+  if (!runtime)
+    return false;
+  const lay = runtime.layout;
+  const channel = channelOf(runtime.version);
+  const published = await fetchPublished({ registry: await registryUrl(), channel }).catch((error) => error);
+  if (published instanceof Error) {
+    log(`✗ Couldn't check for updates: ${published.message}`);
+    process.exitCode = 1;
+    return true;
+  }
+  updateState(lay, ({ failed: _failed, ...state }) => ({ ...state, checkedAt: Date.now(), latest: published.version, integrity: published.integrity }));
+  if (compareVersions(published.version, runtime.version) <= 0) {
+    log(`✓ Up to date: ${runtime.version} is the newest on the ${channel} channel.`);
+    return true;
+  }
+  if (args.includes("--check")) {
+    log(`Update available: ${published.version} (you have ${runtime.version}). Run \`${cliCommand("update")}\` to install it.`);
+    return true;
+  }
+  log(`Installing ${published.version} (you have ${runtime.version})…`);
+  const entry = await installVersion({ layout: lay, version: published.version, integrity: published.integrity, ...process.env.OPENCODE_BROWSER_NPM_REGISTRY ? { registry: await registryUrl() } : {} }).catch((error) => {
+    log(`✗ ${error.message}`);
+    process.exitCode = 1;
+    return;
+  });
+  if (!entry)
+    return true;
+  updateState(lay, ({ skipped: _skipped, ...state }) => ({ ...state, pending: published.version }));
+  const current = readCurrent(lay);
+  const refused = await switchTo(lay, published.version, { previous: current.version, force: args.includes("--force") });
+  if (refused) {
+    const automatic = (autoUpdateOverride() ?? readState(lay).mode ?? "on") === "on";
+    log(`! Installed ${published.version}, but the relay didn't restart (${refused}).`);
+    log(automatic ? "  It switches to the new version by itself once no agent is using the browser." : `  When no agent is using the browser, run \`${cliCommand("update")}\` again.`);
+    return true;
+  }
+  updateState(lay, ({ pending: _pending, ...state }) => ({ ...state, lastUpdate: { from: current.version, to: published.version, at: new Date().toISOString() } }));
+  pruneVersions(lay);
+  log(`✓ Updated ${current.version} → ${published.version}.`);
+  return true;
+}
+async function runRuntimeInstall(args) {
+  const layout = runtimeLayout();
+  const version = args[0];
+  const integrityAt = args.indexOf("--integrity");
+  const integrity = integrityAt === -1 ? undefined : args[integrityAt + 1];
+  if (!version || !UPDATE_VERSION.test(version)) {
+    log(`runtime-install: invalid version ${JSON.stringify(version)}`);
+    process.exitCode = 2;
+    return;
+  }
+  const clear = (installing) => installing?.pid === process.pid ? undefined : installing;
+  try {
+    await installVersion({ layout, version, ...integrity ? { integrity } : {}, ...process.env.OPENCODE_BROWSER_NPM_REGISTRY ? { registry: await registryUrl() } : {} });
+    updateState(layout, ({ installing, lastError: _error, ...state }) => {
+      const still = clear(installing);
+      return { ...state, ...still ? { installing: still } : {}, pending: version };
+    });
+    log(`${new Date().toISOString()} installed ${version}`);
+  } catch (error) {
+    updateState(layout, ({ installing, ...state }) => {
+      const still = clear(installing);
+      return { ...state, ...still ? { installing: still } : {}, lastError: { message: error.message, at: new Date().toISOString(), version } };
+    });
+    log(`${new Date().toISOString()} install of ${version} failed: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+async function runRuntimeSwitch(args) {
+  const layout = runtimeLayout();
+  const version = args[0];
+  const current = readCurrent(layout);
+  if (!version || !current) {
+    process.exitCode = 2;
+    return;
+  }
+  const refused = await switchTo(layout, version, { previous: current.version, force: false });
+  log(`${new Date().toISOString()} switch ${current.version} → ${version}: ${refused ? `refused (${refused})` : "done"}`);
+  if (refused)
+    process.exitCode = 1;
+}
+export {
+  runNpmUpdate,
+  runRollback,
+  runRuntimeInstall,
+  runRuntimeSwitch
+};