@opencode/browse 0.0.6-dev.17 → 0.0.6-dev.19

package/dist/cli.mjs

@@ -2,26 +2,26 @@
 
 // src/main.ts
 import path from "node:path";
-var embeddedVersion = "0.0.6-dev.17";
+var embeddedVersion = "0.0.6-dev.19";
 var setupCommands = new Set(["install", "uninstall", "extension", "pair", "rollback", "set"]);
 var command = process.argv[2];
 var invokedAs = path.basename(process.argv[1] ?? "");
 if (command === "--version" || command === "-v") {
-  const opencodeBrowserVersion = embeddedVersion ?? (await import("./version-wrebjhy7.mjs")).opencodeBrowserVersion;
+  const opencodeBrowserVersion = embeddedVersion ?? (await import("./version-cjhq7cm9.mjs")).opencodeBrowserVersion;
   process.stdout.write(`${opencodeBrowserVersion}
 `);
-} else if (invokedAs === "opencode-browser-mcp") {
+} else if (invokedAs === "opencode-browser-mcp" || command === "mcp" && process.argv.length === 3) {
   const { NodeRuntime } = await import("@effect/platform-node");
-  const { runMcpServer } = await import("./mcp-2smdsn8z.mjs");
+  const { runMcpServer } = await import("./mcp-p0mcjvq9.mjs");
   runMcpServer.pipe(NodeRuntime.runMain);
 } else if (command === "runtime-install" || command === "runtime-switch") {
-  const { runRuntimeInstall, runRuntimeSwitch } = await import("./runtime-update-0mddkfy5.mjs");
+  const { runRuntimeInstall, runRuntimeSwitch } = await import("./runtime-update-pxbj49tf.mjs");
   await (command === "runtime-install" ? runRuntimeInstall : runRuntimeSwitch)(process.argv.slice(3));
 } else if (command === "update") {
-  const { runUpdateCommand } = await import("./update-cyy1grjj.mjs");
+  const { runUpdateCommand } = await import("./update-5fx8t344.mjs");
   await runUpdateCommand(process.argv.slice(3));
 } else if (command && setupCommands.has(command)) {
-  const { runSetup } = await import("./setup-f2qjnvre.mjs");
+  const { runSetup } = await import("./setup-y8pd11b8.mjs");
   await runSetup(command, process.argv.slice(3));
 } else {
   if (!command || command === "--help" || command === "-h") {
@@ -55,9 +55,9 @@ if (command === "--version" || command === "-v") {
 `);
   }
   if (command === "status" && !process.argv.includes("--json")) {
-    const { printSetupStatus } = await import("./setup-f2qjnvre.mjs");
+    const { printSetupStatus } = await import("./setup-y8pd11b8.mjs");
     printSetupStatus();
   }
-  const { runCli } = await import("./cli-b4sbkefj.mjs");
+  const { runCli } = await import("./cli-22fe7etn.mjs");
   runCli();
 }

package/dist/{relay-helpers-pjcbxs7p.mjs → helpers-rta4d2as.mjs}

@@ -31,7 +31,7 @@ import {
   isRestrictedTarget2,
   isRestrictedUrl2,
   dataUrlDocument2
-} from "./main-3qpkwaa7.mjs";
+} from "./main-8a245rm1.mjs";
 export {
   HttpRouteError2 as HttpRouteError,
   chromeExtensionOriginForPath2 as chromeExtensionOriginForPath,

package/dist/{main-4p2p9eey.mjs → main-2wrztakb.mjs}

@@ -1,12 +1,12 @@
 import {
-  unpackedReloadAdvice,
   dataRoot,
   checkoutRoot,
   cliCommand,
   compareVersions,
   npmRuntime,
-  autoUpdateStatus
-} from "./main-g5mke6rn.mjs";
+  autoUpdateStatus,
+  unpackedReloadAdvice
+} from "./main-yd50d95g.mjs";
 
 // src/update.ts
 import { execFile, spawnSync } from "node:child_process";
@@ -312,7 +312,7 @@ function runUpdate(args, deps) {
 async function runUpdateCommand2(args) {
   const log = (line) => process.stdout.write(line + `
 `);
-  const { runNpmUpdate } = await import("./runtime-update-0mddkfy5.mjs");
+  const { runNpmUpdate } = await import("./runtime-update-pxbj49tf.mjs");
   if (await runNpmUpdate(args))
     return;
   if (args.includes("--check")) {

package/dist/main-75rdz6bc.mjs

@@ -0,0 +1,130 @@
+import {
+  dataRoot
+} from "./main-yd50d95g.mjs";
+
+// src/relay/secrets.ts
+import crypto2 from "node:crypto";
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// src/fs-durability.ts
+import { Predicate } from "effect";
+import crypto from "node:crypto";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+var unsupportedDirectorySyncCodes = new Set(["EPERM", "EINVAL", "ENOTSUP"]);
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+function isUnsupportedDirectorySyncError(error) {
+  return isNodeError(error) && Predicate.isString(error.code) && unsupportedDirectorySyncCodes.has(error.code);
+}
+async function writeJsonFileAtomically(filePath, value, options = {}) {
+  const directory = path.dirname(filePath);
+  await fs.mkdir(directory, {
+    recursive: true,
+    ...options.dirMode === undefined ? {} : { mode: options.dirMode }
+  });
+  if (options.dirMode !== undefined) {
+    await fs.chmod(directory, options.dirMode);
+  }
+  const temporaryPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  let renamed = false;
+  try {
+    await fs.writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+    await fs.rename(temporaryPath, filePath);
+    renamed = true;
+    await fs.chmod(filePath, 384);
+  } finally {
+    if (!renamed)
+      await fs.rm(temporaryPath, { force: true }).catch(() => {});
+  }
+}
+function ensurePrivateDirectorySync(directory) {
+  fsSync.mkdirSync(directory, { recursive: true, mode: 448 });
+  if (process.platform !== "win32")
+    fsSync.chmodSync(directory, 448);
+}
+function writePrivateJsonFileSync(filePath, value, options = {}) {
+  if (options.ensureParent)
+    ensurePrivateDirectorySync(path.dirname(filePath));
+  const temporaryPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  let renamed = false;
+  try {
+    fsSync.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+    fsSync.renameSync(temporaryPath, filePath);
+    renamed = true;
+    if (process.platform !== "win32")
+      fsSync.chmodSync(filePath, 384);
+  } finally {
+    if (!renamed)
+      fsSync.rmSync(temporaryPath, { force: true });
+  }
+}
+
+// src/relay/secrets.ts
+var relayTokenQueryParam = "opencodeBrowserToken";
+var tokenPattern = /^[A-Za-z0-9_-]{43}$/;
+function relayTokenPath(root = dataRoot()) {
+  return path2.join(root, "relay-token");
+}
+function relayToken(root = dataRoot()) {
+  return readOrCreateSecret(relayTokenPath(root), () => crypto2.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 = crypto2.createHash("sha256").update(expected).digest();
+  const b = crypto2.createHash("sha256").update(actual).digest();
+  return crypto2.timingSafeEqual(a, b) && expected.length === actual.length;
+}
+function readOrCreateSecret(file, generate, valid) {
+  const existing = readSecret(file);
+  if (existing !== undefined && valid(existing))
+    return existing;
+  ensurePrivateDirectory(path2.dirname(file));
+  const temporary = `${file}.${process.pid}.${crypto2.randomUUID()}.tmp`;
+  fs2.writeFileSync(temporary, `${generate()}
+`, { mode: 384 });
+  try {
+    if (existing === undefined) {
+      try {
+        fs2.linkSync(temporary, file);
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+    } else {
+      fs2.renameSync(temporary, file);
+    }
+  } finally {
+    fs2.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 = fs2.statSync(file);
+    if (process.platform !== "win32" && (stat.mode & 63) !== 0)
+      fs2.chmodSync(file, 384);
+    return fs2.readFileSync(file, "utf8").trim();
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function ensurePrivateDirectory(directory = dataRoot()) {
+  ensurePrivateDirectorySync(directory);
+}
+
+export { isNodeError, isUnsupportedDirectorySyncError, writeJsonFileAtomically, ensurePrivateDirectorySync, writePrivateJsonFileSync, relayTokenQueryParam, relayToken, relayAuthorization, secretsEqual, ensurePrivateDirectory };

package/dist/{main-3qpkwaa7.mjs → main-8a245rm1.mjs}

@@ -1,24 +1,24 @@
 import {
+  cliCommand,
+  installCommand,
+  npmRuntime,
   unpackedExtensionId,
   extensionReconnectAlarmPeriodMs,
   extensionProtocolAdvice,
-  parseJsonObject,
-  cliCommand,
-  installCommand,
-  npmRuntime
-} from "./main-g5mke6rn.mjs";
-import {
-  opencodeBrowserBuildId2
-} from "./main-y7c1atbf.mjs";
+  parseJsonObject
+} from "./main-yd50d95g.mjs";
 import {
   relayAuthorization
-} from "./main-4bht27ry.mjs";
+} from "./main-75rdz6bc.mjs";
+import {
+  opencodeBrowserBuildId2
+} from "./main-ts9jjqs8.mjs";
 
-// src/relay-helpers.ts
+// src/relay/helpers.ts
 import crypto from "node:crypto";
 import { Effect, Option, Predicate, Schema as Schema2 } from "effect";
 
-// src/relay-schema.ts
+// src/relay/schema.ts
 import { Schema } from "effect";
 var SessionSummary = Schema.Struct({
   id: Schema.String,
@@ -524,7 +524,7 @@ var ErrorEnvelope = Schema.Struct({
   code: Schema.optionalKey(RelayErrorCode)
 });
 
-// src/relay-helpers.ts
+// src/relay/helpers.ts
 var defaultHost2 = "127.0.0.1";
 var defaultPort2 = 19988;
 var stableUnpackedExtensionOrigin2 = `chrome-extension://${unpackedExtensionId}`;
@@ -946,7 +946,15 @@ async function dataUrlDocument2(url) {
   return;
 }
 
-// src/relay-client.ts
+// src/relay/lifecycle.ts
+import { Config as Config2, Effect as Effect3, Result, Schedule, Schema as Schema4 } from "effect";
+import { spawn } from "node:child_process";
+import crypto2 from "node:crypto";
+import path from "node:path";
+import process2 from "node:process";
+import { fileURLToPath } from "node:url";
+
+// src/relay/client.ts
 import { NodeHttpClient } from "@effect/platform-node";
 import { Config, Context, Effect as Effect2, Layer, Option as Option2, Schema as Schema3 } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/http";
@@ -1118,14 +1126,8 @@ function mcpClientPid() {
 }
 var layerFetchMcp = Layer.effect(Service, make({ clientPid: mcpClientPid() })).pipe(Layer.provide(NodeHttpClient.layerNodeHttp));
 
-// src/relay-lifecycle.ts
-import { Config as Config2, Effect as Effect3, Result, Schedule, Schema as Schema4 } from "effect";
-import { spawn } from "node:child_process";
-import crypto2 from "node:crypto";
-import path from "node:path";
-import process2 from "node:process";
-import { fileURLToPath } from "node:url";
-var loadedCliEntrypoint = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./main.ts" : "./cli.mjs", import.meta.url));
+// src/relay/lifecycle.ts
+var loadedCliEntrypoint = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "../main.ts" : "./cli.mjs", import.meta.url));
 var clientInstanceId = crypto2.randomUUID();
 function shouldWaitForExtensionReconnect(readiness) {
   return readiness.started || readiness.waitForReconnect === true;
@@ -1408,7 +1410,7 @@ function managedRelayLaunch(entrypoint = loadedCliEntrypoint, executable = proce
 }
 function managedRelayEntrypoint(entrypoint) {
   const name = path.basename(entrypoint);
-  if (name === "mcp-main.ts" || name === "index.ts" || name === "opencode-browser-client.ts" || name === "cli.ts")
+  if (name === "index.ts" || name === "opencode-browser-client.ts" || name === "cli.ts")
     return path.join(path.dirname(entrypoint), "main.ts");
   return entrypoint;
 }