@runuai/host 0.1.0

package/src/index.ts

@@ -0,0 +1,375 @@
+import { agent, AgentError } from "../lib/agent";
+import { cloneRepo } from "../lib/repo-clone";
+import { getOrchestrator } from "../lib/orchestrator";
+import { setupTaskGithub, clearRefresh } from "../lib/github-tokens";
+import { readAttachment, writeAttachment } from "../lib/attachments";
+import { appendTranscript as writeTranscript } from "../lib/transcript";
+import { buildTaskDiff } from "../lib/task-diff";
+import {
+  recordHostEvent,
+  recordTaskDown,
+  recordTaskError,
+  recordTaskOwner,
+  recordTaskStarting,
+  recordTaskUpResult,
+} from "../lib/runtime-state";
+import {
+  HostErrorCode,
+  type CommandContext,
+  type ChannelEnsureInput,
+  type HostCommandResult,
+  type HostCommands,
+  type HostEventStream,
+  type PermissionDecision,
+  type TaskDiffInput,
+  type TaskDownInput,
+  type TaskLaunchInput,
+} from "./protocol";
+
+export type {
+  TaskDownResult,
+  TaskStatusResult,
+  TaskUpResult,
+} from "../lib/agent";
+
+export {
+  parseMentions,
+  resolveAddressing,
+  buildSystemPreamble,
+} from "../lib/orchestrator";
+
+export {
+  AgentKind,
+  Roster,
+  RosterAgent,
+  parseRoster,
+} from "../lib/agents/types";
+export type {
+  AgentEvent,
+  AgentEventHandler,
+  AgentSession,
+  AgentSessionFactory,
+} from "../lib/agents/types";
+
+export {
+  capabilities as agentCapabilities,
+  factoryFor as agentFactoryFor,
+  list as listAgentAdapters,
+  register as registerAgentAdapter,
+} from "../lib/agents/registry";
+export type {
+  AgentKindCapability,
+  RegisteredAdapter,
+} from "../lib/agents/registry";
+
+export {
+  ASDF_DATA_VOLUME,
+  STANDARD_IMAGE_TAG,
+  STANDARD_RUNTIMES,
+  ensureStandardImage,
+  standardRuntimes,
+} from "../lib/standard-image";
+
+export { cloneRepo } from "../lib/repo-clone";
+export type { CloneRepoInput, CloneRepoResult } from "../lib/repo-clone";
+
+export { parseGitDiff, runGitDiff } from "../lib/git-diff";
+export type { DiffFile, DiffHunk, DiffLine, DiffStatus } from "../lib/git-diff";
+
+export {
+  PREVIEW_PORT_NAME_RE,
+  PreviewPortDeclarationSchema,
+  PreviewPortDeclarationsSchema,
+  PreviewPortRuntimeSchema,
+  PreviewPortRuntimesSchema,
+  parsePreviewPortDeclarations,
+  parsePreviewPortRuntimes,
+} from "../lib/preview-ports";
+export type {
+  PreviewPortDeclaration,
+  PreviewPortRuntime,
+} from "../lib/preview-ports";
+
+export const hostEvents: HostEventStream = {
+  subscribe(handler) {
+    return getOrchestrator().subscribeHostEvents(handler);
+  },
+};
+
+export const hostCommands: HostCommands = {
+  async taskUp(ctx, input) {
+    logCommand(ctx, "taskUp", input.task.id);
+    recordTaskStarting(input.task.id);
+    recordTaskOwner(
+      input.task.id,
+      input.task.ownerUserId,
+      input.ownerEmail ?? null,
+      input.ownerName ?? null,
+      input.projects.map((p) => p.slug),
+    );
+    recordHostEvent(input.task.id, "task.created");
+    const result = await wrapAgent(ctx, "taskUp", () => agent.taskUp(input));
+    if (result.ok) {
+      recordTaskUpResult(input.task.id, result.value);
+      recordHostEvent(input.task.id, "task.started");
+      // GitHub auth for the container is best-effort (ADR-027) and runs in the
+      // background — it must never block or fail task-up. Awaiting it here would
+      // couple the command result to a network token-exchange: a slow/hung
+      // exchange (e.g. cloud mid-deploy) would trip the cloud's command timeout
+      // and mark a running task as errored. setupTaskGithub injects + schedules
+      // (or emits a system note on failure) on its own; the agents come up
+      // regardless and the token lands well before the first `gh` call.
+      void setupTaskGithub(input.task.id, input.task.ownerUserId);
+    } else {
+      recordTaskError(input.task.id);
+    }
+    return result;
+  },
+
+  async taskDown(ctx, input) {
+    logCommand(ctx, "taskDown", input.taskId);
+    const result = await wrapAgent(ctx, "taskDown", () => agent.taskDown(input));
+    if (result.ok) {
+      recordTaskDown(input.taskId, result.value.status);
+      recordHostEvent(input.taskId, "task.ended");
+      clearRefresh(input.taskId);
+    }
+    return result;
+  },
+
+  async taskStatus(ctx, taskId) {
+    logCommand(ctx, "taskStatus", taskId);
+    return wrapAgent(ctx, "taskStatus", () => agent.taskStatus(taskId));
+  },
+
+  async channelEnsure(ctx, input) {
+    logCommand(ctx, "channelEnsure", input.taskId);
+    try {
+      getOrchestrator().registerChannelSpec(normalizeChannelSpec(input));
+      await getOrchestrator().ensureStarted(input.taskId);
+      return ok(undefined);
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async channelTeardown(ctx, taskId) {
+    logCommand(ctx, "channelTeardown", taskId);
+    try {
+      await getOrchestrator().closeChannel(taskId);
+      return ok(undefined);
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async channelDeliver(ctx, taskId, agentId, text) {
+    logCommand(ctx, "channelDeliver", taskId, agentId);
+    try {
+      const result = await getOrchestrator().deliver(taskId, agentId, text);
+      if (!result.ok) {
+        return {
+          ok: false,
+          code: mapDeliverError(result.error),
+          message: result.error,
+        };
+      }
+      return ok(undefined);
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async channelResolvePermission(ctx, taskId, agentId, requestId, decision) {
+    logCommand(ctx, "channelResolvePermission", taskId, agentId, requestId);
+    try {
+      const okResolved = await getOrchestrator().resolvePermission(
+        taskId,
+        agentId,
+        requestId,
+        toLegacyDecision(decision),
+      );
+      if (!okResolved) {
+        return {
+          ok: false,
+          code: HostErrorCode.NoSuchPermission,
+          message: "no live session for that permission request",
+        };
+      }
+      return ok(undefined);
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async cloneRepo(ctx, input) {
+    logCommand(ctx, "cloneRepo", input.projectId);
+    try {
+      return ok(cloneRepo(input));
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async taskDiff(ctx, input) {
+    logCommand(ctx, "taskDiff", input.taskId);
+    try {
+      return ok(await buildTaskDiff(input));
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async attachmentWrite(ctx, input) {
+    logCommand(ctx, "attachmentWrite", input.taskId, input.filename);
+    try {
+      writeAttachment(
+        input.taskId,
+        input.filename,
+        Buffer.from(input.dataBase64, "base64"),
+      );
+      return ok(undefined);
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async attachmentRead(ctx, input) {
+    logCommand(ctx, "attachmentRead", input.taskId, input.filename);
+    try {
+      const bytes = readAttachment(input.taskId, input.filename);
+      if (!bytes) {
+        return {
+          ok: false,
+          code: HostErrorCode.TaskNotFound,
+          message: `no such attachment: ${input.filename}`,
+        };
+      }
+      return ok({ dataBase64: bytes.toString("base64") });
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async channelInterrupt(ctx, taskId, agentId) {
+    logCommand(ctx, "channelInterrupt", taskId, agentId);
+    try {
+      const result = await getOrchestrator().interrupt(taskId, agentId);
+      if (!result.ok) {
+        return {
+          ok: false,
+          code: HostErrorCode.TaskNotRunning,
+          message: result.error,
+        };
+      }
+      return ok(undefined);
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async appendTranscript(_ctx, taskId, author, text) {
+    // Per-message + high-frequency, so no logCommand (avoid log spam).
+    try {
+      writeTranscript(taskId, author, text);
+      return ok(undefined);
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+};
+
+function normalizeChannelSpec(input: ChannelEnsureInput): ChannelEnsureInput {
+  return { ...input, workspacePath: "/workspace" };
+}
+
+function logCommand(
+  ctx: CommandContext,
+  command: keyof HostCommands,
+  ...parts: string[]
+): void {
+  console.log(`[host-agent] ${ctx.commandId} ${command} ${parts.join(" ")}`);
+}
+
+async function wrapAgent<T>(
+  _ctx: CommandContext,
+  _command: keyof HostCommands,
+  fn: () => Promise<T>,
+): Promise<HostCommandResult<T>> {
+  try {
+    return ok(await fn());
+  } catch (err) {
+    return failFromUnknown(err);
+  }
+}
+
+function ok<T>(value: T): HostCommandResult<T> {
+  return { ok: true, value };
+}
+
+function failFromUnknown<T = never>(err: unknown): HostCommandResult<T> {
+  if (AgentError.is(err)) {
+    return {
+      ok: false,
+      code: mapAgentError(err.code),
+      message: err.message,
+      retryable: isRetryableAgentError(err.code),
+    };
+  }
+  return {
+    ok: false,
+    code: HostErrorCode.Internal,
+    message: err instanceof Error ? err.message : String(err),
+  };
+}
+
+function mapAgentError(code: string): HostErrorCode {
+  switch (code) {
+    case "TASK_NOT_FOUND":
+      return HostErrorCode.TaskNotFound;
+    case "PROJECT_NOT_FOUND":
+      return HostErrorCode.ProjectNotFound;
+    case "TEMPLATE_NOT_FOUND":
+      return HostErrorCode.TemplateNotFound;
+    case "COMPOSE_UP_FAILED":
+      return HostErrorCode.ComposeUpFailed;
+    case "COMPOSE_DOWN_FAILED":
+      return HostErrorCode.ComposeDownFailed;
+    case "WORKTREE_FAILED":
+      return HostErrorCode.WorktreeFailed;
+    case "CLONE_FAILED":
+      return HostErrorCode.CloneFailed;
+    case "FETCH_FAILED":
+      return HostErrorCode.FetchFailed;
+    case "RENDER_FAILED":
+      return HostErrorCode.RenderFailed;
+    case "CONTAINER_INIT_FAILED":
+      return HostErrorCode.ContainerInitFailed;
+    case "DB_FAILED":
+      return HostErrorCode.DbFailed;
+    default:
+      return HostErrorCode.Internal;
+  }
+}
+
+function mapDeliverError(message: string): HostErrorCode {
+  if (message.includes("not found")) return HostErrorCode.TaskNotFound;
+  if (message.includes("not running")) return HostErrorCode.TaskNotRunning;
+  if (message.includes("no such agent")) return HostErrorCode.NoSuchAgent;
+  return HostErrorCode.Internal;
+}
+
+function isRetryableAgentError(code: string): boolean {
+  return code === "FETCH_FAILED" || code === "CONTAINER_INIT_FAILED";
+}
+
+function toLegacyDecision(decision: PermissionDecision): "accept" | "decline" {
+  return decision.kind;
+}
+
+export type {
+  ChannelEnsureInput,
+  TaskDiffInput,
+  TaskDownInput,
+  TaskLaunchInput,
+};

package/src/load-env.ts

@@ -0,0 +1,52 @@
+/**
+ * Side-effect module: load `.env.local` then `.env` before host-agent modules
+ * read environment variables.
+ */
+
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const proc = process as unknown as {
+  loadEnvFile?: (path: string) => void;
+};
+
+const here = dirname(fileURLToPath(import.meta.url)); // <pkg>/src
+
+// Resolve the same UAI_HOME as lib/env.ts, but independently: this module runs
+// FIRST (before lib/env is imported) so it can't depend on it. .env.local is
+// what *sets* UAI_DATA_DIR, so we can't key off that here — only an explicit
+// UAI_HOME env, then repo detection, then ~/.uai (installed via npm).
+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;
+  }
+}
+
+const repoRoot = findUp(
+  here,
+  (d) =>
+    existsSync(resolve(d, "pnpm-workspace.yaml")) &&
+    existsSync(resolve(d, "host-agent")),
+);
+
+const uaiHome = process.env.UAI_HOME
+  ? resolve(process.env.UAI_HOME.replace(/^~(?=\/|$)/, homedir()))
+  : (repoRoot ?? resolve(homedir(), ".uai"));
+
+for (const file of [".env.local", ".env"]) {
+  const path = join(uaiHome, file);
+  if (!proc.loadEnvFile || !existsSync(path)) continue;
+  try {
+    proc.loadEnvFile(path);
+  } catch (err) {
+    console.warn(
+      `[host-agent] could not load ${file}: ${(err as Error).message}`,
+    );
+  }
+}