@hiroleague/taskmanager 0.0.1 → 0.0.3

package/src/cli/lib/process.test.ts

@@ -52,7 +52,14 @@ describe("process.ts server lifecycle (mock fetch)", () => {
     setMockFetch(async (input: RequestInfo | URL) => {
       const url = typeof input === "string" ? input : (input as Request).url;
       expect(url).toContain("/api/health");
-      return new Response(JSON.stringify({ ok: true }), {
+      return new Response(JSON.stringify({
+        pid: 1001,
+        port: 17_001,
+        running: true,
+        runtime: "installed",
+        source: "installed",
+        url: "http://127.0.0.1:17001",
+      }), {
         status: 200,
         headers: { "content-type": "application/json" },
       });
@@ -60,15 +67,18 @@ describe("process.ts server lifecycle (mock fetch)", () => {
 
     const status = await readServerStatus({ port: 17_001 });
     expect(status).toEqual({
+      pid: 1001,
       running: true,
       port: 17_001,
+      runtime: "installed",
+      source: "installed",
       url: "http://127.0.0.1:17001",
     });
   });
 
   test("readServerStatus — no health, no pid file", async () => {
     setMockFetch(async () =>
-      new Response(JSON.stringify({ ok: false }), {
+      new Response(JSON.stringify({ running: false }), {
         status: 200,
         headers: { "content-type": "application/json" },
       }),
@@ -93,7 +103,7 @@ describe("process.ts server lifecycle (mock fetch)", () => {
     expect(existsSync(pidPath)).toBe(true);
 
     setMockFetch(async () =>
-      new Response(JSON.stringify({ ok: false }), {
+      new Response(JSON.stringify({ running: false }), {
         status: 200,
         headers: { "content-type": "application/json" },
       }),
@@ -120,16 +130,25 @@ describe("process.ts server lifecycle (mock fetch)", () => {
     setMockFetch(async (input: RequestInfo | URL) => {
       const url = typeof input === "string" ? input : (input as Request).url;
       expect(url).toContain("/api/health");
-      return new Response(JSON.stringify({ ok: true }), {
+      return new Response(JSON.stringify({
+        pid: process.pid,
+        port,
+        running: true,
+        runtime: "dev",
+        source: "repo",
+        url: `http://127.0.0.1:${port}`,
+      }), {
         status: 200,
         headers: { "content-type": "application/json" },
       });
     });
 
     const status = await readServerStatus({ port });
-    expect(status.running).toBe(true);
+    if (!status.running) expect.unreachable();
     expect(status.port).toBe(port);
     expect(status.pid).toBe(process.pid);
+    expect(status.runtime).toBe("dev");
+    expect(status.source).toBe("repo");
     expect(status.url).toBe(`http://127.0.0.1:${port}`);
   });
 

package/src/cli/lib/process.ts

@@ -7,6 +7,12 @@ import {
 } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveRuntimeSource } from "../../shared/runtimeIdentity";
+import {
+  buildLocalServerUrl,
+  type RunningServerStatus,
+  type ServerStatus,
+} from "../../shared/serverStatus";
 import {
   getServerPidFilePath,
   resolveDataDir,
@@ -15,11 +21,11 @@ import {
   resolveRuntimeKind,
   type ConfigOverrides,
 } from "./config";
-import { fetchHealth } from "./api-client";
+import { fetchHealth, fetchHealthStatus } from "./api-client";
 import { CLI_DEFAULTS, CLI_POLLING } from "./constants";
 import { CLI_ERR } from "../types/errors";
-import type { ServerStatus } from "../types/config";
 import { CliError } from "./output";
+import type { ServerStartMode } from "../ports/process";
 
 interface ManagedServerRecord {
   pid: number;
@@ -29,7 +35,11 @@ interface ManagedServerRecord {
 
 export type { ServerStatus };
 
-type ServerReadyCallback = (status: ServerStatus) => void | Promise<void>;
+type ServerReadyCallback = (status: RunningServerStatus) => void | Promise<void>;
+
+function buildStoppedStatus(): ServerStatus {
+  return { running: false };
+}
 
 function getPidFilePath(overrides: ConfigOverrides = {}): string {
   return getServerPidFilePath(overrides);
@@ -94,9 +104,8 @@ function buildServerEnv(overrides: ConfigOverrides): NodeJS.ProcessEnv {
   const env: NodeJS.ProcessEnv = {
     ...process.env,
     TASKMANAGER_RUNTIME: resolveRuntimeKind(overrides),
-    TASKMANAGER_PROFILE: resolveProfileName(overrides),
-    TASKMANAGER_PORT: String(overrides.port),
   };
+  delete env.TASKMANAGER_PORT;
 
   // Pass the resolved data directory explicitly so the child process uses the
   // same profile-aware runtime config as the parent command.
@@ -108,26 +117,15 @@ function buildServerEnv(overrides: ConfigOverrides): NodeJS.ProcessEnv {
 export async function readServerStatus(
   overrides: ConfigOverrides = {},
 ): Promise<ServerStatus> {
-  const port = resolvePort(overrides);
-  const healthy = await fetchHealth(overrides);
+  const health = await fetchHealthStatus(overrides);
+  const healthy = health?.running === true;
   const managedRecord = readManagedServerRecord(overrides);
 
   if (healthy) {
     if (managedRecord && !isProcessAlive(managedRecord.pid)) {
       removeManagedServerRecord(overrides);
-      return {
-        port,
-        running: true,
-        url: `http://127.0.0.1:${port}`,
-      };
     }
-
-    return {
-      pid: managedRecord?.pid,
-      port,
-      running: true,
-      url: `http://127.0.0.1:${port}`,
-    };
+    return health;
   }
 
   if (managedRecord && !isProcessAlive(managedRecord.pid)) {
@@ -139,7 +137,7 @@ export async function readServerStatus(
 
 export async function startServer(
   overrides: ConfigOverrides = {},
-  background = false,
+  mode: ServerStartMode = "foreground",
   onReady?: ServerReadyCallback,
 ): Promise<ServerStatus> {
   const port = overrides.port;
@@ -153,17 +151,36 @@ export async function startServer(
     return currentStatus;
   }
 
+  const resolvedPort = resolvePort({ ...overrides, port: overrides.port });
+  const runDetached = mode !== "foreground";
+  const silenceConsole = mode === "background";
+  const runtime = resolveRuntimeKind(overrides);
+  const source = resolveRuntimeSource(import.meta.url);
+  const spawnCmd = [
+    process.execPath,
+    getServerEntryPath(overrides),
+    "--profile",
+    resolveProfileName(overrides),
+    "--port",
+    String(resolvedPort),
+  ];
+  // Pass --dev explicitly so the child bootstrap sets dev runtime.
+  if (runtime === "dev") {
+    spawnCmd.push("--dev");
+  }
   const child = Bun.spawn({
-    cmd: [process.execPath, getServerEntryPath(overrides)],
+    cmd: spawnCmd,
     cwd: process.cwd(),
-    detached: background,
+    detached: runDetached,
     env: buildServerEnv({ ...overrides, port }),
-    stderr: background ? "ignore" : "inherit",
-    stdin: background ? "ignore" : "inherit",
-    stdout: background ? "ignore" : "inherit",
+    // First-run launcher mode keeps the server alive after the launcher exits,
+    // but still lets the recovery key print in the same terminal.
+    stderr: silenceConsole ? "ignore" : "inherit",
+    stdin: runDetached ? "ignore" : "inherit",
+    stdout: silenceConsole ? "ignore" : "inherit",
   });
 
-  if (background) {
+  if (runDetached) {
     child.unref();
 
     const healthy = await waitForHealth(port, CLI_DEFAULTS.SERVER_START_WAIT_MS);
@@ -171,18 +188,24 @@ export async function startServer(
       throw new CliError("Server failed to start", 7, {
         code: CLI_ERR.serverStartTimeout,
         retryable: true,
-        hint: "Try running `hirotm server start` without --background to inspect logs.",
+        hint: "Try running `hirotm server start --foreground` to inspect logs.",
         url: `http://127.0.0.1:${port}`,
       });
     }
 
+    const health = await fetchHealthStatus({ ...overrides, port });
+
     if (onReady) {
-      await onReady({
-        pid: child.pid,
-        port,
-        running: true,
-        url: `http://127.0.0.1:${port}`,
-      });
+      await onReady(
+        health ?? {
+          pid: child.pid,
+          port,
+          running: true,
+          runtime,
+          source,
+          url: buildLocalServerUrl(port),
+        },
+      );
     }
 
     // Persist the pid so later status calls can report a CLI-managed background server.
@@ -192,12 +215,16 @@ export async function startServer(
       startedAt: new Date().toISOString(),
     }, overrides);
 
-    return {
-      pid: child.pid,
-      port,
-      running: true,
-      url: `http://127.0.0.1:${port}`,
-    };
+    return (
+      health ?? {
+        pid: child.pid,
+        port,
+        running: true,
+        runtime,
+        source,
+        url: buildLocalServerUrl(port),
+      }
+    );
   }
 
   // Wait for health before handing control back to the launcher so first-run
@@ -213,16 +240,27 @@ export async function startServer(
     });
   }
 
+  const health = await fetchHealthStatus({ ...overrides, port });
+
   if (onReady) {
-    await onReady({
-      pid: child.pid,
-      port,
-      running: true,
-      url: `http://127.0.0.1:${port}`,
-    });
+    await onReady(
+      health ?? {
+        pid: child.pid,
+        port,
+        running: true,
+        runtime,
+        source,
+        url: buildLocalServerUrl(port),
+      },
+    );
   }
 
+  // Track whether the CLI forwarded a termination signal so we can treat
+  // the resulting non-zero exit code as a normal user-initiated shutdown
+  // rather than an unexpected crash.
+  let signalForwarded = false;
   const forwardSignal = (signal: NodeJS.Signals) => {
+    signalForwarded = true;
     child.kill(signal);
   };
 
@@ -233,17 +271,14 @@ export async function startServer(
   process.off("SIGINT", forwardSignal);
   process.off("SIGTERM", forwardSignal);
 
-  if (exitCode !== 0) {
+  if (exitCode !== 0 && !signalForwarded) {
     throw new CliError("Server exited unexpectedly", 1, {
       code: CLI_ERR.serverExited,
       childExitCode: exitCode,
     });
   }
 
-  return {
-    port,
-    running: false,
-  };
+  return buildStoppedStatus();
 }
 
 /**
@@ -312,9 +347,5 @@ export async function stopServer(
 
   removeManagedServerRecord(overrides);
 
-  return {
-    pid: record.pid,
-    port: waitPort,
-    running: false,
-  };
+  return buildStoppedStatus();
 }

package/src/cli/ports/process.ts

@@ -1,9 +1,15 @@
+import type { RunningServerStatus } from "../../shared/serverStatus";
 import type { ConfigOverrides, ServerStatus } from "../types/config";
 
 export type ServerReadyCallback = (
-  status: ServerStatus,
+  status: RunningServerStatus,
 ) => void | Promise<void>;
 
+export type ServerStartMode =
+  | "foreground"
+  | "background"
+  | "background-attached";
+
 /**
  * Local process lifecycle for `hirotm server` (spawn, pid file, health polling).
  * Implemented by `adapters/node-process.ts` (delegates to `lib/process.ts`).
@@ -14,7 +20,7 @@ export type ProcessPort = {
   ) => Promise<ServerStatus>;
   startServer: (
     overrides?: ConfigOverrides,
-    background?: boolean,
+    mode?: ServerStartMode,
     onReady?: ServerReadyCallback,
   ) => Promise<ServerStatus>;
   stopServer: (overrides?: ConfigOverrides) => Promise<ServerStatus>;