@ycodium-ai/plugin-browser-workbench 0.2.2098

package/dist/index.js

@@ -0,0 +1,1327 @@
+// src/index.ts
+import { definePlugin } from "@ycodium-ai/plugin-api";
+
+// src/catalog.ts
+var catalog = {
+  settings: {
+    card: {
+      title: "External workbench",
+      description: "Point this machine at a code-server you already run. Ycodium only forwards the port; it does not start or stop that process."
+    },
+    attachPort: {
+      label: "code-server port",
+      description: "Loopback port of a code-server already listening on this machine. Leave empty to use the official VS Code CLI instead."
+    }
+  },
+  failure: {
+    "license-required": "Confirm the VS Code Server license terms to continue.",
+    "download-failed": "The VS Code CLI could not be downloaded.",
+    "disk-full": "This machine does not have enough disk space to install the VS Code CLI.",
+    "launch-failed": "The VS Code CLI started but did not publish a local address in time.",
+    "port-in-use": "The local port for the workbench is already in use.",
+    "server-download-failed": "The VS Code server did not become ready in time.",
+    "grant-expired": "The desktop connection grant expired.",
+    "host-key-mismatch": "This machine's key does not match the pinned host key.",
+    "channel-failed": "The desktop could not open a channel to the workbench.",
+    unknown: "The workbench could not be opened."
+  },
+  attach: {
+    noListener: "Nothing is listening on 127.0.0.1:{{port}}."
+  },
+  running: {
+    stopFirst: "Stop the workbench before updating the CLI."
+  }
+};
+var failureMessage = (kind) => catalog.failure[kind];
+var attachNoListenerMessage = (port) => catalog.attach.noListener.replace("{{port}}", String(port));
+
+// src/progress.ts
+var PROGRESS_BUFFER_LIMIT = 64;
+var computeTransfer = (input) => {
+  const elapsedSec = (input.nowMs - input.startedAtMs) / 1e3;
+  return {
+    transferredBytes: input.transferredBytes,
+    totalBytes: input.totalBytes,
+    bytesPerSecond: elapsedSec > 0 ? input.transferredBytes / elapsedSec : null
+  };
+};
+var progressEvent = (input) => ({
+  stage: input.stage,
+  status: input.status,
+  at: input.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+  ...input.detail === void 0 ? {} : { detail: input.detail },
+  ...input.skipReason === void 0 ? {} : { skipReason: input.skipReason },
+  ...input.transfer === void 0 ? {} : { transfer: input.transfer },
+  ...input.failureKind === void 0 ? {} : { failureKind: input.failureKind }
+});
+var ProgressBus = class {
+  listeners = /* @__PURE__ */ new Set();
+  latest = [];
+  emit(event) {
+    this.latest = [...this.latest, event].slice(-PROGRESS_BUFFER_LIMIT);
+    for (const listener of this.listeners) listener(event);
+  }
+  subscribe(listener) {
+    for (const event of this.latest) listener(event);
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+};
+
+// src/runtime.ts
+import * as NodeFSP3 from "node:fs/promises";
+
+// src/attach.ts
+import * as NodeNet from "node:net";
+var ATTACH_PROBE_TIMEOUT_MS = 1e3;
+var probeLoopback = (port, timeoutMs = ATTACH_PROBE_TIMEOUT_MS) => new Promise((resolve) => {
+  const socket = NodeNet.connect({ host: "127.0.0.1", port });
+  const finish = (ok) => {
+    socket.removeAllListeners();
+    socket.destroy();
+    resolve(ok);
+  };
+  const timer = setTimeout(() => finish(false), timeoutMs);
+  socket.once("connect", () => {
+    clearTimeout(timer);
+    finish(true);
+  });
+  socket.once("error", () => {
+    clearTimeout(timer);
+    finish(false);
+  });
+});
+
+// src/cli.ts
+import * as NodeFS from "node:fs";
+import * as NodeFSP2 from "node:fs/promises";
+import * as NodeProcess2 from "node:process";
+import * as NodeStream from "node:stream";
+import * as NodeStreamPromises from "node:stream/promises";
+
+// src/archive.ts
+import * as NodeZlib from "node:zlib";
+
+// src/types.ts
+var WORKBENCH_PROGRESS_STAGES = [
+  "license",
+  "check-cli",
+  "download-cli",
+  "start-server",
+  "download-server",
+  "register-port"
+];
+var WORKBENCH_PROGRESS_STATUSES = [
+  "started",
+  "progress",
+  "output",
+  "succeeded",
+  "skipped",
+  "failed"
+];
+var WORKBENCH_FAILURE_KINDS = [
+  "license-required",
+  "download-failed",
+  "disk-full",
+  "launch-failed",
+  "port-in-use",
+  "server-download-failed",
+  "grant-expired",
+  "host-key-mismatch",
+  "channel-failed",
+  "unknown"
+];
+var WorkbenchFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "WorkbenchFailure";
+    this.code = code;
+  }
+};
+
+// src/archive.ts
+var TAR_BLOCK = 512;
+var ZIP_LOCAL = 67324752;
+var ZIP_CENTRAL = 33639248;
+var ZIP_EOCD = 101010256;
+var isCliBinaryName = (name) => {
+  const base = name.split("/").pop() ?? name;
+  return base === "code" || base === "code.exe";
+};
+var gunzip2 = (input) => new Promise((resolve, reject) => {
+  NodeZlib.gunzip(input, (error, result) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve(result);
+  });
+});
+var readOctal = (bytes, start, length) => {
+  const raw = bytes.subarray(start, start + length).toString("utf8").replaceAll("\0", "").trim();
+  if (raw.length === 0) return 0;
+  const parsed = Number.parseInt(raw, 8);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var tarChecksumOk = (header) => {
+  const stored = readOctal(header, 148, 8);
+  let sum = 0;
+  for (let i = 0; i < TAR_BLOCK; i += 1) {
+    sum += i >= 148 && i < 156 ? 32 : header[i] ?? 0;
+  }
+  return sum === stored;
+};
+var extractTar = (archive) => {
+  const buf = Buffer.from(archive);
+  const files = [];
+  let offset = 0;
+  while (offset + TAR_BLOCK <= buf.length) {
+    const header = buf.subarray(offset, offset + TAR_BLOCK);
+    if (header.every((byte) => byte === 0)) break;
+    if (!tarChecksumOk(header)) {
+      throw new WorkbenchFailure("download-failed", "The CLI archive is not a valid tar.");
+    }
+    const name = header.subarray(0, 100).toString("utf8").replaceAll("\0", "").trim();
+    const prefix = header.subarray(345, 345 + 155).toString("utf8").replaceAll("\0", "").trim();
+    const fullName = prefix.length > 0 ? `${prefix}/${name}` : name;
+    const size = readOctal(header, 124, 12);
+    const type = header[156] === 0 ? 48 : header[156];
+    offset += TAR_BLOCK;
+    const content = buf.subarray(offset, offset + size);
+    offset += Math.ceil(size / TAR_BLOCK) * TAR_BLOCK;
+    if ((type === 48 || type === 0) && fullName.length > 0 && size > 0) {
+      files.push({ name: fullName, content: new Uint8Array(content) });
+    }
+  }
+  return files;
+};
+var readU32 = (buf, offset) => buf.readUInt32LE(offset);
+var readU16 = (buf, offset) => buf.readUInt16LE(offset);
+var inflateRaw2 = (input) => new Promise((resolve, reject) => {
+  NodeZlib.inflateRaw(input, (error, result) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve(result);
+  });
+});
+var extractZip = async (archive) => {
+  const buf = Buffer.from(archive);
+  const files = [];
+  let offset = 0;
+  while (offset + 30 <= buf.length) {
+    const sig = readU32(buf, offset);
+    if (sig === ZIP_CENTRAL || sig === ZIP_EOCD) break;
+    if (sig !== ZIP_LOCAL) {
+      throw new WorkbenchFailure("download-failed", "The CLI archive is not a valid zip.");
+    }
+    const flags = readU16(buf, offset + 6);
+    const method = readU16(buf, offset + 8);
+    const compressedSize = readU32(buf, offset + 18);
+    const nameLength = readU16(buf, offset + 26);
+    const extraLength = readU16(buf, offset + 28);
+    const nameStart = offset + 30;
+    const name = buf.subarray(nameStart, nameStart + nameLength).toString("utf8");
+    if ((flags & 1) !== 0) {
+      throw new WorkbenchFailure("download-failed", "The CLI zip is encrypted.");
+    }
+    if ((flags & 8) !== 0) {
+      throw new WorkbenchFailure("download-failed", "The CLI zip uses a data descriptor.");
+    }
+    const dataStart = nameStart + nameLength + extraLength;
+    const compressed = buf.subarray(dataStart, dataStart + compressedSize);
+    offset = dataStart + compressedSize;
+    if (name.endsWith("/")) continue;
+    let content;
+    if (method === 0) content = new Uint8Array(compressed);
+    else if (method === 8) content = await inflateRaw2(compressed);
+    else {
+      throw new WorkbenchFailure(
+        "download-failed",
+        `The CLI zip uses compression ${String(method)}.`
+      );
+    }
+    files.push({ name, content });
+  }
+  return files;
+};
+var pickCliBinary = (files) => {
+  const named = files.find((file) => isCliBinaryName(file.name));
+  if (named !== void 0) return named.content;
+  if (files.length === 1 && files[0] !== void 0) return files[0].content;
+  throw new WorkbenchFailure("download-failed", "The CLI archive did not contain a code binary.");
+};
+var extractCliBinary = async (archive, kind) => {
+  if (kind === "tar.gz") {
+    const tar = await gunzip2(archive);
+    return pickCliBinary(extractTar(tar));
+  }
+  return pickCliBinary(await extractZip(archive));
+};
+
+// src/platform.ts
+import * as NodeProcess from "node:process";
+var CLI_DOWNLOAD_BASE_URL = "https://update.code.visualstudio.com/latest";
+var CLI_PROGRAM_SELECTOR = "data:bin/code";
+var CLI_RELATIVE_PATH = "bin/code";
+var detectCliPlatform = (platform3 = NodeProcess.platform, arch3 = NodeProcess.arch) => {
+  if (platform3 === "linux" && arch3 === "x64") return "linux-x64";
+  if (platform3 === "linux" && arch3 === "arm64") return "linux-arm64";
+  if (platform3 === "darwin" && arch3 === "x64") return "darwin-x64";
+  if (platform3 === "darwin" && arch3 === "arm64") return "darwin-arm64";
+  if (platform3 === "win32" && arch3 === "x64") return "win32-x64";
+  return null;
+};
+var cliDownloadUrl = (cliPlatform) => `${CLI_DOWNLOAD_BASE_URL}/cli-${cliPlatform}/stable`;
+var cliArchiveKind = (cliPlatform) => cliPlatform.startsWith("win32") ? "zip" : "tar.gz";
+
+// src/paths.ts
+import * as NodeCrypto from "node:crypto";
+import * as NodeFSP from "node:fs/promises";
+import * as NodePath from "node:path";
+var workbenchPaths = (dataDir) => ({
+  dataDir,
+  binDir: NodePath.join(dataDir, "bin"),
+  cliPath: NodePath.join(dataDir, CLI_RELATIVE_PATH),
+  cliDataDir: NodePath.join(dataDir, "cli-data"),
+  serverDataDir: NodePath.join(dataDir, "server-data"),
+  tokenPath: NodePath.join(dataDir, "serve-web-token"),
+  instancePath: NodePath.join(dataDir, "instance.json"),
+  licensePath: NodePath.join(dataDir, "license-accepted.json"),
+  configPath: NodePath.join(dataDir, "config.json")
+});
+var writeAtomic = async (filePath, contents, mode) => {
+  await NodeFSP.mkdir(NodePath.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${NodeCrypto.randomBytes(8).toString("hex")}.tmp`;
+  const payload = typeof contents === "string" ? contents : Buffer.from(contents);
+  try {
+    await NodeFSP.writeFile(tmp, payload, mode === void 0 ? {} : { mode });
+    await NodeFSP.rename(tmp, filePath);
+    if (mode !== void 0) await NodeFSP.chmod(filePath, mode);
+  } catch (error) {
+    await NodeFSP.unlink(tmp).catch(() => void 0);
+    throw error;
+  }
+};
+var fileExists = async (filePath) => {
+  try {
+    await NodeFSP.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var readJsonFile = async (filePath) => {
+  try {
+    const text = await NodeFSP.readFile(filePath, "utf8");
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+};
+var writeJsonFile = async (filePath, value, mode) => {
+  await writeAtomic(filePath, `${JSON.stringify(value)}
+`, mode);
+};
+var removeFile = async (filePath) => {
+  await NodeFSP.unlink(filePath).catch(() => void 0);
+};
+var readInstance = (paths) => readJsonFile(paths.instancePath);
+var writeInstance = (paths, record) => writeJsonFile(paths.instancePath, record);
+var readConfigFile = (paths) => readJsonFile(paths.configPath);
+var writeConfigFile = (paths, value) => writeJsonFile(paths.configPath, value);
+var writeLicenseAccepted = async (paths) => {
+  await writeJsonFile(paths.licensePath, { acceptedAt: (/* @__PURE__ */ new Date()).toISOString() });
+};
+var TOKEN_BYTES = 32;
+var readServeWebToken = async (paths) => {
+  try {
+    const text = (await NodeFSP.readFile(paths.tokenPath, "utf8")).trim();
+    return text.length > 0 ? text : null;
+  } catch {
+    return null;
+  }
+};
+var ensureServeWebToken = async (paths) => {
+  const existing = await readServeWebToken(paths);
+  if (existing !== null) return existing;
+  const token = NodeCrypto.randomBytes(TOKEN_BYTES).toString("base64url");
+  await writeAtomic(paths.tokenPath, `${token}
+`, 384);
+  return token;
+};
+var ensureDataDirs = async (paths) => {
+  await NodeFSP.mkdir(paths.binDir, { recursive: true });
+  await NodeFSP.mkdir(paths.cliDataDir, { recursive: true });
+  await NodeFSP.mkdir(paths.serverDataDir, { recursive: true });
+};
+var directorySize = async (dir) => {
+  let total = 0;
+  const walk = async (current) => {
+    let entries;
+    try {
+      entries = await NodeFSP.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const child = NodePath.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(child);
+        continue;
+      }
+      try {
+        total += (await NodeFSP.stat(child)).size;
+      } catch {
+      }
+    }
+  };
+  await walk(dir);
+  return total;
+};
+
+// src/util.ts
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+var isDiskFull = (error) => {
+  if (typeof error !== "object" || error === null || !("code" in error)) return false;
+  return error.code === "ENOSPC";
+};
+var parsePort = (value) => {
+  const asNumber = (input) => Number.isInteger(input) && input >= 1 && input <= 65535 ? input : null;
+  if (typeof value === "number") return asNumber(value);
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? asNumber(parsed) : null;
+  }
+  return null;
+};
+var redactWorkbenchSecrets = (line) => line.replaceAll(/([?&]tkn=)[^&\s]+/gi, "$1<redacted>");
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(signal.reason instanceof Error ? signal.reason : new Error("aborted"));
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason instanceof Error ? signal.reason : new Error("aborted"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+
+// src/cli.ts
+var CLI_DOWNLOAD_SUFFIX = ".download";
+var CLI_NEW_SUFFIX = ".new";
+var parseCliVersion = (stdout) => {
+  const match = /(?:^|\n)code\s+(\S+)/.exec(stdout);
+  const version = match?.[1];
+  return version === void 0 || version.length === 0 ? null : version;
+};
+var cliIsInstalled = (paths) => fileExists(paths.cliPath);
+var readInstalledCliVersion = async (processApi) => {
+  const result = await processApi.run({
+    program: CLI_PROGRAM_SELECTOR,
+    args: ["--version"],
+    timeoutMs: 15e3
+  });
+  if (result.exitCode !== 0) {
+    throw new WorkbenchFailure("unknown", "The VS Code CLI did not report a version.");
+  }
+  return parseCliVersion(result.stdout) ?? parseCliVersion(result.stderr) ?? "unknown";
+};
+var contentLengthOf = (response) => {
+  const raw = response.headers.get("content-length");
+  if (raw === null || raw.trim() === "") return null;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+};
+var streamResponseToFile = async (input) => {
+  if (input.response.body === null) {
+    throw new WorkbenchFailure("download-failed", "The CLI download had no body.");
+  }
+  const totalBytes = contentLengthOf(input.response);
+  const startedAtMs = Date.now();
+  let transferredBytes = 0;
+  const readable = NodeStream.Readable.fromWeb(
+    input.response.body
+  );
+  readable.on("data", (chunk) => {
+    transferredBytes += chunk.length;
+    input.onTransfer(
+      computeTransfer({
+        transferredBytes,
+        totalBytes,
+        startedAtMs,
+        nowMs: Date.now()
+      })
+    );
+  });
+  try {
+    await NodeStreamPromises.pipeline(readable, NodeFS.createWriteStream(input.filePath));
+  } catch (error) {
+    await NodeFSP2.unlink(input.filePath).catch(() => void 0);
+    if (isDiskFull(error)) {
+      throw new WorkbenchFailure("disk-full", messageOf(error));
+    }
+    throw error;
+  }
+};
+var downloadCliBinary = async (input) => {
+  const platform3 = input.platform === void 0 ? detectCliPlatform() : input.platform;
+  if (platform3 === null) {
+    throw new WorkbenchFailure(
+      "download-failed",
+      `This machine's platform (${NodeProcess2.platform}/${NodeProcess2.arch}) has no VS Code CLI build.`
+    );
+  }
+  const url = input.url ?? cliDownloadUrl(platform3);
+  let response;
+  try {
+    response = await input.http(url, input.signal === void 0 ? {} : { signal: input.signal });
+  } catch (error) {
+    if (isDiskFull(error)) throw new WorkbenchFailure("disk-full", messageOf(error));
+    throw new WorkbenchFailure("download-failed", messageOf(error));
+  }
+  if (!response.ok) {
+    throw new WorkbenchFailure(
+      "download-failed",
+      `The CLI download returned HTTP ${String(response.status)}.`
+    );
+  }
+  await NodeFSP2.mkdir(input.paths.binDir, { recursive: true });
+  const archivePath = `${input.destPath}${CLI_DOWNLOAD_SUFFIX}`;
+  try {
+    await streamResponseToFile({
+      response,
+      filePath: archivePath,
+      onTransfer: input.onTransfer
+    });
+    const archive = await NodeFSP2.readFile(archivePath);
+    const binary = await extractCliBinary(archive, cliArchiveKind(platform3));
+    await writeAtomic(input.destPath, binary, 493);
+  } catch (error) {
+    if (error instanceof WorkbenchFailure) throw error;
+    if (isDiskFull(error)) throw new WorkbenchFailure("disk-full", messageOf(error));
+    throw new WorkbenchFailure("download-failed", messageOf(error));
+  } finally {
+    await NodeFSP2.unlink(archivePath).catch(() => void 0);
+  }
+};
+
+// src/serveWeb.ts
+var START_SERVER_TIMEOUT_MS = 3e4;
+var DOWNLOAD_SERVER_TIMEOUT_MS = 10 * 6e4;
+var DOWNLOAD_SERVER_POLL_MS = 1e3;
+var WEB_UI_AVAILABLE_PATTERN = /Web UI available at http:\/\/127\.0\.0\.1:(\d+)/;
+var SERVER_DOWNLOADING_PATTERN = /Downloading server\b/;
+var SERVER_STARTING_PATTERN = /Starting server\b/;
+var parseWebUiPort = (line) => {
+  const match = WEB_UI_AVAILABLE_PATTERN.exec(line);
+  if (match === null) return null;
+  const port = Number(match[1]);
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : null;
+};
+var isServerLogLine = (line) => SERVER_DOWNLOADING_PATTERN.test(line) || SERVER_STARTING_PATTERN.test(line);
+var serveWebArgs = (paths) => [
+  "serve-web",
+  "--host",
+  "127.0.0.1",
+  "--port",
+  "0",
+  "--connection-token-file",
+  paths.tokenPath,
+  "--accept-server-license-terms",
+  "--server-data-dir",
+  paths.serverDataDir,
+  "--cli-data-dir",
+  paths.cliDataDir,
+  "--disable-telemetry"
+];
+var splitLines = (text) => {
+  const parts = text.split(/\r?\n/);
+  const rest = parts.pop() ?? "";
+  return { complete: parts, rest };
+};
+var consumeProcessLines = (stream, onLine) => {
+  const decoder = new TextDecoder();
+  let pending = "";
+  const run = async () => {
+    for await (const chunk of stream) {
+      pending += decoder.decode(chunk, { stream: true });
+      const split = splitLines(pending);
+      pending = split.rest;
+      for (const line of split.complete) onLine(redactWorkbenchSecrets(line));
+    }
+    pending += decoder.decode();
+    if (pending.length > 0) onLine(redactWorkbenchSecrets(pending));
+  };
+  return run();
+};
+var waitForServeWebPort = (input) => {
+  const timeoutMs = input.timeoutMs ?? START_SERVER_TIMEOUT_MS;
+  const stderrChunks = [];
+  let settled = false;
+  let resolvePort = () => void 0;
+  let rejectPort = () => void 0;
+  const portPromise = new Promise((resolve, reject) => {
+    resolvePort = resolve;
+    rejectPort = reject;
+  });
+  const finishError = (error) => {
+    if (settled) return;
+    settled = true;
+    rejectPort(error);
+  };
+  const finishPort = (port) => {
+    if (settled) return;
+    settled = true;
+    resolvePort(port);
+  };
+  const timer = setTimeout(() => {
+    finishError(
+      new WorkbenchFailure(
+        "launch-failed",
+        "The VS Code CLI started but did not publish a local address in time."
+      )
+    );
+  }, timeoutMs);
+  void consumeProcessLines(input.handle.stdout, (line) => {
+    input.onStdoutLine(line);
+    const port = parseWebUiPort(line);
+    if (port !== null) finishPort(port);
+  }).catch((error) => {
+    finishError(error instanceof Error ? error : new Error(String(error)));
+  });
+  void consumeProcessLines(input.handle.stderr, (line) => {
+    stderrChunks.push(line);
+    input.onStderrLine(line);
+  }).catch(() => void 0);
+  void input.handle.exited.then((code) => {
+    if (settled) return;
+    const tail = stderrChunks.slice(-20).join("\n");
+    finishError(
+      new WorkbenchFailure(
+        "launch-failed",
+        tail.length > 0 ? `The VS Code CLI exited before it published a local address.
+${tail}` : `The VS Code CLI exited before it published a local address (code ${String(code)}).`
+      )
+    );
+  });
+  return portPromise.then(
+    (port) => {
+      clearTimeout(timer);
+      return { port, stderr: stderrChunks.join("\n") };
+    },
+    (error) => {
+      clearTimeout(timer);
+      throw error;
+    }
+  );
+};
+var serverReadyStatus = (status) => {
+  if (status === 202) return "downloading";
+  if (status === 200 || status === 301 || status === 302 || status === 307 || status === 308) {
+    return "ready";
+  }
+  if (status === 403) return "forbidden";
+  return "other";
+};
+var waitForServerDownload = async (input) => {
+  const timeoutMs = input.timeoutMs ?? DOWNLOAD_SERVER_TIMEOUT_MS;
+  const pollMs = input.pollMs ?? DOWNLOAD_SERVER_POLL_MS;
+  const startedAtMs = Date.now();
+  const deadline = startedAtMs + timeoutMs;
+  const url = `http://127.0.0.1:${String(input.port)}/?tkn=${input.token}`;
+  const serveWebDir = `${input.cliDataDir}/serve-web`;
+  while (Date.now() < deadline) {
+    if (input.signal?.aborted) {
+      throw new WorkbenchFailure("server-download-failed", "The server download was cancelled.");
+    }
+    try {
+      const response = await input.http(
+        url,
+        input.signal === void 0 ? { redirect: "manual" } : { redirect: "manual", signal: input.signal }
+      );
+      const kind = serverReadyStatus(response.status);
+      if (kind === "ready") return;
+      if (kind === "forbidden") {
+        throw new WorkbenchFailure(
+          "server-download-failed",
+          "The VS Code server rejected the connection token."
+        );
+      }
+    } catch (error) {
+      if (error instanceof WorkbenchFailure) throw error;
+    }
+    const transferredBytes = await directorySize(serveWebDir);
+    input.onTransfer(
+      computeTransfer({
+        transferredBytes,
+        totalBytes: null,
+        startedAtMs,
+        nowMs: Date.now()
+      })
+    );
+    await sleep(pollMs, input.signal);
+  }
+  throw new WorkbenchFailure(
+    "server-download-failed",
+    "The VS Code server did not become ready in time."
+  );
+};
+
+// src/instance.ts
+var instanceIsLive = async (record) => isProcessAlive(record.pid) && await probeLoopback(record.port);
+var reapOrphanInstance = async (paths) => {
+  const record = await readInstance(paths);
+  if (record === null) return;
+  if (isProcessAlive(record.pid)) {
+    try {
+      process.kill(record.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  await removeFile(paths.instancePath);
+};
+var startServeWeb = async (input) => {
+  await ensureDataDirs(input.paths);
+  await ensureServeWebToken(input.paths);
+  const handle = await input.processApi.spawn({
+    program: CLI_PROGRAM_SELECTOR,
+    args: [...serveWebArgs(input.paths)]
+  });
+  try {
+    await handle.closeStdin();
+  } catch {
+  }
+  const waitForPort = input.waitForPort ?? waitForServeWebPort;
+  try {
+    const { port } = await waitForPort({
+      handle,
+      onStdoutLine: input.onStdoutLine,
+      onStderrLine: input.onStderrLine
+    });
+    const record = {
+      pid: handle.pid,
+      port,
+      cliVersion: input.cliVersion,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeInstance(input.paths, record);
+    return { handle, record };
+  } catch (error) {
+    await handle.kill("SIGTERM").catch(() => void 0);
+    throw error;
+  }
+};
+var STOP_GRACE_MS = 5e3;
+var stopManagedProcess = async (managed, paths) => {
+  if (managed !== null) {
+    await managed.handle.kill("SIGTERM").catch(() => void 0);
+    const timedOut = await Promise.race([
+      managed.handle.exited.then(() => false).catch(() => false),
+      sleep(STOP_GRACE_MS).then(() => true)
+    ]);
+    if (timedOut) {
+      await managed.handle.kill("SIGKILL").catch(() => void 0);
+      await managed.handle.exited.catch(() => void 0);
+    }
+  }
+  await removeFile(paths.instancePath);
+};
+
+// src/runtime.ts
+var MANAGED_LABEL = "VS Code";
+var EXTERNAL_LABEL = "code-server";
+var WorkbenchRuntime = class {
+  bus = new ProgressBus();
+  ctx;
+  paths;
+  chain = Promise.resolve();
+  managed = null;
+  managedPort = null;
+  externalPort = null;
+  externalListenPort = null;
+  outputStage = "start-server";
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.paths = workbenchPaths(ctx.paths.dataDir);
+  }
+  /** 激活时收孤儿、按设置接外接端口。不能让 activate 失败。 */
+  async start() {
+    await reapOrphanInstance(this.paths);
+    const desired = await this.desiredExternalPort();
+    if (desired === null) return;
+    try {
+      await this.attachPort(desired);
+    } catch (error) {
+      this.ctx.log.warn("external workbench is not listening", {
+        port: desired,
+        detail: messageOf(error)
+      });
+    }
+  }
+  async dispose() {
+    await this.enqueue(async () => {
+      await this.stopManaged();
+      await this.clearExternal();
+    });
+  }
+  status() {
+    return this.enqueue(() => this.readStatus());
+  }
+  open(payload) {
+    return this.enqueue(() => this.runOpen(payload));
+  }
+  stop() {
+    return this.enqueue(async () => {
+      await this.stopManaged();
+      return {};
+    });
+  }
+  update() {
+    return this.enqueue(() => this.runUpdate());
+  }
+  attach(port) {
+    return this.enqueue(async () => {
+      const registration = await this.attachPort(port);
+      await writeConfigFile(this.paths, { attachPort: port });
+      return { portId: registration.portId };
+    });
+  }
+  detach() {
+    return this.enqueue(async () => {
+      await this.clearExternal();
+      await writeConfigFile(this.paths, {});
+      return {};
+    });
+  }
+  enqueue(fn) {
+    const run = this.chain.then(fn, fn);
+    this.chain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  emit(event) {
+    this.bus.emit(event);
+  }
+  stage(stage, status, extra = {}) {
+    this.emit(progressEvent({ stage, status, ...extra }));
+  }
+  fail(stage, kind, detail) {
+    this.stage(stage, "failed", {
+      failureKind: kind,
+      ...detail === void 0 ? {} : { detail }
+    });
+    throw new WorkbenchFailure(kind, failureMessage(kind));
+  }
+  async desiredExternalPort() {
+    const fromSettings = parsePort(this.ctx.config.attachPort);
+    if (fromSettings !== null) return fromSettings;
+    const file = await readConfigFile(this.paths);
+    return parsePort(file?.attachPort);
+  }
+  async readStatus() {
+    const installed = await cliIsInstalled(this.paths);
+    const live = await this.managedIsLive();
+    const external = this.externalPort !== null && this.externalListenPort !== null ? { port: this.externalListenPort, portId: this.externalPort.portId } : void 0;
+    if (live && this.managed !== null) {
+      return {
+        mode: "managed",
+        installed,
+        running: true,
+        port: this.managed.record.port,
+        cliVersion: this.managed.record.cliVersion,
+        ...this.managedPort === null ? {} : { portId: this.managedPort.portId },
+        ...external === void 0 ? {} : { external }
+      };
+    }
+    if (external !== void 0) {
+      return {
+        mode: "external",
+        installed,
+        running: await probeLoopback(external.port),
+        external
+      };
+    }
+    let cliVersion;
+    if (installed) {
+      try {
+        cliVersion = await readInstalledCliVersion(this.ctx.process);
+      } catch {
+        cliVersion = void 0;
+      }
+    }
+    return {
+      mode: "none",
+      installed,
+      running: false,
+      ...cliVersion === void 0 ? {} : { cliVersion }
+    };
+  }
+  async managedIsLive() {
+    if (this.managed !== null) {
+      if (await instanceIsLive(this.managed.record)) return true;
+      this.managed = null;
+      return false;
+    }
+    const record = await readInstance(this.paths);
+    if (record === null) return false;
+    return instanceIsLive(record);
+  }
+  async runOpen(payload) {
+    const desiredExternal = await this.desiredExternalPort();
+    if (desiredExternal !== null && !await this.managedIsLive()) {
+      if (this.externalPort === null) await this.attachPort(desiredExternal);
+      this.stage("register-port", "skipped", { skipReason: "external" });
+      const portId2 = this.externalPort?.portId;
+      if (portId2 === void 0) this.fail("register-port", "unknown");
+      return { portId: portId2 };
+    }
+    await this.stepLicense(payload.acceptLicense === true);
+    const cliVersion = await this.stepCheckAndDownloadCli();
+    await this.stepStartServer(cliVersion);
+    const token = await ensureServeWebToken(this.paths);
+    await this.stepDownloadServer(token);
+    const portId = await this.stepRegisterManaged();
+    return { portId, token };
+  }
+  async stepLicense(acceptLicense) {
+    this.stage("license", "started");
+    if (await fileExists(this.paths.licensePath)) {
+      this.stage("license", "skipped", { skipReason: "already-accepted" });
+      return;
+    }
+    if (!acceptLicense) this.fail("license", "license-required");
+    await writeLicenseAccepted(this.paths);
+    this.stage("license", "succeeded");
+  }
+  async stepCheckAndDownloadCli() {
+    this.stage("check-cli", "started");
+    if (await fileExists(this.paths.cliPath)) {
+      try {
+        const version = await readInstalledCliVersion(this.ctx.process);
+        this.stage("check-cli", "succeeded", { detail: version });
+        this.stage("download-cli", "skipped", { skipReason: "already-installed" });
+        return version;
+      } catch (error) {
+        this.fail("check-cli", "unknown", messageOf(error));
+      }
+    }
+    this.stage("check-cli", "succeeded");
+    return this.stepDownloadCli(this.paths.cliPath);
+  }
+  async stepDownloadCli(destPath) {
+    this.stage("download-cli", "started");
+    try {
+      await downloadCliBinary({
+        http: this.ctx.http,
+        paths: this.paths,
+        destPath,
+        onTransfer: (transfer) => this.stage("download-cli", "progress", { transfer })
+      });
+    } catch (error) {
+      this.rethrowAs(error, "download-cli");
+    }
+    try {
+      const version = await readInstalledCliVersion(this.ctx.process);
+      this.stage("download-cli", "succeeded", { detail: version });
+      return version;
+    } catch (error) {
+      this.fail("download-cli", "unknown", messageOf(error));
+    }
+  }
+  async stepStartServer(cliVersion) {
+    this.stage("start-server", "started");
+    this.outputStage = "start-server";
+    if (this.managed !== null && await instanceIsLive(this.managed.record)) {
+      this.stage("start-server", "skipped", { skipReason: "already-running" });
+      return;
+    }
+    const record = await readInstance(this.paths);
+    if (record !== null && await instanceIsLive(record)) {
+      this.managed = { handle: orphanHandle(record.pid), record };
+      this.stage("start-server", "skipped", { skipReason: "already-running" });
+      return;
+    }
+    try {
+      this.managed = await startServeWeb({
+        processApi: this.ctx.process,
+        paths: this.paths,
+        cliVersion,
+        onStdoutLine: (line) => this.onProcessLine(line),
+        onStderrLine: (line) => this.onProcessLine(line)
+      });
+    } catch (error) {
+      this.rethrowAs(error, "start-server", "launch-failed");
+    }
+    const started = this.managed;
+    if (started === null) this.fail("start-server", "launch-failed");
+    this.stage("start-server", "succeeded", {
+      detail: `127.0.0.1:${String(started.record.port)}`
+    });
+  }
+  onProcessLine(line) {
+    if (line.trim().length === 0) return;
+    const stage = isServerLogLine(line) ? "download-server" : this.outputStage;
+    this.stage(stage, "output", { detail: line });
+  }
+  async stepDownloadServer(token) {
+    this.stage("download-server", "started");
+    this.outputStage = "download-server";
+    const managed = this.managed;
+    if (managed === null) this.fail("download-server", "launch-failed");
+    try {
+      await waitForServerDownload({
+        http: this.ctx.http,
+        port: managed.record.port,
+        token,
+        cliDataDir: this.paths.cliDataDir,
+        onTransfer: (transfer) => this.stage("download-server", "progress", { transfer })
+      });
+    } catch (error) {
+      this.rethrowAs(error, "download-server", "server-download-failed");
+    }
+    this.stage("download-server", "succeeded");
+  }
+  async stepRegisterManaged() {
+    this.stage("register-port", "started");
+    const managed = this.managed;
+    if (managed === null) this.fail("register-port", "launch-failed");
+    if (this.managedPort !== null) {
+      this.stage("register-port", "skipped", { skipReason: "already-registered" });
+      return this.managedPort.portId;
+    }
+    try {
+      this.managedPort = await this.ctx.ports.register({
+        kind: "workbench",
+        label: MANAGED_LABEL,
+        port: managed.record.port
+      });
+    } catch (error) {
+      const reason = capabilityReason(error);
+      if (reason === "no-listener") this.fail("register-port", "launch-failed", messageOf(error));
+      this.fail("register-port", "unknown", messageOf(error));
+    }
+    this.stage("register-port", "succeeded");
+    return this.managedPort.portId;
+  }
+  async runUpdate() {
+    if (await this.managedIsLive()) {
+      throw new WorkbenchFailure("unknown", catalog.running.stopFirst);
+    }
+    this.stage("download-cli", "started");
+    const destPath = `${this.paths.cliPath}${CLI_NEW_SUFFIX}`;
+    try {
+      await downloadCliBinary({
+        http: this.ctx.http,
+        paths: this.paths,
+        destPath,
+        onTransfer: (transfer) => this.stage("download-cli", "progress", { transfer })
+      });
+      await NodeFSP3.rename(destPath, this.paths.cliPath);
+    } catch (error) {
+      await NodeFSP3.unlink(destPath).catch(() => void 0);
+      this.rethrowAs(error, "download-cli");
+    }
+    this.stage("download-cli", "succeeded");
+    const version = await readInstalledCliVersion(this.ctx.process);
+    return { cliVersion: version };
+  }
+  async attachPort(port) {
+    if (!await probeLoopback(port)) {
+      throw new WorkbenchFailure("unknown", attachNoListenerMessage(port));
+    }
+    if (this.externalPort !== null && this.externalListenPort === port) return this.externalPort;
+    await this.clearExternal();
+    const registration = await this.ctx.ports.register({
+      kind: "workbench-external",
+      label: EXTERNAL_LABEL,
+      port
+    });
+    this.externalPort = registration;
+    this.externalListenPort = port;
+    return registration;
+  }
+  async clearExternal() {
+    if (this.externalPort !== null) {
+      await this.externalPort.unregister().catch(() => void 0);
+    }
+    this.externalPort = null;
+    this.externalListenPort = null;
+  }
+  async stopManaged() {
+    if (this.managedPort !== null) {
+      await this.managedPort.unregister().catch(() => void 0);
+      this.managedPort = null;
+    }
+    await stopManagedProcess(this.managed, this.paths);
+    this.managed = null;
+    const leftover = await readInstance(this.paths);
+    if (leftover !== null && isProcessAlive(leftover.pid)) {
+      try {
+        process.kill(leftover.pid, "SIGTERM");
+      } catch {
+      }
+    }
+    await removeFile(this.paths.instancePath);
+  }
+  rethrowAs(error, stage, fallback = "download-failed") {
+    if (error instanceof WorkbenchFailure) {
+      this.fail(stage, error.code, error.message);
+    }
+    this.fail(stage, fallback, messageOf(error));
+  }
+};
+var capabilityReason = (error) => {
+  if (typeof error !== "object" || error === null || !("reason" in error)) return null;
+  const reason = error.reason;
+  return typeof reason === "string" ? reason : null;
+};
+var orphanHandle = (pid) => ({
+  pid,
+  stdout: emptyBytes(),
+  stderr: emptyBytes(),
+  writeStdin: async () => void 0,
+  closeStdin: async () => void 0,
+  kill: async (signal) => {
+    if (isProcessAlive(pid)) process.kill(pid, signal ?? "SIGTERM");
+  },
+  exited: Promise.resolve(null)
+});
+async function* emptyBytes() {
+}
+
+// src/schemas.ts
+var emptyObject = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var emptyPayloadSchema = emptyObject;
+var openPayloadSchema = {
+  type: "object",
+  properties: {
+    acceptLicense: { type: "boolean" }
+  },
+  additionalProperties: false
+};
+var attachPayloadSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["port"],
+  properties: {
+    port: { type: "integer", minimum: 1, maximum: 65535 }
+  }
+};
+var portIdSchema = { type: "string", minLength: 1 };
+var openResultSchema = {
+  oneOf: [
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["portId", "token"],
+      properties: {
+        portId: portIdSchema,
+        token: { type: "string", minLength: 1 }
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["portId"],
+      properties: {
+        portId: portIdSchema
+      }
+    }
+  ]
+};
+var statusResultSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["mode", "installed", "running"],
+  properties: {
+    mode: { type: "string", enum: ["managed", "external", "none"] },
+    installed: { type: "boolean" },
+    running: { type: "boolean" },
+    port: { type: "integer", minimum: 1, maximum: 65535 },
+    cliVersion: { type: "string", minLength: 1 },
+    portId: portIdSchema,
+    external: {
+      type: "object",
+      additionalProperties: false,
+      required: ["port", "portId"],
+      properties: {
+        port: { type: "integer", minimum: 1, maximum: 65535 },
+        portId: portIdSchema
+      }
+    }
+  }
+};
+var updateResultSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["cliVersion"],
+  properties: {
+    cliVersion: { type: "string", minLength: 1 }
+  }
+};
+var attachResultSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["portId"],
+  properties: {
+    portId: portIdSchema
+  }
+};
+var emptyResultSchema = emptyObject;
+var progressItemSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["stage", "status", "at"],
+  properties: {
+    stage: { type: "string", enum: [...WORKBENCH_PROGRESS_STAGES] },
+    status: { type: "string", enum: [...WORKBENCH_PROGRESS_STATUSES] },
+    detail: { type: "string" },
+    skipReason: { type: "string" },
+    transfer: {
+      type: "object",
+      additionalProperties: false,
+      required: ["transferredBytes", "totalBytes", "bytesPerSecond"],
+      properties: {
+        transferredBytes: { type: "number" },
+        totalBytes: { type: ["number", "null"] },
+        bytesPerSecond: { type: ["number", "null"] }
+      }
+    },
+    failureKind: { type: "string", enum: [...WORKBENCH_FAILURE_KINDS] },
+    at: { type: "string" }
+  }
+};
+
+// src/index.ts
+var index_default = definePlugin({
+  id: "browser-workbench",
+  apiVersion: 2,
+  activate: (ctx) => {
+    const runtime = new WorkbenchRuntime(ctx);
+    void runtime.start().catch((error) => {
+      ctx.log.warn("browser-workbench failed to recover previous state", {
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    });
+    ctx.stream({
+      name: "progress",
+      description: "Install and start progress for the browser VS Code workbench.",
+      scope: "read",
+      payloadSchema: emptyPayloadSchema,
+      itemSchema: progressItemSchema,
+      buffer: { latest: PROGRESS_BUFFER_LIMIT },
+      handle: async (_payload, emit, signal) => {
+        const unsubscribe = runtime.bus.subscribe((event) => {
+          if (!signal.aborted) emit(event);
+        });
+        try {
+          await new Promise((resolve) => {
+            if (signal.aborted) {
+              resolve();
+              return;
+            }
+            signal.addEventListener("abort", () => resolve(), { once: true });
+          });
+        } finally {
+          unsubscribe();
+        }
+      }
+    });
+    ctx.command({
+      name: "status",
+      description: "Whether the browser VS Code workbench is installed, running, or attached.",
+      scope: "read",
+      payloadSchema: emptyPayloadSchema,
+      resultSchema: statusResultSchema,
+      handle: () => runtime.status()
+    });
+    ctx.command({
+      name: "open",
+      description: "Install, start, and register the browser VS Code workbench.",
+      scope: "operate",
+      payloadSchema: openPayloadSchema,
+      resultSchema: openResultSchema,
+      handle: (payload) => runtime.open({
+        acceptLicense: payload["acceptLicense"] === true
+      })
+    });
+    ctx.command({
+      name: "stop",
+      description: "Stop the managed VS Code CLI and unregister its port.",
+      scope: "operate",
+      payloadSchema: emptyPayloadSchema,
+      resultSchema: emptyResultSchema,
+      handle: () => runtime.stop()
+    });
+    ctx.command({
+      name: "update",
+      description: "Replace the VS Code CLI. The workbench must be stopped first.",
+      scope: "operate",
+      payloadSchema: emptyPayloadSchema,
+      resultSchema: updateResultSchema,
+      handle: () => runtime.update()
+    });
+    ctx.command({
+      name: "attach",
+      description: "Register a code-server already listening on this machine.",
+      scope: "operate",
+      payloadSchema: attachPayloadSchema,
+      resultSchema: attachResultSchema,
+      handle: (payload) => {
+        const port = parsePort(payload["port"]);
+        if (port === null) {
+          throw new Error("attach requires a port between 1 and 65535.");
+        }
+        return runtime.attach(port);
+      }
+    });
+    ctx.command({
+      name: "detach",
+      description: "Unregister the attached code-server port.",
+      scope: "operate",
+      payloadSchema: emptyPayloadSchema,
+      resultSchema: emptyResultSchema,
+      handle: () => runtime.detach()
+    });
+    ctx.settingsCard({
+      title: catalog.settings.card.title,
+      description: catalog.settings.card.description,
+      fields: [
+        {
+          key: "attachPort",
+          kind: "number",
+          label: catalog.settings.attachPort.label,
+          description: catalog.settings.attachPort.description
+        }
+      ]
+    });
+    ctx.onDispose(() => runtime.dispose());
+  }
+});
+export {
+  index_default as default
+};