@opencode/browse 0.0.3-dev.2 → 0.0.6-dev.17

package/dist/main-4bht27ry.mjs

@@ -0,0 +1,72 @@
+import {
+  dataRoot
+} from "./main-g5mke6rn.mjs";
+
+// src/relay-secrets.ts
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+var relayTokenQueryParam = "opencodeBrowserToken";
+var tokenPattern = /^[A-Za-z0-9_-]{43}$/;
+function relayTokenPath(root = dataRoot()) {
+  return path.join(root, "relay-token");
+}
+function relayToken(root = dataRoot()) {
+  return readOrCreateSecret(relayTokenPath(root), () => crypto.randomBytes(32).toString("base64url"), (value) => tokenPattern.test(value));
+}
+function relayAuthorization(root = dataRoot()) {
+  return `Bearer ${relayToken(root)}`;
+}
+function secretsEqual(expected, actual) {
+  if (actual === undefined)
+    return false;
+  const a = crypto.createHash("sha256").update(expected).digest();
+  const b = crypto.createHash("sha256").update(actual).digest();
+  return crypto.timingSafeEqual(a, b) && expected.length === actual.length;
+}
+function readOrCreateSecret(file, generate, valid) {
+  const existing = readSecret(file);
+  if (existing !== undefined && valid(existing))
+    return existing;
+  ensurePrivateDirectory(path.dirname(file));
+  const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  fs.writeFileSync(temporary, `${generate()}
+`, { mode: 384 });
+  try {
+    if (existing === undefined) {
+      try {
+        fs.linkSync(temporary, file);
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+    } else {
+      fs.renameSync(temporary, file);
+    }
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+  const created = readSecret(file);
+  if (created === undefined || !valid(created))
+    throw new Error(`Could not create ${file}`);
+  return created;
+}
+function readSecret(file) {
+  try {
+    const stat = fs.statSync(file);
+    if (process.platform !== "win32" && (stat.mode & 63) !== 0)
+      fs.chmodSync(file, 384);
+    return fs.readFileSync(file, "utf8").trim();
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function ensurePrivateDirectory(directory = dataRoot()) {
+  fs.mkdirSync(directory, { recursive: true, mode: 448 });
+  if (process.platform !== "win32")
+    fs.chmodSync(directory, 448);
+}
+
+export { relayTokenQueryParam, relayToken, relayAuthorization, secretsEqual, ensurePrivateDirectory };

package/dist/main-4p2p9eey.mjs

@@ -0,0 +1,334 @@
+import {
+  unpackedReloadAdvice,
+  dataRoot,
+  checkoutRoot,
+  cliCommand,
+  compareVersions,
+  npmRuntime,
+  autoUpdateStatus
+} from "./main-g5mke6rn.mjs";
+
+// src/update.ts
+import { execFile, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var UPDATE_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+var FAILED_CHECK_INTERVAL_MS = 60 * 60 * 1000;
+var CACHE_FILE = "update-check.json";
+var quietGitEnv = () => ({
+  ...process.env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? "ssh -o BatchMode=yes"
+});
+var gitIn = (repo) => (args, timeoutMs = 5000) => new Promise((resolve) => {
+  execFile("git", ["-C", repo, ...args], { timeout: timeoutMs, encoding: "utf8", env: quietGitEnv() }, (error, stdout) => resolve(error ? undefined : stdout.trim()));
+});
+var short = (sha) => sha.slice(0, 7);
+async function defaultBranch(remote, git) {
+  return parseDefaultBranch(await git(["ls-remote", "--symref", remote, "HEAD"], 1e4));
+}
+var parseDefaultBranch = (listed) => /^ref: (refs\/heads\/\S+)\s+HEAD$/m.exec(listed ?? "")?.[1];
+async function checkForUpdate(repo, git = gitIn(repo), now = Date.now()) {
+  const [head, branch] = await Promise.all([git(["rev-parse", "HEAD"]), git(["symbolic-ref", "--short", "-q", "HEAD"])]);
+  if (!head || !branch)
+    return;
+  const [remote, merge] = await Promise.all([git(["config", `branch.${branch}.remote`]), git(["config", `branch.${branch}.merge`])]);
+  if (!remote || !merge || remote === ".")
+    return;
+  let upstream = `${remote}/${merge.replace(/^refs\/heads\//, "")}`;
+  let listed = await git(["ls-remote", remote, merge], 1e4);
+  if (listed === "") {
+    const fallback = await defaultBranch(remote, git);
+    if (fallback && fallback !== merge) {
+      upstream = `${remote}/${fallback.replace(/^refs\/heads\//, "")}`;
+      listed = await git(["ls-remote", remote, fallback], 1e4);
+    }
+  }
+  const base = { repo, checkedAt: now, head, upstream };
+  const latest = listed?.split(/\s/)[0];
+  if (!latest || !/^[0-9a-f]{40,64}$/.test(latest))
+    return { ...base, available: false, failed: true };
+  if (latest === head)
+    return { ...base, latest, available: false };
+  if (await git(["cat-file", "-e", `${latest}^{commit}`]) !== undefined) {
+    if (await git(["merge-base", "--is-ancestor", latest, "HEAD"]) !== undefined)
+      return { ...base, latest, available: false };
+    const behind = Number(await git(["rev-list", "--count", `HEAD..${latest}`]));
+    return { ...base, latest, available: true, ...Number.isInteger(behind) && behind > 0 ? { behind } : {} };
+  }
+  return { ...base, latest, available: true };
+}
+function readCache(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+}
+function writeCache(file, check) {
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    writeFileSync(temporary, JSON.stringify(check) + `
+`);
+    renameSync(temporary, file);
+  } catch {}
+}
+async function cachedUpdateCheck(options) {
+  const git = options.git ?? gitIn(options.repo);
+  const now = options.now ?? Date.now();
+  const file = path.join(options.dataDir, CACHE_FILE);
+  const cached = readCache(file);
+  const head = await git(["rev-parse", "HEAD"]);
+  if (!head)
+    return;
+  const maxAge = cached?.failed ? FAILED_CHECK_INTERVAL_MS : UPDATE_CHECK_INTERVAL_MS;
+  if (cached && cached.repo === options.repo && cached.head === head && now - cached.checkedAt >= 0 && now - cached.checkedAt < maxAge)
+    return cached;
+  const fresh = await checkForUpdate(options.repo, git, now);
+  if (fresh)
+    writeCache(file, fresh);
+  return fresh;
+}
+var updateCheckEnabled = () => process.env.OPENCODE_BROWSER_UPDATE_CHECK !== "0";
+function describeUpdate(check) {
+  if (check.behind)
+    return `${check.behind} new commit${check.behind === 1 ? "" : "s"} on ${check.upstream}`;
+  return `${check.upstream} is at ${short(check.latest ?? "")} (you have ${short(check.head)})`;
+}
+function updateJson2(update) {
+  if (!update)
+    return null;
+  const { check } = update;
+  return {
+    available: true,
+    summary: update.summary,
+    command: update.command,
+    notice: formatUpdateNotice2(update),
+    current: check.head,
+    latest: check.latest ?? null,
+    behind: check.behind ?? null,
+    upstream: check.upstream
+  };
+}
+function formatUpdateNotice2(notice) {
+  return `Update available: ${notice.summary}. Run \`${notice.command}\`, then restart opencode.`;
+}
+async function updateNotice2(options = {}) {
+  try {
+    if (!options.repo) {
+      const npm = npmUpdateNotice();
+      if (npm !== false)
+        return npm;
+    }
+    const repo = options.repo ?? checkoutRoot();
+    if (!repo || !updateCheckEnabled() || !existsSync(path.join(repo, ".git")))
+      return;
+    const check = await cachedUpdateCheck({ repo, dataDir: options.dataDir ?? dataRoot(), ...options.git ? { git: options.git } : {} });
+    return check?.available ? { summary: describeUpdate(check), command: cliCommand("update"), check } : undefined;
+  } catch {
+    return;
+  }
+}
+function npmUpdateNotice() {
+  const runtime = npmRuntime();
+  if (!runtime)
+    return false;
+  const status = autoUpdateStatus({ runtime });
+  const latest = status.latest;
+  if (!latest || compareVersions(latest, runtime.version) <= 0 || status.effective === "off" || latest === status.skipped)
+    return;
+  if (status.effective === "on" && !status.lastError)
+    return;
+  const check = { repo: "npm", checkedAt: Date.now(), head: runtime.version, upstream: `npm ${status.channel ?? "latest"}`, latest, available: true };
+  return { summary: `browse ${latest} is available (you have ${runtime.version})`, command: cliCommand("update"), check };
+}
+function createUpdateWatcher2(options = {}) {
+  const check = options.check ?? (() => updateNotice2());
+  const now = options.now ?? Date.now;
+  const interval = options.intervalMs ?? FAILED_CHECK_INTERVAL_MS;
+  let current;
+  let lastRun;
+  let running;
+  return {
+    get current() {
+      return current;
+    },
+    refresh() {
+      if (running)
+        return running;
+      if (lastRun !== undefined && now() - lastRun < interval)
+        return Promise.resolve();
+      lastRun = now();
+      running = check().catch(() => {
+        return;
+      }).then((next) => {
+        const changed = (next ? formatUpdateNotice2(next) : undefined) !== (current ? formatUpdateNotice2(current) : undefined);
+        current = next;
+        if (changed)
+          options.onChange?.(next);
+      }).finally(() => {
+        running = undefined;
+      });
+      return running;
+    }
+  };
+}
+var syncGit = (repo) => (args, timeoutMs = 30000) => {
+  const result = spawnSync("git", ["-C", repo, ...args], { encoding: "utf8", timeout: timeoutMs, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } });
+  return { status: result.status, stdout: (result.stdout ?? "").trim(), stderr: (result.stderr ?? "").trim(), ...result.error ? { error: result.error } : {} };
+};
+var realpath = (file) => {
+  try {
+    return realpathSync(file);
+  } catch {
+    return path.resolve(file);
+  }
+};
+var firstLine = (text) => text.split(/\r?\n/).find((line) => line.trim())?.trim() ?? "";
+var shellQuoted = (value) => /^[\w@%+=:,./-]+$/.test(value) ? value : JSON.stringify(value);
+function defaultSetup(step) {
+  const cli = path.join(step.repo, "cli");
+  const run = (command, args, cwd) => {
+    const result = spawnSync(command, args, { cwd, stdio: "inherit" });
+    return result.status === 0 ? undefined : `\`${[command, ...args].join(" ")}\` failed in ${cwd}${result.error ? ` (${result.error.message})` : ""}`;
+  };
+  const installs = [[step.root, step.repo], [step.cli, cli]];
+  for (const [changed, directory] of installs) {
+    if (!changed && existsSync(path.join(directory, "node_modules")))
+      continue;
+    const failed = run("bun", ["install", "--frozen-lockfile"], directory);
+    if (failed)
+      return failed;
+  }
+  const built = run("bun", ["run", "build"], cli);
+  if (built)
+    return built;
+  const node = process.versions.bun ? "node" : process.execPath;
+  return run(node, [path.join(cli, "dist", "cli.mjs"), "install", ...step.args], cli);
+}
+function installArgs(args) {
+  const passed = [];
+  for (let index = 0;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--opencode" && args[index + 1] !== undefined)
+      passed.push(arg, args[++index]);
+    else if (arg === "--no-open")
+      passed.push(arg);
+  }
+  return [...passed, "--no-wait"];
+}
+function runUpdate(args, deps) {
+  const { log } = deps;
+  const refuse = (problem, fix) => {
+    log(`✗ Not updated: ${problem}`);
+    log(`  ${fix}`);
+    return 1;
+  };
+  const repo = deps.repo;
+  if (!repo) {
+    log("Browse was installed from npm. Update it with:");
+    log("  npx @opencode/browse@latest install");
+    log("then restart opencode.");
+    return 0;
+  }
+  const git = deps.git ?? syncGit(repo);
+  const at = shellQuoted(repo);
+  const version = git(["--version"]);
+  if (version.error || version.status !== 0)
+    return refuse("git isn't installed or isn't on PATH.", "Install git, then run this again.");
+  const top = git(["rev-parse", "--show-toplevel"]).stdout;
+  if (!top || realpath(top) !== realpath(repo))
+    return refuse(`${repo} isn't a git clone.`, `Clone it again: git clone https://github.com/anomalyco/browse.git && cd browse && bun run setup`);
+  if (!(deps.hasBun ?? (() => !spawnSync("bun", ["--version"], { stdio: "ignore" }).error))())
+    return refuse("bun isn't installed or isn't on PATH (setup builds with it).", "Install Bun from https://bun.sh, then run this again.");
+  const branch = git(["symbolic-ref", "--short", "-q", "HEAD"]).stdout;
+  const head = git(["rev-parse", "HEAD"]).stdout;
+  if (!branch)
+    return refuse(`${repo} isn't on a branch (HEAD is detached at ${short(head)}).`, `Check out the branch to follow, e.g. \`git -C ${at} checkout dev\`, then run this again.`);
+  let upstream = git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]).stdout;
+  const remote = git(["config", `branch.${branch}.remote`]).stdout;
+  let merge = git(["config", `branch.${branch}.merge`]).stdout;
+  if (!upstream || !remote || !merge || remote === ".")
+    return refuse(`branch ${branch} doesn't track a remote branch.`, `Set one, e.g. \`git -C ${at} branch --set-upstream-to origin/dev\`, then run this again.`);
+  const changes = git(["diff", "--name-only", "HEAD"]).stdout;
+  if (changes) {
+    const files = changes.split(/\r?\n/);
+    return refuse(`${repo} has uncommitted changes (${files.slice(0, 5).join(", ")}${files.length > 5 ? `, and ${files.length - 5} more` : ""}).`, `Commit or stash them (\`git -C ${at} stash\`), then run this again.`);
+  }
+  if (git(["ls-remote", "--exit-code", remote, merge], 30000).status === 2) {
+    const fallback = parseDefaultBranch(git(["ls-remote", "--symref", remote, "HEAD"], 30000).stdout);
+    if (fallback && fallback !== merge) {
+      const gone = upstream;
+      merge = fallback;
+      upstream = `${remote}/${fallback.replace(/^refs\/heads\//, "")}`;
+      git(["config", `branch.${branch}.merge`, merge]);
+      log(`${gone} is gone from the remote; following ${upstream}, its default branch, from now on.`);
+    }
+  }
+  const fetched = git(["fetch", "--quiet", remote, merge], 120000);
+  if (fetched.status !== 0) {
+    const url = git(["remote", "get-url", remote]).stdout;
+    return refuse(`couldn't fetch ${upstream}${url ? ` from ${url}` : ""}: ${firstLine(fetched.stderr) || fetched.error?.message || "git fetch failed"}.`, "Check your network connection, then run this again.");
+  }
+  const latest = git(["rev-parse", "FETCH_HEAD"]).stdout;
+  if (!latest)
+    return refuse(`couldn't read ${upstream} after fetching.`, `Run \`git -C ${at} pull --ff-only\` to see why.`);
+  if (latest === head || git(["merge-base", "--is-ancestor", latest, "HEAD"]).status === 0) {
+    log(`✓ Already up to date: ${short(head)} on ${branch} (${upstream}).`);
+    log(`  If your unpacked extension still reports an older protocol: ${unpackedReloadAdvice}`);
+    return 0;
+  }
+  if (git(["merge-base", "--is-ancestor", "HEAD", latest]).status !== 0) {
+    const counts = git(["rev-list", "--left-right", "--count", `HEAD...${latest}`]).stdout.split(/\s+/);
+    return refuse(`${branch} has diverged from ${upstream} (${counts[0] ?? "?"} local commit(s), ${counts[1] ?? "?"} new on the remote), so it can't fast-forward.`, `Reconcile them yourself (e.g. \`git -C ${at} pull --rebase\`), then run \`cd ${at} && bun run setup\`.`);
+  }
+  const count = Number(git(["rev-list", "--count", `HEAD..${latest}`]).stdout) || 0;
+  const commits = git(["log", "--oneline", "--no-decorate", "-n", "20", `HEAD..${latest}`]).stdout;
+  const changed = (...files) => !!git(["diff", "--name-only", "HEAD", latest, "--", ...files]).stdout;
+  const rootDeps = changed("package.json", "bun.lock");
+  const cliDeps = changed("cli/package.json", "cli/bun.lock");
+  log(`Updating browse ${short(head)} → ${short(latest)} (${count} new commit${count === 1 ? "" : "s"} on ${upstream}):`);
+  for (const line of commits.split(/\r?\n/).filter(Boolean))
+    log(`  ${line}`);
+  if (count > 20)
+    log(`  … and ${count - 20} more`);
+  log("");
+  const pulled = git(["merge", "--ff-only", "--quiet", latest], 60000);
+  if (pulled.status !== 0)
+    return refuse(`couldn't fast-forward to ${short(latest)}: ${firstLine(pulled.stderr) || "git merge failed"}.`, `Run \`git -C ${at} pull --ff-only\` to see why.`);
+  const failed = (deps.setup ?? defaultSetup)({ repo, root: rootDeps, cli: cliDeps, args: installArgs(args) });
+  if (failed) {
+    log("");
+    log(`✗ Pulled ${short(head)} → ${short(latest)}, but setup failed: ${failed}.`);
+    log(`  Fix it, then run \`cd ${at} && bun run setup\`.`);
+    return 1;
+  }
+  log("");
+  log(`✓ Updated browse ${short(head)} → ${short(latest)}.`);
+  log("  Restart opencode to load the new browse MCP server.");
+  return 0;
+}
+async function runUpdateCommand2(args) {
+  const log = (line) => process.stdout.write(line + `
+`);
+  const { runNpmUpdate } = await import("./runtime-update-0mddkfy5.mjs");
+  if (await runNpmUpdate(args))
+    return;
+  if (args.includes("--check")) {
+    const repo = checkoutRoot();
+    if (!repo)
+      return log("Installed from npm: run `npx @opencode/browse@latest install` to update.");
+    const check = await checkForUpdate(repo);
+    if (check)
+      writeCache(path.join(dataRoot(), CACHE_FILE), check);
+    if (!check)
+      return log("Can't check: this clone isn't on a branch that tracks a remote.");
+    if (check.failed)
+      return log(`Can't check: ${check.upstream} couldn't be reached.`);
+    return log(check.available ? formatUpdateNotice2({ summary: describeUpdate(check), command: cliCommand("update") }) : `✓ Up to date with ${check.upstream}.`);
+  }
+  process.exitCode = runUpdate(args, { repo: checkoutRoot(), log });
+}
+
+export { updateJson2, formatUpdateNotice2, updateNotice2, createUpdateWatcher2, runUpdateCommand2 };