workplane 0.1.2 → 0.3.0

package/dist/server.js

@@ -1,9 +1,126 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../dbos/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DbosWorkflows: () => DbosWorkflows,
+  createDbosWorkflows: () => createDbosWorkflows
+});
+import { DBOS } from "@dbos-inc/dbos-sdk";
+function createDbosWorkflows(store) {
+  return new DbosWorkflows(store);
+}
+var DbosWorkflows;
+var init_src = __esm({
+  "../dbos/src/index.ts"() {
+    "use strict";
+    DbosWorkflows = class {
+      registered;
+      constructor(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" }
+        );
+        const appendInputEvent = DBOS.registerWorkflow(
+          async (runId, input) => DBOS.runStep(() => store.appendInputEvent(runId, input), { name: "store-append-input-event" }),
+          { name: "appendInputEventWorkflow" }
+        );
+        const markInputDelivered = DBOS.registerWorkflow(
+          async (runId, sequence) => DBOS.runStep(() => store.markInputDelivered(runId, sequence), { name: "store-mark-input-delivered" }),
+          { name: "markInputDeliveredWorkflow" }
+        );
+        this.registered = {
+          createTask,
+          retryTask,
+          cancelTask,
+          updateRunStatus,
+          appendRunLogs,
+          createArtifact,
+          appendInputEvent,
+          markInputDelivered
+        };
+      }
+      async launch(options) {
+        DBOS.setConfig({
+          name: options.appName,
+          systemDatabaseUrl: options.systemDatabaseUrl
+        });
+        await DBOS.launch({
+          conductorKey: options.conductorKey,
+          conductorURL: options.conductorUrl
+        });
+      }
+      async shutdown() {
+        await DBOS.shutdown();
+      }
+      async createTask(input) {
+        const handle = await DBOS.startWorkflow(this.registered.createTask)(input);
+        return handle.getResult();
+      }
+      async retryTask(taskId) {
+        const handle = await DBOS.startWorkflow(this.registered.retryTask)(taskId);
+        return handle.getResult();
+      }
+      async cancelTask(taskId) {
+        const handle = await DBOS.startWorkflow(this.registered.cancelTask)(taskId);
+        return handle.getResult();
+      }
+      async updateRunStatus(runId, status, error) {
+        const handle = await DBOS.startWorkflow(this.registered.updateRunStatus)(runId, status, error);
+        return handle.getResult();
+      }
+      async appendRunLogs(runId, logs) {
+        const handle = await DBOS.startWorkflow(this.registered.appendRunLogs)(runId, logs);
+        return handle.getResult();
+      }
+      async createArtifact(runId, input) {
+        const handle = await DBOS.startWorkflow(this.registered.createArtifact)(runId, input);
+        return handle.getResult();
+      }
+      async appendInputEvent(runId, input) {
+        const handle = await DBOS.startWorkflow(this.registered.appendInputEvent)(runId, input);
+        return handle.getResult();
+      }
+      async markInputDelivered(runId, sequence) {
+        const handle = await DBOS.startWorkflow(this.registered.markInputDelivered)(runId, sequence);
+        await handle.getResult();
+      }
+    };
+  }
+});
 
 // ../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
@@ -97,6 +214,17 @@ function mapRun(row) {
     error: row.error ? String(row.error) : null
   };
 }
+function mapInputEvent(row) {
+  return {
+    id: Number(row.id),
+    runId: String(row.run_id),
+    sequence: Number(row.sequence),
+    kind: row.kind,
+    payload: row.payload ?? {},
+    createdAt: new Date(String(row.created_at)).toISOString(),
+    deliveredAt: row.delivered_at ? new Date(String(row.delivered_at)).toISOString() : null
+  };
+}
 function mapArtifact(row) {
   return {
     id: String(row.id),
@@ -414,6 +542,45 @@ var PgStore = class {
       client.release();
     }
   }
+  async appendInputEvent(runId, input) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("begin");
+      const seqResult = await client.query(
+        "select coalesce(max(sequence), 0) + 1 as next_seq from run_input_events where run_id = $1",
+        [runId]
+      );
+      const sequence = Number(seqResult.rows[0].next_seq);
+      const result = await client.query(
+        `
+        insert into run_input_events (run_id, sequence, kind, payload)
+        values ($1, $2, $3, $4::jsonb)
+        returning *
+        `,
+        [runId, sequence, input.kind, JSON.stringify(input.payload)]
+      );
+      await client.query("commit");
+      return mapInputEvent(result.rows[0]);
+    } catch (error) {
+      await client.query("rollback");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async getInputEvents(runId, afterSequence) {
+    const result = await this.pool.query(
+      "select * from run_input_events where run_id = $1 and sequence > $2 order by sequence asc",
+      [runId, afterSequence]
+    );
+    return result.rows.map((row) => mapInputEvent(row));
+  }
+  async markInputDelivered(runId, sequence) {
+    await this.pool.query(
+      "update run_input_events set delivered_at = now() where run_id = $1 and sequence = $2",
+      [runId, sequence]
+    );
+  }
   async touchNode(client, nodeId, capabilities) {
     await client.query(
       `
@@ -426,54 +593,37 @@ var PgStore = class {
   }
 };
 
-// ../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/workflows-vanilla.ts
+var VanillaWorkflows = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  createTask(input) {
+    return this.store.createTask(input);
+  }
+  retryTask(taskId) {
+    return this.store.retryTask(taskId);
+  }
+  cancelTask(taskId) {
+    return this.store.cancelTask(taskId);
+  }
+  updateRunStatus(runId, status, error) {
+    return this.store.updateRunStatus(runId, status, error);
+  }
+  appendRunLogs(runId, logs) {
+    return this.store.appendRunLogs(runId, logs);
+  }
+  createArtifact(runId, input) {
+    return this.store.createArtifact(runId, input);
+  }
+  appendInputEvent(runId, input) {
+    return this.store.appendInputEvent(runId, input);
+  }
+  markInputDelivered(runId, sequence) {
+    return this.store.markInputDelivered(runId, sequence);
+  }
+};
 
 // ../server/src/validation.ts
 import { z as z2 } from "zod";
@@ -520,7 +670,8 @@ var harnessPayloadSchema = z2.object({
   repo: z2.string().min(1),
   branch: z2.string().min(1).optional(),
   testCommand: z2.string().min(1).optional(),
-  extraArgs: z2.array(z2.string()).optional()
+  extraArgs: z2.array(z2.string()).optional(),
+  interactive: z2.boolean().optional()
 });
 var codexTaskSchema = z2.object({
   kind: z2.literal("agent.run"),
@@ -544,6 +695,26 @@ var taskSchema = z2.discriminatedUnion("adapter", [
 function validateCreateTaskInput(input) {
   return taskSchema.parse(input);
 }
+var inputEventSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("stdin"),
+    payload: z2.object({ data: z2.string() })
+  }),
+  z2.object({
+    kind: z2.literal("signal"),
+    payload: z2.object({ signal: z2.enum(["SIGTERM", "SIGKILL", "SIGINT"]) })
+  }),
+  z2.object({
+    kind: z2.literal("resize"),
+    payload: z2.object({
+      rows: z2.number().int().positive(),
+      cols: z2.number().int().positive()
+    })
+  })
+]);
+function validateInputEvent(input) {
+  return inputEventSchema.parse(input);
+}
 
 // ../core/src/auth.ts
 function parseBearerToken(authorizationHeader) {
@@ -613,6 +784,15 @@ function routeAuthFor(method, pathname) {
   if (method === "POST" && /^\/runs\/[^/]+\/artifacts$/.test(pathname)) {
     return "node";
   }
+  if (method === "GET" && /^\/runs\/[^/]+\/input$/.test(pathname)) {
+    return "node";
+  }
+  if (method === "POST" && /^\/runs\/[^/]+\/input\/\d+\/delivered$/.test(pathname)) {
+    return "node";
+  }
+  if (method === "POST" && /^\/runs\/[^/]+\/input$/.test(pathname)) {
+    return "operator";
+  }
   if (method === "POST" && pathname === "/tasks") {
     return "operator";
   }
@@ -659,22 +839,26 @@ function writeJson(res, statusCode, payload) {
   res.setHeader("content-type", "application/json");
   res.end(json);
 }
+async function buildWorkflows(store, config) {
+  if (process.env.WORKPLANE_USE_DBOS === "true") {
+    const { createDbosWorkflows: createDbosWorkflows2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const dbos = createDbosWorkflows2(store);
+    await dbos.launch({
+      appName: process.env.DBOS_APPLICATION_NAME ?? "workplane-server",
+      systemDatabaseUrl: config.databaseUrl,
+      conductorKey: process.env.DBOS_CONDUCTOR_KEY,
+      conductorUrl: process.env.DBOS_CONDUCTOR_URL
+    });
+    return { workflows: dbos, shutdown: () => dbos.shutdown() };
+  }
+  return { workflows: new VanillaWorkflows(store), shutdown: async () => {
+  } };
+}
 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 { workflows, shutdown: shutdownWorkflows } = await buildWorkflows(store, config);
   const server = createServer(async (req, res) => {
     try {
       if (!req.url || !req.method) {
@@ -694,13 +878,12 @@ async function main() {
       if (req.method === "POST" && url.pathname === "/tasks") {
         const body = await readJson(req);
         const validated = validateCreateTaskInput(body);
-        const handle = await DBOS2.startWorkflow(workflows.createTask)({
+        const task = await workflows.createTask({
           kind: validated.kind,
           adapter: validated.adapter,
           payload: validated.payload,
           requires: validated.requires ?? []
         });
-        const task = await handle.getResult();
         writeJson(res, 201, task);
         return;
       }
@@ -722,8 +905,7 @@ async function main() {
       }
       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();
+        const task = await workflows.retryTask(taskId);
         if (!task) {
           writeJson(res, 409, { error: "task is not retryable" });
           return;
@@ -733,8 +915,7 @@ async function main() {
       }
       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();
+        const task = await workflows.cancelTask(taskId);
         if (!task) {
           writeJson(res, 409, { error: "task is not cancellable" });
           return;
@@ -787,8 +968,7 @@ async function main() {
       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();
+        const run = await workflows.updateRunStatus(runId, body.status, body.error);
         if (!run) {
           writeJson(res, 404, { error: "run not found" });
           return;
@@ -799,19 +979,49 @@ async function main() {
       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();
+        const inserted = await workflows.appendRunLogs(runId, body.logs ?? []);
         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();
+        const artifact = await workflows.createArtifact(runId, body);
         writeJson(res, 201, artifact);
         return;
       }
+      if (req.method === "POST" && /^\/runs\/[^/]+\/input$/.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;
+        }
+        if (run.status !== "running") {
+          writeJson(res, 409, { error: "run is not active" });
+          return;
+        }
+        const body = await readJson(req);
+        const validated = validateInputEvent(body);
+        const event = await workflows.appendInputEvent(runId, validated);
+        writeJson(res, 201, event);
+        return;
+      }
+      if (req.method === "GET" && /^\/runs\/[^/]+\/input$/.test(url.pathname)) {
+        const runId = url.pathname.split("/")[2];
+        const afterSequence = Number(url.searchParams.get("afterSequence") ?? "0");
+        const events = await store.getInputEvents(runId, afterSequence);
+        writeJson(res, 200, { events });
+        return;
+      }
+      if (req.method === "POST" && /^\/runs\/[^/]+\/input\/\d+\/delivered$/.test(url.pathname)) {
+        const parts = url.pathname.split("/");
+        const runId = parts[2];
+        const sequence = Number(parts[4]);
+        await workflows.markInputDelivered(runId, sequence);
+        writeJson(res, 200, { ok: true });
+        return;
+      }
       writeJson(res, 404, { error: "not found" });
     } catch (error) {
       if (error instanceof ZodError) {
@@ -831,7 +1041,7 @@ async function main() {
 `);
   });
   const shutdown = async () => {
-    await DBOS2.shutdown();
+    await shutdownWorkflows();
     await pool.end();
     server.close();
     process.exit(0);