bootstrap.ts

import { createKeychainStore, resolveConfiguredProvider } from "@procni/ai";
import {
  createAnalyzeJobHandler,
  createDraftJobHandler,
  createJobWorker,
  openDb,
  readProjectConfig,
  resolveProjectDir,
  sweepStaleJobsOnStartup,
  type JobWorker,
} from "@procni/core";
import { ProcniError } from "@procni/shared";
import { join } from "node:path";
import { buildServer } from "./app.js";
import { listenOnAvailablePort } from "./listen.js";
import { assertNotAlreadyRunning, releaseLock, writeLock } from "./pidLock.js";

export interface DevServerOptions {
  /** Preferred port; `0` lets the OS choose (what tests use to avoid collisions). Defaults to 4173. */
  port?: number | undefined;
  /** Where the built web SPA lives. Static-serving is skipped if this directory doesn't exist. */
  webDistDir: string;
}

export interface DevServerHandle {
  url: string;
  port: number;
  stop: () => Promise<void>;
}

/**
 * Everything `procni dev` needs to go from "a project on disk" to "a running
 * local server": confirm `procni init` has already run, refuse to start a
 * second instance for the same project, open (and migrate) its database,
 * resolve a configured AI provider if one exists (the server still starts
 * without one — see `resolveConfiguredProvider` — since browsing existing
 * data never needs AI), sweep any jobs left stuck `"running"` by a crashed
 * previous instance, start the job worker, bind the API server, then record
 * the lock so the *next* `procni dev` can find this one.
 */
export async function startDevServer(
  repoRoot: string,
  options: DevServerOptions,
): Promise<DevServerHandle> {
  const projectDir = resolveProjectDir(repoRoot);

  const config = await readProjectConfig(repoRoot);
  if (!config) {
    throw new ProcniError(
      "NOT_INITIALIZED",
      `${repoRoot} has not been initialized. Run "procni init" first.`,
    );
  }

  await assertNotAlreadyRunning(projectDir);

  const db = openDb(join(projectDir, "procni.db"));
  const resolved = await resolveConfiguredProvider(createKeychainStore());

  await sweepStaleJobsOnStartup(db);
  const worker: JobWorker = createJobWorker({
    db,
    handlers: resolved
      ? { analyze: createAnalyzeJobHandler(db, resolved.provider), draft: createDraftJobHandler(db, resolved.provider) }
      : {},
  });
  worker.start();

  const app = buildServer(options.webDistDir, {
    db,
    repoRoot,
    projectName: config.name,
    providerId: resolved?.id ?? null,
    defaultModel: resolved?.model ?? "",
  });
  const port = await listenOnAvailablePort(app, options.port ?? 4173);

  await writeLock(projectDir, { pid: process.pid, port, startedAt: new Date().toISOString() });

  return {
    url: `http://127.0.0.1:${port}`,
    port,
    stop: async () => {
      worker.stop();
      await app.close();
      await db.destroy();
      await releaseLock(projectDir);
    },
  };
}