@op1/threads 0.1.7 → 0.2.0

package/src/permissions.ts

@@ -1,6 +1,6 @@
 import type { Permission } from "@opencode/schema/permission";
 
-function matches(pattern: string, value: string) {
+export function permissionMatches(pattern: string, value: string) {
   const expression = pattern
     .replaceAll("\\", "/")
     .replace(/[.+^${}()|[\]\\]/g, "\\$&")
@@ -19,7 +19,7 @@ export function delegationEffect(
   agentID: string,
 ): Permission.Effect {
   return rules.findLast((rule) =>
-    matches(rule.action, "subagent") && matches(rule.resource, agentID)
+    permissionMatches(rule.action, "subagent") && permissionMatches(rule.resource, agentID)
   )?.effect ?? "ask";
 }
 

package/src/threads.ts

@@ -8,7 +8,7 @@ import type { Permission } from "@opencode/schema/permission";
 import { Session } from "@opencode/schema/session";
 import { SessionMessage } from "@opencode/schema/session-message";
 import { z } from "zod";
-import { requireDelegation } from "./permissions";
+import { permissionMatches, requireDelegation } from "./permissions";
 import { Report, WorkerView } from "./rpc";
 
 const sessionID = z.string().transform((value) => Session.ID.make(value));
@@ -48,6 +48,12 @@ export const Send = z
   })
   .strict();
 export const WorkerTarget = z.object({ workerID: sessionID }).strict();
+export const WorkflowWorker = z.object({
+  ownerID: sessionID,
+  runID: z.string().min(1),
+  stepKey: z.string().min(1),
+  callerAgent: z.string().min(1),
+}).strict();
 
 const digest = (parts: string[]) =>
   createHash("sha256").update(JSON.stringify(parts)).digest("hex");
@@ -62,6 +68,24 @@ export const fingerprint = (input: z.infer<typeof Spawn>) =>
   ]);
 
 const locks = new Map<string, Promise<void>>();
+type WorkflowExecutionGrant = { watching: boolean };
+const workflowState = globalThis as typeof globalThis & { __opWorkflowExecutionGrantsV2?: Map<string, WorkflowExecutionGrant> };
+const workflowExecutionGrants = workflowState.__opWorkflowExecutionGrantsV2 ??= new Map<string, WorkflowExecutionGrant>();
+export function authorizeWorkflowExecution(workerID: string) {
+  workflowExecutionGrants.set(workerID, { watching: false });
+}
+export function workflowExecutionAuthorized(workerID: string) {
+  return workflowExecutionGrants.has(workerID);
+}
+export function watchWorkflowExecution(workerID: string, untilIdle: () => Promise<void>) {
+  const grant = workflowExecutionGrants.get(workerID);
+  if (!grant || grant.watching) return;
+  grant.watching = true;
+  const revoke = () => {
+    if (workflowExecutionGrants.get(workerID) === grant) workflowExecutionGrants.delete(workerID);
+  };
+  void untilIdle().then(revoke, revoke);
+}
 export async function serialized<T>(
   key: string,
   run: () => Promise<T>,
@@ -119,6 +143,81 @@ export function threads(
     return [...agent.data.permissions, ...(session.permissions ?? [])];
   }
 
+  function workflowPermissions(inherited: Permission.Ruleset, readProfile?: Permission.Ruleset): Permission.Ruleset {
+    const readActions = ["read", "glob", "grep", "webfetch", "websearch", "skill", "external_directory"];
+    return [
+      ...(readProfile === undefined ? [] : [
+        { action: "*", resource: "*", effect: "deny" as const },
+        ...readProfile.flatMap((rule) => readActions
+          .filter((action) => permissionMatches(rule.action, action))
+          .map((action) => ({ ...rule, action }))),
+      ]),
+      ...inherited.filter((rule) => rule.effect !== "allow").map((rule) => ({ ...rule, effect: "deny" as const })),
+      { action: "subagent", resource: "*", effect: "deny" },
+      { action: "threads_*", resource: "*", effect: "deny" },
+      { action: "workflows_*", resource: "*", effect: "deny" },
+      { action: "workflows_result", resource: "*", effect: "allow" },
+    ];
+  }
+
+  async function prepareRole(
+    session: NativeSession,
+    link: z.infer<typeof Link>,
+    messageID: string,
+    callerAgent: string,
+  ) {
+    if (await initialized(session, link)) return;
+    if (link.initialMessageID !== messageID || session.agent === undefined) {
+      throw new Error(
+        "Worker initialization is pending. Retry the original dispatch request.",
+      );
+    }
+    const coordinator = await ctx.session.get({ sessionID: link.coordinatorID });
+    requireDelegation(
+      await callerPermissions(coordinator, callerAgent),
+      session.agent,
+    );
+    const agent = await ctx.agent.get({
+      agentID: session.agent,
+      location: session.location,
+    });
+    if (agent.data.model) {
+      await ctx.session.switchModel({
+        sessionID: session.id,
+        model: agent.data.model,
+      });
+    }
+  }
+
+  async function journalReport(
+    session: NativeSession,
+    link: z.infer<typeof Link>,
+    input: z.infer<typeof Report>,
+    silent: boolean,
+  ) {
+    let canonical = Report.parse(input);
+    if (!silent) {
+      const admitted = await ctx.session.synthetic({
+        sessionID: link.coordinatorID,
+        id: link.reportMessageID,
+        text: `Managed worker ${link.workerID} (${link.key}) report:\n${JSON.stringify(input)}`,
+        metadata: { opThreadsReport: input, workerID: link.workerID },
+        delivery: "queue",
+        resume: true,
+      });
+      canonical = Report.parse(admitted.payload.metadata?.opThreadsReport);
+      if (JSON.stringify(canonical) !== JSON.stringify(Report.parse(input))) {
+        throw new Error("This worker already has a different report. Start a new task with a new spawn key.");
+      }
+    }
+    const existing = await ctx.storage.get(reportKey(link));
+    if (existing !== undefined && JSON.stringify(Report.parse(existing)) !== JSON.stringify(canonical)) {
+      throw new Error("This worker already has a different report. Start a new task with a new spawn key.");
+    }
+    await ctx.storage.set(reportKey(link), canonical);
+    return canonical;
+  }
+
   async function view(
     session: NativeSession,
   ): Promise<z.infer<typeof WorkerView>> {
@@ -193,24 +292,24 @@ export function threads(
       if (session.parentID !== undefined || recorded.workerID !== session.id) return;
       const link = workerLink(session);
       if (await initialized(session, link)) return;
-      if (link.initialMessageID !== messageID || session.agent === undefined) {
-        throw new Error(
-          "Worker initialization is pending. Retry the original threads_spawn request.",
-        );
+      await prepareRole(session, link, messageID, z.string().min(1).parse(callerAgent));
+    },
+    async prepareWorkflowPrompt(actor: string, messageID: string) {
+      const session = await ctx.session.get({ sessionID: actor });
+      const workflow = WorkflowWorker.safeParse(session.metadata?.opWorkflow);
+      if (!workflow.success) return;
+      const link = workerLink(session);
+      if (await initialized(session, link)) {
+        authorizeWorkflowExecution(actor);
+        return;
       }
-      const coordinator = await ctx.session.get({ sessionID: link.coordinatorID });
-      requireDelegation(
-        await callerPermissions(coordinator, z.string().min(1).parse(callerAgent)),
-        session.agent,
-      );
-      const agent = await ctx.agent.get({
-        agentID: session.agent,
-        location: session.location,
-      });
-      if (agent.data.model) {
-        await ctx.session.switchModel({
+      await prepareRole(session, link, messageID, workflow.data.callerAgent);
+      if (!await initialized(session, link) && session.metadata?.opWorkflowAccess === "read") {
+        const coordinator = await ctx.session.get({ sessionID: link.coordinatorID });
+        const profile = await ctx.agent.get({ agentID: session.agent!, location: session.location });
+        await ctx.session.update({
           sessionID: session.id,
-          model: agent.data.model,
+          permissions: workflowPermissions(await callerPermissions(coordinator, workflow.data.callerAgent), profile.data.permissions),
         });
       }
     },
@@ -330,6 +429,81 @@ export function threads(
         return view(await ctx.session.get({ sessionID: workerID }));
       });
     },
+    async spawnWorkflow(
+      actor: string,
+      input: z.infer<typeof Spawn>,
+      runtime: Pick<ToolContext, "agent"> & Pick<SessionContext, "model">,
+      workflow: z.infer<typeof WorkflowWorker> & { access: "read" | "write" },
+    ) {
+      return serialized(actor, async () => {
+        const workflowMetadata = WorkflowWorker.parse({
+          ownerID: workflow.ownerID,
+          runID: workflow.runID,
+          stepKey: workflow.stepKey,
+          callerAgent: workflow.callerAgent,
+        });
+        const coordinator = await ctx.session.get({ sessionID: actor });
+        if (workflow.ownerID !== actor || workflow.callerAgent !== runtime.agent) {
+          throw new Error("Workflow worker ownership must be server-derived");
+        }
+        if (coordinator.parentID !== undefined || coordinator.metadata?.opThreads !== undefined) {
+          throw new Error("Native subagents and managed workers cannot start workflow workers");
+        }
+        if (!isAbsolute(input.directory) || !(await stat(input.directory)).isDirectory()) {
+          throw new Error("directory must be an existing absolute directory");
+        }
+        if (input.agent === undefined) throw new Error("Workflow workers require an explicit role agent");
+        const workerID = workerIdentity(actor, input.key);
+        let session = await ctx.session.get({ sessionID: workerID }).catch((error: unknown) => {
+          const missing = MissingSession.safeParse(error);
+          if (!missing.success || missing.data.sessionID !== workerID) throw error;
+          return undefined;
+        });
+        const proposed = Link.parse({
+          workerID,
+          coordinatorID: actor,
+          key: input.key,
+          fingerprint: fingerprint(input),
+          initialMessageID: SessionMessage.ID.create(),
+          reportMessageID: SessionMessage.ID.create(),
+        });
+        if (!session) {
+          const existing = await list(actor);
+          if (existing.filter((worker) => !worker.report && worker.outcome !== "failed" && worker.outcome !== "interrupted").length >= limit) {
+            throw new Error(`Coordinator worker limit reached (${limit}); wait for existing managed work before starting another workflow`);
+          }
+          const inherited = await callerPermissions(coordinator, runtime.agent);
+          requireDelegation(inherited, input.agent);
+          const restrictions = workflowPermissions(inherited, workflow.access === "read" ? [] : undefined);
+          session = await ctx.session.create({
+            id: workerID,
+            title: input.title,
+            location: { directory: input.directory },
+            agent: input.agent,
+            model: runtime.model,
+            permissions: restrictions,
+            metadata: { opThreads: proposed, opThreadsRole: true, opWorkflow: workflowMetadata, opWorkflowAccess: workflow.access },
+          });
+        }
+        const link = workerLink(session);
+        const recorded = WorkflowWorker.parse(session.metadata?.opWorkflow);
+        if (link.fingerprint !== proposed.fingerprint || JSON.stringify(recorded) !== JSON.stringify(workflowMetadata)) {
+          throw new Error("This workflow spawn identity belongs to a different request");
+        }
+        await ctx.storage.set(indexKey(link), link);
+        if (!await initialized(session, link)) {
+          await ctx.session.prompt({
+            sessionID: link.workerID,
+            id: link.initialMessageID,
+            delivery: "queue",
+            metadata: { opThreadsCallerAgent: runtime.agent, opWorkflowRunID: workflow.runID },
+            text: `${input.task}\n\nYou are a leaf workflow worker. Do not delegate, spawn or control other workers, or operate workflow controls. Work only in ${input.directory}. Finish by submitting one accepted workflows_result with a verdict, concise summary, evidence, and a result matching the requested JSON schema. If validation rejects your result, correct it and resubmit. Native completion without that validated report is not success.`,
+          });
+          await ctx.storage.set(initializedKey(link), true);
+        }
+        return view(await ctx.session.get({ sessionID: workerID }));
+      });
+    },
     async send(actor: string, input: z.infer<typeof Send>) {
       const { session, link } = await owned(actor, input.workerID);
       if (!await initialized(session, link)) {
@@ -338,6 +512,7 @@ export function threads(
       const id = SessionMessage.ID.make(
         `msg_${digest([input.workerID, "send", input.key]).slice(0, 32)}`,
       );
+      if (session.metadata?.opWorkflow !== undefined) authorizeWorkflowExecution(input.workerID);
       const admitted = await ctx.session.synthetic({
         sessionID: input.workerID,
         id,
@@ -365,22 +540,16 @@ export function threads(
     async report(actor: string, input: z.infer<typeof Report>) {
       const session = await ctx.session.get({ sessionID: actor });
       const link = workerLink(session);
-      const admitted = await ctx.session.synthetic({
-        sessionID: link.coordinatorID,
-        id: link.reportMessageID,
-        text: `Managed worker ${link.workerID} (${link.key}) report:\n${JSON.stringify(input)}`,
-        metadata: { opThreadsReport: input, workerID: link.workerID },
-        delivery: "queue",
-        resume: true,
-      });
-      const canonical = Report.parse(
-        admitted.payload.metadata?.opThreadsReport,
-      );
-      await ctx.storage.set(reportKey(link), canonical);
-      if (JSON.stringify(canonical) !== JSON.stringify(input)) {
-        throw new Error("This worker already has a different report. Start a new task with a new spawn key.");
-      }
+      if (session.metadata?.opWorkflow !== undefined) throw new Error("Workflow workers must call workflows_result");
+      const canonical = await journalReport(session, link, input, false);
       return { workerID: link.workerID, report: canonical };
     },
+    async reportWorkflow(actor: string, input: z.infer<typeof Report>) {
+      const session = await ctx.session.get({ sessionID: actor });
+      WorkflowWorker.parse(session.metadata?.opWorkflow);
+      const link = workerLink(session);
+      const report = { verdict: input.verdict, summary: input.summary, evidence: input.evidence };
+      return { workerID: link.workerID, report: await journalReport(session, link, report, true) };
+    },
   };
 }