@devframes/plugin-code-server 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# @devframes/plugin-code-server
+
+> [!WARNING] Experimental
+> This plugin is experimental and may change without a major version bump until
+> it stabilizes.
+
+Run [code-server](https://github.com/coder/code-server) (VS Code in the
+browser) as a devframe panel. The plugin detects a local `code-server`
+install, launches it on demand, and embeds the editor in an
+auto-authenticated `<iframe>`.
+
+## How it works
+
+- **Detection** — on startup it runs `code-server --version`. When the binary
+  is missing, the launcher renders install instructions and links instead of a
+  launch button.
+- **Launch** — the launcher's button starts code-server as a managed child
+  process bound to a free port, scoped to the workspace. Readiness is probed
+  via code-server's `/healthz` endpoint.
+- **Auto-auth** — code-server runs with password auth. The plugin generates a
+  random token, sets `HASHED_PASSWORD` to its SHA-256, and hands the matching
+  session cookie back to the already-authorized devframe client. The launcher
+  applies that cookie for the current host before loading the iframe, so the
+  editor opens already signed in — no code-server login page.
+
+The editor iframe points at code-server's own origin
+(`<protocol>//<host>:<port>/`), so WebSocket traffic flows directly without a
+reverse proxy.
+
+## Usage
+
+### Standalone CLI
+
+```sh
+npx @devframes/plugin-code-server        # dev server + launcher
+```
+
+### Programmatic
+
+```ts
+import { createCodeServerDevframe } from '@devframes/plugin-code-server'
+
+export default createCodeServerDevframe({
+  // bin: 'code-server',     // binary to detect/launch (default: PATH)
+  // serverPort: 8080,       // force a port (default: free port near 8080)
+  // args: ['--disable-getting-started-override'],
+})
+```
+
+### Vite host
+
+```ts
+import { codeServerVite } from '@devframes/plugin-code-server/vite'
+
+export default {
+  plugins: [codeServerVite()],
+}
+```
+
+## RPC
+
+| Function | Type | Purpose |
+|----------|------|---------|
+| `devframes-plugin-code-server:detect` | query | Re-probe for the binary; returns `{ installed, version, bin }`. |
+| `devframes-plugin-code-server:status` | query | Current status + auth cookie when running. |
+| `devframes-plugin-code-server:start` | action | Launch and wait for readiness. |
+| `devframes-plugin-code-server:stop` | action | Stop the process. |
+
+Status (minus the auth cookie) is mirrored into the
+`devframes-plugin-code-server:state` shared state for reactive UIs.
+
+## UI
+
+The launcher UI is a pure, state-driven view (`src/client/view.ts`) decoupled
+from RPC, so every state renders in isolation. `mountCodeServer` wires the live
+connection to it. Each UI state has a Storybook story:
+
+```sh
+pnpm storybook         # dev
+pnpm build-storybook   # static build
+```
+
+Stories: connecting, not-installed, launch, launch-error, starting, running
+(the running story mounts a mock editor instead of a live server).

package/bin.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import process from 'node:process'
+import { createCodeServerCli } from './dist/cli.mjs'
+
+async function main() {
+  const cli = createCodeServerCli()
+  await cli.parse()
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/dist/cli.d.mts

@@ -0,0 +1,12 @@
+import { CodeServerOptions } from "./types.mjs";
+import { CliHandle, CreateCliOptions } from "devframe/adapters/cli";
+
+//#region src/cli.d.ts
+/**
+ * Build a standalone CLI for the code-server panel — `dev` / `build` / `mcp`
+ * subcommands, backed by {@link createCodeServerDevframe}. Used by the package
+ * `bin` (`devframe-code-server`).
+ */
+declare function createCodeServerCli(options?: CodeServerOptions, cliOptions?: CreateCliOptions): CliHandle;
+//#endregion
+export { createCodeServerCli };

package/dist/cli.mjs

@@ -0,0 +1,13 @@
+import { n as createCodeServerDevframe } from "./src-BDRH3xta.mjs";
+import { createCli } from "devframe/adapters/cli";
+//#region src/cli.ts
+/**
+* Build a standalone CLI for the code-server panel — `dev` / `build` / `mcp`
+* subcommands, backed by {@link createCodeServerDevframe}. Used by the package
+* `bin` (`devframe-code-server`).
+*/
+function createCodeServerCli(options = {}, cliOptions = {}) {
+	return createCli(createCodeServerDevframe(options), cliOptions);
+}
+//#endregion
+export { createCodeServerCli };

package/dist/client/index.d.mts

@@ -0,0 +1,75 @@
+import { CodeServerAuth, CodeServerDetection, CodeServerServerInfo, CodeServerSharedState, CodeServerStatus } from "../types.mjs";
+import { o as STATE_KEY } from "../constants-ICLvdiRe.mjs";
+import { DevframeRpcClient } from "devframe/client";
+
+//#region src/client/view.d.ts
+/** The data the view renders from. Pure — no RPC, no process knowledge. */
+interface CodeServerViewState {
+  detection: CodeServerDetection;
+  server: CodeServerServerInfo;
+  /** Auth handoff; present only once the editor is reachable. */
+  auth?: CodeServerAuth;
+  /** A request (launch / re-check) is in flight. */
+  busy?: boolean;
+}
+/** User intents the view surfaces. */
+interface CodeServerViewActions {
+  launch: () => void;
+  recheck: () => void;
+}
+interface CodeServerViewOptions {
+  actions?: Partial<CodeServerViewActions>;
+  /**
+   * Build the editor iframe URL from the running port. Defaults to the
+   * current page host so the cookie set on this origin reaches the iframe.
+   */
+  resolveEditorUrl?: (port: number) => string;
+  /**
+   * Apply code-server's session cookie before the iframe loads. Defaults to
+   * `document.cookie`. Storybook overrides this to a no-op.
+   */
+  applyAuth?: (auth: CodeServerAuth) => void;
+}
+/** Discrete UI states, one per Storybook story. */
+type CodeServerPhase = 'connecting' | 'not-installed' | 'launch' | 'starting' | 'running';
+interface CodeServerViewHandle {
+  /** Re-render from a new state (cheap; reuses the live iframe when unchanged). */
+  update: (state: CodeServerViewState) => void;
+  dispose: () => void;
+}
+/** Map a state to its discrete UI phase. */
+declare function resolvePhase(state: CodeServerViewState): CodeServerPhase;
+/**
+ * Create the code-server launcher view inside `container`. The view is a pure
+ * function of {@link CodeServerViewState}: callers (the SPA via
+ * `mountCodeServer`, or Storybook) push state with `update()` and wire intent
+ * through `options.actions`. It performs no RPC and owns no process state, so
+ * every UI phase can be rendered in isolation.
+ */
+declare function createCodeServerView(container: HTMLElement, options?: CodeServerViewOptions): CodeServerViewHandle;
+//#endregion
+//#region src/client/index.d.ts
+interface MountCodeServerOptions {
+  /** Pre-connected client. When omitted, `connectDevframe()` is awaited. */
+  rpc?: DevframeRpcClient;
+}
+interface CodeServerHandle {
+  rpc: DevframeRpcClient;
+  /** Stop the code-server process (no UI control is rendered over the editor). */
+  stop: () => Promise<void>;
+  dispose: () => void;
+}
+/**
+ * Mount the code-server launcher into `container`. Connects to the devframe
+ * backend, then drives a {@link createCodeServerView} from the live
+ * detection/server state: install instructions when the binary is missing, a
+ * launch screen when stopped, a progress state while starting, and the editor
+ * in a full-bleed, auto-authenticated iframe once running.
+ *
+ * The connection is assumed already authorized with devframe's auth, so the
+ * server-issued session cookie is applied transparently before the iframe
+ * loads — the user never sees code-server's login page.
+ */
+declare function mountCodeServer(container: HTMLElement, options?: MountCodeServerOptions): Promise<CodeServerHandle>;
+//#endregion
+export { CodeServerHandle, type CodeServerPhase, type CodeServerServerInfo, type CodeServerSharedState, type CodeServerStatus, type CodeServerViewActions, type CodeServerViewHandle, type CodeServerViewOptions, type CodeServerViewState, MountCodeServerOptions, STATE_KEY, createCodeServerView, mountCodeServer, resolvePhase };

package/dist/client/index.mjs

@@ -0,0 +1,354 @@
+import { connectDevframe } from "devframe/client";
+import { createIframePanes } from "iframe-pane";
+//#region src/constants.ts
+/**
+* Shared-state key holding the serializable, secret-free server status and
+* detection result. The authentication cookie is never published here — it
+* is returned only from the `start` / `status` RPCs to the already-authorized
+* client (see {@link CodeServerAuth}).
+*/
+const STATE_KEY = "devframes-plugin-code-server:state";
+//#endregion
+//#region src/client/design.ts
+function cx(...parts) {
+	return parts.filter(Boolean).join(" ");
+}
+function button({ variant = "primary", size = "md", class: extra } = {}) {
+	const variantClass = {
+		primary: "btn-primary",
+		secondary: "btn-action",
+		outline: "btn-action",
+		ghost: "inline-flex items-center justify-center gap-1.5 rounded px2 py1 op75 hover:op100 hover:bg-active transition disabled:pointer-events-none disabled:op30!",
+		destructive: "btn-action text-error border-error/30!",
+		link: "inline-flex items-center gap-1.5 color-active hover:underline underline-offset-2"
+	};
+	const sizeClass = size === "sm" ? variant === "primary" ? "text-sm px-2.5! py-1!" : "text-sm" : size === "lg" ? "text-base px-4! py-2!" : "";
+	return cx(variantClass[variant], sizeClass, extra);
+}
+function link(extra) {
+	return cx("color-active hover:underline underline-offset-2", extra);
+}
+function spinner(extra) {
+	return cx("inline-block size-4 rounded-full border-2 border-current border-t-transparent animate-spin", extra);
+}
+//#endregion
+//#region src/client/view.ts
+const DOCS_URL = "https://coder.com/docs/code-server/latest/install";
+const REPO_URL = "https://github.com/coder/code-server";
+const panes = createIframePanes();
+let paneCounter = 0;
+const INSTALL_COMMANDS = [
+	{
+		label: "Install script (Linux / macOS)",
+		command: "curl -fsSL https://code-server.dev/install.sh | sh"
+	},
+	{
+		label: "npm",
+		command: "npm install -g code-server"
+	},
+	{
+		label: "Homebrew",
+		command: "brew install code-server"
+	}
+];
+/** Map a state to its discrete UI phase. */
+function resolvePhase(state) {
+	const { detection, server, auth, busy } = state;
+	if (server.status === "running" && server.port != null) return auth ? "running" : "starting";
+	if (server.status === "starting" || busy && server.status !== "error") return "starting";
+	if (!detection.checked) return "connecting";
+	if (!detection.installed) return "not-installed";
+	return "launch";
+}
+function el(tag, className, text) {
+	const node = document.createElement(tag);
+	if (className) node.className = className;
+	if (text != null) node.textContent = text;
+	return node;
+}
+/** A Phosphor icon (UnoCSS presetIcons), matching the other devframe plugins. */
+function icon(name, cls = "") {
+	return el("span", cx(name, "shrink-0", cls));
+}
+/** The uppercase "code-server" eyebrow, prefixed with the brand icon. */
+function eyebrow() {
+	const p = el("p", "flex items-center gap-1.5 mb-2.5 text-xs tracking-wider uppercase color-muted");
+	p.append(icon("i-ph-code-duotone", "text-sm"), document.createTextNode("code-server"));
+	return p;
+}
+function defaultEditorUrl(port) {
+	return `${location.protocol}//${location.hostname}:${port}/`;
+}
+function defaultApplyAuth(auth) {
+	document.cookie = `${auth.cookieName}=${auth.cookieValue}; path=/; SameSite=Lax`;
+}
+/**
+* Create the code-server launcher view inside `container`. The view is a pure
+* function of {@link CodeServerViewState}: callers (the SPA via
+* `mountCodeServer`, or Storybook) push state with `update()` and wire intent
+* through `options.actions`. It performs no RPC and owns no process state, so
+* every UI phase can be rendered in isolation.
+*/
+function createCodeServerView(container, options = {}) {
+	const resolveEditorUrl = options.resolveEditorUrl ?? defaultEditorUrl;
+	const applyAuth = options.applyAuth ?? defaultApplyAuth;
+	const launch = () => options.actions?.launch?.();
+	const recheck = () => options.actions?.recheck?.();
+	const root = el("div", "absolute inset-0 flex flex-col of-hidden bg-base color-base font-sans");
+	container.append(root);
+	const paneId = `code-server-editor-${++paneCounter}`;
+	const editorTarget = el("div", "dcs-frame flex-1 w-full");
+	let editorUrl = null;
+	function shell(...children) {
+		panes.get(paneId)?.unmount();
+		editorUrl = null;
+		const center = el("div", "flex-1 flex items-center justify-center p-6");
+		const card = el("div", "w-full max-w-[560px]");
+		card.append(...children);
+		center.append(card);
+		root.replaceChildren(center);
+	}
+	function renderConnecting() {
+		const wrap = el("div", "flex items-center gap-2.5");
+		wrap.append(el("div", spinner("color-muted")), el("span", "text-sm color-muted", "Connecting to devframe…"));
+		shell(wrap);
+	}
+	function renderNotInstalled(busy) {
+		const nodes = [];
+		nodes.push(eyebrow());
+		nodes.push(el("h1", "mb-2 text-[1.35rem] font-semibold", "code-server is not installed"));
+		nodes.push(el("p", "mb-5 text-sm leading-relaxed color-muted", "Install code-server (VS Code in the browser) to open the editor here. Pick whichever fits your setup, then re-check."));
+		const install = el("div", "flex flex-col gap-3 mb-5");
+		for (const { label, command } of INSTALL_COMMANDS) {
+			const row = el("div");
+			row.append(el("label", "block mb-1 text-xs color-muted", label));
+			const cmd = el("div", "flex items-center gap-2 px-2.5 py-2 rounded-md border border-base bg-secondary");
+			cmd.append(el("code", "flex-1 of-x-auto whitespace-nowrap font-mono text-xs color-base", command));
+			const copy = el("button", button({
+				variant: "outline",
+				size: "sm",
+				class: "shrink-0 text-[11px]"
+			}), "Copy");
+			copy.onclick = () => {
+				navigator.clipboard?.writeText(command).then(() => {
+					copy.textContent = "Copied";
+					setTimeout(() => {
+						copy.textContent = "Copy";
+					}, 1200);
+				}).catch(() => {});
+			};
+			cmd.append(copy);
+			row.append(cmd);
+			install.append(row);
+		}
+		nodes.push(install);
+		const actions = el("div", "flex flex-wrap items-center gap-2.5");
+		const recheckBtn = el("button", button({ variant: "primary" }));
+		recheckBtn.append(icon("i-ph-arrows-clockwise", cx("size-4", busy && "animate-spin")), document.createTextNode(busy ? "Checking…" : "Re-check"));
+		recheckBtn.disabled = busy;
+		recheckBtn.onclick = recheck;
+		actions.append(recheckBtn);
+		actions.append(link$1("Installation docs", DOCS_URL));
+		actions.append(link$1("GitHub", REPO_URL));
+		nodes.push(actions);
+		shell(...nodes);
+	}
+	function renderLaunch(state) {
+		const { detection, server, busy } = state;
+		const nodes = [];
+		nodes.push(eyebrow());
+		nodes.push(el("h1", "mb-2 text-[1.35rem] font-semibold", "Launch the editor"));
+		nodes.push(el("p", "mb-5 text-sm leading-relaxed color-muted", "Start a code-server instance scoped to this workspace and open VS Code right here. The server runs with a generated password and the editor is signed in automatically."));
+		if (server.status === "error" && server.error) nodes.push(el("div", "mb-4 px-3 py-2.5 rounded-md border border-error/35 bg-error/10 text-error text-sm whitespace-pre-wrap break-words", server.error));
+		const meta = el("div", "flex flex-wrap gap-x-4 gap-y-1.5 mb-5 text-xs color-muted");
+		if (detection.version) {
+			const v = el("span");
+			v.append(document.createTextNode("version "), el("code", "font-mono color-base", detection.version));
+			meta.append(v);
+		}
+		const b = el("span");
+		b.append(document.createTextNode("binary "), el("code", "font-mono color-base", detection.bin));
+		meta.append(b);
+		nodes.push(meta);
+		const actions = el("div", "flex flex-wrap items-center gap-2.5");
+		const launchBtn = el("button", button({ variant: "primary" }));
+		if (busy) launchBtn.append(el("span", spinner()), document.createTextNode("Starting…"));
+		else launchBtn.append(icon("i-ph-rocket-launch-duotone", "size-4"), document.createTextNode("Launch code-server"));
+		launchBtn.disabled = busy ?? false;
+		launchBtn.onclick = launch;
+		actions.append(launchBtn);
+		nodes.push(actions);
+		shell(...nodes);
+	}
+	function renderStarting() {
+		const wrap = el("div", "flex items-center gap-2.5");
+		wrap.append(el("div", spinner("color-muted")), el("span", "text-sm color-muted", "Starting code-server…"));
+		shell(wrap);
+	}
+	function renderRunning(state) {
+		const url = resolveEditorUrl(state.server.port);
+		if (editorUrl !== url) {
+			if (state.auth) applyAuth(state.auth);
+			editorUrl = url;
+		}
+		const pane = panes.ensure(paneId, {
+			src: url,
+			attrs: { allow: "clipboard-read; clipboard-write; cross-origin-isolated" },
+			style: { border: "0" }
+		});
+		if (pane.iframe.src !== url) pane.iframe.src = url;
+		if (root.firstElementChild !== editorTarget) root.replaceChildren(editorTarget);
+		pane.mount(editorTarget);
+	}
+	function link$1(text, href) {
+		const a = el("a", link("inline-flex items-center gap-1 text-sm"));
+		a.append(document.createTextNode(text), icon("i-ph-arrow-square-out", "size-3.5"));
+		a.href = href;
+		a.target = "_blank";
+		a.rel = "noreferrer";
+		return a;
+	}
+	function update(state) {
+		switch (resolvePhase(state)) {
+			case "running":
+				renderRunning(state);
+				break;
+			case "starting":
+				renderStarting();
+				break;
+			case "connecting":
+				renderConnecting();
+				break;
+			case "not-installed":
+				renderNotInstalled(state.busy ?? false);
+				break;
+			case "launch":
+				renderLaunch(state);
+				break;
+		}
+	}
+	return {
+		update,
+		dispose() {
+			panes.get(paneId)?.dispose();
+			root.remove();
+		}
+	};
+}
+//#endregion
+//#region src/client/index.ts
+/**
+* Mount the code-server launcher into `container`. Connects to the devframe
+* backend, then drives a {@link createCodeServerView} from the live
+* detection/server state: install instructions when the binary is missing, a
+* launch screen when stopped, a progress state while starting, and the editor
+* in a full-bleed, auto-authenticated iframe once running.
+*
+* The connection is assumed already authorized with devframe's auth, so the
+* server-issued session cookie is applied transparently before the iframe
+* loads — the user never sees code-server's login page.
+*/
+async function mountCodeServer(container, options = {}) {
+	const rpc = options.rpc ?? await connectDevframe();
+	if (rpc.connectionMeta.backend === "websocket") await rpc.ensureTrusted(5e3).catch(() => {});
+	let detection = {
+		checked: false,
+		installed: false,
+		bin: "code-server"
+	};
+	let server = { status: "stopped" };
+	let auth;
+	let busy = false;
+	let disposed = false;
+	const view = createCodeServerView(container, { actions: {
+		launch,
+		recheck
+	} });
+	function sync() {
+		if (disposed) return;
+		view.update({
+			detection,
+			server,
+			auth,
+			busy
+		});
+	}
+	function applyResult(result) {
+		detection = result.detection;
+		server = result.server;
+		if (result.auth) auth = result.auth;
+	}
+	async function call(method, ...args) {
+		try {
+			return await rpc.call(method, ...args);
+		} catch (error) {
+			server = {
+				status: "error",
+				error: error instanceof Error ? error.message : String(error)
+			};
+			return;
+		}
+	}
+	async function launch() {
+		if (busy) return;
+		busy = true;
+		sync();
+		const result = await call("devframes-plugin-code-server:start", {});
+		if (result) applyResult(result);
+		busy = false;
+		sync();
+	}
+	async function stop() {
+		if (busy) return;
+		busy = true;
+		sync();
+		const result = await call("devframes-plugin-code-server:stop");
+		if (result) applyResult(result);
+		auth = void 0;
+		busy = false;
+		sync();
+	}
+	async function recheck() {
+		if (busy) return;
+		busy = true;
+		sync();
+		await call("devframes-plugin-code-server:detect");
+		busy = false;
+		sync();
+	}
+	sync();
+	const initial = await call("devframes-plugin-code-server:status");
+	if (initial) applyResult(initial);
+	sync();
+	const state = await rpc.sharedState.get(STATE_KEY, { initialValue: {
+		detection,
+		server
+	} });
+	const current = state.value();
+	detection = current.detection ?? detection;
+	server = current.server ?? server;
+	const off = state.on("updated", (full) => {
+		detection = full.detection ?? detection;
+		server = full.server ?? server;
+		if (server.status === "running" && !auth) {
+			call("devframes-plugin-code-server:status").then((result) => {
+				if (result?.auth) auth = result.auth;
+				sync();
+			});
+			return;
+		}
+		sync();
+	});
+	sync();
+	return {
+		rpc,
+		stop,
+		dispose() {
+			disposed = true;
+			off?.();
+			view.dispose();
+		}
+	};
+}
+//#endregion
+export { STATE_KEY, createCodeServerView, mountCodeServer, resolvePhase };

package/dist/constants-ICLvdiRe.d.mts

@@ -0,0 +1,36 @@
+//#region src/constants.d.ts
+/** Stable devframe id for the code-server plugin. */
+declare const PLUGIN_ID = "devframes-plugin-code-server";
+/**
+ * Shared-state key holding the serializable, secret-free server status and
+ * detection result. The authentication cookie is never published here — it
+ * is returned only from the `start` / `status` RPCs to the already-authorized
+ * client (see {@link CodeServerAuth}).
+ */
+declare const STATE_KEY = "devframes-plugin-code-server:state";
+/** Default dev-server port for the plugin's own launcher SPA (standalone CLI). */
+declare const DEFAULT_PORT = 9013;
+/** Preferred port for the spawned code-server process (falls back if taken). */
+declare const DEFAULT_CODE_SERVER_PORT = 8080;
+/** How long to wait for code-server to answer its `/healthz` probe. */
+declare const DEFAULT_START_TIMEOUT = 30000;
+/** code-server's session cookie base name (see `getCookieSessionName`). */
+declare const SESSION_COOKIE_BASE = "code-server-session";
+/**
+ * Title for the read-only terminal session surfaced when the plugin is mounted
+ * in a hub (`ctx.terminals`). Mirrors the plugin's own name.
+ */
+declare const TERMINAL_SESSION_TITLE = "Code Server";
+/**
+ * Icon for that terminal session. Mirrors the plugin's declared icon so the
+ * hub's terminals panel shows the same glyph as the rest of the plugin.
+ */
+declare const TERMINAL_SESSION_ICON = "ph:code-duotone";
+/**
+ * Compute code-server's session cookie name for an optional `--cookie-suffix`.
+ * Mirrors code-server's own `getCookieSessionName` so the client sets the
+ * exact cookie the server reads.
+ */
+declare function getCookieSessionName(suffix?: string): string;
+//#endregion
+export { SESSION_COOKIE_BASE as a, TERMINAL_SESSION_TITLE as c, PLUGIN_ID as i, getCookieSessionName as l, DEFAULT_PORT as n, STATE_KEY as o, DEFAULT_START_TIMEOUT as r, TERMINAL_SESSION_ICON as s, DEFAULT_CODE_SERVER_PORT as t };

package/dist/constants.d.mts

@@ -0,0 +1,2 @@
+import { a as SESSION_COOKIE_BASE, c as TERMINAL_SESSION_TITLE, i as PLUGIN_ID, l as getCookieSessionName, n as DEFAULT_PORT, o as STATE_KEY, r as DEFAULT_START_TIMEOUT, s as TERMINAL_SESSION_ICON, t as DEFAULT_CODE_SERVER_PORT } from "./constants-ICLvdiRe.mjs";
+export { DEFAULT_CODE_SERVER_PORT, DEFAULT_PORT, DEFAULT_START_TIMEOUT, PLUGIN_ID, SESSION_COOKIE_BASE, STATE_KEY, TERMINAL_SESSION_ICON, TERMINAL_SESSION_TITLE, getCookieSessionName };

package/dist/constants.mjs

@@ -0,0 +1,38 @@
+//#region src/constants.ts
+/** Stable devframe id for the code-server plugin. */
+const PLUGIN_ID = "devframes-plugin-code-server";
+/**
+* Shared-state key holding the serializable, secret-free server status and
+* detection result. The authentication cookie is never published here — it
+* is returned only from the `start` / `status` RPCs to the already-authorized
+* client (see {@link CodeServerAuth}).
+*/
+const STATE_KEY = "devframes-plugin-code-server:state";
+/** Default dev-server port for the plugin's own launcher SPA (standalone CLI). */
+const DEFAULT_PORT = 9013;
+/** Preferred port for the spawned code-server process (falls back if taken). */
+const DEFAULT_CODE_SERVER_PORT = 8080;
+/** How long to wait for code-server to answer its `/healthz` probe. */
+const DEFAULT_START_TIMEOUT = 3e4;
+/** code-server's session cookie base name (see `getCookieSessionName`). */
+const SESSION_COOKIE_BASE = "code-server-session";
+/**
+* Title for the read-only terminal session surfaced when the plugin is mounted
+* in a hub (`ctx.terminals`). Mirrors the plugin's own name.
+*/
+const TERMINAL_SESSION_TITLE = "Code Server";
+/**
+* Icon for that terminal session. Mirrors the plugin's declared icon so the
+* hub's terminals panel shows the same glyph as the rest of the plugin.
+*/
+const TERMINAL_SESSION_ICON = "ph:code-duotone";
+/**
+* Compute code-server's session cookie name for an optional `--cookie-suffix`.
+* Mirrors code-server's own `getCookieSessionName` so the client sets the
+* exact cookie the server reads.
+*/
+function getCookieSessionName(suffix) {
+	return suffix ? `${SESSION_COOKIE_BASE}-${suffix.replace(/[^a-z0-9-]/gi, "-")}` : SESSION_COOKIE_BASE;
+}
+//#endregion
+export { DEFAULT_CODE_SERVER_PORT, DEFAULT_PORT, DEFAULT_START_TIMEOUT, PLUGIN_ID, SESSION_COOKIE_BASE, STATE_KEY, TERMINAL_SESSION_ICON, TERMINAL_SESSION_TITLE, getCookieSessionName };