@devframes/plugin-code-server 0.7.5 → 0.7.6

package/dist/constants.d.mts

@@ -1,2 +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-DZKOXnxd.mjs";
+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-DtQz38ex.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

@@ -3,16 +3,16 @@
 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}).
+* detection result. Authentication material is never published here — it is
+* returned only from the `start` / `status` RPCs to the already-authorized
+* client (see {@link import('./types').CodeServerConnect}).
 */
 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). */
+/** Preferred port for the spawned editor process (falls back if taken). */
 const DEFAULT_CODE_SERVER_PORT = 8080;
-/** How long to wait for code-server to answer its `/healthz` probe. */
+/** How long to wait for the editor to answer its readiness probe. */
 const DEFAULT_START_TIMEOUT = 3e4;
 /** code-server's session cookie base name (see `getCookieSessionName`). */
 const SESSION_COOKIE_BASE = "code-server-session";

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-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-DZKOXnxd.mjs";
+import { CodeServerBackend, CodeServerConnect, CodeServerDetection, CodeServerLogin, CodeServerMode, CodeServerOptions, CodeServerServerInfo, CodeServerSharedState, CodeServerStartRequest, CodeServerStartResult, CodeServerStatus, CodeServerStatusResult, CodeServerTunnelOptions } 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-DtQz38ex.mjs";
 import { DevframeDefinition } from "devframe/types";
 //#region src/index.d.ts
 /**
@@ -22,4 +22,4 @@ declare function createCodeServerDevframe(options?: CodeServerOptions): Devframe
 /** Default-configured code-server devframe. */
 declare const codeServer: DevframeDefinition;
 //#endregion
-export { type CodeServerAuth, type CodeServerDetection, type CodeServerOptions, type CodeServerServerInfo, type CodeServerSharedState, type CodeServerStartRequest, type CodeServerStartResult, type CodeServerStatus, type CodeServerStatusResult, DEFAULT_CODE_SERVER_PORT, DEFAULT_PORT, PLUGIN_ID, STATE_KEY, createCodeServerDevframe, codeServer as default, getCookieSessionName };
+export { type CodeServerBackend, type CodeServerConnect, type CodeServerDetection, type CodeServerLogin, type CodeServerMode, type CodeServerOptions, type CodeServerServerInfo, type CodeServerSharedState, type CodeServerStartRequest, type CodeServerStartResult, type CodeServerStatus, type CodeServerStatusResult, type CodeServerTunnelOptions, DEFAULT_CODE_SERVER_PORT, DEFAULT_PORT, PLUGIN_ID, STATE_KEY, createCodeServerDevframe, codeServer as default, getCookieSessionName };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { n as createCodeServerDevframe, t as codeServer } from "./src-CjjdHGFH.mjs";
+import { n as createCodeServerDevframe, t as codeServer } from "./src-EUgoe7om.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

@@ -1,34 +1,49 @@
-import { CodeServerDetection, CodeServerOptions, CodeServerStartRequest, CodeServerStartResult, CodeServerStatusResult } from "../types.mjs";
+import { CodeServerBackend, CodeServerConnect, CodeServerDetection, CodeServerLogin, CodeServerMode, CodeServerOptions, CodeServerStartRequest, CodeServerStartResult, CodeServerStatusResult } from "../types.mjs";
 import { DevframeNodeContext } from "devframe/types";
 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.
+ * 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.
  */
 declare class CodeServerSupervisor {
   private readonly ctx;
-  private readonly bin;
+  private readonly mode;
+  private readonly explicitBackend?;
+  private readonly explicitBin?;
   private readonly workspace;
   private readonly host;
   private readonly forcedPort?;
   private readonly extraArgs;
   private readonly extraEnv;
-  private readonly cookieName;
   private readonly cookieSuffix?;
+  private readonly cookieName;
   private readonly startTimeout;
+  private readonly reuseExistingServer;
+  private readonly tunnelName;
+  /** Resolved after the first detection. */
+  private backend;
+  private bin;
+  private profile;
   private state?;
   private detection;
   private server;
   private proc?;
-  private cookieValue?;
+  /** Context of the live launch, used to compute the client connect descriptor. */
+  private launchCtx?;
+  /** Whether the running server was adopted (reused) rather than launched. */
+  private adopted;
+  /** Captured `vscode.dev` URL for a running tunnel. */
+  private readyUrl?;
   private logBuffer;
-  private cleanupRegistered;
+  private exitHandler?;
   /** Stable id of the hub terminal session, reused across start/stop. */
   private readonly sessionId;
   /** The live hub terminal session when launched through `ctx.terminals`. */
@@ -36,21 +51,41 @@ declare class CodeServerSupervisor {
   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. */
+  /**
+   * 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.
+   */
   detect(): Promise<CodeServerDetection>;
-  /** Current status (+ auth when running) for the launcher UI. */
+  /** Current status (+ connect info 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.
+   * 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.
    */
   start(req?: CodeServerStartRequest): Promise<CodeServerStartResult>;
-  /** Stop the code-server process and reset to `stopped`. */
+  /** Stop the editor process and reset to `stopped`. */
   stop(): CodeServerStatusResult;
   /** Kill the process on host shutdown / test teardown. */
   dispose(): void;
-  private authInfo;
+  /** Resolved backend for tests / callers. */
+  get resolvedBackend(): CodeServerBackend;
+  private setResolved;
+  private baseCtx;
+  /** Clear per-launch process state (keeps `server`/`detection`). */
+  private reset;
+  /**
+   * 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).
+   */
+  private awaitTunnel;
+  private connectInfo;
   private terminate;
   /**
    * Resolve the hub's terminals subsystem when this devframe is mounted in a
@@ -62,24 +97,78 @@ declare class CodeServerSupervisor {
   /** 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.
+   * 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.
    */
   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.
+   * Poll the server's readiness path until it responds or the timeout elapses.
+   * Returns false if the process exits first.
    */
   private waitForReady;
   private registerCleanup;
 }
 //#endregion
+//#region src/node/backends.d.ts
+/**
+ * The internal launch profile the supervisor drives. One of three "kinds":
+ * the two local {@link CodeServerBackend}s plus the `code tunnel` profile
+ * selected by `mode: 'tunnel'`. Each profile owns the backend-specific pieces
+ * — binary, arguments, auth env, readiness detection, and how the client
+ * ultimately reaches the editor — while the supervisor owns the shared
+ * spawn / log / publish lifecycle.
+ */
+type CodeServerProfileKind = 'code-server' | 'serve-web' | 'tunnel';
+/** Everything a profile needs to build a launch and the client's connect info. */
+interface ProfileContext {
+  host: string;
+  /** Resolved local port (0 until dynamically allocated). Unused by tunnel. */
+  port: number;
+  folder: string;
+  /** Fresh per-launch secret (session token / connection token). */
+  secret: string;
+  /** Session cookie name for the `code-server` backend. */
+  cookieName: string;
+  extraArgs: string[];
+  /** Machine name for the tunnel profile. */
+  tunnelName: string;
+}
+interface CodeServerProfile {
+  kind: CodeServerProfileKind;
+  /** Public backend id (tunnel reports `ms-code-serve-web`'s sibling `code` binary). */
+  backend: CodeServerBackend;
+  /** Default binary when the caller doesn't override `bin`. */
+  defaultBin: string;
+  /** Build the argv passed to the binary. */
+  buildArgs: (c: ProfileContext) => string[];
+  /** Merge auth material into the child environment. */
+  buildEnv: (c: ProfileContext, base: Record<string, string>) => Record<string, string>;
+  /** Local readiness path polled over HTTP, or `null` for log-driven (tunnel). */
+  healthPath: string | null;
+  /** Parse a log line for a dynamically-bound local port. */
+  matchPort?: (line: string) => number | undefined;
+  /** Parse a log line for the tunnel's `vscode.dev` URL (marks it ready). */
+  matchReadyUrl?: (line: string) => string | undefined;
+  /** Parse a log line for a device-login prompt. */
+  matchLogin?: (line: string) => CodeServerLogin | undefined;
+  /** Compute the client connect descriptor for a freshly launched server. */
+  connect: (c: ProfileContext & {
+    readyUrl?: string;
+  }) => CodeServerConnect;
+  /** Connect descriptor for an adopted (reused) server we didn't launch. */
+  connectReused: (c: {
+    port: number;
+  }) => CodeServerConnect;
+}
+/** Resolve the launch profile for a mode + backend. */
+declare function resolveProfile(mode: CodeServerMode, backend: CodeServerBackend): CodeServerProfile;
+//#endregion
 //#region src/node/context.d.ts
 declare function setCodeServerSupervisor(ctx: DevframeNodeContext, supervisor: CodeServerSupervisor): void;
 declare function getCodeServerSupervisor(ctx: DevframeNodeContext): CodeServerSupervisor;
@@ -119,14 +208,14 @@ declare const diagnostics: import("nostics").Diagnostics<{
     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 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";
   };
   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 fix: "Check the editor logs for startup errors, raise `startTimeout`, or free the port.";
   };
   readonly DP_CODE_SERVER_0003: {
     readonly why: (p: {
@@ -144,6 +233,12 @@ declare const diagnostics: import("nostics").Diagnostics<{
     }) => string;
     readonly fix: "Inspect the captured output in the launcher and re-launch.";
   };
+  readonly DP_CODE_SERVER_0006: {
+    readonly why: (p: {
+      timeout: number;
+    }) => string;
+    readonly fix: "Check the tunnel logs, ensure the `code` CLI is signed in, or raise `startTimeout`.";
+  };
 }, readonly [typeof reporter]>;
 //#endregion
 //#region src/node/index.d.ts
@@ -158,4 +253,4 @@ declare const diagnostics: import("nostics").Diagnostics<{
  */
 declare function setupCodeServer(ctx: DevframeNodeContext, options?: CodeServerOptions): Promise<CodeServerSupervisor>;
 //#endregion
-export { CodeServerSupervisor, detectCodeServer, diagnostics, getCodeServerSupervisor, setCodeServerSupervisor, setupCodeServer };
+export { type CodeServerProfile, type CodeServerProfileKind, CodeServerSupervisor, detectCodeServer, diagnostics, getCodeServerSupervisor, resolveProfile, setCodeServerSupervisor, setupCodeServer };