@rigkit/sdk 0.1.8

package/src/runtime/runs.ts

@@ -0,0 +1,292 @@
+import type { RuntimeEvent, RuntimeOperation } from "./protocol.ts";
+import {
+  RuntimeHostRequestError,
+  runtimeFailureBody,
+} from "./errors.ts";
+
+export type RunStatus = "running" | "completed" | "failed";
+
+export type PendingHostResponse = {
+  resolve(value: unknown): void;
+  reject(error: Error): void;
+};
+
+export type PendingHostCapabilityResource = {
+  resolveClosed(): void;
+  rejectClosed(error: Error): void;
+};
+
+export type HostCapabilitySessionResult<Result = unknown> = {
+  result: Result;
+  closed: Promise<void>;
+};
+
+export type RunRecord = {
+  id: string;
+  operation: string;
+  operationDefinition?: RuntimeOperation;
+  input: unknown;
+  status: RunStatus;
+  events: RuntimeEvent[];
+  result?: unknown;
+  error?: { code: string; message: string };
+  pendingHostRequestIds: Set<string>;
+  pendingHostCapabilityResourceIds: Set<string>;
+  subscribers: Set<ReadableStreamDefaultController<Uint8Array>>;
+  eventSubscribers: Set<(event: RuntimeEvent) => void>;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type RuntimeRunSummary = {
+  runId: string;
+  operation: string;
+  input: unknown;
+  status: RunStatus;
+  result?: unknown;
+  error?: { code: string; message: string };
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type RunStore = {
+  runs: Map<string, RunRecord>;
+  hostResponses: Map<string, PendingHostResponse>;
+  hostCapabilityResources: Map<string, PendingHostCapabilityResource>;
+  activeSessions: number;
+};
+
+const encoder = new TextEncoder();
+
+export function createRunStore(): RunStore {
+  return {
+    runs: new Map(),
+    hostResponses: new Map(),
+    hostCapabilityResources: new Map(),
+    activeSessions: 0,
+  };
+}
+
+export function createRun(operation: string, input: unknown, operationDefinition?: RuntimeOperation): RunRecord {
+  const now = new Date().toISOString();
+  return {
+    id: `run_${crypto.randomUUID()}`,
+    operation,
+    operationDefinition,
+    input,
+    status: "running",
+    events: [],
+    pendingHostRequestIds: new Set(),
+    pendingHostCapabilityResourceIds: new Set(),
+    subscribers: new Set(),
+    eventSubscribers: new Set(),
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+export function emitRunEvent(run: RunRecord, event: RuntimeEvent): void {
+  run.events.push(event);
+  run.updatedAt = new Date().toISOString();
+  const payload = encodeSse(event);
+  for (const subscriber of run.subscribers) {
+    subscriber.enqueue(payload);
+  }
+  for (const subscriber of run.eventSubscribers) {
+    subscriber(event);
+  }
+}
+
+export function completeRun(run: RunRecord, result: unknown, store?: RunStore): void {
+  if (run.status !== "running") return;
+  run.status = "completed";
+  run.result = result;
+  run.updatedAt = new Date().toISOString();
+  if (store) {
+    settleHostCapabilityResources(run, store, (pending) => pending.resolveClosed());
+  }
+  emitRunEvent(run, { type: "run.completed", runId: run.id, result });
+  closeRunSubscribers(run);
+}
+
+export function failRun(run: RunRecord, error: unknown, store?: RunStore): void {
+  if (run.status !== "running") return;
+  run.status = "failed";
+  run.error = runtimeFailureBody(error);
+  run.updatedAt = new Date().toISOString();
+  if (store) {
+    for (const requestId of run.pendingHostRequestIds) {
+      const pending = store.hostResponses.get(requestId);
+      if (pending) {
+        store.hostResponses.delete(requestId);
+        pending.reject(new RuntimeHostRequestError({
+          message: run.error.message,
+          requestId,
+          cause: error,
+        }));
+      }
+    }
+    run.pendingHostRequestIds.clear();
+    settleHostCapabilityResources(run, store, (pending) =>
+      pending.rejectClosed(new RuntimeHostRequestError({
+        message: run.error?.message ?? "Run failed",
+        cause: error,
+      }))
+    );
+  }
+  emitRunEvent(run, { type: "run.failed", runId: run.id, error: run.error });
+  closeRunSubscribers(run);
+}
+
+export function summarizeRun(run: RunRecord): RuntimeRunSummary {
+  return {
+    runId: run.id,
+    operation: run.operation,
+    input: run.input,
+    status: run.status,
+    result: run.result,
+    error: run.error,
+    createdAt: run.createdAt,
+    updatedAt: run.updatedAt,
+  };
+}
+
+export function sseResponse(run: RunRecord): Response {
+  let controllerRef: ReadableStreamDefaultController<Uint8Array> | undefined;
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controllerRef = controller;
+      for (const event of run.events) controller.enqueue(encodeSse(event));
+      if (run.status !== "running") {
+        controller.close();
+        return;
+      }
+      run.subscribers.add(controller);
+    },
+    cancel() {
+      if (controllerRef) run.subscribers.delete(controllerRef);
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive",
+    },
+  });
+}
+
+export function requestHost(store: RunStore, run: RunRecord, method: string, params: unknown): Promise<unknown> {
+  if (run.status !== "running") {
+    return Promise.reject(new RuntimeHostRequestError({
+      message: `Run ${run.id} is ${run.status}`,
+      method,
+    }));
+  }
+  const requestId = `host_req_${crypto.randomUUID()}`;
+  run.pendingHostRequestIds.add(requestId);
+  emitRunEvent(run, { type: "host.request", requestId, id: requestId, method, params });
+  return new Promise<unknown>((resolve, reject) => {
+    store.hostResponses.set(requestId, { resolve, reject });
+  });
+}
+
+export function requestHostCapability(
+  store: RunStore,
+  run: RunRecord,
+  capability: string,
+  params: unknown,
+): Promise<unknown> {
+  const { requestId } = emitHostCapabilityRequest(run, capability, params);
+  return waitForHostResponse(store, requestId);
+}
+
+export async function requestHostCapabilitySession<Result = unknown>(
+  store: RunStore,
+  run: RunRecord,
+  capability: string,
+  params: unknown,
+): Promise<HostCapabilitySessionResult<Result>> {
+  const { requestId } = emitHostCapabilityRequest(run, capability, params);
+  const closed = new Promise<void>((resolveClosed, rejectClosed) => {
+    store.hostCapabilityResources.set(requestId, { resolveClosed, rejectClosed });
+    run.pendingHostCapabilityResourceIds.add(requestId);
+  });
+  const result = await waitForHostResponse(store, requestId).catch((error) => {
+    closeHostCapabilityResource(store, requestId, error instanceof Error ? error : new Error(String(error)));
+    throw error;
+  });
+  return { result: result as Result, closed };
+}
+
+export function closeHostCapabilityResource(store: RunStore, requestId: string, error?: Error): boolean {
+  const pending = store.hostCapabilityResources.get(requestId);
+  if (!pending) return false;
+  store.hostCapabilityResources.delete(requestId);
+  clearPendingHostCapabilityResource(store, requestId);
+  if (error) pending.rejectClosed(error);
+  else pending.resolveClosed();
+  return true;
+}
+
+function emitHostCapabilityRequest(
+  run: RunRecord,
+  capability: string,
+  params: unknown,
+): { requestId: string } {
+  if (run.status !== "running") {
+    throw new RuntimeHostRequestError({
+      message: `Run ${run.id} is ${run.status}`,
+      method: capability,
+    });
+  }
+  const requestId = `cap_req_${crypto.randomUUID()}`;
+  run.pendingHostRequestIds.add(requestId);
+  emitRunEvent(run, { type: "host.capability.request", requestId, id: requestId, capability, params });
+  return { requestId };
+}
+
+function waitForHostResponse(store: RunStore, requestId: string): Promise<unknown> {
+  return new Promise<unknown>((resolve, reject) => {
+    store.hostResponses.set(requestId, { resolve, reject });
+  });
+}
+
+export function subscribeRunEvents(run: RunRecord, handler: (event: RuntimeEvent) => void): () => void {
+  run.eventSubscribers.add(handler);
+  return () => {
+    run.eventSubscribers.delete(handler);
+  };
+}
+
+function closeRunSubscribers(run: RunRecord): void {
+  for (const subscriber of run.subscribers) {
+    subscriber.close();
+  }
+  run.subscribers.clear();
+}
+
+function settleHostCapabilityResources(
+  run: RunRecord,
+  store: RunStore,
+  settle: (pending: PendingHostCapabilityResource) => void,
+): void {
+  for (const requestId of run.pendingHostCapabilityResourceIds) {
+    const pending = store.hostCapabilityResources.get(requestId);
+    if (!pending) continue;
+    store.hostCapabilityResources.delete(requestId);
+    settle(pending);
+  }
+  run.pendingHostCapabilityResourceIds.clear();
+}
+
+function clearPendingHostCapabilityResource(store: RunStore, requestId: string): void {
+  for (const run of store.runs.values()) {
+    run.pendingHostCapabilityResourceIds.delete(requestId);
+  }
+}
+
+function encodeSse(event: RuntimeEvent): Uint8Array {
+  return encoder.encode(`data: ${JSON.stringify(event)}\n\n`);
+}

package/src/runtime/server.ts

@@ -0,0 +1,182 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import {
+  HttpApp,
+  HttpServer,
+  HttpServerRequest,
+  HttpServerResponse,
+} from "@effect/platform";
+import * as BunHttpServer from "@effect/platform-bun/BunHttpServer";
+import { RIGKIT_ENGINE_VERSION } from "@rigkit/engine";
+import { Effect, Exit, Scope } from "effect";
+import { RIGKIT_RUNTIME_VERSION } from "./version.ts";
+import { runtimeJsonError, sessionRunIdFor } from "./app.ts";
+import { createRuntimeControlApiHandler } from "./api-handlers.ts";
+import type { RuntimeAppState } from "./control.ts";
+import { runSessionSocketEffect } from "./sessions.ts";
+import { DEFAULT_IDLE_MS } from "./protocol.ts";
+import { createRunStore } from "./runs.ts";
+import { readOrCreateToken } from "./token.ts";
+import type { RuntimeContext, RuntimeServer, ServeRuntimeOptions } from "./types.ts";
+
+export class RuntimeServerError extends Error {
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options);
+    this.name = "RuntimeServerError";
+  }
+}
+
+export function serveRuntimeEffect(options: ServeRuntimeOptions): Effect.Effect<RuntimeServer, RuntimeServerError, Scope.Scope> {
+  return Effect.acquireRelease(
+    Effect.tryPromise({
+      try: () => serveRuntime(options),
+      catch: (cause) => new RuntimeServerError("Failed to start Rigkit runtime server", { cause }),
+    }),
+    (server) => Effect.sync(() => server.stop()),
+  );
+}
+
+export async function serveRuntime(options: ServeRuntimeOptions): Promise<RuntimeServer> {
+  const projectDir = resolve(options.projectDir);
+  const configPath = resolve(options.configPath);
+  const statePath = options.statePath ? resolve(options.statePath) : undefined;
+  const host = options.host ?? "127.0.0.1";
+  const token = options.token ?? readOrCreateToken(options.tokenPath);
+  const idleMs = options.idleMs ?? DEFAULT_IDLE_MS;
+  const startedAt = new Date().toISOString();
+  const store = createRunStore();
+  let expiresAt = new Date(Date.now() + idleMs).toISOString();
+  let url = "";
+  let stopServer = () => {};
+  let idleTimer: ReturnType<typeof setInterval> | undefined;
+  let resolveClosed!: () => void;
+  const closed = new Promise<void>((resolve) => {
+    resolveClosed = resolve;
+  });
+
+  const writeHandle = () => {
+    mkdirSync(dirname(options.handlePath), { recursive: true });
+    writeFileSync(
+      options.handlePath,
+      `${JSON.stringify({
+        projectId: options.projectId,
+        projectDir,
+        configPath,
+        statePath,
+        pid: process.pid,
+        url,
+        tokenPath: options.tokenPath,
+        engineVersion: RIGKIT_ENGINE_VERSION,
+        runtimeVersion: RIGKIT_RUNTIME_VERSION,
+        startedAt,
+        expiresAt,
+      }, null, 2)}\n`,
+    );
+  };
+
+  const context: RuntimeContext = {
+    projectId: options.projectId,
+    projectDir,
+    configPath,
+    statePath,
+    source: options.source,
+    token,
+    startedAt,
+    getExpiresAt: () => expiresAt,
+    touch: () => {
+      expiresAt = new Date(Date.now() + idleMs).toISOString();
+      if (url) writeHandle();
+    },
+    stop: () => stopServer(),
+  };
+  const state: RuntimeAppState = { context, store };
+  const controlApi = createRuntimeControlApiHandler(context, store);
+  const app = createRuntimeHttpApp(state, controlApi);
+  const scope = Effect.runSync(Scope.make());
+  const server = await Effect.runPromise(Scope.extend(BunHttpServer.make({
+    hostname: host,
+    port: options.port ?? 0,
+  }), scope));
+  await Effect.runPromise(Scope.extend(
+    HttpServer.serveEffect(app).pipe(Effect.provideService(HttpServer.HttpServer, server)),
+    scope,
+  ));
+
+  let stopped = false;
+  stopServer = () => {
+    if (stopped) return;
+    stopped = true;
+    if (idleTimer) clearInterval(idleTimer);
+    void controlApi.dispose();
+    void Effect.runPromise(Scope.close(scope, Exit.void))
+      .catch(() => {})
+      .finally(resolveClosed);
+  };
+
+  const port = server.address._tag === "TcpAddress" ? server.address.port : options.port ?? 0;
+  url = `http://${host}:${port}`;
+  writeHandle();
+
+  idleTimer = setInterval(() => {
+    if ([...store.runs.values()].some((run) => run.status === "running") || store.activeSessions > 0) return;
+    if (Date.now() <= Date.parse(expiresAt)) return;
+    stopServer();
+  }, Math.min(idleMs, 30_000));
+  idleTimer.unref?.();
+
+  return {
+    url,
+    token,
+    closed,
+    stop() {
+      stopServer();
+    },
+  };
+}
+
+function createRuntimeHttpApp(
+  state: RuntimeAppState,
+  controlApi: ReturnType<typeof createRuntimeControlApiHandler>,
+): HttpApp.Default<unknown> {
+  const controlApp = HttpApp.fromWebHandler(controlApi.handler);
+  return Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const sessionRunId = sessionRunIdFor(requestPathname(request.url));
+    if (sessionRunId) return yield* handleRunSessionRequest(state, sessionRunId);
+    return yield* controlApp;
+  });
+}
+
+function handleRunSessionRequest(
+  state: RuntimeAppState,
+  runId: string,
+) {
+  return Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    if (request.headers.authorization !== `Bearer ${state.context.token}`) {
+      return HttpServerResponse.fromWeb(runtimeJsonError(401, "Unauthorized"));
+    }
+
+    if (!state.store.runs.has(runId)) {
+      return HttpServerResponse.fromWeb(runtimeJsonError(404, `Unknown run ${runId}`));
+    }
+
+    state.context.touch();
+    const socket = yield* Effect.either(HttpServerRequest.upgrade);
+    if (socket._tag === "Left") {
+      return HttpServerResponse.fromWeb(runtimeJsonError(400, "WebSocket upgrade failed"));
+    }
+
+    yield* Effect.forkDaemon(
+      runSessionSocketEffect(state, runId, socket.right).pipe(Effect.scoped),
+    );
+    return HttpServerResponse.empty({ status: 101 });
+  });
+}
+
+function requestPathname(url: string): string {
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) return new URL(url).pathname;
+  return url.split("?", 1)[0] || "/";
+}
+
+export type { RuntimeServer, ServeRuntimeOptions } from "./types.ts";