@devframes/plugin-code-server 0.7.5 → 0.7.7

package/dist/node/index.mjs

@@ -1,10 +1,114 @@
 import { DEFAULT_CODE_SERVER_PORT, PLUGIN_ID, STATE_KEY, TERMINAL_SESSION_ICON, TERMINAL_SESSION_TITLE, getCookieSessionName } from "../constants.mjs";
-import { i as diagnostics, n as getCodeServerSupervisor, r as setCodeServerSupervisor, t as serverFunctions } from "../rpc-DjerPudu.mjs";
+import { i as diagnostics, n as getCodeServerSupervisor, r as setCodeServerSupervisor, t as serverFunctions } from "../rpc-BdNzxqDi.mjs";
 import { execSync, spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { request } from "node:http";
+import { hostname } from "node:os";
 import process from "node:process";
 import { getPort } from "get-port-please";
+//#region src/node/backends.ts
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+/** Coder's open-source `code-server`, with password auth + session cookie handoff. */
+const codeServerProfile = {
+	kind: "code-server",
+	backend: "code-server",
+	defaultBin: "code-server",
+	buildArgs: (c) => [
+		"--auth",
+		"password",
+		"--bind-addr",
+		`${c.host}:${c.port}`,
+		"--disable-telemetry",
+		"--disable-update-check",
+		...c.extraArgs,
+		c.folder
+	],
+	buildEnv: (c, base) => {
+		const env = { ...base };
+		delete env.PASSWORD;
+		env.HASHED_PASSWORD = sha256(c.secret);
+		return env;
+	},
+	healthPath: "/healthz",
+	matchPort: (line) => {
+		const m = line.match(/HTTP server listening on https?:\/\/(?:[^:]+|\[[^\]]+\]):(\d+)/);
+		return m ? Number.parseInt(m[1], 10) : void 0;
+	},
+	connect: (c) => ({
+		path: "/",
+		cookie: {
+			name: c.cookieName,
+			value: sha256(c.secret)
+		}
+	}),
+	connectReused: () => ({ path: "/" })
+};
+/** Microsoft's `code serve-web`, with a connection token passed via `?tkn=`. */
+const serveWebProfile = {
+	kind: "serve-web",
+	backend: "ms-code-serve-web",
+	defaultBin: "code",
+	buildArgs: (c) => [
+		"serve-web",
+		"--accept-server-license-terms",
+		"--host",
+		c.host,
+		"--port",
+		String(c.port),
+		"--connection-token",
+		c.secret,
+		...c.extraArgs
+	],
+	buildEnv: (_c, base) => ({ ...base }),
+	healthPath: "/",
+	matchPort: (line) => {
+		const m = line.match(/available at https?:\/\/[^:]+:(\d+)/i);
+		return m ? Number.parseInt(m[1], 10) : void 0;
+	},
+	connect: (c) => ({ path: `/?tkn=${encodeURIComponent(c.secret)}&folder=${encodeURIComponent(c.folder)}` }),
+	connectReused: () => ({ path: "/" })
+};
+const TUNNEL_URL_RE = /(https:\/\/vscode\.dev\/tunnel\/\S+)/;
+const DEVICE_LOGIN_RE = /log in(?:to)? (https?:\/\/\S+) and use code ([A-Z0-9-]+)/i;
+/** Microsoft's `code tunnel`, embedding the hosted `vscode.dev` editor. */
+const tunnelProfile = {
+	kind: "tunnel",
+	backend: "ms-code-serve-web",
+	defaultBin: "code",
+	buildArgs: (c) => [
+		"tunnel",
+		"--accept-server-license-terms",
+		"--name",
+		c.tunnelName,
+		...c.extraArgs
+	],
+	buildEnv: (_c, base) => ({ ...base }),
+	healthPath: null,
+	matchReadyUrl: (line) => {
+		const m = line.match(TUNNEL_URL_RE);
+		return m ? m[1].replace(/[)\].,]+$/, "") : void 0;
+	},
+	matchLogin: (line) => {
+		const m = line.match(DEVICE_LOGIN_RE);
+		return m ? {
+			url: m[1],
+			code: m[2]
+		} : void 0;
+	},
+	connect: (c) => ({ url: c.readyUrl ?? `https://vscode.dev/tunnel/${c.tunnelName}${c.folder}` }),
+	connectReused: () => ({})
+};
+const LOCAL_PROFILES = {
+	"code-server": codeServerProfile,
+	"ms-code-serve-web": serveWebProfile
+};
+/** The ordered auto-detection candidates for `mode: 'local'` with no explicit backend. */
+const AUTO_DETECT_ORDER = ["code-server", "ms-code-serve-web"];
+/** Resolve the launch profile for a mode + backend. */
+function resolveProfile(mode, backend) {
+	return mode === "tunnel" ? tunnelProfile : LOCAL_PROFILES[backend];
+}
+//#endregion
 //#region src/node/detect.ts
 /**
 * Probe the host for a usable code-server binary by running
@@ -86,53 +190,77 @@ const LOG_BUFFER_LINES = 200;
 /** Interval between readiness probes. */
 const PROBE_INTERVAL = 250;
 /**
-* Owns the lifecycle of a single code-server child process: detects the
-* binary, launches it with a freshly generated password-auth token, probes
-* `/healthz` for readiness, and mirrors a secret-free status into shared
-* state. The auth cookie is handed back only through `start()` / `status()`
-* so the already-authorized client can sign the iframe in automatically.
+* Owns the lifecycle of a single editor child process. Resolves a launch
+* {@link CodeServerProfile} (Coder `code-server`, Microsoft `code serve-web`,
+* or `code tunnel`), detects the binary, launches it with freshly generated
+* auth material, waits for readiness, and mirrors a secret-free status into
+* shared state. The connect descriptor (session cookie / connection token /
+* tunnel URL) is handed back only through `start()` / `status()` so the
+* already-authorized client can open the editor without a login page.
 *
 * Depends only on the core devframe context (shared state), not on the hub.
 */
 var CodeServerSupervisor = class {
 	ctx;
-	bin;
+	mode;
+	explicitBackend;
+	explicitBin;
 	workspace;
 	host;
 	forcedPort;
 	extraArgs;
 	extraEnv;
-	cookieName;
 	cookieSuffix;
+	cookieName;
 	startTimeout;
+	reuseExistingServer;
+	tunnelName;
+	/** Resolved after the first detection. */
+	backend;
+	bin;
+	profile;
 	state;
 	detection;
 	server = { status: "stopped" };
 	proc;
-	cookieValue;
+	/** Context of the live launch, used to compute the client connect descriptor. */
+	launchCtx;
+	/** Whether the running server was adopted (reused) rather than launched. */
+	adopted = false;
+	/** Captured `vscode.dev` URL for a running tunnel. */
+	readyUrl;
 	logBuffer = [];
-	cleanupRegistered = false;
+	exitHandler;
 	/** Stable id of the hub terminal session, reused across start/stop. */
 	sessionId;
 	/** The live hub terminal session when launched through `ctx.terminals`. */
 	session;
 	constructor(ctx, options = {}) {
 		this.ctx = ctx;
-		this.bin = options.bin ?? "code-server";
+		this.mode = options.mode ?? "local";
+		this.explicitBackend = options.backend;
+		this.explicitBin = options.bin;
 		this.workspace = options.cwd ?? ctx.cwd;
-		this.host = options.host ?? "0.0.0.0";
+		this.host = options.host ?? "127.0.0.1";
 		this.forcedPort = options.serverPort;
 		this.extraArgs = options.args ?? [];
 		this.extraEnv = options.env ?? {};
 		this.cookieSuffix = options.cookieSuffix;
 		this.cookieName = getCookieSessionName(options.cookieSuffix);
 		this.startTimeout = options.startTimeout ?? 3e4;
+		this.reuseExistingServer = options.reuseExistingServer ?? false;
+		this.tunnelName = options.tunnel?.name || hostname().split(".").join("") || "devframe";
+		this.sessionId = options.cookieSuffix ? `${PLUGIN_ID}:${options.cookieSuffix}` : PLUGIN_ID;
+		this.backend = this.explicitBackend ?? "code-server";
+		this.profile = resolveProfile(this.mode, this.backend);
+		this.bin = this.explicitBin ?? this.profile.defaultBin;
 		this.detection = {
 			checked: false,
 			installed: false,
-			bin: this.bin
+			bin: this.bin,
+			backend: this.backend,
+			mode: this.mode
 		};
-		this.sessionId = options.cookieSuffix ? `${PLUGIN_ID}:${options.cookieSuffix}` : PLUGIN_ID;
 	}
 	/** Resolve shared state, register process-exit cleanup, run first detection. */
 	async init() {
@@ -141,72 +269,124 @@ var CodeServerSupervisor = class {
 			detection: this.detection,
 			server: this.server
 		} });
-		this.registerCleanup();
 		await this.detect();
 	}
-	/** Re-probe for the code-server binary and publish the result. */
+	/**
+	* Probe for a usable editor binary and publish the result. Resolves the
+	* backend + binary when the caller left them implicit: tunnel mode always
+	* uses `code`; an explicit backend or `bin` is honored as-is; otherwise the
+	* plugin tries each {@link AUTO_DETECT_ORDER} candidate and keeps the first
+	* that is installed.
+	*/
 	async detect() {
-		const result = await detectCodeServer(this.bin);
+		let installed = false;
+		let version;
+		if (this.mode === "tunnel" || this.explicitBackend || this.explicitBin) {
+			const result = await detectCodeServer(this.bin);
+			installed = result.installed;
+			version = result.version;
+		} else {
+			let resolved;
+			for (const backend of AUTO_DETECT_ORDER) {
+				const bin = resolveProfile("local", backend).defaultBin;
+				const result = await detectCodeServer(bin);
+				if (result.installed) {
+					resolved = {
+						backend,
+						bin,
+						version: result.version
+					};
+					break;
+				}
+			}
+			if (resolved) {
+				this.setResolved(resolved.backend, resolved.bin);
+				installed = true;
+				version = resolved.version;
+			}
+		}
 		this.detection = {
 			checked: true,
-			...result
+			installed,
+			version,
+			bin: this.bin,
+			backend: this.backend,
+			mode: this.mode
 		};
 		this.publish();
 		return this.detection;
 	}
-	/** Current status (+ auth when running) for the launcher UI. */
+	/** Current status (+ connect info when running) for the launcher UI. */
 	status() {
 		return {
 			detection: { ...this.detection },
 			server: { ...this.server },
-			auth: this.authInfo()
+			connect: this.connectInfo()
 		};
 	}
 	/**
-	* Launch code-server (if not already up) and resolve once it answers its
-	* readiness probe. Idempotent while starting/running — returns the live
-	* status instead of spawning a second process.
+	* Launch the editor (if not already up) and resolve once it is reachable.
+	* Idempotent while starting/running — returns the live status instead of
+	* spawning a second process. In tunnel mode it resolves as soon as either
+	* the `vscode.dev` URL or a device-login prompt is seen, so the action never
+	* blocks on interactive authentication.
 	*/
 	async start(req = {}) {
 		if (this.server.status === "running" || this.server.status === "starting") return this.status();
 		if (!this.detection.checked) await this.detect();
 		if (!this.detection.installed) throw diagnostics.DP_CODE_SERVER_0001({ bin: this.bin });
-		const initialPort = this.forcedPort !== void 0 && this.forcedPort !== 0 ? this.forcedPort : this.forcedPort === 0 ? 0 : await getPort({
+		const folder = req.folder ?? this.workspace;
+		const isLocal = this.profile.kind !== "tunnel";
+		if (isLocal && this.reuseExistingServer) {
+			const target = this.forcedPort && this.forcedPort !== 0 ? this.forcedPort : DEFAULT_CODE_SERVER_PORT;
+			if (this.profile.healthPath && await probeHealth(target, this.profile.healthPath)) {
+				this.adopted = true;
+				this.launchCtx = this.baseCtx(folder, target, "");
+				this.server = {
+					status: "running",
+					port: target,
+					startedAt: Date.now()
+				};
+				this.publish();
+				return this.status();
+			}
+		}
+		const secret = randomBytes(32).toString("hex");
+		const initialPort = !isLocal ? 0 : this.forcedPort !== void 0 && this.forcedPort !== 0 ? this.forcedPort : this.forcedPort === 0 ? 0 : await getPort({
 			host: "127.0.0.1",
 			port: DEFAULT_CODE_SERVER_PORT
 		});
-		const token = randomBytes(32).toString("hex");
-		this.cookieValue = createHash("sha256").update(token).digest("hex");
-		const folder = req.folder ?? this.workspace;
-		const args = [
-			"--auth",
-			"password",
-			"--bind-addr",
-			`${this.host}:${initialPort}`,
-			"--disable-telemetry",
-			"--disable-update-check",
-			...this.cookieSuffix ? ["--cookie-suffix", this.cookieSuffix] : [],
-			...this.extraArgs,
-			folder
-		];
-		const env = {};
-		for (const [k, v] of Object.entries(process.env)) if (v !== void 0) env[k] = v;
-		delete env.PASSWORD;
-		env.HASHED_PASSWORD = this.cookieValue;
-		Object.assign(env, this.extraEnv);
+		const ctx = this.baseCtx(folder, initialPort, secret);
+		this.launchCtx = ctx;
+		this.adopted = false;
+		this.readyUrl = void 0;
+		const args = this.profile.buildArgs(ctx);
+		const baseEnv = {};
+		for (const [k, v] of Object.entries(process.env)) if (v !== void 0) baseEnv[k] = v;
+		Object.assign(baseEnv, this.extraEnv);
+		const env = this.profile.buildEnv(ctx, baseEnv);
 		this.logBuffer = [];
 		let actualPort = initialPort;
 		let portResolver;
 		let portRejecter;
-		const portPromise = initialPort === 0 ? new Promise((resolve, reject) => {
+		const portPromise = isLocal && initialPort === 0 ? new Promise((resolve, reject) => {
 			portResolver = resolve;
 			portRejecter = reject;
 		}) : Promise.resolve(initialPort);
+		let readyUrlResolver;
+		let loginResolver;
+		const readyUrlPromise = new Promise((resolve) => {
+			readyUrlResolver = resolve;
+		});
+		const loginPromise = new Promise((resolve) => {
+			loginResolver = resolve;
+		});
 		const child = await this.launchProcess(args, env, folder);
+		this.registerCleanup();
 		this.proc = child;
 		this.server = {
 			status: "starting",
-			port: actualPort || void 0,
+			port: isLocal ? actualPort || void 0 : void 0,
 			pid: child.pid,
 			startedAt: Date.now()
 		};
@@ -214,14 +394,34 @@ var CodeServerSupervisor = class {
 		const capture = (chunk) => {
 			const text = chunk.toString("utf8");
 			this.appendLog(text);
-			if (actualPort === 0 && portResolver) for (const line of text.split("\n")) {
-				const match = line.match(/HTTP server listening on https?:\/\/(?:[^:]+|\[[^\]]+\]):(\d+)/);
-				if (match) {
-					actualPort = Number.parseInt(match[1], 10);
-					this.server.port = actualPort;
-					this.publish();
-					portResolver?.(actualPort);
-					portResolver = void 0;
+			for (const line of text.split("\n")) {
+				if (isLocal && actualPort === 0 && this.profile.matchPort) {
+					const port = this.profile.matchPort(line);
+					if (port) {
+						actualPort = port;
+						this.server.port = port;
+						this.publish();
+						portResolver?.(port);
+						portResolver = void 0;
+					}
+				}
+				if (this.profile.matchLogin) {
+					const login = this.profile.matchLogin(line);
+					if (login && this.proc === child) {
+						this.server = {
+							...this.server,
+							login
+						};
+						this.publish();
+						loginResolver?.(login);
+					}
+				}
+				if (this.profile.matchReadyUrl) {
+					const url = this.profile.matchReadyUrl(line);
+					if (url && this.proc === child) {
+						this.readyUrl = url;
+						readyUrlResolver?.(url);
+					}
 				}
 			}
 		};
@@ -233,30 +433,29 @@ var CodeServerSupervisor = class {
 				status: "error",
 				error: error.message
 			};
-			this.proc = void 0;
-			this.cookieValue = void 0;
-			if (portRejecter) portRejecter?.(error);
+			this.reset();
+			portRejecter?.(error);
 			this.publish();
 		});
 		child.on("exit", (code) => {
 			if (this.proc !== child) return;
 			const exitCode = code ?? 0;
 			const crashed = this.server.status !== "stopped" && exitCode !== 0;
-			this.proc = void 0;
-			this.cookieValue = void 0;
+			this.reset();
 			this.server = crashed ? {
 				status: "error",
-				error: this.lastLog() || `code-server exited with code ${exitCode}`
+				error: this.lastLog() || `${this.bin} exited with code ${exitCode}`
 			} : { status: "stopped" };
 			if (crashed) diagnostics.DP_CODE_SERVER_0005({ code: exitCode }, { method: "warn" });
 			this.reflectHub(crashed ? "error" : "stopped");
 			this.session = void 0;
-			if (portRejecter) portRejecter?.(/* @__PURE__ */ new Error(`code-server exited before binding (code ${exitCode})`));
+			portRejecter?.(/* @__PURE__ */ new Error(`${this.bin} exited before binding (code ${exitCode})`));
 			this.publish();
 		});
 		try {
+			if (!isLocal) return await this.awaitTunnel(child, readyUrlPromise, loginPromise);
 			const port = await Promise.race([portPromise, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("timeout waiting for dynamic port allocation")), this.startTimeout))]);
-			if (!await this.waitForReady(port)) throw new Error(this.lastLog() || "startup timed out");
+			if (!await this.waitForReady(port, this.profile.healthPath)) throw new Error(this.lastLog() || "startup timed out");
 			if (this.proc !== child) return this.status();
 			this.server = {
 				status: "running",
@@ -275,23 +474,23 @@ var CodeServerSupervisor = class {
 					status: "error",
 					error: error instanceof Error ? error.message : String(error)
 				};
-				this.proc = void 0;
-				this.cookieValue = void 0;
+				this.reset();
 				this.publish();
 			}
+			if (!isLocal) throw diagnostics.DP_CODE_SERVER_0006({ timeout: this.startTimeout });
 			throw diagnostics.DP_CODE_SERVER_0002({
 				port: actualPort,
 				timeout: this.startTimeout
 			});
 		}
 	}
-	/** Stop the code-server process and reset to `stopped`. */
+	/** Stop the editor process and reset to `stopped`. */
 	stop() {
 		const child = this.proc;
-		this.proc = void 0;
-		this.cookieValue = void 0;
+		const wasAdopted = this.adopted;
+		this.reset();
 		this.server = { status: "stopped" };
-		if (child) this.terminate(child);
+		if (child && !wasAdopted) this.terminate(child);
 		this.reflectHub("stopped");
 		this.session = void 0;
 		this.publish();
@@ -299,18 +498,85 @@ var CodeServerSupervisor = class {
 	}
 	/** Kill the process on host shutdown / test teardown. */
 	dispose() {
-		if (this.proc) this.terminate(this.proc);
-		this.proc = void 0;
-		this.cookieValue = void 0;
+		if (this.proc && !this.adopted) this.terminate(this.proc);
+		this.reset();
 		this.session = void 0;
+		if (this.exitHandler) {
+			process.off("exit", this.exitHandler);
+			this.exitHandler = void 0;
+		}
 	}
-	authInfo() {
-		if (this.server.status !== "running" || !this.cookieValue) return void 0;
+	/** Resolved backend for tests / callers. */
+	get resolvedBackend() {
+		return this.backend;
+	}
+	setResolved(backend, bin) {
+		this.backend = backend;
+		this.bin = bin;
+		this.profile = resolveProfile(this.mode, backend);
+	}
+	baseCtx(folder, port, secret) {
 		return {
+			host: this.host,
+			port,
+			folder,
+			secret,
 			cookieName: this.cookieName,
-			cookieValue: this.cookieValue
+			extraArgs: this.extraArgs,
+			tunnelName: this.tunnelName
 		};
 	}
+	/** Clear per-launch process state (keeps `server`/`detection`). */
+	reset() {
+		this.proc = void 0;
+		this.launchCtx = void 0;
+		this.adopted = false;
+		this.readyUrl = void 0;
+	}
+	/**
+	* Resolve start() for a tunnel: succeed as soon as the `vscode.dev` URL
+	* appears (→ running) or a device-login prompt is seen (→ starting, so the
+	* user can authenticate while the log stream continues to a running URL).
+	*/
+	async awaitTunnel(child, readyUrlPromise, loginPromise) {
+		const timeout = new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("timed out waiting for the tunnel")), this.startTimeout));
+		const outcome = await Promise.race([
+			readyUrlPromise.then(() => "ready"),
+			loginPromise.then(() => "login"),
+			timeout
+		]);
+		if (this.proc !== child) return this.status();
+		if (outcome === "ready") {
+			this.server = {
+				status: "running",
+				pid: child.pid,
+				startedAt: this.server.startedAt
+			};
+			this.publish();
+			return this.status();
+		}
+		readyUrlPromise.then(() => {
+			if (this.proc === child && this.server.status !== "running") {
+				this.server = {
+					status: "running",
+					pid: child.pid,
+					startedAt: this.server.startedAt,
+					login: void 0
+				};
+				this.publish();
+			}
+		});
+		return this.status();
+	}
+	connectInfo() {
+		if (this.server.status !== "running" || !this.launchCtx) return void 0;
+		if (this.adopted) return this.profile.connectReused({ port: this.launchCtx.port });
+		return this.profile.connect({
+			...this.launchCtx,
+			port: this.server.port ?? this.launchCtx.port,
+			readyUrl: this.readyUrl
+		});
+	}
 	terminate(child) {
 		if (this.session) {
 			this.session.terminate().catch(() => {});
@@ -340,11 +606,11 @@ var CodeServerSupervisor = class {
 		});
 	}
 	/**
-	* Launch code-server. In a hub, spawn it through `ctx.terminals` so it shows
-	* up as a read-only terminal session (proper icon + name) whose output the
-	* hub streams to its terminals panel; standalone, spawn it directly. Either
-	* way, return the underlying {@link ChildProcess} so the shared readiness /
-	* port / log wiring in `start()` is identical.
+	* Launch the editor binary. In a hub, spawn it through `ctx.terminals` so it
+	* shows up as a read-only terminal session (proper icon + name) whose output
+	* the hub streams to its terminals panel; standalone, spawn it directly.
+	* Either way, return the underlying {@link ChildProcess} so the shared
+	* readiness / port / log wiring in `start()` is identical.
 	*/
 	async launchProcess(args, env, folder) {
 		const hub = this.resolveHubTerminals();
@@ -364,10 +630,11 @@ var CodeServerSupervisor = class {
 					id: this.sessionId,
 					title: TERMINAL_SESSION_TITLE,
 					description: folder,
-					icon: TERMINAL_SESSION_ICON
+					icon: TERMINAL_SESSION_ICON,
+					restartable: false
 				});
 				const child = session.getChildProcess();
-				if (!child) throw new Error("code-server process handle was unavailable");
+				if (!child) throw new Error("editor process handle was unavailable");
 				this.session = session;
 				return child;
 			} catch (error) {
@@ -428,22 +695,22 @@ var CodeServerSupervisor = class {
 		});
 	}
 	/**
-	* Poll code-server's unauthenticated `/healthz` endpoint until it responds
-	* or the timeout elapses. Returns false if the process exits first.
+	* Poll the server's readiness path until it responds or the timeout elapses.
+	* Returns false if the process exits first.
 	*/
-	async waitForReady(port) {
+	async waitForReady(port, path) {
 		const deadline = Date.now() + this.startTimeout;
 		while (Date.now() < deadline) {
 			if (!this.proc) return false;
-			if (await probeHealthz(port)) return true;
+			if (await probeHealth(port, path)) return true;
 			await delay(PROBE_INTERVAL);
 		}
 		return false;
 	}
 	registerCleanup() {
-		if (this.cleanupRegistered) return;
-		this.cleanupRegistered = true;
-		process.once("exit", () => this.dispose());
+		if (this.exitHandler) return;
+		this.exitHandler = () => this.dispose();
+		process.once("exit", this.exitHandler);
 	}
 };
 function delay(ms) {
@@ -451,12 +718,12 @@ function delay(ms) {
 		setTimeout(resolve, ms).unref?.();
 	});
 }
-function probeHealthz(port) {
+function probeHealth(port, path) {
 	return new Promise((resolve) => {
 		const req = request({
 			host: "127.0.0.1",
 			port,
-			path: "/healthz",
+			path,
 			method: "GET",
 			timeout: 1500
 		}, (res) => {
@@ -487,7 +754,8 @@ async function setupCodeServer(ctx, options = {}) {
 	setCodeServerSupervisor(ctx, supervisor);
 	await supervisor.init();
 	for (const fn of serverFunctions) ctx.rpc.register(fn);
+	if (options.startOnBoot) supervisor.start().catch(() => {});
 	return supervisor;
 }
 //#endregion
-export { CodeServerSupervisor, detectCodeServer, diagnostics, getCodeServerSupervisor, setCodeServerSupervisor, setupCodeServer };
+export { CodeServerSupervisor, detectCodeServer, diagnostics, getCodeServerSupervisor, resolveProfile, setCodeServerSupervisor, setupCodeServer };

package/dist/rpc/index.mjs

@@ -1,2 +1,2 @@
-import { t as serverFunctions } from "../rpc-DjerPudu.mjs";
+import { t as serverFunctions } from "../rpc-BdNzxqDi.mjs";
 export { serverFunctions };

package/dist/{rpc-DjerPudu.mjs → rpc-BdNzxqDi.mjs}

@@ -17,21 +17,25 @@ const diagnostics = defineDiagnostics({
 	reporters: [reporter],
 	codes: {
 		DP_CODE_SERVER_0001: {
-			why: (p) => `code-server is not installed (could not run "${p.bin} --version")`,
-			fix: "Install code-server — e.g. `curl -fsSL https://code-server.dev/install.sh | sh` — or set the `bin` option to its path. See https://coder.com/docs/code-server/latest/install"
+			why: (p) => `No editor binary found (could not run "${p.bin} --version")`,
+			fix: "Install Coder code-server (`curl -fsSL https://code-server.dev/install.sh | sh`) or the Microsoft `code` CLI, or set the `bin` option to its path. See https://coder.com/docs/code-server/latest/install"
 		},
 		DP_CODE_SERVER_0002: {
-			why: (p) => `code-server did not become ready on port ${p.port} within ${p.timeout}ms`,
-			fix: "Check the code-server logs for startup errors, raise `startTimeout`, or free the port."
+			why: (p) => `the editor did not become ready on port ${p.port} within ${p.timeout}ms`,
+			fix: "Check the editor logs for startup errors, raise `startTimeout`, or free the port."
 		},
-		DP_CODE_SERVER_0003: { why: (p) => `Failed to spawn code-server ("${p.bin}"): ${p.reason}` },
+		DP_CODE_SERVER_0003: { why: (p) => `Failed to spawn the editor ("${p.bin}"): ${p.reason}` },
 		DP_CODE_SERVER_0004: {
 			why: "code-server supervisor is not initialised on this context",
 			fix: "Call setupCodeServer(ctx) (or use createCodeServerDevframe) before invoking the code-server RPCs."
 		},
 		DP_CODE_SERVER_0005: {
-			why: (p) => `code-server exited unexpectedly with code ${p.code}`,
+			why: (p) => `the editor process exited unexpectedly with code ${p.code}`,
 			fix: "Inspect the captured output in the launcher and re-launch."
+		},
+		DP_CODE_SERVER_0006: {
+			why: (p) => `the tunnel did not open within ${p.timeout}ms`,
+			fix: "Check the tunnel logs, ensure the `code` CLI is signed in, or raise `startTimeout`."
 		}
 	}
 });