@spencer-kit/coder-studio 0.4.0 → 0.4.1

package/src/update-runtime.ts

@@ -0,0 +1,44 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getCliPackageName } from "./package-manifest.js";
+
+export interface UpdateRuntimeInfo {
+  supported: boolean;
+  installKind: "global_npm" | "unsupported";
+  packageName: string;
+  cliCommand: string;
+  workerEntryPath?: string;
+  npmCommand: string;
+  restartArgs: string[];
+  installArgsPrefix: string[];
+  unsupportedReason: string | null;
+}
+
+function resolveWorkerEntryPath(importMetaUrl: string): string | undefined {
+  const currentDir = dirname(fileURLToPath(importMetaUrl));
+  const candidates = [
+    join(currentDir, "update-worker.mjs"),
+    join(currentDir, "../src/update-worker.ts"),
+  ];
+  return candidates.find((candidate) => existsSync(candidate));
+}
+
+export function getUpdateRuntimeInfo(importMetaUrl: string): UpdateRuntimeInfo {
+  const workerEntryPath = resolveWorkerEntryPath(importMetaUrl);
+  const packageName = getCliPackageName(importMetaUrl);
+  const unsupportedReason =
+    workerEntryPath === undefined ? "In-app update worker bundle is not available" : null;
+
+  return {
+    supported: workerEntryPath !== undefined,
+    installKind: workerEntryPath !== undefined ? "global_npm" : "unsupported",
+    packageName,
+    cliCommand: "coder-studio",
+    workerEntryPath,
+    npmCommand: "npm",
+    restartArgs: ["serve", "--restart"],
+    installArgsPrefix: ["install", "-g"],
+    unsupportedReason,
+  };
+}

package/src/update-worker.test.ts

@@ -0,0 +1,99 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { runUpdateWorker } from "./update-worker.js";
+
+describe("update-worker", () => {
+  const tempDirs: string[] = [];
+
+  afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  function createEnv() {
+    const dir = mkdtempSync(join(tmpdir(), "update-worker-"));
+    tempDirs.push(dir);
+    return {
+      stateFilePath: join(dir, "update-state.json"),
+      logFilePath: join(dir, "update-worker.log"),
+      packageName: "@spencer-kit/coder-studio",
+      targetVersion: "0.5.0",
+      cliCommand: "coder-studio",
+      currentVersion: "0.4.0",
+      npmCommand: "npm",
+      restartArgs: ["serve", "--restart"],
+      installArgsPrefix: ["install", "-g"],
+    };
+  }
+
+  it("writes restarting state after install success and restart handoff", async () => {
+    const env = createEnv();
+    const runCommand = vi.fn(async () => {});
+
+    await runUpdateWorker(env, {
+      runCommand,
+      now: () => 1000,
+    });
+
+    const state = JSON.parse(readFileSync(env.stateFilePath, "utf-8")) as { updateStatus: string };
+    expect(state.updateStatus).toBe("restarting");
+    expect(runCommand).toHaveBeenNthCalledWith(
+      1,
+      "npm",
+      ["install", "-g", "@spencer-kit/coder-studio@0.5.0"],
+      expect.any(Object)
+    );
+    expect(runCommand).toHaveBeenNthCalledWith(
+      2,
+      "coder-studio",
+      ["serve", "--restart"],
+      expect.any(Object)
+    );
+  });
+
+  it("falls back to manual_required on permission-related install errors", async () => {
+    const env = createEnv();
+    const runCommand = vi.fn(async () => {
+      throw new Error("npm install failed with EACCES");
+    });
+
+    await runUpdateWorker(env, {
+      runCommand,
+      now: () => 1000,
+    });
+
+    const state = JSON.parse(readFileSync(env.stateFilePath, "utf-8")) as {
+      updateStatus: string;
+      manualCommand: string;
+      requiresManualStep: boolean;
+    };
+    expect(state.updateStatus).toBe("manual_required");
+    expect(state.requiresManualStep).toBe(true);
+    expect(state.manualCommand).toContain("npm install -g @spencer-kit/coder-studio@0.5.0");
+  });
+
+  it("marks restart failures with manual restart guidance", async () => {
+    const env = createEnv();
+    const runCommand = vi
+      .fn()
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error("pm2 restart failed"));
+
+    await runUpdateWorker(env, {
+      runCommand,
+      now: () => 1000,
+    });
+
+    const state = JSON.parse(readFileSync(env.stateFilePath, "utf-8")) as {
+      updateStatus: string;
+      manualCommand: string;
+      errorSummary: string;
+    };
+    expect(state.updateStatus).toBe("failed");
+    expect(state.manualCommand).toBe("coder-studio serve --restart");
+    expect(state.errorSummary).toContain("restart failed");
+  });
+});

package/src/update-worker.ts

@@ -0,0 +1,213 @@
+import { spawn } from "node:child_process";
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+
+interface UpdateStateSnapshot {
+  version: 1;
+  currentVersion: string;
+  latestVersion: string | null;
+  availability: "unknown" | "up_to_date" | "update_available" | "check_failed";
+  updateStatus:
+    | "idle"
+    | "checking"
+    | "installing"
+    | "restarting"
+    | "succeeded"
+    | "failed"
+    | "manual_required";
+  lastCheckedAt: number | null;
+  targetVersion: string | null;
+  startedAt: number | null;
+  finishedAt: number | null;
+  requiresManualStep: boolean;
+  manualCommand: string | null;
+  errorSummary: string | null;
+}
+
+interface WorkerEnv {
+  stateFilePath: string;
+  logFilePath: string;
+  packageName: string;
+  targetVersion: string;
+  cliCommand: string;
+  currentVersion: string;
+  npmCommand: string;
+  restartArgs: string[];
+  installArgsPrefix: string[];
+}
+
+async function writeState(filePath: string, value: UpdateStateSnapshot): Promise<void> {
+  await mkdir(dirname(filePath), { recursive: true });
+  await import("node:fs/promises").then(({ writeFile }) =>
+    writeFile(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8")
+  );
+}
+
+function parseJsonArray(value: string | undefined, fallback: string[]): string[] {
+  if (!value) {
+    return fallback;
+  }
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+      return parsed;
+    }
+  } catch {}
+  return fallback;
+}
+
+function readEnv(env = process.env): WorkerEnv {
+  const stateFilePath = env.CODER_STUDIO_UPDATE_STATE_PATH;
+  const logFilePath = env.CODER_STUDIO_UPDATE_LOG_PATH;
+  const packageName = env.CODER_STUDIO_UPDATE_PACKAGE_NAME;
+  const targetVersion = env.CODER_STUDIO_UPDATE_TARGET_VERSION;
+  const cliCommand = env.CODER_STUDIO_UPDATE_CLI_COMMAND;
+  const currentVersion = env.CODER_STUDIO_UPDATE_CURRENT_VERSION;
+  if (
+    !stateFilePath ||
+    !logFilePath ||
+    !packageName ||
+    !targetVersion ||
+    !cliCommand ||
+    !currentVersion
+  ) {
+    throw new Error("Missing detached update worker environment");
+  }
+  return {
+    stateFilePath,
+    logFilePath,
+    packageName,
+    targetVersion,
+    cliCommand,
+    currentVersion,
+    npmCommand: env.CODER_STUDIO_UPDATE_NPM_COMMAND || "npm",
+    restartArgs: parseJsonArray(env.CODER_STUDIO_UPDATE_RESTART_ARGS, ["serve", "--restart"]),
+    installArgsPrefix: parseJsonArray(env.CODER_STUDIO_UPDATE_INSTALL_ARGS_PREFIX, [
+      "install",
+      "-g",
+    ]),
+  };
+}
+
+function buildManualCommand(input: WorkerEnv): string {
+  return [
+    `${input.npmCommand} ${[...input.installArgsPrefix, `${input.packageName}@${input.targetVersion}`].join(" ")}`,
+    `${input.cliCommand} ${input.restartArgs.join(" ")}`,
+  ].join("\n");
+}
+
+function runCommand(
+  command: string,
+  args: string[],
+  options?: { stdio?: "ignore" | "pipe"; logStream?: NodeJS.WritableStream }
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: options?.stdio === "ignore" ? "ignore" : "pipe",
+      env: process.env,
+    });
+
+    if (options?.logStream && child.stdout) {
+      child.stdout.pipe(options.logStream, { end: false });
+    }
+    if (options?.logStream && child.stderr) {
+      child.stderr.pipe(options.logStream, { end: false });
+    }
+
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} exited with code ${code ?? 1}`));
+    });
+  });
+}
+
+export async function runUpdateWorker(
+  input = readEnv(),
+  deps?: {
+    runCommand?: typeof runCommand;
+    now?: () => number;
+  }
+): Promise<void> {
+  const now = deps?.now ?? Date.now;
+  await mkdir(dirname(input.logFilePath), { recursive: true });
+  const logStream = createWriteStream(input.logFilePath, { flags: "a" });
+  const execute = deps?.runCommand ?? runCommand;
+
+  try {
+    await execute(
+      input.npmCommand,
+      [...input.installArgsPrefix, `${input.packageName}@${input.targetVersion}`],
+      { logStream }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const permissionRelated =
+      /EACCES|EPERM|permission|not permitted/i.test(message) ||
+      /requires elevated privileges/i.test(message);
+    await writeState(input.stateFilePath, {
+      version: 1,
+      currentVersion: input.currentVersion,
+      latestVersion: input.targetVersion,
+      availability: "update_available",
+      updateStatus: permissionRelated ? "manual_required" : "failed",
+      lastCheckedAt: now(),
+      targetVersion: input.targetVersion,
+      startedAt: now(),
+      finishedAt: now(),
+      requiresManualStep: permissionRelated,
+      manualCommand: permissionRelated ? buildManualCommand(input) : null,
+      errorSummary: message,
+    });
+    logStream.end();
+    return;
+  }
+
+  await writeState(input.stateFilePath, {
+    version: 1,
+    currentVersion: input.currentVersion,
+    latestVersion: input.targetVersion,
+    availability: "update_available",
+    updateStatus: "restarting",
+    lastCheckedAt: now(),
+    targetVersion: input.targetVersion,
+    startedAt: now(),
+    finishedAt: null,
+    requiresManualStep: false,
+    manualCommand: null,
+    errorSummary: null,
+  });
+
+  try {
+    await execute(input.cliCommand, input.restartArgs, { logStream });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await writeState(input.stateFilePath, {
+      version: 1,
+      currentVersion: input.currentVersion,
+      latestVersion: input.targetVersion,
+      availability: "update_available",
+      updateStatus: "failed",
+      lastCheckedAt: now(),
+      targetVersion: input.targetVersion,
+      startedAt: now(),
+      finishedAt: now(),
+      requiresManualStep: true,
+      manualCommand: `${input.cliCommand} ${input.restartArgs.join(" ")}`,
+      errorSummary: `new version installed but service restart failed: ${message}`,
+    });
+  } finally {
+    logStream.end();
+  }
+}
+
+if (process.env.CODER_STUDIO_UPDATE_STATE_PATH) {
+  void runUpdateWorker().catch((error) => {
+    console.error("[update-worker]", error);
+    process.exitCode = 1;
+  });
+}