@op1/threads 0.1.8 → 0.2.0

package/src/workflow-worker.ts

@@ -0,0 +1,210 @@
+import { createHash } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import type { Plugin } from "@opencode/plugin";
+import { Session } from "@opencode/schema/session";
+import type { threads } from "./threads";
+import type { WorkflowAgentInput, WorkflowRun } from "./workflow-types";
+
+type Threads = ReturnType<typeof threads>;
+type Waiter = {
+  limit: number;
+  signal: AbortSignal;
+  resolve: (release: () => void) => void;
+  reject: (reason: unknown) => void;
+  abort: () => void;
+};
+type Semaphore = { active: number; queue: Waiter[] };
+
+const globalState = globalThis as typeof globalThis & {
+  __opWorkflowOwnerSlots?: Map<string, Semaphore>;
+  __opWorkflowRunSlots?: Map<string, Semaphore>;
+};
+const ownerSlots = globalState.__opWorkflowOwnerSlots ??= new Map();
+const runSlots = globalState.__opWorkflowRunSlots ??= new Map();
+
+async function acquire(
+  states: Map<string, Semaphore>,
+  key: string,
+  limit: number,
+  signal: AbortSignal,
+) {
+  if (signal.aborted) throw signal.reason ?? new Error("Workflow cancelled");
+  const state = states.get(key) ?? { active: 0, queue: [] };
+  states.set(key, state);
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    state.active--;
+    for (;;) {
+      const waiter = state.queue[0];
+      if (!waiter || state.active >= waiter.limit) break;
+      state.queue.shift();
+      waiter.signal.removeEventListener("abort", waiter.abort);
+      if (waiter.signal.aborted) {
+        waiter.reject(waiter.signal.reason ?? new Error("Workflow cancelled"));
+        continue;
+      }
+      state.active++;
+      waiter.resolve(releaseFor(states, key, state));
+    }
+    if (state.active === 0 && state.queue.length === 0) states.delete(key);
+  };
+  if (state.active < limit) {
+    state.active++;
+    return release;
+  }
+  return new Promise<() => void>((resolve, reject) => {
+    const waiter: Waiter = {
+      limit,
+      signal,
+      resolve,
+      reject,
+      abort: () => {
+        const index = state.queue.indexOf(waiter);
+        if (index >= 0) state.queue.splice(index, 1);
+        reject(signal.reason ?? new Error("Workflow cancelled"));
+        if (state.active === 0 && state.queue.length === 0) states.delete(key);
+      },
+    };
+    state.queue.push(waiter);
+    signal.addEventListener("abort", waiter.abort, { once: true });
+  });
+}
+
+function releaseFor(states: Map<string, Semaphore>, key: string, state: Semaphore) {
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    state.active--;
+    for (;;) {
+      const waiter = state.queue[0];
+      if (!waiter || state.active >= waiter.limit) break;
+      state.queue.shift();
+      waiter.signal.removeEventListener("abort", waiter.abort);
+      if (waiter.signal.aborted) {
+        waiter.reject(waiter.signal.reason ?? new Error("Workflow cancelled"));
+        continue;
+      }
+      state.active++;
+      waiter.resolve(releaseFor(states, key, state));
+    }
+    if (state.active === 0 && state.queue.length === 0) states.delete(key);
+  };
+}
+
+export async function withWorkflowSlot<T>(
+  ownerID: string,
+  ownerLimit: number,
+  runID: string,
+  runLimit: number,
+  signal: AbortSignal,
+  run: () => Promise<T>,
+): Promise<T> {
+  const releaseRun = await acquire(runSlots, runID, runLimit, signal);
+  try {
+    const releaseOwner = await acquire(ownerSlots, ownerID, ownerLimit, signal);
+    try {
+      return await run();
+    } finally {
+      releaseOwner();
+    }
+  } finally {
+    releaseRun();
+  }
+}
+
+function safePrefix(value: string) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 28);
+}
+
+export function workflowDirectoryPlan(
+  run: WorkflowRun,
+  input: WorkflowAgentInput,
+  namespacedKey: string,
+) {
+  const source = input.directory ?? run.directory;
+  if (input.isolation === "shared") return { source, directory: source };
+  if (input.access !== "write") {
+    throw new Error("Worktree isolation is only supported for explicit write steps");
+  }
+  const hash = createHash("sha256").update(namespacedKey).digest("hex").slice(0, 16);
+  const name = `workflow-${run.id.slice(-10)}-${safePrefix(namespacedKey)}-${hash}`;
+  const parent = join(dirname(source), ".opencode-workflows");
+  return { source, name, parent, directory: join(parent, name) };
+}
+
+function inside(path: string, root: string) {
+  const child = relative(root, path);
+  return child === "" || (!child.startsWith("..") && !isAbsolute(child));
+}
+
+export async function workflowSourceDirectory(
+  ctx: Pick<Plugin.Context, "worktree">,
+  run: WorkflowRun,
+  input: WorkflowAgentInput,
+) {
+  const source = await realpath(input.directory ?? run.directory);
+  const roots = [await realpath(run.directory)];
+  for (const entry of await ctx.worktree.list({ projectID: run.projectID })) {
+    try {
+      roots.push(await realpath(entry.directory));
+    } catch {
+      // Ignore stale inventory entries. They cannot authorize a real source directory.
+    }
+  }
+  if (!roots.some((root) => inside(source, root))) {
+    throw new Error("Workflow directory must be inside the owner project or one of its registered worktrees");
+  }
+  return source;
+}
+
+export async function workflowDirectory(
+  ctx: Pick<Plugin.Context, "worktree">,
+  run: WorkflowRun,
+  input: WorkflowAgentInput,
+  namespacedKey: string,
+): Promise<string> {
+  const plan = workflowDirectoryPlan(run, input, namespacedKey);
+  if (input.isolation === "shared") return plan.directory;
+  const inventory = await ctx.worktree.list({ projectID: run.projectID });
+  if (inventory.some((entry) => entry.directory === plan.directory)) return plan.directory;
+  try {
+    const created = await ctx.worktree.create({
+      projectID: run.projectID,
+      from: plan.source,
+      directory: plan.parent,
+      name: plan.name,
+    });
+    if (created.directory !== plan.directory) {
+      throw new Error(`Worktree strategy returned non-canonical directory ${created.directory}; expected ${plan.directory}`);
+    }
+    return created.directory;
+  } catch (error) {
+    const reconciled = (await ctx.worktree.list({ projectID: run.projectID }))
+      .find((entry) => entry.directory === plan.directory);
+    if (reconciled) return reconciled.directory;
+    throw error;
+  }
+}
+
+export function workflowTask(input: WorkflowAgentInput) {
+  const schema = input.schema === undefined
+    ? "No additional result schema was supplied; return a JSON value appropriate to the task."
+    : `The result field must validate against this JSON Schema:\n${JSON.stringify(input.schema)}`;
+  return `${input.prompt}\n\n${schema}`;
+}
+
+export async function interruptWorkflowWorkers(
+  workers: Threads,
+  ownerID: string,
+  run: WorkflowRun,
+) {
+  await Promise.allSettled(
+    run.steps
+      .filter((step) => step.status === "running" || step.status === "prepared")
+      .map((step) => workers.interrupt(ownerID, { workerID: Session.ID.make(step.workerID) })),
+  );
+}

package/src/workflows.ts

@@ -0,0 +1,180 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { Skill } from "@opencode/plugin";
+import type { Plugin } from "@opencode/plugin";
+import type { SessionContext } from "@opencode/plugin/promise/session";
+import { z } from "zod";
+import { threads } from "./threads";
+import { workflowEngine } from "./workflow-engine";
+import { WorkflowControl, WorkflowsRpc } from "./workflow-rpc";
+import { savedWorkflows, SavedWorkflow } from "./workflow-saved";
+import { WorkflowLimits, WorkflowResult, WorkflowRun, WorkflowStart, WorkflowSummary, workflowSummary } from "./workflow-types";
+
+export async function workflows(
+  ctx: Plugin.Context,
+  workers: ReturnType<typeof threads>,
+  models: Map<SessionContext["sessionID"], SessionContext["model"]>,
+  maxWorkers: number,
+) {
+  const concurrency = WorkflowLimits.shape.concurrency.parse(ctx.options.workflowConcurrency);
+  const maxAgents = WorkflowLimits.shape.maxAgents.parse(ctx.options.workflowMaxAgents);
+  const startInput = WorkflowStart.safeExtend({
+    concurrency: WorkflowLimits.shape.concurrency.default(concurrency),
+    maxAgents: WorkflowLimits.shape.maxAgents.default(maxAgents),
+  });
+  const saved = savedWorkflows(ctx.location.directory, ctx.location.project.canonical);
+  const engine = workflowEngine(ctx, workers, {
+    maxWorkers,
+    loadSaved: (name: string) => saved.load(name),
+    warmWorker: (sessionID: string) => ctx.session.command({ sessionID, name: "workflow-refresh", text: "" }),
+  });
+  const rpc = await ctx.rpc.register(WorkflowsRpc, {
+    snapshot: async ({ ownerID }) => ({ runs: (await engine.list(ownerID)).map(workflowSummary) }),
+    inspect: ({ ownerID, runID }) => engine.get(ownerID, runID),
+    control: async ({ ownerID, ...input }) => {
+      const run = await engine.control(ownerID, input);
+      await rpc.events.emit("updated", { ownerID, runID: run.id });
+      return run;
+    },
+    save: async ({ ownerID, runID, name, scope }) => {
+      const run = await engine.get(ownerID, runID);
+      const result = await saved.save(name, run.script, scope);
+      await refreshCommands();
+      return result;
+    },
+  });
+  await ctx.session.hook("prompt", (event) => engine.preparePrompt(event.sessionID, event.messageID));
+  await ctx.session.hook("context", (event) => engine.prepareContext(event.sessionID));
+  await ctx.tool.transform((editor) => {
+    editor.namespace({ name: "workflows", description: "Durable background JavaScript workflows using native OpenCode agents" });
+    editor.add({
+      name: "start",
+      description: "Start a dynamic JavaScript workflow in the background. Load workflow-authoring first. Supply script or a saved name, a stable retry key, and optional JSON args. The runner owns parallel agents, structured results, checkpoints, and resumable progress. Keep the same key and identical inputs for an exact retry. Configured role permissions apply to every agent. Returns immediately; inspect/control using the run ID.",
+      input: startInput,
+      output: WorkflowSummary,
+      options: { namespace: "workflows", codemode: false },
+      execute: async (input, tool) => {
+        const model = models.get(tool.sessionID);
+        if (!model) throw new Error("Workflow start requires a resolved session model");
+        const run = await engine.start(tool.sessionID, startInput.parse(input), { agent: tool.agent, model });
+        await rpc.events.emit("updated", { ownerID: tool.sessionID, runID: run.id });
+        const output = workflowSummary(run);
+        return { content: JSON.stringify(output), output };
+      },
+    });
+    editor.add({
+      name: "list",
+      description: "List your dynamic workflow runs and recorded progress. The final result and explicit worker evidence determine task success.",
+      input: z.object({}).strict(),
+      output: z.object({ runs: z.array(WorkflowSummary) }),
+      options: { namespace: "workflows", codemode: false },
+      execute: async (_input, tool) => {
+        const output = { runs: (await engine.list(tool.sessionID)).map(workflowSummary) };
+        return { content: JSON.stringify(output), output };
+      },
+    });
+    editor.add({
+      name: "inspect",
+      description: "Read a workflow's saved script, phases, step sessions, structured reports, usage, checkpoints, and final result.",
+      input: z.object({ runID: z.string().min(1) }).strict(),
+      output: WorkflowRun,
+      options: { namespace: "workflows", codemode: false },
+      execute: async (input, tool) => {
+        const output = await engine.get(tool.sessionID, input.runID);
+        return { content: JSON.stringify(output), output };
+      },
+    });
+    editor.add({
+      name: "control",
+      description: "Pause new workflow scheduling, stop active work, or explicitly resume the same recorded script. Resume a waiting checkpoint with checkpointKey and a JSON response. Only the owning session controls the run. Resume reconciles existing workers and recorded results.",
+      input: WorkflowControl,
+      output: WorkflowSummary,
+      options: { namespace: "workflows", codemode: false },
+      execute: async (input, tool) => {
+        const run = await engine.control(tool.sessionID, input);
+        await rpc.events.emit("updated", { ownerID: tool.sessionID, runID: run.id });
+        const output = workflowSummary(run);
+        return { content: JSON.stringify(output), output };
+      },
+    });
+    editor.add({
+      name: "result",
+      description: "Submit the assigned workflow step's final verdict, evidence, and JSON result. Only the original workflow worker can submit. The runner validates result against the step's schema before accepting it. Correct validation errors and retry. PASS requires completed verification, INCONCLUSIVE is not a pass.",
+      input: WorkflowResult,
+      output: z.object({ accepted: z.literal(true) }),
+      options: { namespace: "workflows", codemode: false },
+      execute: async (input, tool) => {
+        const output = await engine.result(tool.sessionID, input);
+        return { content: JSON.stringify(output), output };
+      },
+    });
+    editor.add({
+      name: "save",
+      description: "Save a run's JavaScript as a reusable workflow in the current project's .opencode/workflows or your OpenCode config's workflows directory. Existing files are never overwritten. Saves the script, not run arguments or worker transcripts.",
+      input: z.object({ runID: z.string(), name: z.string(), scope: z.enum(["project", "user"]).default("project") }).strict(),
+      output: z.object({ path: z.string() }),
+      options: { namespace: "workflows", codemode: false, permission: "edit" },
+      execute: async (input, tool) => {
+        const run = await engine.get(tool.sessionID, input.runID);
+        const output = await saved.save(input.name, run.script, input.scope);
+        await refreshCommands();
+        return { content: JSON.stringify(output), output };
+      },
+    });
+    editor.add({
+      name: "saved",
+      description: "List reusable workflow scripts available in this project and your OpenCode configuration. Project names take precedence over user names.",
+      input: z.object({}).strict(),
+      output: z.object({ workflows: z.array(SavedWorkflow) }),
+      options: { namespace: "workflows", codemode: false },
+      execute: async () => {
+        const output = { workflows: await saved.list() };
+        return { content: JSON.stringify(output), output };
+      },
+    });
+  });
+  const skillPath = fileURLToPath(new URL("../skills/workflow-authoring/SKILL.md", import.meta.url));
+  const skill = await readFile(skillPath, "utf8");
+  await ctx.skill.transform((editor) => editor.add({
+    id: Skill.ID.make("workflow-authoring"),
+    name: Skill.Name.make("Workflow authoring"),
+    description: "Author and run durable dynamic JavaScript workflows in OpenCode: parallel agents, structured handoffs, worktrees, recovery, and VERA verification.",
+    path: Skill.Info.fields.path.make(skillPath),
+    content: skill.replace(/^---\n[\s\S]*?\n---\n/, ""),
+  }));
+  let commands = await saved.list();
+  await ctx.command.transform((editor) => {
+    editor.add({
+      name: "workflow-refresh",
+      description: "Reload saved workflow commands for this location",
+      execute: refreshCommands,
+    });
+    editor.add({
+      name: "workflow-run",
+      description: "Ask the current agent to author and start a dynamic workflow",
+      execute: ({ sessionID, prompt, delivery }) => ctx.session.prompt({
+        ...prompt,
+        sessionID,
+        delivery,
+        text: `Load workflow-authoring and use a dynamic workflow for this task. Choose explicit roles and verification requirements, then start it with workflows_start.\n\n${prompt.text}`,
+      }).then(() => {}),
+    });
+    for (const command of commands) {
+      editor.add({
+        name: `workflow-${command.name}`,
+        description: command.description,
+        execute: ({ sessionID, prompt, delivery }) => ctx.session.prompt({
+          ...prompt,
+          sessionID,
+          delivery,
+          text: `Load workflow-authoring, then run saved workflow ${JSON.stringify(command.name)} through workflows_start with arguments from this request:\n\n${prompt.text}`,
+        }).then(() => {}),
+      });
+    }
+  });
+  async function refreshCommands() {
+    commands = await saved.list();
+    await ctx.command.reload();
+  }
+  return () => engine.dispose();
+}

package/tui.ts

@@ -4,6 +4,7 @@ import { createEffect, createSignal } from "solid-js";
 import { z } from "zod";
 import { ThreadsRpc } from "./src/rpc";
 import { activity } from "./src/activity";
+import { workflowUI } from "./src/workflow-ui";
 import { cleanRoleTitle } from "./src/activity-model";
 import {
   BoxRenderable,
@@ -18,6 +19,7 @@ const CoordinatorRef = z.object({ coordinatorID: z.string() });
 export default Plugin.define({
   id: "op-threads",
   setup(ctx) {
+    const stopWorkflows = workflowUI(ctx);
     const rpc = ctx.client.rpc(ThreadsRpc);
     const sidebar = activity(
       ctx,
@@ -226,6 +228,7 @@ export default Plugin.define({
     });
     refresh();
     return () => {
+      stopWorkflows();
       stopped = true;
       abort.abort();
       sidebar.dispose();