@devframes/plugin-code-server 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,26 @@
+import { CodeServerAuth, CodeServerDetection, CodeServerOptions, CodeServerServerInfo, CodeServerSharedState, CodeServerStartRequest, CodeServerStartResult, CodeServerStatus, CodeServerStatusResult } from "./types.mjs";
+import { i as PLUGIN_ID, l as getCookieSessionName, n as DEFAULT_PORT, o as STATE_KEY, t as DEFAULT_CODE_SERVER_PORT } from "./constants-ICLvdiRe.mjs";
+import { DevframeDefinition } from "devframe/types";
+
+//#region src/index.d.ts
+/**
+ * Build a {@link DevframeDefinition} for the code-server panel. The same
+ * definition runs standalone (`createCli`), mounts into a Vite host
+ * (`/vite`), or docks inside a hub — its `setup` only relies on the core
+ * devframe RPC + shared-state surface.
+ *
+ * @experimental This plugin is experimental and may change without a major
+ * version bump until it stabilizes.
+ *
+ * @example
+ * ```ts
+ * import { createCodeServerDevframe } from '@devframes/plugin-code-server'
+ *
+ * export default createCodeServerDevframe({ serverPort: 8080 })
+ * ```
+ */
+declare function createCodeServerDevframe(options?: CodeServerOptions): DevframeDefinition;
+/** Default-configured code-server devframe. */
+declare const codeServer: DevframeDefinition;
+//#endregion
+export { CodeServerAuth, CodeServerDetection, CodeServerOptions, CodeServerServerInfo, CodeServerSharedState, CodeServerStartRequest, CodeServerStartResult, CodeServerStatus, CodeServerStatusResult, DEFAULT_CODE_SERVER_PORT, DEFAULT_PORT, PLUGIN_ID, STATE_KEY, createCodeServerDevframe, codeServer as default, getCookieSessionName };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { n as createCodeServerDevframe, t as codeServer } from "./src-BDRH3xta.mjs";
+import { DEFAULT_CODE_SERVER_PORT, DEFAULT_PORT, PLUGIN_ID, STATE_KEY, getCookieSessionName } from "./constants.mjs";
+export { DEFAULT_CODE_SERVER_PORT, DEFAULT_PORT, PLUGIN_ID, STATE_KEY, createCodeServerDevframe, codeServer as default, getCookieSessionName };

package/dist/node/index.d.mts

@@ -0,0 +1,165 @@
+import { CodeServerDetection, CodeServerOptions, CodeServerStartRequest, CodeServerStartResult, CodeServerStatusResult } from "../types.mjs";
+import { DevframeNodeContext } from "devframe/types";
+import * as _$nostics from "nostics";
+import { Diagnostic } from "nostics";
+
+//#region src/node/supervisor.d.ts
+/**
+ * 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.
+ *
+ * Depends only on the core devframe context (shared state), not on the hub.
+ */
+declare class CodeServerSupervisor {
+  private readonly ctx;
+  private readonly bin;
+  private readonly workspace;
+  private readonly host;
+  private readonly forcedPort?;
+  private readonly extraArgs;
+  private readonly extraEnv;
+  private readonly cookieName;
+  private readonly cookieSuffix?;
+  private readonly startTimeout;
+  private state?;
+  private detection;
+  private server;
+  private proc?;
+  private cookieValue?;
+  private logBuffer;
+  private cleanupRegistered;
+  /** Stable id of the hub terminal session, reused across start/stop. */
+  private readonly sessionId;
+  /** The live hub terminal session when launched through `ctx.terminals`. */
+  private session?;
+  constructor(ctx: DevframeNodeContext, options?: CodeServerOptions);
+  /** Resolve shared state, register process-exit cleanup, run first detection. */
+  init(): Promise<void>;
+  /** Re-probe for the code-server binary and publish the result. */
+  detect(): Promise<CodeServerDetection>;
+  /** Current status (+ auth when running) for the launcher UI. */
+  status(): CodeServerStatusResult;
+  /**
+   * 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.
+   */
+  start(req?: CodeServerStartRequest): Promise<CodeServerStartResult>;
+  /** Stop the code-server process and reset to `stopped`. */
+  stop(): CodeServerStatusResult;
+  /** Kill the process on host shutdown / test teardown. */
+  dispose(): void;
+  private authInfo;
+  private terminate;
+  /**
+   * Resolve the hub's terminals subsystem when this devframe is mounted in a
+   * hub. `ctx.terminals` only exists on a `DevframeHubContext`, so it is
+   * duck-typed — standalone runtimes (CLI / Vite / build) have no such property
+   * and fall back to a direct child process.
+   */
+  private resolveHubTerminals;
+  /** Update the mirrored hub terminal session's status, when one exists. */
+  private reflectHub;
+  /**
+   * 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.
+   */
+  private launchProcess;
+  private appendLog;
+  private lastLog;
+  private publish;
+  /**
+   * Poll code-server's unauthenticated `/healthz` endpoint until it responds
+   * or the timeout elapses. Returns false if the process exits first.
+   */
+  private waitForReady;
+  private registerCleanup;
+}
+//#endregion
+//#region src/node/context.d.ts
+declare function setCodeServerSupervisor(ctx: DevframeNodeContext, supervisor: CodeServerSupervisor): void;
+declare function getCodeServerSupervisor(ctx: DevframeNodeContext): CodeServerSupervisor;
+//#endregion
+//#region src/node/detect.d.ts
+interface DetectCodeServerResult {
+  installed: boolean;
+  version?: string;
+  bin: string;
+}
+/**
+ * Probe the host for a usable code-server binary by running
+ * `<bin> --version`. Resolves to `installed: false` when the binary is
+ * missing (ENOENT), errors, or exits non-zero — never throws — so the
+ * launcher can fall back to install instructions.
+ *
+ * `code-server --version` prints e.g. `4.96.4 abc123 with Code 1.96.4`; the
+ * first semver-looking token is taken as the version. Matching a semver
+ * pattern (rather than the leading whitespace token) keeps cold-start i18n
+ * noise — e.g. an `i18next: …` initialization line printed before the version
+ * — from leaking into the reported version.
+ */
+declare function detectCodeServer(bin?: string, timeoutMs?: number): Promise<DetectCodeServerResult>;
+//#endregion
+//#region src/node/diagnostics.d.ts
+interface ReporterOptions {
+  method?: 'log' | 'warn' | 'error';
+}
+declare function reporter(d: Diagnostic, {
+  method
+}?: ReporterOptions): void;
+/**
+ * Structured diagnostics for the code-server plugin. Uses the plugin's own
+ * `DP_CODE_SERVER_` prefix per the built-in plugin convention, keeping it
+ * collision-free with devframe core (`DF`) and the hub (`DF8xxx`).
+ */
+declare const diagnostics: _$nostics.Diagnostics<{
+  readonly DP_CODE_SERVER_0001: {
+    readonly why: (p: {
+      bin: string;
+    }) => string;
+    readonly 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";
+  };
+  readonly DP_CODE_SERVER_0002: {
+    readonly why: (p: {
+      port: number;
+      timeout: number;
+    }) => string;
+    readonly fix: "Check the code-server logs for startup errors, raise `startTimeout`, or free the port.";
+  };
+  readonly DP_CODE_SERVER_0003: {
+    readonly why: (p: {
+      bin: string;
+      reason: string;
+    }) => string;
+  };
+  readonly DP_CODE_SERVER_0004: {
+    readonly why: "code-server supervisor is not initialised on this context";
+    readonly fix: "Call setupCodeServer(ctx) (or use createCodeServerDevframe) before invoking the code-server RPCs.";
+  };
+  readonly DP_CODE_SERVER_0005: {
+    readonly why: (p: {
+      code: number;
+    }) => string;
+    readonly fix: "Inspect the captured output in the launcher and re-launch.";
+  };
+}, readonly [typeof reporter]>;
+//#endregion
+//#region src/node/index.d.ts
+/**
+ * Wire the code-server subsystem onto a devframe node context: create the
+ * {@link CodeServerSupervisor}, run the initial binary detection, publish
+ * status into shared state, and register the control RPC functions. Returns
+ * the supervisor so callers can launch/stop or dispose it on shutdown.
+ *
+ * Works in any devframe runtime (CLI, Vite, embedded, build) — it only relies
+ * on the core `ctx.rpc` shared-state surface, not on the hub.
+ */
+declare function setupCodeServer(ctx: DevframeNodeContext, options?: CodeServerOptions): Promise<CodeServerSupervisor>;
+//#endregion
+export { CodeServerSupervisor, detectCodeServer, diagnostics, getCodeServerSupervisor, setCodeServerSupervisor, setupCodeServer };

package/dist/node/index.mjs

@@ -0,0 +1,491 @@
+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-njPEEDSx.mjs";
+import { execSync, spawn } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { request } from "node:http";
+import process from "node:process";
+import { getPort } from "get-port-please";
+//#region src/node/detect.ts
+/**
+* Probe the host for a usable code-server binary by running
+* `<bin> --version`. Resolves to `installed: false` when the binary is
+* missing (ENOENT), errors, or exits non-zero — never throws — so the
+* launcher can fall back to install instructions.
+*
+* `code-server --version` prints e.g. `4.96.4 abc123 with Code 1.96.4`; the
+* first semver-looking token is taken as the version. Matching a semver
+* pattern (rather than the leading whitespace token) keeps cold-start i18n
+* noise — e.g. an `i18next: …` initialization line printed before the version
+* — from leaking into the reported version.
+*/
+function detectCodeServer(bin = "code-server", timeoutMs = 5e3) {
+	return new Promise((resolve) => {
+		let settled = false;
+		let stdout = "";
+		const finish = (result) => {
+			if (settled) return;
+			settled = true;
+			resolve(result);
+		};
+		let child;
+		try {
+			child = spawn(bin, ["--version"], {
+				windowsHide: true,
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				],
+				shell: process.platform === "win32" && bin.endsWith(".cmd")
+			});
+		} catch {
+			finish({
+				installed: false,
+				bin
+			});
+			return;
+		}
+		const timer = setTimeout(() => {
+			child.kill();
+			finish({
+				installed: false,
+				bin
+			});
+		}, timeoutMs);
+		timer.unref?.();
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString("utf8");
+		});
+		child.on("error", () => {
+			clearTimeout(timer);
+			finish({
+				installed: false,
+				bin
+			});
+		});
+		child.on("exit", (code) => {
+			clearTimeout(timer);
+			if (code === 0) finish({
+				installed: true,
+				version: stdout.match(/\d+\.\d+\.\d\S*/)?.[0] ?? (stdout.trim().split(/\s+/)[0] || void 0),
+				bin
+			});
+			else finish({
+				installed: false,
+				bin
+			});
+		});
+	});
+}
+//#endregion
+//#region src/node/supervisor.ts
+/** Recent output lines retained for surfacing startup failures. */
+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.
+*
+* Depends only on the core devframe context (shared state), not on the hub.
+*/
+var CodeServerSupervisor = class {
+	ctx;
+	bin;
+	workspace;
+	host;
+	forcedPort;
+	extraArgs;
+	extraEnv;
+	cookieName;
+	cookieSuffix;
+	startTimeout;
+	state;
+	detection;
+	server = { status: "stopped" };
+	proc;
+	cookieValue;
+	logBuffer = [];
+	cleanupRegistered = false;
+	/** 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.workspace = options.cwd ?? ctx.cwd;
+		this.host = options.host ?? "0.0.0.0";
+		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.detection = {
+			checked: false,
+			installed: false,
+			bin: this.bin
+		};
+		this.sessionId = options.cookieSuffix ? `${PLUGIN_ID}:${options.cookieSuffix}` : PLUGIN_ID;
+	}
+	/** Resolve shared state, register process-exit cleanup, run first detection. */
+	async init() {
+		if (this.state) return;
+		this.state = await this.ctx.rpc.sharedState.get(STATE_KEY, { initialValue: {
+			detection: this.detection,
+			server: this.server
+		} });
+		this.registerCleanup();
+		await this.detect();
+	}
+	/** Re-probe for the code-server binary and publish the result. */
+	async detect() {
+		const result = await detectCodeServer(this.bin);
+		this.detection = {
+			checked: true,
+			...result
+		};
+		this.publish();
+		return this.detection;
+	}
+	/** Current status (+ auth when running) for the launcher UI. */
+	status() {
+		return {
+			detection: { ...this.detection },
+			server: { ...this.server },
+			auth: this.authInfo()
+		};
+	}
+	/**
+	* 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.
+	*/
+	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({
+			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);
+		this.logBuffer = [];
+		let actualPort = initialPort;
+		let portResolver;
+		let portRejecter;
+		const portPromise = initialPort === 0 ? new Promise((resolve, reject) => {
+			portResolver = resolve;
+			portRejecter = reject;
+		}) : Promise.resolve(initialPort);
+		const child = await this.launchProcess(args, env, folder);
+		this.proc = child;
+		this.server = {
+			status: "starting",
+			port: actualPort || void 0,
+			pid: child.pid,
+			startedAt: Date.now()
+		};
+		this.publish();
+		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;
+				}
+			}
+		};
+		child.stdout?.on("data", capture);
+		child.stderr?.on("data", capture);
+		child.on("error", (error) => {
+			if (this.proc !== child) return;
+			this.server = {
+				status: "error",
+				error: error.message
+			};
+			this.proc = void 0;
+			this.cookieValue = void 0;
+			if (portRejecter) 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.server = crashed ? {
+				status: "error",
+				error: this.lastLog() || `code-server 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})`));
+			this.publish();
+		});
+		try {
+			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 (this.proc !== child) return this.status();
+			this.server = {
+				status: "running",
+				port,
+				pid: child.pid,
+				startedAt: this.server.startedAt
+			};
+			this.publish();
+			return this.status();
+		} catch (error) {
+			if (this.proc === child) {
+				this.terminate(child);
+				this.reflectHub("error");
+				this.session = void 0;
+				this.server = {
+					status: "error",
+					error: error instanceof Error ? error.message : String(error)
+				};
+				this.proc = void 0;
+				this.cookieValue = void 0;
+				this.publish();
+			}
+			throw diagnostics.DP_CODE_SERVER_0002({
+				port: actualPort,
+				timeout: this.startTimeout
+			});
+		}
+	}
+	/** Stop the code-server process and reset to `stopped`. */
+	stop() {
+		const child = this.proc;
+		this.proc = void 0;
+		this.cookieValue = void 0;
+		this.server = { status: "stopped" };
+		if (child) this.terminate(child);
+		this.reflectHub("stopped");
+		this.session = void 0;
+		this.publish();
+		return this.status();
+	}
+	/** Kill the process on host shutdown / test teardown. */
+	dispose() {
+		if (this.proc) this.terminate(this.proc);
+		this.proc = void 0;
+		this.cookieValue = void 0;
+		this.session = void 0;
+	}
+	authInfo() {
+		if (this.server.status !== "running" || !this.cookieValue) return void 0;
+		return {
+			cookieName: this.cookieName,
+			cookieValue: this.cookieValue
+		};
+	}
+	terminate(child) {
+		if (this.session) {
+			this.session.terminate().catch(() => {});
+			return;
+		}
+		try {
+			if (process.platform === "win32" && this.bin.endsWith(".cmd") && child.pid) execSync(`taskkill /pid ${child.pid} /t /f`, { stdio: "ignore" });
+			else child.kill("SIGTERM");
+		} catch {}
+	}
+	/**
+	* Resolve the hub's terminals subsystem when this devframe is mounted in a
+	* hub. `ctx.terminals` only exists on a `DevframeHubContext`, so it is
+	* duck-typed — standalone runtimes (CLI / Vite / build) have no such property
+	* and fall back to a direct child process.
+	*/
+	resolveHubTerminals() {
+		const terminals = this.ctx.terminals;
+		return terminals && typeof terminals.startChildProcess === "function" ? terminals : void 0;
+	}
+	/** Update the mirrored hub terminal session's status, when one exists. */
+	reflectHub(status) {
+		const hub = this.resolveHubTerminals();
+		if (hub?.sessions.has(this.sessionId)) hub.update({
+			id: this.sessionId,
+			status
+		});
+	}
+	/**
+	* 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.
+	*/
+	async launchProcess(args, env, folder) {
+		const hub = this.resolveHubTerminals();
+		if (hub) {
+			const stale = hub.sessions.get(this.sessionId);
+			if (stale) hub.remove?.(stale);
+			try {
+				const session = await hub.startChildProcess({
+					command: this.bin,
+					args,
+					cwd: folder,
+					env: {
+						...env,
+						PASSWORD: ""
+					}
+				}, {
+					id: this.sessionId,
+					title: TERMINAL_SESSION_TITLE,
+					description: folder,
+					icon: TERMINAL_SESSION_ICON
+				});
+				const child = session.getChildProcess();
+				if (!child) throw new Error("code-server process handle was unavailable");
+				this.session = session;
+				return child;
+			} catch (error) {
+				const reason = error instanceof Error ? error.message : String(error);
+				const orphan = hub.sessions.get(this.sessionId);
+				if (orphan) hub.remove?.(orphan);
+				this.session = void 0;
+				this.server = {
+					status: "error",
+					error: reason
+				};
+				this.publish();
+				throw diagnostics.DP_CODE_SERVER_0003({
+					bin: this.bin,
+					reason
+				});
+			}
+		}
+		try {
+			return spawn(this.bin, args, {
+				cwd: folder,
+				env,
+				windowsHide: true,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				shell: process.platform === "win32" && this.bin.endsWith(".cmd")
+			});
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			this.server = {
+				status: "error",
+				error: reason
+			};
+			this.publish();
+			throw diagnostics.DP_CODE_SERVER_0003({
+				bin: this.bin,
+				reason
+			});
+		}
+	}
+	appendLog(text) {
+		for (const line of text.split("\n")) {
+			if (line.length === 0) continue;
+			this.logBuffer.push(line);
+		}
+		if (this.logBuffer.length > LOG_BUFFER_LINES) this.logBuffer.splice(0, this.logBuffer.length - LOG_BUFFER_LINES);
+	}
+	lastLog() {
+		return this.logBuffer.length ? this.logBuffer[this.logBuffer.length - 1] : void 0;
+	}
+	publish() {
+		this.state?.mutate((draft) => {
+			draft.detection = { ...this.detection };
+			draft.server = { ...this.server };
+		});
+	}
+	/**
+	* Poll code-server's unauthenticated `/healthz` endpoint until it responds
+	* or the timeout elapses. Returns false if the process exits first.
+	*/
+	async waitForReady(port) {
+		const deadline = Date.now() + this.startTimeout;
+		while (Date.now() < deadline) {
+			if (!this.proc) return false;
+			if (await probeHealthz(port)) return true;
+			await delay(PROBE_INTERVAL);
+		}
+		return false;
+	}
+	registerCleanup() {
+		if (this.cleanupRegistered) return;
+		this.cleanupRegistered = true;
+		process.once("exit", () => this.dispose());
+	}
+};
+function delay(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms).unref?.();
+	});
+}
+function probeHealthz(port) {
+	return new Promise((resolve) => {
+		const req = request({
+			host: "127.0.0.1",
+			port,
+			path: "/healthz",
+			method: "GET",
+			timeout: 1500
+		}, (res) => {
+			res.resume();
+			resolve((res.statusCode ?? 0) >= 200 && (res.statusCode ?? 0) < 500);
+		});
+		req.on("error", () => resolve(false));
+		req.on("timeout", () => {
+			req.destroy();
+			resolve(false);
+		});
+		req.end();
+	});
+}
+//#endregion
+//#region src/node/index.ts
+/**
+* Wire the code-server subsystem onto a devframe node context: create the
+* {@link CodeServerSupervisor}, run the initial binary detection, publish
+* status into shared state, and register the control RPC functions. Returns
+* the supervisor so callers can launch/stop or dispose it on shutdown.
+*
+* Works in any devframe runtime (CLI, Vite, embedded, build) — it only relies
+* on the core `ctx.rpc` shared-state surface, not on the hub.
+*/
+async function setupCodeServer(ctx, options = {}) {
+	const supervisor = new CodeServerSupervisor(ctx, options);
+	setCodeServerSupervisor(ctx, supervisor);
+	await supervisor.init();
+	for (const fn of serverFunctions) ctx.rpc.register(fn);
+	return supervisor;
+}
+//#endregion
+export { CodeServerSupervisor, detectCodeServer, diagnostics, getCodeServerSupervisor, setCodeServerSupervisor, setupCodeServer };