Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
6.6 KB
Raw Blame
import { randomUUID } from "node:crypto";
import { z } from "zod";
import type { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
import { localRoutingSettingsSchema, localWorkflowInputSchema, localModelRefSchema, localRouteCategorySchema } from "@omnirush/types/local-workflows";
import { ApiError } from "../errors.js";
import { recordAudit } from "../audit.js";
import { LocalWorkflowService, type LocalWorkflowPromptDispatcher } from "../local-workflows.js";
import type { Actor, ServerConfig, WorkspaceInfo } from "../types.js";
import { addRoute, type RequestContext, type Route } from "./registry.js";
type JsonResponse = (data: unknown, status?: number) => Response;
type ReadJsonBody = (request: Request) => Promise<Record<string, unknown>>;

export interface RegisterLocalWorkflowRoutesOptions {
  routes: Route[]; config: ServerConfig; jsonResponse: JsonResponse; readJsonBody: ReadJsonBody;
  ensureWritable: (config: ServerConfig) => void; requireClientScope: (ctx: RequestContext, required: "collaborator") => void;
  resolveWorkspace: (config: ServerConfig, id: string) => Promise<WorkspaceInfo>;
  resolveWorkspaceWithoutBootstrap: (config: ServerConfig, id: string) => Promise<WorkspaceInfo>;
  createWorkspaceOpencodeClient: (config: ServerConfig, workspace: WorkspaceInfo, options?: { sessionId?: string }) => ReturnType<typeof createOpencodeClient>;
  /** Step prompts go through the server's gated, captured engine proxy. */
  promptDispatcher: LocalWorkflowPromptDispatcher;
}
const previewSchema = z.object({
  prompt: z.string().trim().min(1).max(16000),
  category: z.union([localRouteCategorySchema, z.literal("auto")]).optional(),
  model: localModelRefSchema.nullable().optional(),
});
function parse<T>(schema: z.ZodType<T>, input: unknown): T {
  const result = schema.safeParse(input);
  if (!result.success) throw new ApiError(400, "invalid_payload", result.error.issues[0]?.message ?? "Invalid workflow request");
  return result.data;
}
export function registerLocalWorkflowRoutes(options: RegisterLocalWorkflowRoutesOptions): LocalWorkflowService {
  const service = new LocalWorkflowService(options.config, options.createWorkspaceOpencodeClient, options.promptDispatcher); service.start();
  const { routes, config, jsonResponse, readJsonBody, ensureWritable, requireClientScope, resolveWorkspace, resolveWorkspaceWithoutBootstrap } = options;
  const writableWorkspace = async (ctx: RequestContext) => {
    ensureWritable(config);
    requireClientScope(ctx, "collaborator");
    return resolveWorkspace(config, ctx.params.id);
  };
  addRoute(routes, "GET", "/workspace/:id/local-workflows", "client", async (ctx) => {
    return jsonResponse(await service.snapshot(await resolveWorkspaceWithoutBootstrap(config, ctx.params.id)));
  });
  addRoute(routes, "PUT", "/workspace/:id/local-workflows/routing", "client", async (ctx) => {
    const workspace = await writableWorkspace(ctx);
    const routing = parse(localRoutingSettingsSchema, await readJsonBody(ctx.request));
    const result = await service.saveRouting(workspace, routing);
    await audit(workspace, "local_workflow.routing.updated", workspace.id, "Updated workflow model routing", ctx.actor, { enabled: result.enabled, defaultModel: result.defaultModel, categories: result.categories });
    return jsonResponse(result);
  });
  addRoute(routes, "POST", "/workspace/:id/local-workflows/route", "client", async (ctx) => {
    const workspace = await resolveWorkspaceWithoutBootstrap(config, ctx.params.id);
    const body = parse(previewSchema, await readJsonBody(ctx.request));
    return jsonResponse(await service.route(workspace, body.prompt, body.category, body.model));
  });
  addRoute(routes, "POST", "/workspace/:id/local-workflows", "client", async (ctx) => {
    const workspace = await writableWorkspace(ctx);
    const workflow = await service.upsert(workspace, parse(localWorkflowInputSchema, await readJsonBody(ctx.request)));
    await audit(workspace, "local_workflow.created", workflow.id, "Created workflow", ctx.actor, { name: workflow.name, enabled: workflow.enabled, intervalMinutes: workflow.intervalMinutes, stepCount: workflow.steps.length });
    return jsonResponse(workflow, 201);
  });
  addRoute(routes, "PATCH", "/workspace/:id/local-workflows/:workflowId", "client", async (ctx) => {
    const workspace = await writableWorkspace(ctx);
    const state = await service.snapshot(workspace);
    const current = state.workflows.find((item) => item.id === ctx.params.workflowId);
    if (!current) throw new ApiError(404, "workflow_not_found", "Workflow not found");
    const body = parse(z.record(z.string(), z.unknown()), await readJsonBody(ctx.request));
    const workflow = await service.upsert(workspace, parse(localWorkflowInputSchema, { ...current, ...body }), ctx.params.workflowId);
    await audit(workspace, "local_workflow.updated", workflow.id, workflow.enabled ? "Updated workflow schedule/settings" : "Updated workflow; schedule paused", ctx.actor, { name: workflow.name, enabled: workflow.enabled, intervalMinutes: workflow.intervalMinutes, nextRunAt: workflow.nextRunAt, stepCount: workflow.steps.length });
    return jsonResponse(workflow);
  });
  addRoute(routes, "DELETE", "/workspace/:id/local-workflows/:workflowId", "client", async (ctx) => {
    const workspace = await writableWorkspace(ctx);
    await service.remove(workspace, ctx.params.workflowId);
    await audit(workspace, "local_workflow.deleted", ctx.params.workflowId, "Deleted workflow", ctx.actor, { workflowId: ctx.params.workflowId });
    return jsonResponse({ ok: true });
  });
  addRoute(routes, "POST", "/workspace/:id/local-workflows/:workflowId/run", "client", async (ctx) => {
    const workspace = await writableWorkspace(ctx);
    return jsonResponse(await service.run(workspace, ctx.params.workflowId, "manual", ctx.actor), 202);
  });
  addRoute(routes, "POST", "/workspace/:id/local-workflows/runs/:runId/cancel", "client", async (ctx) => {
    return jsonResponse(await service.cancel(await writableWorkspace(ctx), ctx.params.runId));
  });
  addRoute(routes, "GET", "/workspace/:id/local-workflows/runs/:runId", "client", async (ctx) => {
    return jsonResponse(await service.getRun(await resolveWorkspaceWithoutBootstrap(config, ctx.params.id), ctx.params.runId));
  });
  return service;
}
async function audit(workspace: WorkspaceInfo, action: string, target: string, summary: string, actor: Actor = { type: "host" }, details?: Record<string, unknown>): Promise<void> {
  await recordAudit(workspace.path, { id: `audit_${randomUUID()}`, workspaceId: workspace.id, actor, action, target, summary, timestamp: Date.now(), ...(details ? { details } : {}) });
}