workplane 0.1.1

package/dist/server.js

@@ -0,0 +1,851 @@
+#!/usr/bin/env node
+
+// ../server/src/index.ts
+import { createServer } from "http";
+import { URL } from "url";
+import { DBOS as DBOS2 } from "@dbos-inc/dbos-sdk";
+import { ZodError } from "zod";
+
+// ../core/src/config.ts
+import { z } from "zod";
+
+// ../core/src/env.ts
+import { config as dotenvConfig } from "dotenv";
+var envLoaded = false;
+function loadLocalEnv() {
+  if (envLoaded) {
+    return;
+  }
+  dotenvConfig({ path: ".env" });
+  dotenvConfig({ path: ".env.local", override: true });
+  envLoaded = true;
+}
+
+// ../core/src/config.ts
+loadLocalEnv();
+var serverEnvSchema = z.object({
+  DATABASE_URL: z.string().min(1),
+  WORKPLANE_SERVER_PORT: z.string().optional().default("8787").transform((value) => Number.parseInt(value, 10)),
+  WORKPLANE_NODE_TOKEN: z.string().optional(),
+  WORKPLANE_OPERATOR_TOKEN: z.string().optional(),
+  WORKPLANE_ENV_ALLOWLIST: z.string().optional()
+});
+var nodeEnvSchema = z.object({
+  WORKPLANE_SERVER_URL: z.string().url().optional().default("http://localhost:8787"),
+  WORKPLANE_NODE_NAME: z.string().optional().default("local-node-1"),
+  WORKPLANE_NODE_ID: z.string().optional(),
+  WORKPLANE_NODE_CAPABILITIES: z.string().optional().default("shell,git,node,typescript,aider,ollama,codex,claude-code"),
+  WORKPLANE_NODE_TOKEN: z.string().optional(),
+  WORKPLANE_POLL_INTERVAL_MS: z.string().optional().default("3000").transform((value) => Number.parseInt(value, 10)),
+  WORKPLANE_ENV_ALLOWLIST: z.string().optional()
+});
+function loadServerConfig(env = process.env) {
+  const parsed = serverEnvSchema.parse(env);
+  return {
+    databaseUrl: parsed.DATABASE_URL,
+    port: parsed.WORKPLANE_SERVER_PORT,
+    nodeToken: parsed.WORKPLANE_NODE_TOKEN,
+    operatorToken: parsed.WORKPLANE_OPERATOR_TOKEN,
+    envAllowlist: parseCsv(parsed.WORKPLANE_ENV_ALLOWLIST ?? "")
+  };
+}
+function parseCsv(value) {
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+
+// ../db/src/client.ts
+import { Pool } from "pg";
+var pools = /* @__PURE__ */ new Map();
+function getPool(databaseUrl) {
+  const existing = pools.get(databaseUrl);
+  if (existing) {
+    return existing;
+  }
+  const pool = new Pool({ connectionString: databaseUrl });
+  pools.set(databaseUrl, pool);
+  return pool;
+}
+
+// ../core/src/ids.ts
+import { randomUUID } from "crypto";
+function makeId(prefix) {
+  return `${prefix}_${randomUUID().replace(/-/g, "").slice(0, 12)}`;
+}
+
+// ../server/src/store.ts
+function mapTask(row) {
+  return {
+    id: String(row.id),
+    kind: String(row.kind),
+    adapter: String(row.adapter),
+    payload: row.payload ?? {},
+    requires: row.requires ?? [],
+    status: row.status,
+    createdAt: new Date(String(row.created_at)).toISOString(),
+    updatedAt: new Date(String(row.updated_at)).toISOString()
+  };
+}
+function mapRun(row) {
+  return {
+    id: String(row.id),
+    taskId: String(row.task_id),
+    nodeId: String(row.node_id),
+    attempt: Number(row.attempt),
+    status: row.status,
+    startedAt: row.started_at ? new Date(String(row.started_at)).toISOString() : null,
+    endedAt: row.ended_at ? new Date(String(row.ended_at)).toISOString() : null,
+    error: row.error ? String(row.error) : null
+  };
+}
+function mapArtifact(row) {
+  return {
+    id: String(row.id),
+    runId: String(row.run_id),
+    type: String(row.type),
+    name: String(row.name),
+    path: String(row.path),
+    metadata: row.metadata ?? null,
+    createdAt: new Date(String(row.created_at)).toISOString()
+  };
+}
+var PgStore = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  pool;
+  async createTask(input) {
+    const taskId = makeId("task");
+    const result = await this.pool.query(
+      `
+      insert into tasks (id, kind, adapter, payload, requires, status)
+      values ($1, $2, $3, $4::jsonb, $5::text[], 'queued')
+      returning *
+      `,
+      [taskId, input.kind, input.adapter, JSON.stringify(input.payload), input.requires ?? []]
+    );
+    return mapTask(result.rows[0]);
+  }
+  async listTasks(status) {
+    const result = status ? await this.pool.query("select * from tasks where status = $1 order by created_at desc limit 100", [status]) : await this.pool.query("select * from tasks order by created_at desc limit 100");
+    return result.rows.map((row) => mapTask(row));
+  }
+  async getTask(taskId) {
+    const result = await this.pool.query("select * from tasks where id = $1", [taskId]);
+    if (result.rowCount === 0) {
+      return null;
+    }
+    return mapTask(result.rows[0]);
+  }
+  async listRuns(filters) {
+    const taskId = filters?.taskId;
+    const status = filters?.status;
+    const result = taskId && status ? await this.pool.query("select * from runs where task_id = $1 and status = $2 order by created_at desc", [
+      taskId,
+      status
+    ]) : taskId ? await this.pool.query("select * from runs where task_id = $1 order by created_at desc", [taskId]) : status ? await this.pool.query("select * from runs where status = $1 order by created_at desc limit 100", [status]) : await this.pool.query("select * from runs order by created_at desc limit 100");
+    return result.rows.map((row) => mapRun(row));
+  }
+  async getRun(runId) {
+    const result = await this.pool.query("select * from runs where id = $1", [runId]);
+    if (result.rowCount === 0) {
+      return null;
+    }
+    return mapRun(result.rows[0]);
+  }
+  async registerNode(name, capabilities, preferredId) {
+    const existing = await this.pool.query("select * from nodes where name = $1", [name]);
+    if (existing.rowCount && existing.rowCount > 0) {
+      const row = existing.rows[0];
+      const nodeId2 = String(row.id);
+      const updated = await this.pool.query(
+        `
+        update nodes
+        set capabilities = $2::text[], status = 'online', last_heartbeat_at = now(), updated_at = now()
+        where id = $1
+        returning *
+        `,
+        [nodeId2, capabilities]
+      );
+      return this.mapNodeRecord(updated.rows[0]);
+    }
+    const nodeId = preferredId ?? makeId("node");
+    const result = await this.pool.query(
+      `
+      insert into nodes (id, name, capabilities, status, last_heartbeat_at)
+      values ($1, $2, $3::text[], 'online', now())
+      returning *
+      `,
+      [nodeId, name, capabilities]
+    );
+    return this.mapNodeRecord(result.rows[0]);
+  }
+  async getRunCancellationState(runId) {
+    const result = await this.pool.query(
+      `
+      select r.status as run_status, t.status as task_status
+      from runs r
+      join tasks t on t.id = r.task_id
+      where r.id = $1
+      `,
+      [runId]
+    );
+    if (result.rowCount === 0) {
+      return null;
+    }
+    const row = result.rows[0];
+    return {
+      runStatus: String(row.run_status),
+      taskStatus: String(row.task_status)
+    };
+  }
+  mapNodeRecord(row) {
+    return {
+      id: String(row.id),
+      name: String(row.name),
+      capabilities: row.capabilities ?? [],
+      status: row.status,
+      lastHeartbeatAt: row.last_heartbeat_at ? new Date(String(row.last_heartbeat_at)).toISOString() : null
+    };
+  }
+  async pollNode(nodeId, capabilities) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("begin");
+      await this.touchNode(client, nodeId, capabilities);
+      const taskResult = await client.query(
+        `
+        select *
+        from tasks
+        where status = 'queued'
+          and requires <@ $1::text[]
+        order by created_at asc
+        limit 1
+        for update skip locked
+        `,
+        [capabilities]
+      );
+      if (taskResult.rowCount === 0) {
+        await client.query("commit");
+        return null;
+      }
+      const taskRow = taskResult.rows[0];
+      const taskId = String(taskRow.id);
+      const runId = makeId("run");
+      const attemptResult = await client.query("select coalesce(max(attempt), 0) as max_attempt from runs where task_id = $1", [
+        taskId
+      ]);
+      const attempt = Number(attemptResult.rows[0].max_attempt) + 1;
+      const runResult = await client.query(
+        `
+        insert into runs (id, task_id, node_id, attempt, status, started_at)
+        values ($1, $2, $3, $4, 'assigned', now())
+        returning *
+        `,
+        [runId, taskId, nodeId, attempt]
+      );
+      await client.query("update tasks set status = 'assigned', updated_at = now() where id = $1", [taskId]);
+      await client.query("commit");
+      return {
+        task: mapTask(taskRow),
+        run: mapRun(runResult.rows[0])
+      };
+    } catch (error) {
+      await client.query("rollback");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async updateRunStatus(runId, status, error) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("begin");
+      const currentResult = await client.query(
+        `
+        select r.*, t.status as task_status
+        from runs r
+        join tasks t on t.id = r.task_id
+        where r.id = $1
+        for update
+        `,
+        [runId]
+      );
+      if (currentResult.rowCount === 0) {
+        await client.query("rollback");
+        return null;
+      }
+      const currentRow = currentResult.rows[0];
+      const currentTaskStatus = String(currentRow.task_status);
+      if (currentTaskStatus === "cancelled" && status !== "cancelled") {
+        await client.query("commit");
+        return mapRun(currentRow);
+      }
+      const runResult = await client.query(
+        `
+        update runs
+        set status = $2, error = $3, ended_at = case when $2 in ('succeeded', 'failed', 'cancelled') then now() else ended_at end, updated_at = now()
+        where id = $1
+        returning *
+        `,
+        [runId, status, error ?? null]
+      );
+      if (runResult.rowCount === 0) {
+        await client.query("rollback");
+        return null;
+      }
+      const run = mapRun(runResult.rows[0]);
+      const nextTaskStatus = status === "succeeded" || status === "failed" || status === "cancelled" ? status : "running";
+      if (currentTaskStatus !== "cancelled" || status === "cancelled") {
+        await client.query("update tasks set status = $2, updated_at = now() where id = $1", [run.taskId, nextTaskStatus]);
+      }
+      await client.query("commit");
+      return run;
+    } catch (error2) {
+      await client.query("rollback");
+      throw error2;
+    } finally {
+      client.release();
+    }
+  }
+  async appendRunLogs(runId, logs) {
+    let inserted = 0;
+    for (const log of logs) {
+      await this.pool.query(
+        `
+        insert into run_logs (run_id, step_name, stream, message)
+        values ($1, $2, $3, $4)
+        `,
+        [runId, log.stepName ?? null, log.stream, log.message]
+      );
+      inserted += 1;
+    }
+    return inserted;
+  }
+  async getRunLogs(runId) {
+    const result = await this.pool.query("select * from run_logs where run_id = $1 order by timestamp asc", [runId]);
+    return result.rows;
+  }
+  async createArtifact(runId, input) {
+    const artifactId = makeId("artifact");
+    const result = await this.pool.query(
+      `
+      insert into artifacts (id, run_id, type, name, path, metadata)
+      values ($1, $2, $3, $4, $5, $6::jsonb)
+      returning *
+      `,
+      [artifactId, runId, input.type, input.name, input.path, input.metadata ? JSON.stringify(input.metadata) : null]
+    );
+    return mapArtifact(result.rows[0]);
+  }
+  async listRunArtifacts(runId) {
+    const result = await this.pool.query("select * from artifacts where run_id = $1 order by created_at asc", [runId]);
+    return result.rows.map((row) => mapArtifact(row));
+  }
+  async retryTask(taskId) {
+    const result = await this.pool.query(
+      `
+      update tasks
+      set status = 'queued', updated_at = now()
+      where id = $1 and status = 'failed'
+      returning *
+      `,
+      [taskId]
+    );
+    if (result.rowCount === 0) {
+      return null;
+    }
+    return mapTask(result.rows[0]);
+  }
+  async cancelTask(taskId) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("begin");
+      const taskResult = await client.query("select * from tasks where id = $1 for update", [taskId]);
+      if (taskResult.rowCount === 0) {
+        await client.query("rollback");
+        return null;
+      }
+      const taskRow = taskResult.rows[0];
+      const taskStatus = String(taskRow.status);
+      if (taskStatus === "succeeded" || taskStatus === "failed" || taskStatus === "cancelled") {
+        await client.query("rollback");
+        return null;
+      }
+      if (taskStatus === "assigned" || taskStatus === "running") {
+        const runResult = await client.query(
+          `
+          select * from runs
+          where task_id = $1
+          order by attempt desc
+          limit 1
+          for update
+          `,
+          [taskId]
+        );
+        if (runResult.rowCount !== 0) {
+          const runStatus = String(runResult.rows[0].status);
+          if (runStatus !== "succeeded" && runStatus !== "failed" && runStatus !== "cancelled") {
+            await client.query(
+              `
+              update runs
+              set status = 'cancelled', ended_at = now(), updated_at = now(), error = coalesce(error, 'task cancelled')
+              where id = $1
+              `,
+              [runResult.rows[0].id]
+            );
+          }
+        }
+      }
+      const updateTaskResult = await client.query(
+        `
+        update tasks
+        set status = 'cancelled', updated_at = now()
+        where id = $1
+        returning *
+        `,
+        [taskId]
+      );
+      await client.query("commit");
+      return mapTask(updateTaskResult.rows[0]);
+    } catch (error) {
+      await client.query("rollback");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async touchNode(client, nodeId, capabilities) {
+    await client.query(
+      `
+      update nodes
+      set capabilities = $2::text[], status = 'online', last_heartbeat_at = now(), updated_at = now()
+      where id = $1
+      `,
+      [nodeId, capabilities]
+    );
+  }
+};
+
+// ../server/src/workflows.ts
+import { DBOS } from "@dbos-inc/dbos-sdk";
+function registerWorkflows(store) {
+  const createTask = DBOS.registerWorkflow(
+    async (input) => DBOS.runStep(() => store.createTask(input), {
+      name: "store-create-task"
+    }),
+    { name: "createTaskWorkflow" }
+  );
+  const retryTask = DBOS.registerWorkflow(
+    async (taskId) => DBOS.runStep(() => store.retryTask(taskId), {
+      name: "store-retry-task"
+    }),
+    { name: "retryTaskWorkflow" }
+  );
+  const cancelTask = DBOS.registerWorkflow(
+    async (taskId) => DBOS.runStep(() => store.cancelTask(taskId), {
+      name: "store-cancel-task"
+    }),
+    { name: "cancelTaskWorkflow" }
+  );
+  const updateRunStatus = DBOS.registerWorkflow(
+    async (runId, status, error) => DBOS.runStep(() => store.updateRunStatus(runId, status, error), {
+      name: "store-update-run-status"
+    }),
+    { name: "updateRunStatusWorkflow" }
+  );
+  const appendRunLogs = DBOS.registerWorkflow(
+    async (runId, logs) => DBOS.runStep(() => store.appendRunLogs(runId, logs), {
+      name: "store-append-run-logs"
+    }),
+    { name: "appendRunLogsWorkflow" }
+  );
+  const createArtifact = DBOS.registerWorkflow(
+    async (runId, input) => DBOS.runStep(() => store.createArtifact(runId, input), {
+      name: "store-create-artifact"
+    }),
+    { name: "createArtifactWorkflow" }
+  );
+  return {
+    createTask,
+    retryTask,
+    cancelTask,
+    updateRunStatus,
+    appendRunLogs,
+    createArtifact
+  };
+}
+
+// ../server/src/validation.ts
+import { z as z2 } from "zod";
+var repoFields = {
+  repo: z2.string().min(1).optional(),
+  branch: z2.string().min(1).optional()
+};
+var shellTaskSchema = z2.object({
+  kind: z2.literal("shell.exec"),
+  adapter: z2.literal("shell"),
+  requires: z2.array(z2.string().min(1)).optional(),
+  payload: z2.object({
+    command: z2.string().min(1),
+    args: z2.array(z2.string()).optional(),
+    cwd: z2.string().min(1).optional(),
+    ...repoFields
+  })
+});
+var aiderTaskSchema = z2.object({
+  kind: z2.literal("agent.run"),
+  adapter: z2.literal("aider"),
+  requires: z2.array(z2.string().min(1)).optional(),
+  payload: z2.object({
+    prompt: z2.string().min(1),
+    model: z2.string().min(1).optional(),
+    repo: z2.string().min(1),
+    branch: z2.string().min(1).optional(),
+    testCommand: z2.string().min(1).optional()
+  })
+});
+var ollamaTaskSchema = z2.object({
+  kind: z2.literal("inference.batch"),
+  adapter: z2.literal("ollama"),
+  requires: z2.array(z2.string().min(1)).optional(),
+  payload: z2.object({
+    model: z2.string().min(1),
+    prompt: z2.string().min(1),
+    inputFile: z2.string().min(1).optional()
+  })
+});
+var harnessPayloadSchema = z2.object({
+  prompt: z2.string().min(1),
+  model: z2.string().min(1).optional(),
+  repo: z2.string().min(1),
+  branch: z2.string().min(1).optional(),
+  testCommand: z2.string().min(1).optional(),
+  extraArgs: z2.array(z2.string()).optional()
+});
+var codexTaskSchema = z2.object({
+  kind: z2.literal("agent.run"),
+  adapter: z2.literal("codex"),
+  requires: z2.array(z2.string().min(1)).optional(),
+  payload: harnessPayloadSchema
+});
+var claudeCodeTaskSchema = z2.object({
+  kind: z2.literal("agent.run"),
+  adapter: z2.literal("claude-code"),
+  requires: z2.array(z2.string().min(1)).optional(),
+  payload: harnessPayloadSchema
+});
+var taskSchema = z2.discriminatedUnion("adapter", [
+  shellTaskSchema,
+  aiderTaskSchema,
+  ollamaTaskSchema,
+  codexTaskSchema,
+  claudeCodeTaskSchema
+]);
+function validateCreateTaskInput(input) {
+  return taskSchema.parse(input);
+}
+
+// ../core/src/auth.ts
+function parseBearerToken(authorizationHeader) {
+  if (!authorizationHeader) {
+    return void 0;
+  }
+  const match = /^Bearer\s+(.+)$/i.exec(authorizationHeader.trim());
+  return match?.[1];
+}
+function isAuthorizedBearer(provided, expected) {
+  if (!expected) {
+    return true;
+  }
+  if (!provided) {
+    return false;
+  }
+  return provided === expected;
+}
+function getRequestBearer(req) {
+  const header = req.headers.authorization;
+  const value = Array.isArray(header) ? header[0] : header;
+  return parseBearerToken(value);
+}
+
+// ../server/src/auth-middleware.ts
+function checkRouteAuth(req, res, auth, config) {
+  const bearer = getRequestBearer(req);
+  if (auth === "public") {
+    return true;
+  }
+  if (auth === "node") {
+    if (!isAuthorizedBearer(bearer, config.nodeToken)) {
+      res.statusCode = 401;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ error: "unauthorized node request" }));
+      return false;
+    }
+    return true;
+  }
+  if (auth === "operator") {
+    if (!isAuthorizedBearer(bearer, config.operatorToken)) {
+      res.statusCode = 401;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ error: "unauthorized operator request" }));
+      return false;
+    }
+    return true;
+  }
+  return true;
+}
+function routeAuthFor(method, pathname) {
+  if (pathname === "/healthz") {
+    return "public";
+  }
+  if (method === "POST" && pathname === "/nodes/register") {
+    return "node";
+  }
+  if (method === "POST" && /^\/nodes\/[^/]+\/poll$/.test(pathname)) {
+    return "node";
+  }
+  if (method === "POST" && /^\/runs\/[^/]+\/status$/.test(pathname)) {
+    return "node";
+  }
+  if (method === "POST" && /^\/runs\/[^/]+\/logs$/.test(pathname)) {
+    return "node";
+  }
+  if (method === "POST" && /^\/runs\/[^/]+\/artifacts$/.test(pathname)) {
+    return "node";
+  }
+  if (method === "POST" && pathname === "/tasks") {
+    return "operator";
+  }
+  if (method === "POST" && /^\/tasks\/[^/]+\/retry$/.test(pathname)) {
+    return "operator";
+  }
+  if (method === "POST" && /^\/tasks\/[^/]+\/cancel$/.test(pathname)) {
+    return "operator";
+  }
+  return "public";
+}
+function requiresConfiguredToken(auth, config) {
+  if (auth === "node") {
+    return Boolean(config.nodeToken);
+  }
+  if (auth === "operator") {
+    return Boolean(config.operatorToken);
+  }
+  return false;
+}
+
+// ../server/src/index.ts
+var taskStatuses = /* @__PURE__ */ new Set(["queued", "assigned", "running", "succeeded", "failed", "cancelled"]);
+function parseStatus(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (!taskStatuses.has(value)) {
+    throw new Error(`invalid status filter: ${value}`);
+  }
+  return value;
+}
+async function readJson(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const body = Buffer.concat(chunks).toString("utf8");
+  return body ? JSON.parse(body) : {};
+}
+function writeJson(res, statusCode, payload) {
+  const json = JSON.stringify(payload);
+  res.statusCode = statusCode;
+  res.setHeader("content-type", "application/json");
+  res.end(json);
+}
+async function main() {
+  const config = loadServerConfig();
+  const pool = getPool(config.databaseUrl);
+  const store = new PgStore(pool);
+  const workflows = registerWorkflows(store);
+  const appName = process.env.DBOS_APPLICATION_NAME ?? "workplane-server";
+  const conductorKey = process.env.DBOS_CONDUCTOR_KEY;
+  const conductorUrl = process.env.DBOS_CONDUCTOR_URL;
+  DBOS2.setConfig({
+    name: appName,
+    systemDatabaseUrl: config.databaseUrl
+  });
+  await DBOS2.launch({
+    conductorKey,
+    conductorURL: conductorUrl
+  });
+  const server = createServer(async (req, res) => {
+    try {
+      if (!req.url || !req.method) {
+        writeJson(res, 400, { error: "invalid request" });
+        return;
+      }
+      const url = new URL(req.url, "http://localhost");
+      const routeAuth = routeAuthFor(req.method, url.pathname);
+      const authConfig = { nodeToken: config.nodeToken, operatorToken: config.operatorToken };
+      if (requiresConfiguredToken(routeAuth, authConfig) && !checkRouteAuth(req, res, routeAuth, authConfig)) {
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/healthz") {
+        writeJson(res, 200, { ok: true });
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/tasks") {
+        const body = await readJson(req);
+        const validated = validateCreateTaskInput(body);
+        const handle = await DBOS2.startWorkflow(workflows.createTask)({
+          kind: validated.kind,
+          adapter: validated.adapter,
+          payload: validated.payload,
+          requires: validated.requires ?? []
+        });
+        const task = await handle.getResult();
+        writeJson(res, 201, task);
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/tasks") {
+        const status = parseStatus(url.searchParams.get("status"));
+        const tasks = await store.listTasks(status);
+        writeJson(res, 200, { tasks });
+        return;
+      }
+      if (req.method === "GET" && /^\/tasks\/[^/]+$/.test(url.pathname)) {
+        const taskId = url.pathname.split("/")[2];
+        const task = await store.getTask(taskId);
+        if (!task) {
+          writeJson(res, 404, { error: "task not found" });
+          return;
+        }
+        writeJson(res, 200, task);
+        return;
+      }
+      if (req.method === "POST" && /^\/tasks\/[^/]+\/retry$/.test(url.pathname)) {
+        const taskId = url.pathname.split("/")[2];
+        const handle = await DBOS2.startWorkflow(workflows.retryTask)(taskId);
+        const task = await handle.getResult();
+        if (!task) {
+          writeJson(res, 409, { error: "task is not retryable" });
+          return;
+        }
+        writeJson(res, 200, task);
+        return;
+      }
+      if (req.method === "POST" && /^\/tasks\/[^/]+\/cancel$/.test(url.pathname)) {
+        const taskId = url.pathname.split("/")[2];
+        const handle = await DBOS2.startWorkflow(workflows.cancelTask)(taskId);
+        const task = await handle.getResult();
+        if (!task) {
+          writeJson(res, 409, { error: "task is not cancellable" });
+          return;
+        }
+        writeJson(res, 200, task);
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/runs") {
+        const taskId = url.searchParams.get("taskId") ?? void 0;
+        const status = parseStatus(url.searchParams.get("status"));
+        const runs = await store.listRuns({ taskId, status });
+        writeJson(res, 200, { runs });
+        return;
+      }
+      if (req.method === "GET" && /^\/runs\/[^/]+$/.test(url.pathname)) {
+        const runId = url.pathname.split("/")[2];
+        const run = await store.getRun(runId);
+        if (!run) {
+          writeJson(res, 404, { error: "run not found" });
+          return;
+        }
+        writeJson(res, 200, run);
+        return;
+      }
+      if (req.method === "GET" && /^\/runs\/[^/]+\/logs$/.test(url.pathname)) {
+        const runId = url.pathname.split("/")[2];
+        const logs = await store.getRunLogs(runId);
+        writeJson(res, 200, { logs });
+        return;
+      }
+      if (req.method === "GET" && /^\/runs\/[^/]+\/artifacts$/.test(url.pathname)) {
+        const runId = url.pathname.split("/")[2];
+        const artifacts = await store.listRunArtifacts(runId);
+        writeJson(res, 200, { artifacts });
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/nodes/register") {
+        const body = await readJson(req);
+        const node = await store.registerNode(body.name, body.capabilities ?? [], body.nodeId);
+        writeJson(res, 201, node);
+        return;
+      }
+      if (req.method === "POST" && /^\/nodes\/[^/]+\/poll$/.test(url.pathname)) {
+        const nodeId = url.pathname.split("/")[2];
+        const body = await readJson(req);
+        const assignment = await store.pollNode(nodeId, body.capabilities ?? []);
+        writeJson(res, 200, { assignment });
+        return;
+      }
+      if (req.method === "POST" && /^\/runs\/[^/]+\/status$/.test(url.pathname)) {
+        const runId = url.pathname.split("/")[2];
+        const body = await readJson(req);
+        const handle = await DBOS2.startWorkflow(workflows.updateRunStatus)(runId, body.status, body.error);
+        const run = await handle.getResult();
+        if (!run) {
+          writeJson(res, 404, { error: "run not found" });
+          return;
+        }
+        writeJson(res, 200, run);
+        return;
+      }
+      if (req.method === "POST" && /^\/runs\/[^/]+\/logs$/.test(url.pathname)) {
+        const runId = url.pathname.split("/")[2];
+        const body = await readJson(req);
+        const handle = await DBOS2.startWorkflow(workflows.appendRunLogs)(runId, body.logs ?? []);
+        const inserted = await handle.getResult();
+        writeJson(res, 200, { inserted });
+        return;
+      }
+      if (req.method === "POST" && /^\/runs\/[^/]+\/artifacts$/.test(url.pathname)) {
+        const runId = url.pathname.split("/")[2];
+        const body = await readJson(req);
+        const handle = await DBOS2.startWorkflow(workflows.createArtifact)(runId, body);
+        const artifact = await handle.getResult();
+        writeJson(res, 201, artifact);
+        return;
+      }
+      writeJson(res, 404, { error: "not found" });
+    } catch (error) {
+      if (error instanceof ZodError) {
+        writeJson(res, 400, { error: "invalid task payload", details: error });
+        return;
+      }
+      if (error instanceof Error && error.message.startsWith("invalid status filter:")) {
+        writeJson(res, 400, { error: error.message });
+        return;
+      }
+      const message = error instanceof Error ? error.message : "internal error";
+      writeJson(res, 500, { error: message });
+    }
+  });
+  server.listen(config.port, () => {
+    process.stdout.write(`workplane server listening on http://localhost:${config.port}
+`);
+  });
+  const shutdown = async () => {
+    await DBOS2.shutdown();
+    await pool.end();
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => {
+    void shutdown();
+  });
+  process.on("SIGTERM", () => {
+    void shutdown();
+  });
+}
+main().catch((error) => {
+  process.stderr.write(`${String(error)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map