@linzumi/cli 0.0.20-beta → 0.0.23-beta

package/src/localEditor.ts

@@ -1,1061 +0,0 @@
-/*
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-runner-forwarding-and-editor-plan.md
-  Relationship: Starts loopback-only code-server instances for Kandan-owned
-  local editor sessions after the runner has verified cwd permissions.
-*/
-import { spawn, type ChildProcess } from "node:child_process";
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  realpathSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, delimiter, dirname, join } from "node:path";
-import { chooseLoopbackPort } from "./codexAppServer";
-import { resolveAllowedCwd } from "./localCapabilities";
-import type { InstalledEditorRuntime } from "./localEditorRuntime";
-
-export type LocalEditorState =
-  | { readonly status: "disabled" }
-  | {
-      readonly status: "running";
-      readonly cwd: string;
-      readonly port: number;
-      readonly process: ChildProcess;
-      readonly collaboration?: RunningLocalEditorCollaboration | undefined;
-      readonly exited: Promise<void>;
-    };
-
-export type StartLocalEditorControl = {
-  readonly type: "start_local_editor";
-  readonly instanceId?: string;
-  readonly requestId?: string;
-  readonly cwd: string;
-  readonly browserBaseUrl?: string | undefined;
-  readonly collaboration?: LocalEditorCollaborationControl | undefined;
-};
-
-export type StartLocalEditorOptions = {
-  readonly codeServerBin: string | undefined;
-  readonly editorRuntime?: InstalledEditorRuntime | undefined;
-  readonly allowedCwds: readonly string[];
-  readonly currentState: LocalEditorState;
-  readonly browserBaseUrl?: string | undefined;
-  readonly runnerId?: string | undefined;
-};
-
-export type StartLocalEditorResult =
-  | {
-      readonly ok: true;
-      readonly state: LocalEditorState;
-      readonly event: {
-        readonly cwd: string;
-        readonly port: number;
-        readonly startedAt: string;
-        readonly collaboration?: LocalEditorCollaborationEvent | undefined;
-      };
-    }
-  | {
-      readonly ok: false;
-      readonly state: LocalEditorState;
-      readonly reason:
-        | "local_editor_disabled"
-        | "missing_cwd"
-        | "no_allowed_cwd"
-        | "cwd_not_allowed"
-        | "cwd_not_found"
-        | "local_editor_filesystem_sandbox_unavailable"
-        | "missing_browser_base_url"
-        | "code_server_spawn_failed";
-    };
-
-type PrepareCodeServerProfileResult =
-  | {
-      readonly ok: true;
-      readonly userDataDir: string;
-      readonly extensionsDir: string;
-      readonly collaborationServerDir: string;
-    }
-  | { readonly ok: false; readonly reason: "code_server_spawn_failed" };
-
-export type PrepareCodeServerLaunchOptions = {
-  readonly codeServerBin: string;
-  readonly codeServerRuntimeRoot?: string | undefined;
-  readonly port: number;
-  readonly cwd: string;
-  readonly userDataDir: string;
-  readonly extensionsDir?: string | undefined;
-  readonly platform?: NodeJS.Platform | undefined;
-  readonly sandboxExecBin?: string | undefined;
-  readonly bubblewrapBin?: string | undefined;
-  readonly envPath?: string | undefined;
-};
-
-export type PrepareCodeServerLaunchResult =
-  | {
-      readonly ok: true;
-      readonly command: string;
-      readonly args: readonly string[];
-    }
-  | {
-      readonly ok: false;
-      readonly reason: "local_editor_filesystem_sandbox_unavailable";
-    };
-
-export type LocalEditorCollaborationControl = {
-  readonly provider: "oct";
-  readonly editorSessionId: number;
-  readonly runtimeSessionId: string;
-  readonly roomId: string;
-  readonly extensionAssetPath: string;
-  readonly serverAssetPath: string;
-  readonly bootstrapToken?: string | undefined;
-};
-
-export type RunningLocalEditorCollaboration = {
-  readonly provider: "oct";
-  readonly editorSessionId: number;
-  readonly runtimeSessionId: string;
-  readonly roomId: string;
-  readonly serverPort: number;
-  readonly serverUrl: string;
-  readonly bootstrapServerUrl: string;
-  readonly process: ChildProcess;
-  readonly exited: Promise<void>;
-};
-
-export type LocalEditorCollaborationEvent = {
-  readonly provider: "oct";
-  readonly editorSessionId: number;
-  readonly runtimeSessionId: string;
-  readonly roomId: string;
-  readonly serverPort: number;
-  readonly serverUrl: string;
-};
-
-export function isStartLocalEditorControl(control: {
-  readonly type: string;
-}): control is StartLocalEditorControl {
-  return control.type === "start_local_editor";
-}
-
-export function localEditorCapabilities(
-  editorRuntime: InstalledEditorRuntime | undefined,
-  allowedCwds: readonly string[],
-  state: LocalEditorState,
-): {
-  readonly localEditor: boolean;
-  readonly localEditorStatus: string;
-  readonly localEditorPort?: number;
-  readonly localEditorCwd?: string;
-  readonly localEditorCollaboration?: LocalEditorCollaborationEvent;
-} {
-  const base = {
-    localEditor: editorRuntime !== undefined && allowedCwds.length > 0,
-    localEditorStatus: state.status,
-  };
-
-  return state.status === "running"
-    ? {
-        ...base,
-        localEditorPort: state.port,
-        localEditorCwd: state.cwd,
-        ...(state.collaboration === undefined
-          ? {}
-          : {
-              localEditorCollaboration:
-                collaborationEvent(state.collaboration),
-            }),
-      }
-    : base;
-}
-
-export async function startLocalEditor(
-  control: StartLocalEditorControl,
-  options: StartLocalEditorOptions,
-): Promise<StartLocalEditorResult> {
-  if (options.editorRuntime === undefined) {
-    return {
-      ok: false,
-      state: options.currentState,
-      reason: "local_editor_disabled",
-    };
-  }
-
-  const cwdDecision = resolveAllowedCwd(control.cwd, options.allowedCwds);
-
-  if (!cwdDecision.ok) {
-    return {
-      ok: false,
-      state: options.currentState,
-      reason: cwdDecision.reason,
-    };
-  }
-
-  if (
-    options.currentState.status === "running" &&
-    options.currentState.cwd === cwdDecision.cwd &&
-    sameCollaboration(options.currentState.collaboration, control.collaboration)
-  ) {
-    return {
-      ok: true,
-      state: options.currentState,
-      event: {
-        cwd: options.currentState.cwd,
-        port: options.currentState.port,
-        startedAt: new Date().toISOString(),
-        collaboration: collaborationEvent(options.currentState.collaboration),
-      },
-    };
-  }
-
-  const browserBaseUrl = localEditorBrowserBaseUrl(control, options);
-  if (control.collaboration !== undefined && browserBaseUrl === undefined) {
-    return {
-      ok: false,
-      state: options.currentState,
-      reason: "missing_browser_base_url",
-    };
-  }
-
-  const port = await chooseLoopbackPort();
-  const collaborationPort =
-    control.collaboration === undefined ? undefined : await chooseLoopbackPort();
-  const collaboration =
-    control.collaboration === undefined || browserBaseUrl === undefined
-      ? undefined
-      : prepareLocalEditorCollaboration(
-          control.collaboration,
-          options.runnerId ?? "local-runner",
-          collaborationPort,
-          browserBaseUrl,
-        );
-  const profileResult = prepareCodeServerProfile(
-    collaboration,
-    options.editorRuntime,
-  );
-
-  if (!profileResult.ok) {
-    return {
-      ok: false,
-      state: options.currentState,
-      reason: profileResult.reason,
-    };
-  }
-
-  const launchResult = prepareCodeServerLaunch({
-    codeServerBin: options.editorRuntime.codeServerBin,
-    codeServerRuntimeRoot: options.editorRuntime.root,
-    port,
-    cwd: cwdDecision.cwd,
-    userDataDir: profileResult.userDataDir,
-    extensionsDir: profileResult.extensionsDir,
-  });
-
-  if (!launchResult.ok) {
-    return {
-      ok: false,
-      state: options.currentState,
-      reason: launchResult.reason,
-    };
-  }
-
-  const collaborationResult = await startCollaborationSidecar(
-    collaboration,
-    profileResult,
-    options.editorRuntime,
-  );
-
-  if (!collaborationResult.ok) {
-    return {
-      ok: false,
-      state: options.currentState,
-      reason: "code_server_spawn_failed",
-    };
-  }
-
-  const child = spawn(launchResult.command, [...launchResult.args], {
-    cwd: cwdDecision.cwd,
-    env: codeServerEnv(
-      process.env,
-      profileResult.userDataDir,
-      collaborationResult.collaboration,
-    ),
-    stdio: ["ignore", "inherit", "inherit"],
-  });
-
-  const exited = waitForCodeServerExit(child);
-  const spawnResult = await waitForCodeServerSpawn(child);
-
-  if (spawnResult === "failed") {
-    collaborationResult.collaboration?.process.kill("SIGINT");
-    return {
-      ok: false,
-      state: options.currentState,
-      reason: "code_server_spawn_failed",
-    };
-  }
-
-  const [readyResult, collaborationReadyResult] = await Promise.all([
-    waitForCodeServerReady(port, exited),
-    collaborationResult.ready,
-  ]);
-
-  if (readyResult === "failed" || collaborationReadyResult === "failed") {
-    child.kill("SIGINT");
-    collaborationResult.collaboration?.process.kill("SIGINT");
-    return {
-      ok: false,
-      state: options.currentState,
-      reason: "code_server_spawn_failed",
-    };
-  }
-
-  if (options.currentState.status === "running") {
-    options.currentState.process.kill("SIGINT");
-    options.currentState.collaboration?.process.kill("SIGINT");
-  }
-
-  const state = {
-    status: "running" as const,
-    cwd: cwdDecision.cwd,
-    port,
-    process: child,
-    collaboration: collaborationResult.collaboration,
-    exited,
-  };
-
-  return {
-    ok: true,
-    state,
-    event: {
-      cwd: cwdDecision.cwd,
-      port,
-      startedAt: new Date().toISOString(),
-      collaboration: collaborationEvent(collaborationResult.collaboration),
-    },
-  };
-}
-
-function localEditorBrowserBaseUrl(
-  control: StartLocalEditorControl,
-  options: StartLocalEditorOptions,
-): string | undefined {
-  const value = control.browserBaseUrl ?? options.browserBaseUrl;
-  return value === undefined || value.trim() === ""
-    ? undefined
-    : value.trim().replace(/\/+$/, "");
-}
-
-export function codeServerArgs(
-  port: number,
-  cwd: string,
-  userDataDir: string,
-  extensionsDir?: string | undefined,
-): string[] {
-  return [
-    "--bind-addr",
-    `127.0.0.1:${port}`,
-    "--auth",
-    "none",
-    "--disable-telemetry",
-    "--disable-update-check",
-    "--disable-workspace-trust",
-    "--disable-getting-started-override",
-    "--app-name",
-    "Kandan",
-    "--user-data-dir",
-    userDataDir,
-    ...(extensionsDir === undefined ? [] : ["--extensions-dir", extensionsDir]),
-    cwd,
-  ];
-}
-
-export function prepareCodeServerProfile(
-  collaboration?: PreparedLocalEditorCollaboration | undefined,
-  editorRuntime?: InstalledEditorRuntime | undefined,
-): PrepareCodeServerProfileResult {
-  try {
-    const userDataDir = mkdtempSync(join(tmpdir(), "kandan-local-editor-"));
-    const extensionsDir = join(userDataDir, "extensions");
-    const collaborationServerDir = join(userDataDir, "collaboration-server");
-    const userSettingsDir = join(userDataDir, "User");
-    mkdirSync(userSettingsDir, { recursive: true });
-    mkdirSync(extensionsDir, { recursive: true });
-    mkdirSync(collaborationServerDir, { recursive: true });
-    if (editorRuntime !== undefined) {
-      installDirectory(
-        editorRuntime.assets.documentStateExtensionDir,
-        join(extensionsDir, "kandan.document-state-telemetry"),
-      );
-    }
-    writeFileSync(
-      join(userSettingsDir, "settings.json"),
-      JSON.stringify(
-        codeServerSettings(collaboration),
-        null,
-        2,
-      ),
-    );
-
-    return { ok: true, userDataDir, extensionsDir, collaborationServerDir };
-  } catch (_error) {
-    return { ok: false, reason: "code_server_spawn_failed" };
-  }
-}
-
-export function prepareCodeServerLaunch(
-  options: PrepareCodeServerLaunchOptions,
-): PrepareCodeServerLaunchResult {
-  const platform = options.platform ?? process.platform;
-
-  if (platform === "linux") {
-    return prepareLinuxCodeServerLaunch(options);
-  }
-
-  if (platform !== "darwin") {
-    return filesystemSandboxUnavailable();
-  }
-
-  const sandboxExecBin = options.sandboxExecBin ?? "/usr/bin/sandbox-exec";
-
-  if (!existsSync(sandboxExecBin)) {
-    return filesystemSandboxUnavailable();
-  }
-
-  const codeServerExecutable = resolveCodeServerExecutable(
-    options.codeServerBin,
-    options.envPath ?? process.env.PATH ?? "",
-  );
-
-  if (!codeServerExecutable.ok) {
-    return filesystemSandboxUnavailable();
-  }
-
-  return {
-    ok: true,
-    command: sandboxExecBin,
-    args: [
-      "-p",
-      codeServerSandboxProfile(options, codeServerExecutable.directory),
-      "--",
-      codeServerExecutable.command,
-      ...codeServerArgs(
-        options.port,
-        options.cwd,
-        options.userDataDir,
-        options.extensionsDir,
-      ),
-    ],
-  };
-}
-
-function prepareLinuxCodeServerLaunch(
-  options: PrepareCodeServerLaunchOptions,
-): PrepareCodeServerLaunchResult {
-  const bubblewrapExecutable = resolveCodeServerExecutable(
-    options.bubblewrapBin ?? "bwrap",
-    options.envPath ?? process.env.PATH ?? "",
-  );
-
-  if (!bubblewrapExecutable.ok) {
-    return filesystemSandboxUnavailable();
-  }
-
-  const codeServerExecutable = resolveCodeServerExecutable(
-    options.codeServerBin,
-    options.envPath ?? process.env.PATH ?? "",
-  );
-
-  if (!codeServerExecutable.ok) {
-    return filesystemSandboxUnavailable();
-  }
-
-  const readOnlyRoots = uniquePaths([
-    "/usr",
-    "/bin",
-    "/sbin",
-    "/lib",
-    "/lib64",
-    "/etc",
-    "/nix",
-    "/opt",
-    ...(options.codeServerRuntimeRoot === undefined
-      ? []
-      : sandboxPathAliases(options.codeServerRuntimeRoot)),
-    codeServerExecutable.directory,
-  ]);
-
-  const args = [
-    "--die-with-parent",
-    "--proc",
-    "/proc",
-    "--dev-bind",
-    "/dev",
-    "/dev",
-    "--tmpfs",
-    "/tmp",
-    "--setenv",
-    "HOME",
-    options.userDataDir,
-    "--setenv",
-    "XDG_DATA_HOME",
-    join(options.userDataDir, "data"),
-    "--setenv",
-    "XDG_CONFIG_HOME",
-    join(options.userDataDir, "config"),
-    ...readOnlyRoots.flatMap((path) => ["--ro-bind-try", path, path]),
-    "--bind",
-    options.cwd,
-    options.cwd,
-    "--bind",
-    options.userDataDir,
-    options.userDataDir,
-    ...(options.extensionsDir === undefined
-      ? []
-      : ["--bind", options.extensionsDir, options.extensionsDir]),
-    "--chdir",
-    options.cwd,
-    "--",
-    codeServerExecutable.command,
-    ...codeServerArgs(
-      options.port,
-      options.cwd,
-      options.userDataDir,
-      options.extensionsDir,
-    ),
-  ];
-
-  return {
-    ok: true,
-    command: bubblewrapExecutable.command,
-    args,
-  };
-}
-
-function filesystemSandboxUnavailable(): PrepareCodeServerLaunchResult {
-  return {
-    ok: false,
-    reason: "local_editor_filesystem_sandbox_unavailable",
-  };
-}
-
-function codeServerSandboxProfile(
-  options: PrepareCodeServerLaunchOptions,
-  codeServerBinDir: string,
-): string {
-  const readOnlyRoots = uniquePaths([
-    "/System",
-    "/Library",
-    "/usr",
-    "/bin",
-    "/sbin",
-    "/etc",
-    "/private/etc",
-    "/opt/homebrew",
-    "/dev",
-    ...(options.codeServerRuntimeRoot === undefined
-      ? []
-      : sandboxPathAliases(options.codeServerRuntimeRoot)),
-    codeServerBinDir,
-  ]);
-  const readWriteRoots = uniquePaths([
-    ...sandboxPathAliases(options.cwd),
-    ...sandboxPathAliases(options.userDataDir),
-    ...(options.extensionsDir === undefined
-      ? []
-      : sandboxPathAliases(options.extensionsDir)),
-  ]);
-
-  return [
-    "(version 1)",
-    "(deny default)",
-    "(allow process*)",
-    "(allow signal (target self))",
-    "(allow signal (target same-sandbox))",
-    "(allow sysctl*)",
-    "(allow mach*)",
-    "(allow ipc*)",
-    "(allow network*)",
-    "(allow file-read-metadata)",
-    "(allow file-map-executable)",
-    '(allow file-read* (literal "/") (literal "/private") (literal "/private/var"))',
-    `(allow file-read* ${readOnlyRoots.map(sandboxSubpath).join(" ")})`,
-    `(allow file-read* file-write* ${readWriteRoots.map(sandboxSubpath).join(" ")})`,
-  ].join("\n");
-}
-
-type CodeServerExecutable =
-  | { readonly ok: true; readonly command: string; readonly directory: string }
-  | { readonly ok: false };
-
-function resolveCodeServerExecutable(
-  command: string,
-  envPath: string,
-): CodeServerExecutable {
-  if (hasPathSeparator(command)) {
-    const directory = safeRealpathDir(command);
-    return directory === undefined
-      ? { ok: false }
-      : { ok: true, command, directory };
-  }
-
-  for (const directory of envPath.split(delimiter)) {
-    if (directory.trim() === "") {
-      continue;
-    }
-
-    const candidate = join(directory, command);
-
-    if (!existsSync(candidate)) {
-      continue;
-    }
-
-    const realpath = realpathSync(candidate);
-    return { ok: true, command: realpath, directory: dirname(realpath) };
-  }
-
-  return { ok: false };
-}
-
-function hasPathSeparator(path: string): boolean {
-  return path.includes("/") || path.includes("\\");
-}
-
-function safeRealpathDir(path: string): string | undefined {
-  try {
-    const directory = dirname(realpathSync(path));
-    return directory === "/" ? undefined : directory;
-  } catch (_error) {
-    const directory = dirname(path);
-    return directory === "." || directory === "/" ? undefined : directory;
-  }
-}
-
-function sandboxPathAliases(path: string): readonly string[] {
-  try {
-    return [path, realpathSync(path)];
-  } catch (_error) {
-    return [path];
-  }
-}
-
-function uniquePaths(paths: readonly string[]): readonly string[] {
-  return Array.from(new Set(paths.filter((path) => path.length > 0)));
-}
-
-function sandboxSubpath(path: string): string {
-  return `(subpath "${path.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}")`;
-}
-
-type PreparedLocalEditorCollaboration = LocalEditorCollaborationControl & {
-  readonly serverPort: number;
-  readonly serverUrl: string;
-  readonly bootstrapServerUrl: string;
-};
-
-type StartCollaborationSidecarResult =
-  | {
-      readonly ok: true;
-      readonly collaboration?: RunningLocalEditorCollaboration | undefined;
-      readonly ready: Promise<"ready" | "failed">;
-    }
-  | { readonly ok: false };
-
-export function prepareLocalEditorCollaboration(
-  collaboration: LocalEditorCollaborationControl | undefined,
-  runnerId: string,
-  serverPort: number | undefined,
-  browserBaseUrl: string,
-): PreparedLocalEditorCollaboration | undefined {
-  if (collaboration === undefined || serverPort === undefined) {
-    return undefined;
-  }
-
-  const targetPath = `/local-codex-runners/${encodeURIComponent(runnerId)}/forwards/${serverPort}/preview-target`;
-  const serverUrl = new URL(targetPath, `${browserBaseUrl}/`).toString();
-  const bootstrapServerUrl =
-    collaboration.bootstrapToken === undefined || collaboration.bootstrapToken === ""
-      ? serverUrl
-      : new URL(
-          `${targetPath}/_kandan-collaboration/${encodeURIComponent(collaboration.bootstrapToken)}`,
-          `${browserBaseUrl}/`,
-        ).toString();
-
-  return {
-    ...collaboration,
-    serverPort,
-    serverUrl,
-    bootstrapServerUrl,
-  };
-}
-
-function codeServerSettings(
-  collaboration?: PreparedLocalEditorCollaboration | undefined,
-): Record<string, unknown> {
-  return {
-    "extensions.autoCheckUpdates": false,
-    "extensions.autoUpdate": false,
-    "extensions.ignoreRecommendations": true,
-    "extensions.showRecommendationsOnlyOnDemand": true,
-    "oct.alwaysAskToOverrideServerUrl": false,
-    "oct.joinAcceptMode": "auto",
-    ...(collaboration === undefined
-      ? {}
-      : {
-          "oct.kandanEditorSessionId": collaboration.editorSessionId,
-          "oct.serverUrl": collaboration.bootstrapServerUrl,
-        }),
-    "security.workspace.trust.enabled": false,
-    "telemetry.telemetryLevel": "off",
-    "workbench.secondarySideBar.defaultVisibility": "hidden",
-    "workbench.startupEditor": "none",
-    "workbench.welcomePage.walkthroughs.openOnInstall": false,
-  };
-}
-
-async function startCollaborationSidecar(
-  collaboration: PreparedLocalEditorCollaboration | undefined,
-  profile: Extract<PrepareCodeServerProfileResult, { ok: true }>,
-  editorRuntime: InstalledEditorRuntime,
-): Promise<StartCollaborationSidecarResult> {
-  if (collaboration === undefined) {
-    return { ok: true, ready: Promise.resolve("ready") };
-  }
-
-  try {
-    await Promise.all([
-      installLocalTarball(
-        editorRuntime.assets.collaborationExtensionTarball,
-        profile.extensionsDir,
-      ),
-      installLocalTarball(
-        editorRuntime.assets.collaborationServerTarball,
-        profile.collaborationServerDir,
-      ),
-    ]);
-
-    const child = spawn(
-      nodeRuntimeExecutable(),
-      [
-        join(
-          profile.collaborationServerDir,
-          "open-collaboration-server",
-          "bundle",
-          "app.js",
-        ),
-        "--hostname",
-        "127.0.0.1",
-        "--port",
-        String(collaboration.serverPort),
-      ],
-      {
-        env: {
-          ...process.env,
-          OCT_ACTIVATE_SIMPLE_LOGIN: "true",
-          OCT_SERVER_OWNER: "Kandan",
-        },
-        stdio: ["ignore", "inherit", "inherit"],
-      },
-    );
-    const exited = waitForCodeServerExit(child);
-    const spawnResult = await waitForCodeServerSpawn(child);
-
-    if (spawnResult === "failed") {
-      return { ok: false };
-    }
-
-    const ready = waitForCollaborationServerReady(
-      collaboration.serverPort,
-      exited,
-    );
-
-    return {
-      ok: true,
-      ready,
-      collaboration: {
-        provider: collaboration.provider,
-        editorSessionId: collaboration.editorSessionId,
-        runtimeSessionId: collaboration.runtimeSessionId,
-        roomId: collaboration.roomId,
-        serverPort: collaboration.serverPort,
-        serverUrl: collaboration.serverUrl,
-        bootstrapServerUrl: collaboration.bootstrapServerUrl,
-        process: child,
-        exited,
-      },
-    };
-  } catch (_error) {
-    return { ok: false };
-  }
-}
-
-export function nodeRuntimeExecutable(
-  env: NodeJS.ProcessEnv = process.env,
-  execPath = process.execPath,
-): string {
-  const configured = env.LINZUMI_NODE_BIN?.trim();
-
-  if (configured !== undefined && configured !== "") {
-    return configured;
-  }
-
-  return basename(execPath).toLowerCase().includes("bun") ? "node" : execPath;
-}
-
-async function installLocalTarball(
-  archivePath: string,
-  destinationDir: string,
-): Promise<void> {
-  mkdirSync(destinationDir, { recursive: true });
-  await runProcess("tar", ["-xzf", archivePath, "-C", destinationDir]);
-}
-
-function installDirectory(sourceDir: string, destinationDir: string): void {
-  mkdirSync(dirname(destinationDir), { recursive: true });
-  cpSync(sourceDir, destinationDir, { recursive: true });
-}
-
-function codeServerEnv(
-  env: NodeJS.ProcessEnv,
-  userDataDir: string,
-  collaboration?: RunningLocalEditorCollaboration | undefined,
-): NodeJS.ProcessEnv {
-  const { PORT: _port, ...hostEnv } = env;
-  const base = {
-    ...hostEnv,
-    HOME: userDataDir,
-    XDG_CACHE_HOME: join(userDataDir, "xdg-cache"),
-    XDG_CONFIG_HOME: join(userDataDir, "xdg-config"),
-    XDG_DATA_HOME: join(userDataDir, "xdg-data"),
-  };
-
-  if (collaboration === undefined) {
-    return base;
-  }
-
-  return {
-    ...base,
-    KANDAN_EDITOR_COLLABORATION_DEPLOYMENT_SHAPE: "local_runner_sidecar",
-    KANDAN_EDITOR_COLLABORATION_ENTRY_MODE: "kandan_auto_host_or_join",
-    KANDAN_EDITOR_COLLABORATION_ROOM_ID: collaboration.roomId,
-    KANDAN_EDITOR_COLLABORATION_SERVER_URL: collaboration.bootstrapServerUrl,
-  };
-}
-
-function collaborationEvent(
-  collaboration?: RunningLocalEditorCollaboration | undefined,
-): LocalEditorCollaborationEvent | undefined {
-  if (collaboration === undefined) {
-    return undefined;
-  }
-
-  return {
-    provider: collaboration.provider,
-    editorSessionId: collaboration.editorSessionId,
-    runtimeSessionId: collaboration.runtimeSessionId,
-    roomId: collaboration.roomId,
-    serverPort: collaboration.serverPort,
-    serverUrl: collaboration.serverUrl,
-  };
-}
-
-function sameCollaboration(
-  running: RunningLocalEditorCollaboration | undefined,
-  requested: LocalEditorCollaborationControl | undefined,
-): boolean {
-  if (running === undefined || requested === undefined) {
-    return running === undefined && requested === undefined;
-  }
-
-  return (
-    running.editorSessionId === requested.editorSessionId &&
-    running.runtimeSessionId === requested.runtimeSessionId &&
-    running.roomId === requested.roomId
-  );
-}
-
-function runProcess(command: string, args: readonly string[]): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, [...args], {
-      stdio: ["ignore", "ignore", "inherit"],
-    });
-    child.once("error", reject);
-    child.once("exit", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`${command} exited with ${code ?? "unknown"}`));
-      }
-    });
-  });
-}
-
-function waitForCodeServerExit(child: ChildProcess): Promise<void> {
-  return new Promise((resolve) => {
-    let settled = false;
-    const cleanup = () => {
-      child.off("exit", onDone);
-      child.off("close", onDone);
-    };
-    const onDone = () => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      resolve();
-    };
-
-    child.once("exit", onDone);
-    child.once("close", onDone);
-
-    if (child.exitCode !== null || child.signalCode !== null) {
-      onDone();
-    }
-  });
-}
-
-function waitForCodeServerReady(
-  port: number,
-  exited: Promise<void>,
-  timeoutMs = 10_000,
-): Promise<"ready" | "failed"> {
-  const deadline = Date.now() + timeoutMs;
-  const readyUrl = `http://127.0.0.1:${port}/`;
-
-  return new Promise((resolve) => {
-    let settled = false;
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const finish = (result: "ready" | "failed") => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-
-      if (timer !== undefined) {
-        clearTimeout(timer);
-      }
-
-      resolve(result);
-    };
-    const scheduleCheck = () => {
-      timer = setTimeout(checkReady, 50);
-    };
-    const checkReady = async () => {
-      if (Date.now() > deadline) {
-        finish("failed");
-        return;
-      }
-
-      try {
-        const response = await fetch(readyUrl);
-
-        if (response.status < 500) {
-          finish("ready");
-          return;
-        }
-      } catch (_error) {
-        scheduleCheck();
-        return;
-      }
-
-      scheduleCheck();
-    };
-
-    void exited.then(() => finish("failed"));
-    void checkReady();
-  });
-}
-
-function waitForCollaborationServerReady(
-  port: number,
-  exited: Promise<void>,
-  timeoutMs = 10_000,
-): Promise<"ready" | "failed"> {
-  const deadline = Date.now() + timeoutMs;
-  const readyUrl = `http://127.0.0.1:${port}/api/login/initial`;
-
-  return new Promise((resolve) => {
-    let settled = false;
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const finish = (result: "ready" | "failed") => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-
-      if (timer !== undefined) {
-        clearTimeout(timer);
-      }
-
-      resolve(result);
-    };
-    const scheduleCheck = () => {
-      timer = setTimeout(checkReady, 50);
-    };
-    const checkReady = async () => {
-      if (Date.now() > deadline) {
-        finish("failed");
-        return;
-      }
-
-      try {
-        const response = await fetch(readyUrl, { method: "POST" });
-
-        if (response.status < 500) {
-          finish("ready");
-          return;
-        }
-      } catch (_error) {
-        scheduleCheck();
-        return;
-      }
-
-      scheduleCheck();
-    };
-
-    void exited.then(() => finish("failed"));
-    void checkReady();
-  });
-}
-
-function waitForCodeServerSpawn(
-  child: ChildProcess,
-): Promise<"spawned" | "failed"> {
-  return new Promise((resolve) => {
-    let settled = false;
-    const cleanup = () => {
-      child.off("spawn", onSpawn);
-      child.off("error", onError);
-    };
-    const onSpawn = () => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      resolve("spawned");
-    };
-    const onError = () => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      resolve("failed");
-    };
-
-    child.once("spawn", onSpawn);
-    child.once("error", onError);
-    setImmediate(() => {
-      if (!settled && child.pid !== undefined) {
-        onSpawn();
-      }
-    });
-  });
-}