@runuai/host 0.1.0

package/lib/command-db.ts

@@ -0,0 +1,278 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+import Database from "better-sqlite3";
+
+import { env } from "./env";
+import type { HostTask } from "../db/schema";
+import type {
+  TaskCommandProject,
+  TaskCommandTask,
+  TaskDownInput,
+  TaskLaunchInput,
+} from "../src/protocol";
+
+export function createTaskUpCommandDb(input: TaskLaunchInput): string {
+  const dbPath = newCommandDbPath(input.task.id);
+  const db = openCommandDb(dbPath);
+  try {
+    seedMetadata(db, withRuntime(input.task, null), input.projects);
+  } finally {
+    db.close();
+  }
+  return dbPath;
+}
+
+export function createTaskDownCommandDb(
+  input: TaskDownInput,
+  runtime: HostTask | null,
+): string {
+  const dbPath = newCommandDbPath(input.taskId);
+  const db = openCommandDb(dbPath);
+  try {
+    seedMetadata(db, withRuntime(input.task, runtime), input.projects);
+  } finally {
+    db.close();
+  }
+  return dbPath;
+}
+
+export function createTaskStatusCommandDb(
+  taskId: string,
+  runtime: HostTask | null,
+): string {
+  const dbPath = newCommandDbPath(taskId);
+  const db = openCommandDb(dbPath);
+  try {
+    insertTask(db, runtimeTask(taskId, runtime));
+  } finally {
+    db.close();
+  }
+  return dbPath;
+}
+
+export function removeCommandDb(path: string): void {
+  rmSync(path, { force: true });
+}
+
+function newCommandDbPath(taskId: string): string {
+  if (!existsSync(env.commandDbDir)) {
+    mkdirSync(env.commandDbDir, { recursive: true, mode: 0o700 });
+  }
+  const suffix = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return join(env.commandDbDir, `${taskId}-${suffix}.sqlite`);
+}
+
+function openCommandDb(path: string): Database.Database {
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.exec(schemaSql);
+  return db;
+}
+
+/**
+ * Seed the per-task command DB the bash scripts read (ADR-022 shape):
+ *   - one uai_users row for the owner,
+ *   - one uai_projects row per selected project,
+ *   - one uai_task_projects row per (task, project, position),
+ *   - one uai_tasks row for the task (+ mirrored runtime fields).
+ * Column names mirror the cloud Drizzle schema.
+ */
+function seedMetadata(
+  db: Database.Database,
+  task: CommandTaskRow,
+  projects: TaskCommandProject[],
+): void {
+  db.prepare(
+    `INSERT OR IGNORE INTO uai_users (id, clerk_user_id, email)
+     VALUES (@id, @clerk_user_id, @email)`,
+  ).run({
+    id: task.owner_user_id,
+    clerk_user_id: null,
+    email: "host-command@example.invalid",
+  });
+
+  const insertProject = db.prepare(
+    `INSERT INTO uai_projects (
+      id, owner_user_id, name, slug, repo_url, default_prompt,
+      preview_ports, env, tool_versions, extra
+    ) VALUES (
+      @id, @owner_user_id, @name, @slug, @repo_url, @default_prompt,
+      @preview_ports, @env, @tool_versions, @extra
+    )`,
+  );
+  const insertTaskProject = db.prepare(
+    `INSERT INTO uai_task_projects (task_id, project_id, position)
+     VALUES (@task_id, @project_id, @position)`,
+  );
+
+  for (const project of projects) {
+    insertProject.run({
+      id: project.id,
+      owner_user_id: project.ownerUserId,
+      name: project.name,
+      slug: project.slug,
+      repo_url: project.repoUrl,
+      default_prompt: project.defaultPrompt,
+      preview_ports: project.previewPorts,
+      env: project.env,
+      tool_versions: project.toolVersions ?? null,
+      extra: project.extra ?? null,
+    });
+    insertTaskProject.run({
+      task_id: task.id,
+      project_id: project.id,
+      position: project.position,
+    });
+  }
+
+  insertTask(db, task);
+}
+
+function insertTask(db: Database.Database, task: CommandTaskRow): void {
+  db.prepare(
+    `INSERT INTO uai_tasks (
+      id, owner_user_id, host_id, name, slug, branch, status,
+      global_context, reviewer_order, agents, pr_context,
+      worktree_path, compose_project, code_server_port, preview_ports,
+      locked_at, started_at, ended_at
+    ) VALUES (
+      @id, @owner_user_id, @host_id, @name, @slug, @branch, @status,
+      @global_context, @reviewer_order, @agents, @pr_context,
+      @worktree_path, @compose_project, @code_server_port, @preview_ports,
+      @locked_at, @started_at, @ended_at
+    )`,
+  ).run(task);
+}
+
+/**
+ * The shape of a row inserted into `uai_tasks`. The leading columns mirror
+ * the cloud `tasks` schema; the trailing columns are host runtime fields the
+ * bash scripts write back during task-up / task-down.
+ */
+interface CommandTaskRow {
+  id: string;
+  owner_user_id: string;
+  host_id: string;
+  name: string;
+  slug: string;
+  branch: string;
+  status: string;
+  global_context: string | null;
+  reviewer_order: string | null;
+  agents: string;
+  pr_context: string | null;
+  worktree_path: string | null;
+  compose_project: string | null;
+  code_server_port: number | null;
+  preview_ports: string;
+  locked_at: number | null;
+  started_at: number | null;
+  ended_at: number | null;
+}
+
+function withRuntime(
+  task: TaskCommandTask,
+  runtime: HostTask | null,
+): CommandTaskRow {
+  return {
+    id: task.id,
+    owner_user_id: task.ownerUserId,
+    host_id: task.hostId,
+    name: task.name,
+    slug: task.slug,
+    branch: task.branch,
+    status: runtime?.statusMirror ?? task.status,
+    global_context: task.globalContext ?? null,
+    reviewer_order: task.reviewerOrder
+      ? JSON.stringify(task.reviewerOrder)
+      : null,
+    agents: JSON.stringify(task.agents ?? []),
+    pr_context: null,
+    worktree_path: runtime?.worktreePath ?? null,
+    compose_project: runtime?.composeProject ?? null,
+    code_server_port: runtime?.codeServerPort ?? null,
+    preview_ports: runtime?.previewPorts ?? "[]",
+    locked_at: runtime?.lockedAt ?? null,
+    started_at: runtime?.startedAt ?? null,
+    ended_at: runtime?.endedAt ?? null,
+  };
+}
+
+function runtimeTask(taskId: string, runtime: HostTask | null): CommandTaskRow {
+  return {
+    id: taskId,
+    owner_user_id: "host-runtime",
+    host_id: "host-runtime",
+    name: taskId,
+    slug: taskId,
+    branch: `task/${taskId}`,
+    status: runtime?.statusMirror ?? "queued",
+    global_context: null,
+    reviewer_order: null,
+    agents: "[]",
+    pr_context: null,
+    worktree_path: runtime?.worktreePath ?? null,
+    compose_project: runtime?.composeProject ?? null,
+    code_server_port: runtime?.codeServerPort ?? null,
+    preview_ports: runtime?.previewPorts ?? "[]",
+    locked_at: runtime?.lockedAt ?? null,
+    started_at: runtime?.startedAt ?? null,
+    ended_at: runtime?.endedAt ?? null,
+  };
+}
+
+const schemaSql = `
+CREATE TABLE IF NOT EXISTS uai_users (
+  id text PRIMARY KEY,
+  clerk_user_id text UNIQUE,
+  email text NOT NULL
+);
+CREATE TABLE IF NOT EXISTS uai_projects (
+  id text PRIMARY KEY,
+  owner_user_id text NOT NULL,
+  name text NOT NULL,
+  slug text NOT NULL,
+  repo_url text NOT NULL,
+  default_prompt text NOT NULL DEFAULT '',
+  preview_ports text NOT NULL DEFAULT '[]',
+  env text NOT NULL DEFAULT '[]',
+  tool_versions text,
+  extra text
+);
+CREATE TABLE IF NOT EXISTS uai_task_projects (
+  task_id text NOT NULL,
+  project_id text NOT NULL,
+  position integer NOT NULL DEFAULT 0,
+  PRIMARY KEY (task_id, project_id)
+);
+CREATE TABLE IF NOT EXISTS uai_tasks (
+  id text PRIMARY KEY,
+  owner_user_id text NOT NULL,
+  host_id text NOT NULL,
+  name text NOT NULL,
+  slug text NOT NULL,
+  branch text NOT NULL,
+  status text NOT NULL DEFAULT 'queued',
+  global_context text,
+  reviewer_order text,
+  agents text NOT NULL DEFAULT '[]',
+  pr_context text,
+  worktree_path text,
+  compose_project text,
+  code_server_port integer,
+  preview_ports text NOT NULL DEFAULT '[]',
+  pr_url text,
+  locked_at integer,
+  started_at integer,
+  ended_at integer,
+  updated_at integer NOT NULL DEFAULT (unixepoch() * 1000)
+);
+CREATE TABLE IF NOT EXISTS uai_task_events (
+  id text PRIMARY KEY,
+  task_id text NOT NULL,
+  ts integer NOT NULL DEFAULT (unixepoch() * 1000),
+  kind text NOT NULL,
+  payload text NOT NULL DEFAULT '{}'
+);
+`;

package/lib/db.ts

@@ -0,0 +1,68 @@
+/**
+ * Host-local SQLite access (ADR-020).
+ *
+ * This DB contains only runtime state for tasks assigned to this host. Cloud
+ * metadata remains in the cloud DB and arrives over command arguments.
+ */
+
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+
+import { env } from "./env";
+import * as schema from "../db/schema";
+
+let cached: ReturnType<typeof drizzle> | null = null;
+let migrated = false;
+
+function migrationsFolder(): string {
+  return resolve(
+    dirname(fileURLToPath(import.meta.url)),
+    "..",
+    "db",
+    "migrations",
+  );
+}
+
+function ensureDataDir(): void {
+  const dir = dirname(env.hostDbPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+
+export function migrateHostDb(): void {
+  if (migrated) return;
+  ensureDataDir();
+  const sqlite = new Database(env.hostDbPath);
+  try {
+    const journalMode = String(
+      sqlite.pragma("journal_mode = WAL", { simple: true }),
+    ).toLowerCase();
+    if (journalMode !== "wal") {
+      throw new Error(
+        `host.sqlite journal_mode must be WAL; got "${journalMode}"`,
+      );
+    }
+    sqlite.pragma("foreign_keys = ON");
+    migrate(drizzle(sqlite), { migrationsFolder: migrationsFolder() });
+    migrated = true;
+  } finally {
+    sqlite.close();
+  }
+}
+
+export function getDb(): ReturnType<typeof drizzle> {
+  if (cached) return cached;
+  migrateHostDb();
+  const sqlite = new Database(env.hostDbPath);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+  cached = drizzle(sqlite, { schema });
+  return cached;
+}
+
+export type Db = ReturnType<typeof getDb>;
+export { schema };

package/lib/env.ts

@@ -0,0 +1,140 @@
+/**
+ * Host-agent env access. Runtime state lives in host.sqlite on the host
+ * machine; cloud metadata arrives over the host protocol.
+ */
+
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { z } from "zod";
+
+const schema = z.object({
+  // Base dir for mutable host state (.env.local + the data dir). See the
+  // resolution of `uaiHome` below. Optional — defaults are repo-aware.
+  UAI_HOME: z.string().min(1).optional(),
+  UAI_DATA_DIR: z.string().min(1).optional(),
+  UAI_AGENT_DIR: z.string().min(1).optional(),
+  UAI_HOST_TOKEN: z.string().min(32).optional(),
+  UAI_HOST_BRIDGE_PORT: z.coerce.number().int().min(1).max(65535).default(8789),
+  UAI_CLOUD_URL: z.string().min(1).optional(),
+  UAI_HOST_ID: z.string().min(1).optional(),
+  // Host master key file (ADR-027) — 32 bytes, AES-256-GCM for the host
+  // secret store. Defaults to $UAI_DATA_DIR/host-master.key; generated on
+  // first use. Optional transitional GitHub PAT for unconnected users.
+  UAI_HOST_KEY_FILE: z.string().min(1).optional(),
+  UAI_GH_PAT_FALLBACK: z.string().min(1).optional(),
+  UAI_WORKSPACE_ROOT: z.string().min(1).default("~/.uai"),
+  NODE_ENV: z
+    .enum(["development", "production", "test"])
+    .default("development"),
+});
+
+const parsed = schema.safeParse(process.env);
+
+if (!parsed.success) {
+  console.error(
+    "uai host-agent: invalid environment",
+    parsed.error.flatten().fieldErrors,
+  );
+}
+
+const raw = parsed.success ? parsed.data : schema.parse({});
+const here = dirname(fileURLToPath(import.meta.url)); // <pkg>/lib
+
+function expandHome(path: string): string {
+  if (path === "~") return homedir();
+  if (path.startsWith("~/")) return resolve(homedir(), path.slice(2));
+  return path;
+}
+
+/** Walk up from `start` until `pred` holds; null at the filesystem root. */
+function findUp(start: string, pred: (dir: string) => boolean): string | null {
+  let dir = start;
+  for (;;) {
+    if (pred(dir)) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// Monorepo root iff we're running from a checkout: a dir holding BOTH
+// pnpm-workspace.yaml and a host-agent/ child. null when installed under
+// node_modules — then state lives under ~/.uai, never inside the package.
+const repoRoot = findUp(
+  here,
+  (d) =>
+    existsSync(resolve(d, "pnpm-workspace.yaml")) &&
+    existsSync(resolve(d, "host-agent")),
+);
+
+// UAI_HOME: where .env.local + the data dir live. Explicit UAI_HOME wins; then
+// the parent of an explicit UAI_DATA_DIR; then the repo root (dev checkout);
+// then ~/.uai (installed via npm). Keep this in sync with src/load-env.ts,
+// which resolves the same base independently (it runs before this module).
+const uaiHome = raw.UAI_HOME
+  ? resolve(expandHome(raw.UAI_HOME))
+  : raw.UAI_DATA_DIR
+    ? dirname(resolve(expandHome(raw.UAI_DATA_DIR)))
+    : (repoRoot ?? resolve(homedir(), ".uai"));
+
+// Data dir: explicit UAI_DATA_DIR wins, kept verbatim (e.g. the live host's
+// pinned <repo>/.data); else <repo>/.data in a checkout, or ~/.uai/data when
+// installed.
+const dataDir = raw.UAI_DATA_DIR
+  ? resolve(expandHome(raw.UAI_DATA_DIR))
+  : resolve(uaiHome, repoRoot ? ".data" : "data");
+
+const workspaceRoot = resolve(expandHome(raw.UAI_WORKSPACE_ROOT));
+
+export const env = {
+  ...raw,
+  uaiHome,
+  dataDir,
+  hostDbPath: resolve(dataDir, "host.sqlite"),
+  hostKeyPath: raw.UAI_HOST_KEY_FILE
+    ? resolve(uaiHome, expandHome(raw.UAI_HOST_KEY_FILE))
+    : resolve(dataDir, "host-master.key"),
+  commandDbDir: resolve(dataDir, "host-command-dbs"),
+  // Agent scripts ship inside the package; lib/agent.ts resolves them off the
+  // package root by default. Only an explicit UAI_AGENT_DIR override surfaces
+  // here (undefined → use the shipped scripts).
+  agentDir: raw.UAI_AGENT_DIR
+    ? resolve(uaiHome, expandHome(raw.UAI_AGENT_DIR))
+    : undefined,
+  workspaceRoot,
+} as const;
+
+export type Env = typeof env;
+
+/** Absolute path to a project's uai-owned directory (holds its bare mirror). */
+export function projectDir(projectId: string): string {
+  return resolve(env.workspaceRoot, "projects", projectId);
+}
+
+/** Absolute path to a project's single bare mirror (ADR-022: one repo/project). */
+export function projectRepoMirror(projectId: string): string {
+  return resolve(projectDir(projectId), "repo.git");
+}
+
+/** Absolute path to a task's directory (top-level; a task spans 0..N projects). */
+export function taskDir(taskId: string): string {
+  return resolve(env.workspaceRoot, "tasks", taskId);
+}
+
+/** Absolute path to a task's workspace root (parent of per-project worktrees). */
+export function taskWorkspaceDir(taskId: string): string {
+  return resolve(taskDir(taskId), "workspace");
+}
+
+/** Absolute path to one selected project's worktree within a task. */
+export function taskProjectWorktree(taskId: string, projectSlug: string): string {
+  return resolve(taskWorkspaceDir(taskId), projectSlug);
+}
+
+/** Absolute path to a task's ephemeral `.uai/` render dir (generated compose). */
+export function taskUaiDir(taskId: string): string {
+  return resolve(taskDir(taskId), ".uai");
+}