@trebired/code-server-kit 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## Unreleased
+
+- nothing yet
+
+## 0.3.0
+
+- expand the package from launch planning into a full generic `code-server` session runtime
+- add session lifecycle APIs for start, stop, restart, status, diagnostics, and session-manager creation
+- add Linux-first transient systemd helpers and launch-command builders
+- add disk-backed session metadata, reuse checks, profile restore and persist hooks, and richer startup diagnostics
+- add `@trebired/logger-adapter` support across the higher-level APIs
+
+## 0.2.0
+
+- add `createCodeServerLaunchPlan()` as the main higher-level launch planning API
+- add generic launch spec, command formatting, and startup failure normalization helpers
+- add readiness probe support and broader structured error coverage
+- add generic allowlisted profile sync helpers for `code-server` user data and extensions
+- add reverse-proxy helpers for forwarded headers, trusted origins, and HTML response detection
+
 ## 0.1.0
 
 - Initial release

package/README.md

@@ -1,18 +1,17 @@
 # @trebired/code-server-kit
 
-Framework-agnostic `code-server` launch planning for Node.js applications.
+Framework-agnostic `code-server` session runtime for Node.js applications.
 
-`@trebired/code-server-kit` gives your app a small, typed layer for finding an installed `code-server`, building a stable launch command, waiting for readiness, and optionally spawning the process without leaking `code-server` package layout details into product code.
+`@trebired/code-server-kit` is the generic Trebired package for owning the full `code-server` lifecycle on Linux-first hosts:
 
-The package stays in one lane:
+- resolve the installed `code-server`
+- build launch plans and sandbox-friendly execution specs
+- restore and persist allowlisted profile data
+- launch directly or through transient systemd services
+- supervise readiness and startup failures
+- reuse, stop, restart, and inspect sessions with structured metadata
 
-- resolve the installed `code-server` package root and launch entrypoint
-- build standard `code-server` CLI args for host-managed sessions
-- expose the launch command and args for your own sandbox or supervisor
-- optionally spawn the process and capture stdout and stderr
-- wait for the TCP port to become ready with timeout and early-exit handling
-
-It does not try to be a `code-server` fork, a sandbox manager, a container runtime, or a product layer with app-specific routes and filesystem rules.
+The package stays generic on purpose. It does not know about products, repositories, organizations, users, routes, or app-specific filesystem conventions.
 
 ## Install
 
@@ -22,138 +21,375 @@ Runtime target: Node.js 22+ on Linux first.
 npm install @trebired/code-server-kit code-server
 ```
 
+## What Host Apps Still Provide
+
+After the session runtime layer is in place, host applications mostly choose policy:
+
+- `sessionKey`
+- `stateRoot`
+- `workspacePath`
+- `trustedOrigins`
+- `launchStrategy`
+- systemd `scope` when using systemd
+- optional profile roots
+- optional logging and policy hooks
+
+The package owns the generic mechanics:
+
+- installation resolution
+- entrypoint resolution
+- `node <entry.js>` vs direct executable launch
+- runtime profile directory defaults
+- direct launch vs systemd launch translation
+- readiness probing
+- session reuse checks
+- session metadata persistence
+- startup diagnostics normalization
+
 ## Quick Start
 
 ```ts
 import {
-  createCodeServerLaunch,
-  launchCodeServerProcess,
-  resolveCodeServerInstallation,
-  waitForCodeServerReady,
+  createCodeServerSessionManager,
 } from "@trebired/code-server-kit";
 
-const installation = resolveCodeServerInstallation({
-  resolveFrom: process.cwd(),
+const sessions = createCodeServerSessionManager({
+  logger: console,
 });
 
-const launch = await createCodeServerLaunch({
-  installation,
-  dataRoot: "/srv/code-server/session-42",
-  host: "127.0.0.1",
-  port: 8080,
+const started = await sessions.start({
+  launchStrategy: "direct",
+  sessionKey: "workspace-42",
+  stateRoot: "/srv/code-server-state",
   trustedOrigins: [
     "https://app.example.com",
   ],
   workspacePath: "/srv/workspaces/demo",
 });
 
-const processHandle = await launchCodeServerProcess({
-  plan: launch,
-  stdout(text) {
-    process.stdout.write(text);
-  },
-  stderr(text) {
-    process.stderr.write(text);
-  },
+console.log(started.status.state, started.status.port);
+
+const status = await sessions.getStatus({
+  sessionKey: "workspace-42",
+  stateRoot: "/srv/code-server-state",
 });
 
-await waitForCodeServerReady({
-  host: launch.host,
-  port: launch.port,
-  process: processHandle,
-  timeoutMs: 30_000,
+console.log(status?.ready);
+
+await sessions.stop({
+  sessionKey: "workspace-42",
+  stateRoot: "/srv/code-server-state",
 });
 ```
 
-## Public API
+## Main Session APIs
+
+### `createCodeServerSessionManager(options?)`
+
+Creates the main high-level lifecycle object and wires logging through `@trebired/logger-adapter`.
+
+Manager methods:
+
+- `start(options)`
+- `stop(options)`
+- `restart(options)`
+- `getStatus(options)`
+- `readDiagnostics(options)`
+
+### `startCodeServerSession(options)`
+
+One-shot helper that creates a manager and starts a session.
+
+Lifecycle-managed session APIs require:
+
+- `sessionKey`
+- `stateRoot`
+
+Defaults:
+
+- `launchStrategy` defaults to `"direct"`
+- reuse defaults to exact normalized spec match
+- `dataRoot` defaults to `stateRoot/sessions/<sessionKey>/runtime`
+- systemd never defaults its scope
+
+### `stopCodeServerSession(options)`
+
+Stops a direct child process or a systemd transient unit using the stored session metadata. If profile persistence is configured, the package persists allowlisted profile items after stop.
+
+### `restartCodeServerSession(options)`
+
+Runs stop then start with the same session request shape.
+
+### `getCodeServerSessionStatus(options)`
+
+Loads the package-owned session record and re-probes the live backing resource instead of trusting disk alone.
+
+### `readCodeServerSessionDiagnostics(options)`
+
+Reads the persisted diagnostics snapshot for a session.
+
+## Session Metadata
+
+The package stores generic lifecycle metadata under:
+
+- `<stateRoot>/sessions/<safe-session-key>/session.json`
+- `<stateRoot>/sessions/<safe-session-key>/diagnostics.json`
+
+The session record tracks values such as:
+
+- `state`
+- `launchStrategy`
+- `specHash`
+- `bindAddr`
+- `port`
+- `userDataDir`
+- `extensionsDir`
+- `workspacePath`
+- `pid` for direct launches
+- `unitName` and `systemdScope` for systemd launches
+- timestamps and normalized failure details
+
+This disk-backed record is what allows the package to reuse, stop, restart, and inspect sessions across calls.
+
+## Reuse Model
+
+The package builds a normalized session spec from the effective launch plan plus lifecycle-relevant inputs such as:
+
+- launch strategy
+- workspace path
+- trusted origins
+- env overrides
+- profile restore and persist configuration
+- systemd scope and unit naming
+
+That normalized spec is hashed and stored. Reuse only happens when:
+
+- the same `sessionKey` is used
+- the spec hash matches exactly
+- the backing process or unit still exists
+- the target port becomes ready again
+
+If the hash changes, the package marks the old record stale, stops the old runtime when needed, and starts a fresh session.
+
+## Launch Planning APIs
+
+The lower-level launch planning APIs remain available for callers that want policy ownership while still avoiding `code-server` package-layout details.
 
 ### `resolveCodeServerInstallation(options?)`
 
-Resolves the installed `code-server` package from a caller-controlled starting path and returns:
+Returns installation metadata:
 
 - `packageRoot`
 - `packageJsonPath`
 - `entryPoint`
+- `entryRelativePath`
 - `entryKind`
 - `supportRoot`
 - `version`
 
-### `createCodeServerLaunch(options)`
+### `createCodeServerLaunchPlan(options)`
 
-Builds a stable launch plan and returns:
+Returns a structured launch plan with:
 
 - `command`
 - `args`
-- `codeServerPackageRoot`
-- `supportRoot`
-- `userDataDir`
-- `extensionsDir`
+- `cwd`
+- `env`
+- `entryKind`
+- `launchMode`
+- `installation`
 - `bindAddr`
 - `host`
 - `port`
+- `supportRoot`
+- `supportBindings`
+- `recommendedReadablePaths`
+- `recommendedWritablePaths`
+- `userDataDir`
+- `extensionsDir`
 - `workspacePath`
 
-If you pass `dataRoot`, the package derives:
+### `createCodeServerLaunchSpec(plan)`
 
-- `${dataRoot}/user-data`
-- `${dataRoot}/extensions`
+Converts the launch plan into an execution-oriented shape:
 
-If you omit `port` or pass `0`, the package allocates a free TCP port first.
+- `command`
+- `args`
+- `cwd`
+- `env`
+- `bindings`
+- `readablePaths`
+- `writablePaths`
 
-### `waitForCodeServerReady(options)`
+This is useful when a host wants to feed the same plan into a container, custom sandbox, or generated unit file.
 
-Polls the target TCP port until it accepts connections or fails with:
+## Direct Launch
 
-- `CodeServerProcessExitedBeforeReadyError`
-- `CodeServerStartupTimeoutError`
+Use the built-in child-process helper when you want a plain process owned by the current Node.js runtime.
 
-### `launchCodeServerProcess(options)`
+```ts
+import {
+  createCodeServerLaunchPlan,
+  launchCodeServerProcess,
+  waitForCodeServerReady,
+} from "@trebired/code-server-kit";
 
-Starts the resolved command directly with `stdout` and `stderr` hooks and returns a typed handle with:
+const plan = await createCodeServerLaunchPlan({
+  dataRoot: "/srv/code-server/session-42",
+  workspacePath: "/srv/workspaces/demo",
+});
 
-- `child`
-- `pid`
-- `exit`
-- `kill()`
-- `getStdout()`
-- `getStderr()`
+const handle = await launchCodeServerProcess({ plan });
 
-## Launch Modes
+await waitForCodeServerReady({
+  host: plan.host,
+  port: plan.port,
+  process: handle,
+});
+```
+
+The lifecycle manager uses this same lower-level path internally for `launchStrategy: "direct"`.
+
+## Systemd Launch
+
+Linux systemd support is built into the same package and stays explicit.
+
+Use `launchStrategy: "systemd"` only when you also provide:
+
+- `systemd.scope: "user"` or `"system"`
+
+The package uses transient services through `systemd-run`, not scopes.
 
-`createCodeServerLaunch()` supports two concrete launch modes:
+Relevant APIs:
 
-- `node`, which runs `node <entrypoint> ...`
-- `direct`, which runs the resolved entrypoint directly when it is executable
+- `launchCodeServerWithSystemd(options)`
+- `stopCodeServerSystemdUnit(options)`
+- `readCodeServerSystemdStatus(options)`
+- `readCodeServerSystemdJournal(options)`
+- `createCodeServerSystemdLaunchCommand(options)`
+- `buildSystemdPathProperties(spec)`
 
-`auto` is the default. It prefers `node` for JS entry files and `direct` for non-JS executables.
+The systemd translation layer derives:
 
-## Standard CLI Args
+- `--unit`
+- `--working-directory`
+- `--setenv`
+- `BindPaths`
+- `BindReadOnlyPaths`
+- `ReadOnlyPaths`
+- `ReadWritePaths`
 
-The launch plan always includes:
+That means host applications do not need to rebuild transient unit arguments from raw launch-plan data themselves.
 
-- `--auth none`
-- `--bind-addr`
-- `--disable-telemetry`
-- `--disable-update-check`
-- `--disable-workspace-trust`
-- `--disable-getting-started-override`
-- `--user-data-dir`
-- `--extensions-dir`
+## Profile Restore And Persist
 
-Trusted origins are appended with repeated `--trusted-origins` flags, and `workspacePath` is appended as the positional workspace/folder target when provided.
+Profile sync stays allowlist-based rather than copying the entire runtime tree.
 
-## Dependency vs Peer Dependency for `code-server`
+Supported items:
 
-For an application, prefer a regular `dependency` on `code-server` when you want one installed runtime and want `@trebired/code-server-kit` to resolve the same package reliably every time.
+- `settings.json`
+- `extensions.json`
+- `keybindings.json`
+- `snippets`
+- `extensions`
 
-For a wrapper library on top of this package, prefer a `peerDependency` on `code-server` when the host application must choose the exact `code-server` version and install location itself. In that setup, document that `code-server` must still be resolvable from the host application's dependency tree, and pass `resolveFrom` when you need to anchor resolution to the host side explicitly.
+Lower-level helpers:
 
-## Error Types
+- `createCodeServerProfileSyncPlan(options)`
+- `syncCodeServerProfile(options)`
+- `resolveCodeServerProfilePathMap(overrides?)`
 
-The package exposes structured errors for the failure modes that usually matter in integration code:
+Lifecycle integration:
 
-- `CodeServerBinaryNotFoundError`
-- `CodeServerPackageResolutionError`
+- restore before launch with `profile.restoreFrom`
+- persist after stop with `profile.persistTo`
+- skip missing or unreadable sources cleanly by default
+
+Example:
+
+```ts
+await sessions.start({
+  profile: {
+    items: ["settings.json", "keybindings.json", "extensions"],
+    persistTo: "/srv/profiles/demo",
+    restoreFrom: "/srv/profiles/demo",
+  },
+  sessionKey: "workspace-42",
+  stateRoot: "/srv/code-server-state",
+  workspacePath: "/srv/workspaces/demo",
+});
+```
+
+## Readiness And Failure Handling
+
+### `waitForCodeServerReady(options)`
+
+Waits for the TCP port to accept connections and can also:
+
+- fail on startup timeout
+- fail on direct-process early exit
+- fail on a caller-provided failure probe
+
+The lifecycle manager builds on this and adds strategy-aware supervision:
+
+- direct-process stdout and stderr tails
+- systemd state probing
+- systemd journal collection
+- normalized startup failure metadata
+
+## Structured Errors
+
+The package throws structured error classes so callers can log and branch on them reliably.
+
+Examples:
+
+- `CodeServerInvalidConfigurationError`
+- `CodeServerInstallationResolutionError`
+- `CodeServerEntrypointResolutionError`
+- `CodeServerLaunchPlanningError`
 - `CodeServerPortAllocationError`
-- `CodeServerProcessExitedBeforeReadyError`
 - `CodeServerStartupTimeoutError`
+- `CodeServerProcessExitedBeforeReadyError`
+- `CodeServerSessionLifecycleError`
+- `CodeServerSessionReuseConflictError`
+- `CodeServerSystemdLaunchError`
+- `CodeServerSystemdCollisionError`
+- `CodeServerSystemdStatusError`
+- `CodeServerSystemdJournalError`
+
+Use `normalizeCodeServerStartupFailure(error)` when you want one tagged object shape for logs or API responses.
+
+## Reverse Proxy Helpers
+
+The package also includes a few small generic embedding helpers:
+
+- `buildForwardedHeaders(options)`
+- `normalizeTrustedOrigin(value)`
+- `isCodeServerHtmlResponse(options)`
+
+These helpers stay intentionally small. They do not add product-specific route rewriting.
+
+## Logging
+
+High-level APIs accept:
+
+- `logger`
+- `loggerAdapter`
+
+The package resolves those through `@trebired/logger-adapter`, matching the style used by other `@trebired/*` packages. `createCodeServerSessionManager()` also emits `logPackageInitialized()` on creation.
+
+## `code-server`: Dependency vs Peer Dependency
+
+Use `code-server` as a normal `dependency` when:
+
+- this package is part of an application deployment
+- you want the runtime to own the exact installed `code-server`
+- you want installation resolution to succeed without extra host setup
+
+Use `code-server` as a `peerDependency` in your own higher-level package when:
+
+- your package wraps `@trebired/code-server-kit`
+- the final host application should choose the `code-server` version
+- you want to avoid forcing duplicate `code-server` installs across wrappers
+
+`@trebired/code-server-kit` itself depends on `code-server` because the generic runtime layer needs a predictable package to resolve.

package/dist/errors.d.ts

@@ -1,13 +1,19 @@
-type CodeServerKitErrorCode = "binary_not_found" | "package_resolution_failed" | "port_allocation_failed" | "process_exited_before_ready" | "startup_timeout";
+type CodeServerKitErrorCode = "entrypoint_resolution_failed" | "installation_resolution_failed" | "invalid_configuration" | "launch_planning_failed" | "port_allocation_failed" | "process_exited_before_ready" | "session_lifecycle_failed" | "session_reuse_conflict" | "startup_probe_failed" | "startup_timeout" | "systemd_collision" | "systemd_journal_failed" | "systemd_launch_failed" | "systemd_status_failed";
 declare class CodeServerKitError extends Error {
     code: CodeServerKitErrorCode | string;
     details: Record<string, unknown>;
     constructor(code: CodeServerKitErrorCode | string, message: string, details?: Record<string, unknown>);
 }
-declare class CodeServerBinaryNotFoundError extends CodeServerKitError {
+declare class CodeServerInstallationResolutionError extends CodeServerKitError {
     constructor(message: string, details?: Record<string, unknown>);
 }
-declare class CodeServerPackageResolutionError extends CodeServerKitError {
+declare class CodeServerEntrypointResolutionError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerLaunchPlanningError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerInvalidConfigurationError extends CodeServerKitError {
     constructor(message: string, details?: Record<string, unknown>);
 }
 declare class CodeServerPortAllocationError extends CodeServerKitError {
@@ -19,7 +25,34 @@ declare class CodeServerProcessExitedBeforeReadyError extends CodeServerKitError
 declare class CodeServerStartupTimeoutError extends CodeServerKitError {
     constructor(message: string, details?: Record<string, unknown>);
 }
+declare class CodeServerStartupProbeError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSessionLifecycleError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSessionReuseConflictError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSystemdLaunchError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSystemdCollisionError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSystemdStatusError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSystemdJournalError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerPackageResolutionError extends CodeServerInstallationResolutionError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerBinaryNotFoundError extends CodeServerEntrypointResolutionError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
 declare function isCodeServerKitError(value: unknown): value is CodeServerKitError;
-export { CodeServerBinaryNotFoundError, CodeServerKitError, CodeServerPackageResolutionError, CodeServerPortAllocationError, CodeServerProcessExitedBeforeReadyError, CodeServerStartupTimeoutError, isCodeServerKitError, };
+export { CodeServerBinaryNotFoundError, CodeServerEntrypointResolutionError, CodeServerInstallationResolutionError, CodeServerInvalidConfigurationError, CodeServerKitError, CodeServerLaunchPlanningError, CodeServerPackageResolutionError, CodeServerPortAllocationError, CodeServerProcessExitedBeforeReadyError, CodeServerSessionLifecycleError, CodeServerSessionReuseConflictError, CodeServerStartupProbeError, CodeServerStartupTimeoutError, CodeServerSystemdCollisionError, CodeServerSystemdJournalError, CodeServerSystemdLaunchError, CodeServerSystemdStatusError, isCodeServerKitError, };
 export type { CodeServerKitErrorCode };
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,KAAK,sBAAsB,GACvB,kBAAkB,GAClB,2BAA2B,GAC3B,wBAAwB,GACxB,6BAA6B,GAC7B,iBAAiB,CAAC;AAEtB,cAAM,kBAAmB,SAAQ,KAAK;IACpC,IAAI,EAAE,sBAAsB,GAAG,MAAM,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAErB,IAAI,EAAE,sBAAsB,GAAG,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAM1G;AAED,cAAM,6BAA8B,SAAQ,kBAAkB;gBAChD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,gCAAiC,SAAQ,kBAAkB;gBACnD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,6BAA8B,SAAQ,kBAAkB;gBAChD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,uCAAwC,SAAQ,kBAAkB;gBAC1D,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,6BAA8B,SAAQ,kBAAkB;gBAChD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,iBAAS,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEzE;AAED,OAAO,EACL,6BAA6B,EAC7B,kBAAkB,EAClB,gCAAgC,EAChC,6BAA6B,EAC7B,uCAAuC,EACvC,6BAA6B,EAC7B,oBAAoB,GACrB,CAAC;AACF,YAAY,EAAE,sBAAsB,EAAE,CAAC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/errors.js

@@ -6,16 +6,28 @@ class CodeServerKitError extends Error {
         this.details = details;
     }
 }
-class CodeServerBinaryNotFoundError extends CodeServerKitError {
+class CodeServerInstallationResolutionError extends CodeServerKitError {
     constructor(message, details = {}) {
-        super("binary_not_found", message, details);
-        this.name = "CodeServerBinaryNotFoundError";
+        super("installation_resolution_failed", message, details);
+        this.name = "CodeServerInstallationResolutionError";
     }
 }
-class CodeServerPackageResolutionError extends CodeServerKitError {
+class CodeServerEntrypointResolutionError extends CodeServerKitError {
     constructor(message, details = {}) {
-        super("package_resolution_failed", message, details);
-        this.name = "CodeServerPackageResolutionError";
+        super("entrypoint_resolution_failed", message, details);
+        this.name = "CodeServerEntrypointResolutionError";
+    }
+}
+class CodeServerLaunchPlanningError extends CodeServerKitError {
+    constructor(message, details = {}) {
+        super("launch_planning_failed", message, details);
+        this.name = "CodeServerLaunchPlanningError";
+    }
+}
+class CodeServerInvalidConfigurationError extends CodeServerKitError {
+    constructor(message, details = {}) {
+        super("invalid_configuration", message, details);
+        this.name = "CodeServerInvalidConfigurationError";
     }
 }
 class CodeServerPortAllocationError extends CodeServerKitError {
@@ -36,8 +48,62 @@ class CodeServerStartupTimeoutError extends CodeServerKitError {
         this.name = "CodeServerStartupTimeoutError";
     }
 }
+class CodeServerStartupProbeError extends CodeServerKitError {
+    constructor(message, details = {}) {
+        super("startup_probe_failed", message, details);
+        this.name = "CodeServerStartupProbeError";
+    }
+}
+class CodeServerSessionLifecycleError extends CodeServerKitError {
+    constructor(message, details = {}) {
+        super("session_lifecycle_failed", message, details);
+        this.name = "CodeServerSessionLifecycleError";
+    }
+}
+class CodeServerSessionReuseConflictError extends CodeServerKitError {
+    constructor(message, details = {}) {
+        super("session_reuse_conflict", message, details);
+        this.name = "CodeServerSessionReuseConflictError";
+    }
+}
+class CodeServerSystemdLaunchError extends CodeServerKitError {
+    constructor(message, details = {}) {
+        super("systemd_launch_failed", message, details);
+        this.name = "CodeServerSystemdLaunchError";
+    }
+}
+class CodeServerSystemdCollisionError extends CodeServerKitError {
+    constructor(message, details = {}) {
+        super("systemd_collision", message, details);
+        this.name = "CodeServerSystemdCollisionError";
+    }
+}
+class CodeServerSystemdStatusError extends CodeServerKitError {
+    constructor(message, details = {}) {
+        super("systemd_status_failed", message, details);
+        this.name = "CodeServerSystemdStatusError";
+    }
+}
+class CodeServerSystemdJournalError extends CodeServerKitError {
+    constructor(message, details = {}) {
+        super("systemd_journal_failed", message, details);
+        this.name = "CodeServerSystemdJournalError";
+    }
+}
+class CodeServerPackageResolutionError extends CodeServerInstallationResolutionError {
+    constructor(message, details = {}) {
+        super(message, details);
+        this.name = "CodeServerPackageResolutionError";
+    }
+}
+class CodeServerBinaryNotFoundError extends CodeServerEntrypointResolutionError {
+    constructor(message, details = {}) {
+        super(message, details);
+        this.name = "CodeServerBinaryNotFoundError";
+    }
+}
 function isCodeServerKitError(value) {
     return value instanceof CodeServerKitError;
 }
-export { CodeServerBinaryNotFoundError, CodeServerKitError, CodeServerPackageResolutionError, CodeServerPortAllocationError, CodeServerProcessExitedBeforeReadyError, CodeServerStartupTimeoutError, isCodeServerKitError, };
+export { CodeServerBinaryNotFoundError, CodeServerEntrypointResolutionError, CodeServerInstallationResolutionError, CodeServerInvalidConfigurationError, CodeServerKitError, CodeServerLaunchPlanningError, CodeServerPackageResolutionError, CodeServerPortAllocationError, CodeServerProcessExitedBeforeReadyError, CodeServerSessionLifecycleError, CodeServerSessionReuseConflictError, CodeServerStartupProbeError, CodeServerStartupTimeoutError, CodeServerSystemdCollisionError, CodeServerSystemdJournalError, CodeServerSystemdLaunchError, CodeServerSystemdStatusError, isCodeServerKitError, };
 //# sourceMappingURL=errors.js.map