@fungi.computer/oyster 0.2.0 → 0.3.1

package/dist/standalone/worker.js

@@ -7,9 +7,9 @@ import { createOysterGitWorker, createOysterGitMcpOwner, oysterGitRoot, } from "
 import { defaultTenant, tenantScope } from "../tenant.js";
 import { onBoxVmIngress } from "@fungi.computer/computer";
 import { WorkerEntrypoint } from "cloudflare:workers";
+import { installationWorkerEntrypoint } from "../installation-execution.js";
 import { putContentObject } from "../build-contract.js";
-import { workflowGitPassPrefix } from "../git.js";
-import { z } from "zod";
+import { workflowGitPassTokenSchema } from "@fungi.computer/braid/runtime";
 import { standaloneComputerCapabilities, standaloneWorkspace, } from "./computer.js";
 import { StandaloneAgentBase, standaloneAgents, } from "./agents.js";
 import { workersMedia } from "./media.js";
@@ -20,70 +20,87 @@ import { StandaloneWorkflowRunsBase, } from "./workflows.js";
 import { standaloneTenancy } from "./tenancy.js";
 export { StandaloneTenants } from "./tenancy.js";
 import { standalonePreviewRequest } from "./preview.js";
+import { standaloneMachineLinkRoutes, } from "./machine-link.js";
+export { MachineLinkDO } from "./machine-link.js";
+import { standaloneWorkflowControl } from "./workflow-control.js";
+import { standaloneWorkflowWebhookRoutes, standaloneWorkflowWebhookControls, } from "./workflow-webhooks.js";
+import { Hono } from "hono";
 import { standaloneBuildRoutes } from "./builds.js";
+import { standaloneComputerFleetRoutes, standaloneComputerSelection, } from "./computer-fleet.js";
 import { serveOysterComputerEgress, } from "./computer-egress.js";
 import { appSourceOwnerRoutes, } from "./app-source.js";
 export { StandaloneGraphWorkflow } from "./workflows.js";
 export { MediaOperationDO } from "@fungi.computer/darkroom/cloudflare";
 /** A tenant's registry: it owns that tenant's installations and App builds. */
 const tenantRegistry = (env, scope) => env.REGISTRY.getByName(scope.durableName("registry"));
-/** The standalone's one Computer belongs to its default tenant, whose
- * registry minted every build job that Computer runs. */
+/** The standalone fleet belongs to its default tenant, whose registry also
+ * owns build jobs on the fixed build Computer. */
 const computerRegistry = (env) => tenantRegistry(env, tenantScope(defaultTenant, env.OYSTER_ORIGIN));
 export { ComputerDO } from "./computer.js";
 export { WorkspaceProxy, WorkspaceServiceProxy, } from "@fungi.computer/computer";
-export { StandaloneRegistry as OysterRegistry } from "./registry.js";
+import { StandaloneRegistry as BaseRegistry, } from "./registry.js";
+/** The registry uses the same root, with its own in-process Computer selection. */
+export class OysterRegistry extends BaseRegistry {
+    #rootEnv;
+    #root = standaloneRoot(() => this.selectedComputer());
+    constructor(state, env, git = {}) {
+        super(state, env, git);
+        this.#rootEnv = env;
+    }
+    hostFor(scope) {
+        return this.#root.hostFor(this.#rootEnv, scope);
+    }
+}
 export { OysterKeys } from "../workers-git.js";
 // WEBHOOKS keeps its deployed class name; the standalone owner also delivers to Workflows.
 export { StandaloneEventDelivery as OysterWebhooks } from "./instance.js";
 export { AgentDirectory } from "./agents.js";
-/** After Oyster's bearer prefix: `<library>.<pass>`, as the library minted it. */
-const workflowGitPassToken = z.lazy(() => z
-    .string()
-    .regex(/^([a-zA-Z0-9_-]{1,256})\.([0-9a-f]{64})$/u)
-    .transform((token) => {
-    const [libraryId = "", passId = ""] = token.split(".");
-    return [libraryId, passId];
-}));
 /** The one composition root: every door reaches a tenant's host through `hostFor`. */
-const oysterRoot = oysterGitRoot({
-    tenancy: (env) => ({
-        resolve: async (request) => (await standaloneTenancy(env)).oyster.resolve(request),
-    }),
-    homeInstallationId: (env) => env.OYSTER_HOME_INSTALLATION,
-    agents: standaloneAgents,
-    workspace: standaloneWorkspace,
-    capabilities: (env, workspace, keysLive) => [
-        ...standaloneComputerCapabilities(env, workspace, keysLive),
-        ...workersMedia(env, workspace),
-    ],
-    // A presented pass names the library that minted it; only that library's
-    // run owner admits it, for one installation repository and scope.
-    workflowGitPass: async (env, _scope, pass, target) => {
-        const parsed = workflowGitPassToken.safeParse(pass.slice(workflowGitPassPrefix.length));
-        if (!parsed.success)
-            return null;
-        const [libraryId, passId] = parsed.data;
-        return env.WORKFLOW_RUNS.getByName(libraryId).admitWorkflowGitPass(passId, {
-            kind: "installation",
-            installationId: target.installationId,
-            repository: target.repository,
-        }, target.scope);
-    },
-    // A build job's clone reads one repository as the owner who started it.
-    buildGitPass: async (env, scope, pass, target) => {
-        const admitted = await tenantRegistry(env, scope).admitBuildGitPass(pass, target);
-        return admitted === null
-            ? null
-            : {
-                kind: "actor",
-                actor: { kind: "member", memberId: admitted.requestedBy },
-                role: "owner",
-            };
-    },
-    // Operator source seeding and owner builds share the one owner guard.
-    ownerRoutes: (env, scope) => appSourceOwnerRoutes(env, scope).route("/", standaloneBuildRoutes(() => tenantRegistry(env, scope))),
-});
+const standaloneRoot = (selectComputer) => {
+    const root = oysterGitRoot({
+        tenancy: (env) => ({
+            resolve: async (request) => (await standaloneTenancy(env)).oyster.resolve(request),
+        }),
+        homeInstallationId: (env) => env.OYSTER_HOME_INSTALLATION,
+        agents: standaloneAgents,
+        workflows: standaloneWorkflowControl,
+        workspace: async (env, keysLive, scope, request) => standaloneWorkspace(env, keysLive, await selectComputer(tenantRegistry(env, scope), request)),
+        capabilities: (env, workspace, keysLive) => [
+            ...standaloneComputerCapabilities(env, workspace, keysLive),
+            ...workersMedia(env, workspace),
+        ],
+        // A presented bearer names the library that issued it; only that
+        // library's run owner admits it, for one installation repository and scope.
+        workflowGitPass: async (env, _scope, bearer, target) => {
+            const parsed = workflowGitPassTokenSchema.safeParse(bearer);
+            if (!parsed.success)
+                return null;
+            return env.WORKFLOW_RUNS.getByName(parsed.data.ownerId).admitWorkflowGitPass(bearer, {
+                kind: "installation",
+                installationId: target.installationId,
+                repository: target.repository,
+            }, target.scope);
+        },
+        // A build job's clone reads one repository as the owner who started it.
+        buildGitPass: async (env, scope, pass, target) => {
+            const admitted = await tenantRegistry(env, scope).admitBuildGitPass(pass, target);
+            return admitted === null
+                ? null
+                : {
+                    kind: "actor",
+                    actor: { kind: "member", memberId: admitted.requestedBy },
+                    role: "owner",
+                };
+        },
+        // Operator source seeding and owner builds share the one owner guard.
+        ownerRoutes: (env, scope) => appSourceOwnerRoutes(env, scope)
+            .route("/", standaloneBuildRoutes(() => tenantRegistry(env, scope)))
+            .route("/", standaloneComputerFleetRoutes(() => tenantRegistry(env, scope)))
+            .route("/", standaloneWorkflowWebhookControls(env, () => root.hostFor(env, scope))),
+    });
+    return root;
+};
+const oysterRoot = standaloneRoot(standaloneComputerSelection);
 export class OysterMcp extends createOysterGitMcpOwner(oysterRoot) {
 }
 /** Background wakes readmit members through this root's tenancy, as HTTP and MCP do. */
@@ -105,6 +122,9 @@ export class StandaloneWorkflowRuns extends StandaloneWorkflowRunsBase {
     }
 }
 const oyster = createOysterGitWorker(oysterRoot);
+/** Private loopback execution uses this root's ordinary host composition. */
+export class OysterInstallationExecutor extends installationWorkerEntrypoint((env, scope) => oysterRoot.hostFor(env, scope)) {
+}
 /** The Computer's egress gateway: its own HTTPS Git back into this Worker. */
 export class OysterComputerEgress extends WorkerEntrypoint {
     fetch(request) {
@@ -114,6 +134,7 @@ export class OysterComputerEgress extends WorkerEntrypoint {
             origin: this.env.OYSTER_ORIGIN,
             computerId: computerObjectId,
             publicEgress: this.env.COMPUTER_PUBLIC_EGRESS,
+            internetAccess: () => this.env.COMPUTER.get(this.env.COMPUTER.idFromString(computerObjectId)).internetAccess(),
             build: {
                 gitPassFor: (target) => registry.buildGitPassFor(computerObjectId, target),
                 exchangeTemplate: (repository, request) => registry.exchangeBuildTemplate(computerObjectId, repository, request),
@@ -134,14 +155,29 @@ export class OysterComputerEgress extends WorkerEntrypoint {
 }
 export default {
     async fetch(request, env, context) {
-        const preview = await standalonePreviewRequest(request, env, env.OYSTER_COMPUTER_ID, (signature, port, service) => env.COMPUTER.getByName(env.OYSTER_COMPUTER_ID).portPreview(signature, port, service));
+        const path = new URL(request.url).pathname;
+        if (path === "/local/mesh/join" ||
+            new URLPattern({
+                pathname: "/api/teams/:teamId/local/mesh/:deviceId/connect",
+            }).test(request.url))
+            return standaloneMachineLinkRoutes(env).fetch(request);
+        const preview = await standalonePreviewRequest(request, env, (computerId) => computerRegistry(env).ownsComputer(computerId), (computerId, signature, port, service) => env.COMPUTER.getByName(computerId).portPreview(signature, port, service));
         if (preview !== null)
             return preview;
         const ingress = onBoxVmIngress(request, env, env.COMPUTER);
         if (ingress !== undefined)
             return ingress;
-        if (oyster.fetch === undefined)
+        const fetchOyster = oyster.fetch;
+        if (fetchOyster === undefined)
             throw new Error("Oyster fetch handler is missing");
-        return oyster.fetch(request, env, context);
+        return new Hono()
+            .route("/", standaloneWorkflowWebhookRoutes(env, async (incoming) => {
+            const admitted = await oysterRoot.admit(env, incoming);
+            return admitted === null
+                ? null
+                : oysterRoot.hostFor(env, admitted.scope);
+        }))
+            .all("*", () => fetchOyster(request, env, context))
+            .fetch(request);
     },
 };

package/dist/standalone/workflow-binding.d.ts

@@ -1,8 +1,8 @@
 import * as S from "effect/Schema";
 import { z } from "zod";
+import { type WorkflowGitPassGrant } from "@fungi.computer/braid/runtime";
 import { eventDisarmInputSchema, scheduleDisarmInputSchema } from "@fungi.computer/workflows-wire";
 import type { Installation } from "../apps/index.js";
-import type { WorkflowGitPassResult } from "@fungi.computer/agar/computer-contracts";
 import { type AppEventFact } from "@fungi.computer/puffball/app-event-facts";
 import type { HostRecipientEvent } from "../workers-git.js";
 import type { FrameBindingProps } from "../cloudflare.js";
@@ -34,6 +34,8 @@ export declare const triggerArmTargetSchema: z.ZodObject<{
         kind: z.ZodLiteral<"team-source">;
     }, z.core.$strict>>]>>;
     workflowId: z.ZodString;
+    commit: z.ZodString;
+    triggerId: z.ZodString;
     delivery: z.ZodOptional<z.ZodCustom<{
         readonly agentId: string;
         readonly sessionId: string;
@@ -41,14 +43,12 @@ export declare const triggerArmTargetSchema: z.ZodObject<{
         readonly agentId: string;
         readonly sessionId: string;
     }>>;
-    triggerId: z.ZodString;
-    commit: z.ZodString;
 }, z.core.$strict>;
 export type TriggerArmTarget = z.output<typeof triggerArmTargetSchema>;
 export type ScheduleDisarmInput = z.output<typeof scheduleDisarmInputSchema>;
 export type EventDisarmInput = z.output<typeof eventDisarmInputSchema>;
 /** The frame gate needs only these run-owner calls; it re-decodes each reply with the method's owner schema. */
-export type WorkflowRunCalls = Pick<StandaloneWorkflowRunsBase, "catalog" | "start" | "status" | "cancel" | "answerReview" | "armSchedule" | "disarmSchedule" | "schedules" | "armEventTrigger" | "disarmEventTrigger" | "eventTriggers" | "runs">;
+export type WorkflowRunCalls = Pick<StandaloneWorkflowRunsBase, "admitWorkflowGit" | "catalog" | "start" | "status" | "cancel" | "answerReview" | "armSchedule" | "disarmSchedule" | "schedules" | "armEventTrigger" | "disarmEventTrigger" | "eventTriggers" | "runs">;
 export type WorkflowBindingEnv = Readonly<{
     WORKFLOW_RUNS: Readonly<{
         getByName(installationId: string): WorkflowRunCalls;
@@ -90,6 +90,7 @@ export declare const workflowFrameMethods: {
                     kind: "team-source";
                 }>;
                 readonly requestId: string;
+                readonly definition: S.Json;
                 readonly published: {
                     workflowId: string;
                     commit: string;
@@ -97,7 +98,6 @@ export declare const workflowFrameMethods: {
                         readonly appReleaseKind: "Sha256Digest";
                     };
                 };
-                readonly definition: S.Json;
                 readonly delivery?: {
                     readonly agentId: string;
                     readonly sessionId: string;
@@ -122,8 +122,8 @@ export declare const workflowFrameMethods: {
                     kind: "team-source";
                 }>;
                 workflowId: string;
-                triggerId: string;
                 commit: string;
+                triggerId: string;
                 delivery?: {
                     readonly agentId: string;
                     readonly sessionId: string;
@@ -138,8 +138,8 @@ export declare const workflowFrameMethods: {
                     kind: "team-source";
                 }>;
                 workflowId: string;
-                triggerId: string;
                 commit: string;
+                triggerId: string;
                 delivery?: {
                     readonly agentId: string;
                     readonly sessionId: string;
@@ -160,7 +160,7 @@ export declare const workflowFrameMethods: {
  * delivery per library and returns; the emit never waits on a library.
  */
 export declare function workflowEventRecipients(installations: Readonly<{
-    list(): Promise<readonly Pick<Installation, "installationId" | "status" | "approvedGrants">[]>;
+    list(): Promise<readonly Pick<Installation, "installationId" | "status" | "authority">[]>;
 }>): Promise<readonly string[]>;
 /**
  * One recorded delivery to one library: the host-attested fact reaches its
@@ -168,7 +168,7 @@ export declare function workflowEventRecipients(installations: Readonly<{
  * so the delivery owner's retries never start a run twice.
  */
 export declare function deliverWorkflowEvent(env: WorkflowEventEnv, libraryId: string, event: HostRecipientEvent): Promise<void>;
-/** What a Workflow node frame attests when it asks for its Git step's pass. */
+/** What a Workflow node frame attests when its Git step is admitted. */
 export declare const workflowGitPassRequestSchema: z.ZodLazy<z.ZodObject<{
     installationId: z.ZodString;
     idempotencyKey: z.ZodString;
@@ -191,26 +191,22 @@ export declare const workflowGitPassRequestSchema: z.ZodLazy<z.ZodObject<{
     computerId: z.ZodString;
 }, z.core.$strict>>;
 export type WorkflowGitPassRequest = z.output<typeof workflowGitPassRequestSchema>;
-/** The library run owners a node frame's pass request may reach. */
-export type WorkflowGitPassEnv = Readonly<{
-    OYSTER_COMPUTER_ID: string;
+/** Each run library's per-step Workflow Git admission. */
+export type WorkflowGitStepEnv = Readonly<{
     WORKFLOW_RUNS: Readonly<{
-        getByName(installationId: string): Readonly<{
-            openWorkflowGitPass(request: WorkflowGitPassRequest): Promise<WorkflowGitPassResult | null>;
-        }>;
+        getByName(libraryId: string): Pick<WorkflowRunCalls, "admitWorkflowGit">;
     }>;
 }>;
 /**
- * COMPUTER.workflowGitPass from a published Workflow node frame. Only the
- * frame's host-attested Workflow, call key, member and pinned Computer cross;
- * the library that dispatched that Git step derives the scope from its own
- * stored run and mints or renews the pass.
+ * The public grant for the Git step a member Workflow node frame is running,
+ * from the run library that dispatched it; null for any other frame. Every
+ * native command the step starts carries this grant, never a credential.
  */
-export declare function openWorkflowGitPass(env: WorkflowGitPassEnv, installations: Readonly<{
-    list(): Promise<readonly Pick<Installation, "installationId" | "status" | "approvedGrants">[]>;
+export declare function workflowGitStepGrant(env: WorkflowGitStepEnv, installations: Readonly<{
+    list(): Promise<readonly Pick<Installation, "installationId" | "status" | "authority">[]>;
 }>, frame: Readonly<{
     facts: InvocationFacts;
     signal: AbortSignal;
-}>, args: readonly unknown[]): Promise<WorkflowGitPassResult>;
+}>): Promise<WorkflowGitPassGrant | null>;
 /** Called only after the Instance's shared gate resolves this live frame. */
 export declare function dispatchWorkflowBinding(env: WorkflowBindingEnv, frame: InvocationFrame, props: FrameBindingProps, method: string, args: readonly unknown[]): Promise<OysterJson>;

package/dist/standalone/workflow-binding.js

@@ -79,7 +79,7 @@ export const workflowFrameMethods = {
 export async function workflowEventRecipients(installations) {
     return (await installations.list())
         .filter((installation) => installation.status === "enabled" &&
-        installation.approvedGrants.some((grant) => grant.capability === "workflow.arm"))
+        installation.authority.approvedGrants.some((grant) => grant.capability === "workflow.arm"))
         .map((installation) => installation.installationId);
 }
 /**
@@ -98,7 +98,7 @@ export async function deliverWorkflowEvent(env, libraryId, event) {
     });
     await env.WORKFLOW_RUNS.getByName(libraryId).deliverEvent(fact);
 }
-/** What a Workflow node frame attests when it asks for its Git step's pass. */
+/** What a Workflow node frame attests when its Git step is admitted. */
 export const workflowGitPassRequestSchema = z.lazy(() => z.strictObject({
     installationId: z.string().min(1).max(256),
     idempotencyKey: z.string().min(1).max(128),
@@ -107,21 +107,19 @@ export const workflowGitPassRequestSchema = z.lazy(() => z.strictObject({
     computerId: z.string().min(1).max(256),
 }));
 /**
- * COMPUTER.workflowGitPass from a published Workflow node frame. Only the
- * frame's host-attested Workflow, call key, member and pinned Computer cross;
- * the library that dispatched that Git step derives the scope from its own
- * stored run and mints or renews the pass.
+ * The public grant for the Git step a member Workflow node frame is running,
+ * from the run library that dispatched it; null for any other frame. Every
+ * native command the step starts carries this grant, never a credential.
  */
-export async function openWorkflowGitPass(env, installations, frame, args) {
-    z.tuple([z.strictObject({})]).parse(args);
+export async function workflowGitStepGrant(env, installations, frame) {
     const { subject, selection } = frame.facts;
     if (subject.kind !== "call" ||
         subject.context.workflow === undefined ||
         subject.context.idempotencyKey === undefined ||
         subject.context.actor.kind !== "member" ||
-        subject.context.computerId !== env.OYSTER_COMPUTER_ID ||
+        subject.context.computerId === null ||
         selection.owner.kind !== "installation")
-        throw new AppInstanceError("revoked");
+        return null;
     const request = workflowGitPassRequestSchema.parse({
         installationId: selection.owner.id,
         idempotencyKey: subject.context.idempotencyKey,
@@ -129,21 +127,23 @@ export async function openWorkflowGitPass(env, installations, frame, args) {
         memberId: subject.context.actor.memberId,
         computerId: subject.context.computerId,
     });
-    const libraries = (await installations.list()).filter((installation) => installation.status === "enabled" &&
-        installation.approvedGrants.some((grant) => grant.capability === "workflow.run"));
-    for (const library of libraries) {
+    for (const library of await installations.list()) {
+        if (library.status !== "enabled" ||
+            !library.authority.approvedGrants.some((grant) => grant.capability === "workflow.run"))
+            continue;
         frame.signal.throwIfAborted();
-        const pass = await env.WORKFLOW_RUNS.getByName(library.installationId).openWorkflowGitPass(request);
-        if (pass !== null)
-            return pass;
+        const grant = await env.WORKFLOW_RUNS.getByName(library.installationId).admitWorkflowGit(request);
+        if (grant !== null)
+            return grant;
     }
-    throw new AppInstanceError("revoked");
+    return null;
 }
 /** Called only after the Instance's shared gate resolves this live frame. */
 export async function dispatchWorkflowBinding(env, frame, props, method, args) {
     frame.signal.throwIfAborted();
     if (props.binding !== "WORKFLOWS" ||
-        frame.facts.subject.kind !== "call" ||
+        (frame.facts.subject.kind !== "call" &&
+            !(method === "runGraph" && frame.facts.subject.name === "onGitPush")) ||
         frame.facts.selection.owner.kind !== "installation")
         throw new AppInstanceError("revoked");
     const runs = env.WORKFLOW_RUNS.getByName(frame.facts.selection.owner.id);

package/dist/standalone/workflow-control.d.ts

@@ -0,0 +1,4 @@
+import type { OysterHost } from "../host.js";
+import type { StandaloneWorkflowEnv } from "./workflows.js";
+/** Locate runs in the existing library owners; never create a second run index. */
+export declare function standaloneWorkflowControl(env: Pick<StandaloneWorkflowEnv, "WORKFLOW_RUNS">, host: Pick<OysterHost, "auth" | "installations">): NonNullable<OysterHost["workflows"]>;

package/dist/standalone/workflow-control.js

@@ -0,0 +1,40 @@
+import { cancelReplySchema, statusReply } from "@fungi.computer/workflows-wire";
+import { AppInstanceError } from "../index.js";
+/** Locate runs in the existing library owners; never create a second run index. */
+export function standaloneWorkflowControl(env, host) {
+    return async (principal) => {
+        if (principal.actor.kind !== "member")
+            return null;
+        const actor = principal.actor;
+        const requireOwner = async () => {
+            const current = await host.auth.resolve(actor);
+            if (current === null || !("role" in current) || current.role !== "owner")
+                throw new AppInstanceError("revoked");
+        };
+        await requireOwner();
+        const call = async (operation, runId) => {
+            await requireOwner();
+            for (const installation of await host.installations.list()) {
+                if (installation.status !== "enabled" ||
+                    !installation.authority.approvedGrants.some((grant) => grant.capability === "workflow.run"))
+                    continue;
+                const result = await env.WORKFLOW_RUNS.getByName(installation.installationId).control(principal, operation, runId);
+                if (result !== null)
+                    return result;
+            }
+            return null;
+        };
+        return {
+            status: async (runId) => {
+                const snapshot = await call("status", runId);
+                return snapshot === null
+                    ? null
+                    : statusReply.parse(JSON.parse(JSON.stringify(snapshot)));
+            },
+            cancel: async (runId) => {
+                const result = await call("cancel", runId);
+                return cancelReplySchema.parse(result ?? { kind: "refused", reason: "denied" });
+            },
+        };
+    };
+}

package/dist/standalone/workflow-events.d.ts

@@ -19,7 +19,7 @@ export declare function createStandaloneWorkflowEvents<Frame>(options: Parameter
     } | {
         kind: "refused";
         reason: string;
-        readonly error?: undefined;
+        error?: undefined;
     }>;
     disarm(frame: Frame, raw: EventDisarmInput): Promise<{
         kind: "disarmed";
@@ -41,6 +41,6 @@ export declare function createStandaloneWorkflowEvents<Frame>(options: Parameter
             state: "active" | "paused";
             lastError: string | null;
         }[];
-        readonly error?: undefined;
+        error?: undefined;
     }>;
 };

package/dist/standalone/workflow-events.js

@@ -9,30 +9,29 @@ export function createStandaloneWorkflowEvents(options) {
         deliver: (fact) => router.deliver(fact),
         async arm(frame, raw) {
             const target = triggerArmTargetSchema.parse(raw);
-            const { libraryId, context, installationAuthority } = await options.admitInvocation(frame, "armEventTrigger");
-            if (context.actor.kind !== "member")
+            const { libraryId, context, installationAuthority, authority } = await options.admitInvocation(frame, "armEventTrigger");
+            if (authority === null)
                 return { error: "not_granted" };
             if (context.computerId === null)
                 return {
                     kind: "refused",
                     reason: "Select a Computer before arming an event trigger",
                 };
-            // Standalone has no Agent arming source: the owner arms as themself.
-            return router.arm({ armedBy: context.actor.memberId, armedVia: null }, { ...target, installationId: libraryId }, context.computerId, installationAuthority);
+            return router.arm(authority.armer, { ...target, installationId: libraryId }, context.computerId, installationAuthority);
         },
         async disarm(frame, raw) {
             const { eventTriggerId } = eventDisarmInputSchema.parse(raw);
-            const { libraryId, context } = await options.admitInvocation(frame, "disarmEventTrigger");
-            if (context.actor.kind !== "member")
+            const { libraryId, authority } = await options.admitInvocation(frame, "disarmEventTrigger");
+            if (authority === null)
                 return { error: "not_granted" };
-            return router.disarm({ kind: "member", memberId: context.actor.memberId }, libraryId, eventTriggerId);
+            return router.disarm(authority.principal, libraryId, eventTriggerId);
         },
         async list(frame) {
-            const { libraryId, context } = await options.admitInvocation(frame, "eventTriggers");
-            if (context.actor.kind !== "member")
+            const { libraryId, authority } = await options.admitInvocation(frame, "eventTriggers");
+            if (authority === null)
                 return { error: "not_granted" };
             return {
-                eventTriggers: await router.list({ kind: "member", memberId: context.actor.memberId }, libraryId),
+                eventTriggers: await router.list(authority.principal, libraryId),
             };
         },
     };

package/dist/standalone/workflow-git-capture.js

@@ -30,9 +30,10 @@ export function createStandaloneWorkflowInstallationGitCapture(options) {
             if (current?.status !== "enabled" ||
                 current.installationId !== installation.installationId ||
                 current.instanceId !== installation.instanceId ||
-                current.authorityVersion !== installation.authorityVersion ||
-                current.declaredOperationsDigest !==
-                    installation.declaredOperationsDigest ||
+                current.authority.authorityVersion !==
+                    installation.authority.authorityVersion ||
+                current.authority.declaredOperationsDigest !==
+                    installation.authority.declaredOperationsDigest ||
                 current.release.appId !== installation.release.appId ||
                 current.release.releaseId !== installation.release.releaseId ||
                 current.release.artifact.artifactRef !==