@hachej/boring-automation 0.1.79 → 0.1.81

package/README.md

@@ -15,4 +15,4 @@ Executable model values use explicit `provider:model-id` syntax. Legacy unqualif
 
 Execution is currently composed for trusted local CLI folder mode. Scheduling has no background timer: user-owned cron/systemd may invoke `POST /api/v1/boring-automation/due` once per minute while the CLI server is running. Missed minutes are not backfilled.
 
-Hosted persistence infrastructure is now available as an explicit deployment migration callback (`runBoringAutomationMigrations`) and an actor-bound `PostgresAutomationStore`. Full-app route/executor composition and authenticated hosted triggers remain separate follow-up work; hosted execution is not activated by this infrastructure alone.
+Hosted persistence and creator-scoped execution are available in full-app. The deployment migration callback is `runBoringAutomationMigrations`; configure `BORING_AUTOMATION_TRIGGER_TOKEN` and have the platform scheduler invoke `POST /api/v1/boring-automation/due/hosted` with `Authorization: Bearer <token>`. The endpoint re-checks each creator and fails closed when authorization is lost. It has no hidden timer.

package/dist/front/index.js

@@ -21,7 +21,9 @@ var BORING_AUTOMATION_ERROR_CODES = {
   RUN_ALREADY_RECORDED: "BORING_AUTOMATION_RUN_ALREADY_RECORDED",
   RUN_EXECUTOR_UNAVAILABLE: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE",
   TRIGGER_FORBIDDEN: "BORING_AUTOMATION_TRIGGER_FORBIDDEN",
-  RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED"
+  RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED",
+  OWNER_UNAUTHORIZED: "BORING_AUTOMATION_OWNER_UNAUTHORIZED",
+  TRIGGER_UNAUTHORIZED: "BORING_AUTOMATION_TRIGGER_UNAUTHORIZED"
 };
 
 // src/shared/schema.ts

package/dist/server/index.d.ts

@@ -2,9 +2,9 @@ import { WorkspaceAgentDispatcherResolver } from '@hachej/boring-agent/server';
 import { FastifyRequest, FastifyInstance } from 'fastify';
 import { WorkspaceAgentServerPluginContext } from '@hachej/boring-workspace/app/server';
 import { WorkspaceServerPlugin } from '@hachej/boring-workspace/server';
+import postgres from 'postgres';
 import { Automation, AutomationCreate, AutomationPatch, AutomationRunBegin, AutomationRun, AutomationRunLifecyclePatch, BoringAutomationErrorCode, AutomationScheduleDecision } from '../shared/index.js';
 export { AUTOMATION_SCHEDULE_ERRORS, AutomationCreateInput, AutomationCreateSchema, AutomationPatchInput, AutomationPatchSchema, AutomationRunBeginInput, AutomationRunBeginSchema, AutomationRunLifecyclePatchInput, AutomationRunLifecyclePatchSchema, AutomationRunStatus, AutomationRunStatusSchema, AutomationRunTrigger, AutomationRunTriggerSchema, AutomationScheduleDueDecision, AutomationScheduleDueReason, AutomationScheduleSkipDecision, AutomationScheduleSkipReason, AutomationScheduleValidationResult, BORING_AUTOMATION_ERROR_CODES, BORING_AUTOMATION_PLUGIN_ID, BORING_AUTOMATION_PLUGIN_LABEL, BORING_AUTOMATION_ROUTE_PREFIX, EvaluateAutomationScheduleInput, EvaluateAutomationScheduleResult, IdParamsSchema, PromptUpdateSchema, evaluateAutomationSchedule, isValidFiveFieldCron, isValidIanaTimeZone, validateAutomationSchedule } from '../shared/index.js';
-import postgres from 'postgres';
 import 'zod';
 
 /** Plugin-local dependency injection seam for the single-workspace automation store. */
@@ -46,6 +46,7 @@ interface ManualRunInput {
     request: FastifyRequest;
     trigger?: "manual" | "scheduled";
     scheduledFor?: string | null;
+    actor?: VerifiedAutomationActor;
 }
 declare class ManualRunExecutor {
     private readonly options;
@@ -97,6 +98,55 @@ declare class DueRunService {
     runDue(request: FastifyRequest): Promise<DueRunResult>;
 }
 
+interface HostedAutomationActor {
+    workspaceId: string;
+    userId: string;
+}
+interface HostedAutomationCandidate {
+    automation: Automation;
+    actor: HostedAutomationActor;
+    runs: AutomationRun[];
+}
+type Sql = postgres.Sql;
+/** Hosted store bound to a verified workspace/user pair; every query is scoped by both. */
+declare class PostgresAutomationStore implements AutomationStore {
+    private readonly sql;
+    private readonly actor;
+    private readonly clock;
+    constructor(sql: Sql, actor: HostedAutomationActor, clock?: () => Date);
+    listAutomations(): Promise<Automation[]>;
+    getAutomation(id: string): Promise<Automation | null>;
+    createAutomation(input: AutomationCreate): Promise<Automation>;
+    updateAutomation(id: string, patch: AutomationPatch): Promise<Automation>;
+    deleteAutomation(id: string): Promise<void>;
+    getPrompt(automationId: string): Promise<string>;
+    updatePrompt(automationId: string, body: string): Promise<void>;
+    reconcileOrphanedRuns(automationId: string): Promise<void>;
+    beginRun(input: AutomationRunBegin): Promise<AutomationRun>;
+    updateRunLifecycle(runId: string, patch: AutomationRunLifecyclePatch): Promise<AutomationRun>;
+    listRuns(automationId: string): Promise<AutomationRun[]>;
+    private findRun;
+}
+declare function listHostedAutomationCandidates(sql: Sql): Promise<HostedAutomationCandidate[]>;
+
+interface HostedDueRunServiceOptions {
+    sql: postgres.Sql;
+    dispatcherResolver: WorkspaceAgentDispatcherResolver;
+    verifyActor: (actor: HostedAutomationActor) => Promise<boolean> | boolean;
+    clock?: () => Date;
+}
+interface HostedDueRunResult {
+    now: string;
+    outcomes: DueRunOutcome[];
+}
+/** Runs due work for every creator while preserving creator-scoped execution. */
+declare class HostedDueRunService {
+    private readonly options;
+    private readonly clock;
+    constructor(options: HostedDueRunServiceOptions);
+    runDue(request: FastifyRequest): Promise<HostedDueRunResult>;
+}
+
 type AtomicWriter = (path: string, content: string) => Promise<void>;
 interface FileAutomationStoreOptions {
     writer?: AtomicWriter;
@@ -134,36 +184,13 @@ declare class FileAutomationStore implements AutomationStore {
 /** Deployment-owned hosted schema registration for the automation plugin. */
 declare function runBoringAutomationMigrations(sql: postgres.Sql): Promise<void>;
 
-interface HostedAutomationActor {
-    workspaceId: string;
-    userId: string;
-}
-type Sql = postgres.Sql;
-/** Hosted store bound to a verified workspace/user pair; every query is scoped by both. */
-declare class PostgresAutomationStore implements AutomationStore {
-    private readonly sql;
-    private readonly actor;
-    private readonly clock;
-    constructor(sql: Sql, actor: HostedAutomationActor, clock?: () => Date);
-    listAutomations(): Promise<Automation[]>;
-    getAutomation(id: string): Promise<Automation | null>;
-    createAutomation(input: AutomationCreate): Promise<Automation>;
-    updateAutomation(id: string, patch: AutomationPatch): Promise<Automation>;
-    deleteAutomation(id: string): Promise<void>;
-    getPrompt(automationId: string): Promise<string>;
-    updatePrompt(automationId: string, body: string): Promise<void>;
-    reconcileOrphanedRuns(automationId: string): Promise<void>;
-    beginRun(input: AutomationRunBegin): Promise<AutomationRun>;
-    updateRunLifecycle(runId: string, patch: AutomationRunLifecyclePatch): Promise<AutomationRun>;
-    listRuns(automationId: string): Promise<AutomationRun[]>;
-    private findRun;
-}
-
 interface AutomationRoutesOptions {
     store: AutomationStore;
     storeForRequest?: (request: FastifyRequest) => Promise<AutomationStore> | AutomationStore;
     manualRunExecutor?: Pick<ManualRunExecutor, "run">;
     dueRunService?: Pick<DueRunService, "runDue">;
+    hostedDueRunService?: Pick<HostedDueRunService, "runDue">;
+    hostedTriggerToken?: string;
 }
 declare function automationRoutes(app: FastifyInstance, opts: AutomationRoutesOptions): Promise<void>;
 
@@ -172,8 +199,12 @@ interface BoringAutomationServerPluginOptions {
     store?: AutomationStore;
     dispatcherResolver?: WorkspaceAgentDispatcherResolver;
     actorResolver?: (request: FastifyRequest) => Promise<VerifiedAutomationActor> | VerifiedAutomationActor;
+    storeForRequest?: (request: FastifyRequest, actor: VerifiedAutomationActor) => Promise<AutomationStore> | AutomationStore;
+    actorVerifier?: (actor: VerifiedAutomationActor) => Promise<boolean> | boolean;
+    hostedTriggerToken?: string;
+    hostedDueRunService?: Pick<HostedDueRunService, "runDue">;
 }
 declare function createBoringAutomationServerPlugin(options?: BoringAutomationServerPluginOptions): WorkspaceServerPlugin;
 declare function defaultBoringAutomationServerPlugin(options?: BoringAutomationServerPluginOptions, ctx?: Pick<WorkspaceAgentServerPluginContext, "workspaceRoot"> & Partial<Pick<WorkspaceAgentServerPluginContext, "trusted">>): WorkspaceServerPlugin;
 
-export { Automation, AutomationCreate, AutomationPatch, type AutomationRoutesOptions, AutomationRun, AutomationRunBegin, AutomationRunLifecyclePatch, AutomationScheduleDecision, type AutomationStore, AutomationStoreError, BoringAutomationErrorCode, type BoringAutomationServerPluginOptions, type DueRunOutcome, type DueRunResult, DueRunService, type DueRunServiceOptions, type DueRunSummary, FileAutomationStore, type FileAutomationStoreOptions, type HostedAutomationActor, ManualRunExecutor, type ManualRunExecutorOptions, type ManualRunInput, PostgresAutomationStore, type VerifiedAutomationActor, automationNotFound, automationRoutes, createBoringAutomationServerPlugin, defaultBoringAutomationServerPlugin as default, parseAutomationModel, runAlreadyActive, runAlreadyRecorded, runBoringAutomationMigrations, runNotFound };
+export { Automation, AutomationCreate, AutomationPatch, type AutomationRoutesOptions, AutomationRun, AutomationRunBegin, AutomationRunLifecyclePatch, AutomationScheduleDecision, type AutomationStore, AutomationStoreError, BoringAutomationErrorCode, type BoringAutomationServerPluginOptions, type DueRunOutcome, type DueRunResult, DueRunService, type DueRunServiceOptions, type DueRunSummary, FileAutomationStore, type FileAutomationStoreOptions, type HostedAutomationActor, type HostedAutomationCandidate, type HostedDueRunResult, HostedDueRunService, type HostedDueRunServiceOptions, ManualRunExecutor, type ManualRunExecutorOptions, type ManualRunInput, PostgresAutomationStore, type VerifiedAutomationActor, automationNotFound, automationRoutes, createBoringAutomationServerPlugin, defaultBoringAutomationServerPlugin as default, listHostedAutomationCandidates, parseAutomationModel, runAlreadyActive, runAlreadyRecorded, runBoringAutomationMigrations, runNotFound };

package/dist/server/index.js

@@ -19,7 +19,9 @@ var BORING_AUTOMATION_ERROR_CODES = {
   RUN_ALREADY_RECORDED: "BORING_AUTOMATION_RUN_ALREADY_RECORDED",
   RUN_EXECUTOR_UNAVAILABLE: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE",
   TRIGGER_FORBIDDEN: "BORING_AUTOMATION_TRIGGER_FORBIDDEN",
-  RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED"
+  RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED",
+  OWNER_UNAUTHORIZED: "BORING_AUTOMATION_OWNER_UNAUTHORIZED",
+  TRIGGER_UNAUTHORIZED: "BORING_AUTOMATION_TRIGGER_UNAUTHORIZED"
 };
 
 // src/shared/schema.ts
@@ -524,7 +526,7 @@ var ManualRunExecutor = class {
   options;
   clock;
   async run(input) {
-    const actor = await this.options.actorResolver(input.request);
+    const actor = input.actor ?? await this.options.actorResolver(input.request);
     const store = await this.options.storeForRequest?.(input.request, actor) ?? this.options.store;
     const automation = await store.getAutomation(input.automationId);
     if (!automation) {
@@ -705,8 +707,277 @@ function durationMs(startedAt, completedAt) {
   return Math.max(0, new Date(completedAt).getTime() - new Date(startedAt).getTime());
 }
 
+// src/server/postgresStore.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var PostgresAutomationStore = class {
+  constructor(sql, actor, clock = () => /* @__PURE__ */ new Date()) {
+    this.sql = sql;
+    this.actor = actor;
+    this.clock = clock;
+  }
+  sql;
+  actor;
+  clock;
+  async listAutomations() {
+    const rows = await this.sql`
+      SELECT id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
+      FROM boring_automation_automations
+      WHERE workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+      ORDER BY created_at, id
+    `;
+    return rows.map(toAutomation);
+  }
+  async getAutomation(id) {
+    const rows = await this.sql`
+      SELECT id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
+      FROM boring_automation_automations
+      WHERE id = ${id} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    return rows[0] ? toAutomation(rows[0]) : null;
+  }
+  async createAutomation(input) {
+    const now = this.clock().toISOString();
+    const id = randomUUID2();
+    const prompt = input.prompt ?? "";
+    const rows = await this.sql`
+      INSERT INTO boring_automation_automations (id, workspace_id, owner_user_id, title, enabled, cron, timezone, model, prompt, created_at, updated_at)
+      VALUES (${id}, ${this.actor.workspaceId}, ${this.actor.userId}, ${input.title}, ${input.enabled ?? true}, ${input.cron}, ${input.timezone}, ${input.model}, ${prompt}, ${now}, ${now})
+      RETURNING id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
+    `;
+    return toAutomation(rows[0]);
+  }
+  async updateAutomation(id, patch) {
+    const current = await this.getAutomation(id);
+    if (!current) throw automationNotFound(id);
+    const next = { ...current, ...patch, updatedAt: this.clock().toISOString() };
+    const rows = await this.sql`
+      UPDATE boring_automation_automations
+      SET title = ${next.title}, enabled = ${next.enabled}, cron = ${next.cron}, timezone = ${next.timezone}, model = ${next.model}, updated_at = ${next.updatedAt}
+      WHERE id = ${id} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+      RETURNING id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
+    `;
+    if (!rows[0]) throw automationNotFound(id);
+    return toAutomation(rows[0]);
+  }
+  async deleteAutomation(id) {
+    const result = await this.sql`
+      DELETE FROM boring_automation_automations
+      WHERE id = ${id} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    if (result.count === 0) throw automationNotFound(id);
+  }
+  async getPrompt(automationId) {
+    const automation = await this.getAutomation(automationId);
+    if (!automation) throw automationNotFound(automationId);
+    const rows = await this.sql`
+      SELECT prompt FROM boring_automation_automations
+      WHERE id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    return rows[0]?.prompt ?? "";
+  }
+  async updatePrompt(automationId, body) {
+    const result = await this.sql`
+      UPDATE boring_automation_automations SET prompt = ${body}, updated_at = ${this.clock().toISOString()}
+      WHERE id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    if (result.count === 0) throw automationNotFound(automationId);
+  }
+  async reconcileOrphanedRuns(automationId) {
+    await this.sql`
+      UPDATE boring_automation_runs
+      SET status = 'failed', completed_at = ${this.clock().toISOString()}, error = 'Automation host restarted before the run completed', updated_at = ${this.clock().toISOString()}
+      WHERE automation_id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId} AND status IN ('queued', 'running')
+    `;
+  }
+  async beginRun(input) {
+    const automation = await this.getAutomation(input.automationId);
+    if (!automation) throw automationNotFound(input.automationId);
+    const active = await this.sql`
+      SELECT id FROM boring_automation_runs
+      WHERE automation_id = ${input.automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId} AND status IN ('queued', 'running')
+      LIMIT 1
+    `;
+    if (active[0]) throw runAlreadyActive(input.automationId);
+    try {
+      const now = input.createdAt ?? this.clock().toISOString();
+      const id = randomUUID2();
+      const rows = await this.sql`
+        INSERT INTO boring_automation_runs (id, automation_id, workspace_id, owner_user_id, session_id, status, trigger, scheduled_for, started_at, completed_at, duration_ms, input_tokens, output_tokens, total_tokens, prompt_snapshot, model_snapshot, error, created_at, updated_at)
+        VALUES (${id}, ${input.automationId}, ${this.actor.workspaceId}, ${this.actor.userId}, NULL, 'queued', ${input.trigger}, ${input.scheduledFor ?? null}, NULL, NULL, NULL, NULL, NULL, NULL, ${input.promptSnapshot}, ${input.modelSnapshot}, NULL, ${now}, ${now})
+        RETURNING *
+      `;
+      return toRun(rows[0]);
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        if (constraintName(error) === "boring_automation_runs_active_once_idx") throw runAlreadyActive(input.automationId);
+        if (input.trigger === "scheduled" && input.scheduledFor) throw runAlreadyRecorded(input.automationId, input.scheduledFor);
+      }
+      throw error;
+    }
+  }
+  async updateRunLifecycle(runId, patch) {
+    const current = await this.findRun(runId);
+    if (!current) throw runNotFound(runId);
+    const next = { ...current, ...patch, updatedAt: this.clock().toISOString() };
+    const rows = await this.sql`
+      UPDATE boring_automation_runs
+      SET session_id = ${next.sessionId}, status = ${next.status}, started_at = ${next.startedAt}, completed_at = ${next.completedAt}, duration_ms = ${next.durationMs}, input_tokens = ${next.inputTokens}, output_tokens = ${next.outputTokens}, total_tokens = ${next.totalTokens}, error = ${next.error}, updated_at = ${next.updatedAt}
+      WHERE id = ${runId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+      RETURNING *
+    `;
+    if (!rows[0]) throw runNotFound(runId);
+    return toRun(rows[0]);
+  }
+  async listRuns(automationId) {
+    const rows = await this.sql`
+      SELECT * FROM boring_automation_runs
+      WHERE automation_id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+      ORDER BY created_at DESC, id DESC
+    `;
+    return rows.map(toRun);
+  }
+  async findRun(runId) {
+    const rows = await this.sql`
+      SELECT * FROM boring_automation_runs
+      WHERE id = ${runId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+    `;
+    return rows[0] ? toRun(rows[0]) : null;
+  }
+};
+async function listHostedAutomationCandidates(sql) {
+  const automationRows = await sql`
+    SELECT id, workspace_id, owner_user_id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
+    FROM boring_automation_automations
+    ORDER BY id
+  `;
+  const runRows = await sql`
+    SELECT * FROM boring_automation_runs ORDER BY automation_id, created_at DESC, id DESC
+  `;
+  const runsByAutomation = /* @__PURE__ */ new Map();
+  for (const row of runRows) {
+    const list = runsByAutomation.get(row.automation_id) ?? [];
+    list.push(toRun(row));
+    runsByAutomation.set(row.automation_id, list);
+  }
+  return automationRows.map((row) => ({
+    automation: toAutomation(row),
+    actor: { workspaceId: row.workspace_id, userId: row.owner_user_id },
+    runs: runsByAutomation.get(row.id) ?? []
+  }));
+}
+function toAutomation(row) {
+  return { id: row.id, title: row.title, enabled: row.enabled, cron: row.cron, timezone: row.timezone, model: row.model, promptRef: `hosted:${row.id}`, createdAt: iso(row.created_at), updatedAt: iso(row.updated_at) };
+}
+function toRun(row) {
+  return { id: row.id, automationId: row.automation_id, sessionId: row.session_id, status: row.status, trigger: row.trigger, scheduledFor: nullableIso(row.scheduled_for), startedAt: nullableIso(row.started_at), completedAt: nullableIso(row.completed_at), durationMs: row.duration_ms, inputTokens: row.input_tokens, outputTokens: row.output_tokens, totalTokens: row.total_tokens, promptSnapshot: row.prompt_snapshot, modelSnapshot: row.model_snapshot, error: row.error, createdAt: iso(row.created_at), updatedAt: iso(row.updated_at) };
+}
+function iso(value) {
+  return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}
+function nullableIso(value) {
+  return value === null ? null : iso(value);
+}
+function isUniqueViolation(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "23505");
+}
+function constraintName(error) {
+  return error && typeof error === "object" && "constraint_name" in error ? String(error.constraint_name) : void 0;
+}
+
+// src/server/hostedDueRunService.ts
+var HostedDueRunService = class {
+  constructor(options) {
+    this.options = options;
+    this.clock = options.clock ?? (() => /* @__PURE__ */ new Date());
+  }
+  options;
+  clock;
+  async runDue(request) {
+    const now = this.clock();
+    const candidates = await listHostedAutomationCandidates(this.options.sql);
+    const outcomes = [];
+    for (const candidate of candidates) {
+      if (!await this.options.verifyActor(candidate.actor)) {
+        outcomes.push({
+          kind: "failed",
+          automationId: candidate.automation.id,
+          scheduledFor: now.toISOString(),
+          code: BORING_AUTOMATION_ERROR_CODES.OWNER_UNAUTHORIZED,
+          message: "automation creator is no longer authorized"
+        });
+        continue;
+      }
+      const evaluated = evaluateAutomationSchedule({
+        automations: [candidate.automation],
+        runs: candidate.runs,
+        now
+      });
+      const decision = evaluated.due[0];
+      if (!decision) {
+        const skipped = evaluated.decisions[0];
+        if (skipped?.kind === "skip") outcomes.push({
+          kind: "skipped",
+          automationId: candidate.automation.id,
+          scheduledFor: skipped.scheduledFor,
+          reason: skipped.reason,
+          message: skipped.message
+        });
+        continue;
+      }
+      const store = new PostgresAutomationStore(this.options.sql, candidate.actor, this.clock);
+      const executor = new ManualRunExecutor({
+        store,
+        dispatcherResolver: this.options.dispatcherResolver,
+        actorResolver: () => candidate.actor
+      });
+      try {
+        const run = await executor.run({
+          automationId: candidate.automation.id,
+          request,
+          trigger: "scheduled",
+          scheduledFor: decision.scheduledFor,
+          actor: candidate.actor
+        });
+        outcomes.push({
+          kind: "started",
+          automationId: candidate.automation.id,
+          scheduledFor: decision.scheduledFor,
+          run: toSummary(run)
+        });
+      } catch (error) {
+        outcomes.push({
+          kind: "failed",
+          automationId: candidate.automation.id,
+          scheduledFor: decision.scheduledFor,
+          code: error instanceof Error && "code" in error ? String(error.code) : BORING_AUTOMATION_ERROR_CODES.RUN_FAILED,
+          message: error instanceof Error ? error.message : "Automation run failed"
+        });
+      }
+    }
+    outcomes.sort((a, b) => a.automationId.localeCompare(b.automationId));
+    return { now: now.toISOString(), outcomes };
+  }
+};
+function toSummary(run) {
+  return {
+    id: run.id,
+    automationId: run.automationId,
+    sessionId: run.sessionId,
+    status: run.status,
+    trigger: run.trigger,
+    scheduledFor: run.scheduledFor,
+    startedAt: run.startedAt,
+    completedAt: run.completedAt,
+    durationMs: run.durationMs,
+    inputTokens: run.inputTokens,
+    outputTokens: run.outputTokens,
+    totalTokens: run.totalTokens
+  };
+}
+
 // src/server/routes.ts
 import { ZodError } from "zod";
+import { timingSafeEqual } from "crypto";
 async function automationRoutes(app, opts) {
   app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations`, async (_request, reply) => {
     try {
@@ -769,6 +1040,16 @@ async function automationRoutes(app, opts) {
       return sendError(reply, cause);
     }
   });
+  app.post(`${BORING_AUTOMATION_ROUTE_PREFIX}/due/hosted`, async (request, reply) => {
+    try {
+      if (!opts.hostedDueRunService || !opts.hostedTriggerToken || !hasBearerToken(request.headers.authorization, opts.hostedTriggerToken)) {
+        throw new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.TRIGGER_UNAUTHORIZED, "hosted automation trigger is unauthorized");
+      }
+      return { ok: true, ...await opts.hostedDueRunService.runDue(request) };
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
   app.post(`${BORING_AUTOMATION_ROUTE_PREFIX}/due`, async (request, reply) => {
     try {
       if (!isLoopbackAddress(request.ip)) {
@@ -846,6 +1127,12 @@ function zodIssueErrorCode(issue) {
   if (field === "timezone") return BORING_AUTOMATION_ERROR_CODES.INVALID_TIMEZONE;
   return BORING_AUTOMATION_ERROR_CODES.INVALID_BODY;
 }
+function hasBearerToken(header, expected) {
+  if (!header?.startsWith("Bearer ")) return false;
+  const actual = Buffer.from(header.slice(7), "utf8");
+  const target = Buffer.from(expected, "utf8");
+  return actual.length === target.length && timingSafeEqual(actual, target);
+}
 function isLoopbackAddress(address) {
   const normalized = address.trim().toLowerCase();
   return normalized === "127.0.0.1" || normalized === "::1" || normalized.startsWith("::ffff:127.");
@@ -865,6 +1152,10 @@ function httpStatusForStoreError(error) {
       return 409;
     case BORING_AUTOMATION_ERROR_CODES.TRIGGER_FORBIDDEN:
       return 403;
+    case BORING_AUTOMATION_ERROR_CODES.TRIGGER_UNAUTHORIZED:
+      return 401;
+    case BORING_AUTOMATION_ERROR_CODES.OWNER_UNAUTHORIZED:
+      return 403;
     case BORING_AUTOMATION_ERROR_CODES.RUN_EXECUTOR_UNAVAILABLE:
       return 503;
     case BORING_AUTOMATION_ERROR_CODES.RUN_FAILED:
@@ -934,172 +1225,32 @@ async function runBoringAutomationMigrations(sql) {
   `);
 }
 
-// src/server/postgresStore.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var PostgresAutomationStore = class {
-  constructor(sql, actor, clock = () => /* @__PURE__ */ new Date()) {
-    this.sql = sql;
-    this.actor = actor;
-    this.clock = clock;
-  }
-  sql;
-  actor;
-  clock;
-  async listAutomations() {
-    const rows = await this.sql`
-      SELECT id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
-      FROM boring_automation_automations
-      WHERE workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
-      ORDER BY created_at, id
-    `;
-    return rows.map(toAutomation);
-  }
-  async getAutomation(id) {
-    const rows = await this.sql`
-      SELECT id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
-      FROM boring_automation_automations
-      WHERE id = ${id} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
-    `;
-    return rows[0] ? toAutomation(rows[0]) : null;
-  }
-  async createAutomation(input) {
-    const now = this.clock().toISOString();
-    const id = randomUUID2();
-    const prompt = input.prompt ?? "";
-    const rows = await this.sql`
-      INSERT INTO boring_automation_automations (id, workspace_id, owner_user_id, title, enabled, cron, timezone, model, prompt, created_at, updated_at)
-      VALUES (${id}, ${this.actor.workspaceId}, ${this.actor.userId}, ${input.title}, ${input.enabled ?? true}, ${input.cron}, ${input.timezone}, ${input.model}, ${prompt}, ${now}, ${now})
-      RETURNING id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
-    `;
-    return toAutomation(rows[0]);
-  }
-  async updateAutomation(id, patch) {
-    const current = await this.getAutomation(id);
-    if (!current) throw automationNotFound(id);
-    const next = { ...current, ...patch, updatedAt: this.clock().toISOString() };
-    const rows = await this.sql`
-      UPDATE boring_automation_automations
-      SET title = ${next.title}, enabled = ${next.enabled}, cron = ${next.cron}, timezone = ${next.timezone}, model = ${next.model}, updated_at = ${next.updatedAt}
-      WHERE id = ${id} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
-      RETURNING id, title, enabled, cron, timezone, model, prompt, created_at, updated_at
-    `;
-    if (!rows[0]) throw automationNotFound(id);
-    return toAutomation(rows[0]);
-  }
-  async deleteAutomation(id) {
-    const result = await this.sql`
-      DELETE FROM boring_automation_automations
-      WHERE id = ${id} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
-    `;
-    if (result.count === 0) throw automationNotFound(id);
-  }
-  async getPrompt(automationId) {
-    const automation = await this.getAutomation(automationId);
-    if (!automation) throw automationNotFound(automationId);
-    const rows = await this.sql`
-      SELECT prompt FROM boring_automation_automations
-      WHERE id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
-    `;
-    return rows[0]?.prompt ?? "";
-  }
-  async updatePrompt(automationId, body) {
-    const result = await this.sql`
-      UPDATE boring_automation_automations SET prompt = ${body}, updated_at = ${this.clock().toISOString()}
-      WHERE id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
-    `;
-    if (result.count === 0) throw automationNotFound(automationId);
-  }
-  async reconcileOrphanedRuns(automationId) {
-    await this.sql`
-      UPDATE boring_automation_runs
-      SET status = 'failed', completed_at = ${this.clock().toISOString()}, error = 'Automation host restarted before the run completed', updated_at = ${this.clock().toISOString()}
-      WHERE automation_id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId} AND status IN ('queued', 'running')
-    `;
-  }
-  async beginRun(input) {
-    const automation = await this.getAutomation(input.automationId);
-    if (!automation) throw automationNotFound(input.automationId);
-    const active = await this.sql`
-      SELECT id FROM boring_automation_runs
-      WHERE automation_id = ${input.automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId} AND status IN ('queued', 'running')
-      LIMIT 1
-    `;
-    if (active[0]) throw runAlreadyActive(input.automationId);
-    try {
-      const now = input.createdAt ?? this.clock().toISOString();
-      const id = randomUUID2();
-      const rows = await this.sql`
-        INSERT INTO boring_automation_runs (id, automation_id, workspace_id, owner_user_id, session_id, status, trigger, scheduled_for, started_at, completed_at, duration_ms, input_tokens, output_tokens, total_tokens, prompt_snapshot, model_snapshot, error, created_at, updated_at)
-        VALUES (${id}, ${input.automationId}, ${this.actor.workspaceId}, ${this.actor.userId}, NULL, 'queued', ${input.trigger}, ${input.scheduledFor ?? null}, NULL, NULL, NULL, NULL, NULL, NULL, ${input.promptSnapshot}, ${input.modelSnapshot}, NULL, ${now}, ${now})
-        RETURNING *
-      `;
-      return toRun(rows[0]);
-    } catch (error) {
-      if (isUniqueViolation(error)) {
-        if (constraintName(error) === "boring_automation_runs_active_once_idx") throw runAlreadyActive(input.automationId);
-        if (input.trigger === "scheduled" && input.scheduledFor) throw runAlreadyRecorded(input.automationId, input.scheduledFor);
-      }
-      throw error;
-    }
-  }
-  async updateRunLifecycle(runId, patch) {
-    const current = await this.findRun(runId);
-    if (!current) throw runNotFound(runId);
-    const next = { ...current, ...patch, updatedAt: this.clock().toISOString() };
-    const rows = await this.sql`
-      UPDATE boring_automation_runs
-      SET session_id = ${next.sessionId}, status = ${next.status}, started_at = ${next.startedAt}, completed_at = ${next.completedAt}, duration_ms = ${next.durationMs}, input_tokens = ${next.inputTokens}, output_tokens = ${next.outputTokens}, total_tokens = ${next.totalTokens}, error = ${next.error}, updated_at = ${next.updatedAt}
-      WHERE id = ${runId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
-      RETURNING *
-    `;
-    if (!rows[0]) throw runNotFound(runId);
-    return toRun(rows[0]);
-  }
-  async listRuns(automationId) {
-    const rows = await this.sql`
-      SELECT * FROM boring_automation_runs
-      WHERE automation_id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
-      ORDER BY created_at DESC, id DESC
-    `;
-    return rows.map(toRun);
-  }
-  async findRun(runId) {
-    const rows = await this.sql`
-      SELECT * FROM boring_automation_runs
-      WHERE id = ${runId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
-    `;
-    return rows[0] ? toRun(rows[0]) : null;
-  }
-};
-function toAutomation(row) {
-  return { id: row.id, title: row.title, enabled: row.enabled, cron: row.cron, timezone: row.timezone, model: row.model, promptRef: `hosted:${row.id}`, createdAt: iso(row.created_at), updatedAt: iso(row.updated_at) };
-}
-function toRun(row) {
-  return { id: row.id, automationId: row.automation_id, sessionId: row.session_id, status: row.status, trigger: row.trigger, scheduledFor: nullableIso(row.scheduled_for), startedAt: nullableIso(row.started_at), completedAt: nullableIso(row.completed_at), durationMs: row.duration_ms, inputTokens: row.input_tokens, outputTokens: row.output_tokens, totalTokens: row.total_tokens, promptSnapshot: row.prompt_snapshot, modelSnapshot: row.model_snapshot, error: row.error, createdAt: iso(row.created_at), updatedAt: iso(row.updated_at) };
-}
-function iso(value) {
-  return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
-}
-function nullableIso(value) {
-  return value === null ? null : iso(value);
-}
-function isUniqueViolation(error) {
-  return Boolean(error && typeof error === "object" && "code" in error && error.code === "23505");
-}
-function constraintName(error) {
-  return error && typeof error === "object" && "constraint_name" in error ? String(error.constraint_name) : void 0;
-}
-
 // src/server/index.ts
 function createBoringAutomationServerPlugin(options = {}) {
   const store = options.store ?? createDefaultStore(options.workspaceRoot);
-  const manualRunExecutor = options.dispatcherResolver && options.actorResolver ? new ManualRunExecutor({ store, dispatcherResolver: options.dispatcherResolver, actorResolver: options.actorResolver }) : void 0;
-  const dueRunService = manualRunExecutor ? new DueRunService({ store, executor: manualRunExecutor }) : void 0;
+  const manualRunExecutor = options.dispatcherResolver && options.actorResolver ? new ManualRunExecutor({
+    store,
+    storeForRequest: options.storeForRequest,
+    dispatcherResolver: options.dispatcherResolver,
+    actorResolver: options.actorResolver
+  }) : void 0;
+  const dueRunService = manualRunExecutor && !options.storeForRequest ? new DueRunService({ store, executor: manualRunExecutor }) : void 0;
   return defineServerPlugin({
     id: BORING_AUTOMATION_PLUGIN_ID,
     label: BORING_AUTOMATION_PLUGIN_LABEL,
     routes: async (app) => {
-      await automationRoutes(app, { store, manualRunExecutor, dueRunService });
+      await automationRoutes(app, {
+        store,
+        storeForRequest: options.storeForRequest ? async (request) => {
+          const actor = options.actorResolver ? await options.actorResolver(request) : void 0;
+          if (!actor) throw new Error("automation actor resolver is unavailable");
+          return await options.storeForRequest(request, actor);
+        } : void 0,
+        manualRunExecutor,
+        dueRunService,
+        hostedDueRunService: options.hostedDueRunService,
+        hostedTriggerToken: options.hostedTriggerToken
+      });
     }
   });
 }
@@ -1109,6 +1260,24 @@ function createDefaultStore(workspaceRoot) {
 }
 function defaultBoringAutomationServerPlugin(options, ctx) {
   const trusted = ctx?.trusted;
+  if (!options?.store && trusted?.sql && trusted.workspaceAgentDispatcherResolver && trusted.actorResolver) {
+    const sql = trusted.sql;
+    const fallbackStore = new PostgresAutomationStore(sql, { workspaceId: "unbound", userId: "unbound" });
+    return createBoringAutomationServerPlugin({
+      ...options,
+      store: fallbackStore,
+      storeForRequest: async (_request, actor) => new PostgresAutomationStore(sql, actor),
+      dispatcherResolver: options?.dispatcherResolver ?? trusted.workspaceAgentDispatcherResolver,
+      actorResolver: options?.actorResolver ?? trusted.actorResolver,
+      actorVerifier: options?.actorVerifier ?? trusted.actorVerifier,
+      hostedTriggerToken: options?.hostedTriggerToken ?? trusted.hostedAutomationTriggerToken,
+      hostedDueRunService: options?.hostedDueRunService ?? new HostedDueRunService({
+        sql,
+        dispatcherResolver: options?.dispatcherResolver ?? trusted.workspaceAgentDispatcherResolver,
+        verifyActor: options?.actorVerifier ?? trusted.actorVerifier
+      })
+    });
+  }
   return createBoringAutomationServerPlugin({
     ...options,
     workspaceRoot: options?.workspaceRoot ?? ctx?.workspaceRoot,
@@ -1131,6 +1300,7 @@ export {
   BORING_AUTOMATION_ROUTE_PREFIX,
   DueRunService,
   FileAutomationStore,
+  HostedDueRunService,
   IdParamsSchema,
   ManualRunExecutor,
   PostgresAutomationStore,
@@ -1142,6 +1312,7 @@ export {
   evaluateAutomationSchedule,
   isValidFiveFieldCron,
   isValidIanaTimeZone,
+  listHostedAutomationCandidates,
   parseAutomationModel,
   runAlreadyActive,
   runAlreadyRecorded,

package/dist/shared/index.d.ts

@@ -16,6 +16,8 @@ declare const BORING_AUTOMATION_ERROR_CODES: {
     readonly RUN_EXECUTOR_UNAVAILABLE: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE";
     readonly TRIGGER_FORBIDDEN: "BORING_AUTOMATION_TRIGGER_FORBIDDEN";
     readonly RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED";
+    readonly OWNER_UNAUTHORIZED: "BORING_AUTOMATION_OWNER_UNAUTHORIZED";
+    readonly TRIGGER_UNAUTHORIZED: "BORING_AUTOMATION_TRIGGER_UNAUTHORIZED";
 };
 type BoringAutomationErrorCode = typeof BORING_AUTOMATION_ERROR_CODES[keyof typeof BORING_AUTOMATION_ERROR_CODES];
 

package/dist/shared/index.js

@@ -15,7 +15,9 @@ var BORING_AUTOMATION_ERROR_CODES = {
   RUN_ALREADY_RECORDED: "BORING_AUTOMATION_RUN_ALREADY_RECORDED",
   RUN_EXECUTOR_UNAVAILABLE: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE",
   TRIGGER_FORBIDDEN: "BORING_AUTOMATION_TRIGGER_FORBIDDEN",
-  RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED"
+  RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED",
+  OWNER_UNAUTHORIZED: "BORING_AUTOMATION_OWNER_UNAUTHORIZED",
+  TRIGGER_UNAUTHORIZED: "BORING_AUTOMATION_TRIGGER_UNAUTHORIZED"
 };
 
 // src/shared/schema.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-automation",
-  "version": "0.1.79",
+  "version": "0.1.81",
   "type": "module",
   "private": false,
   "license": "MIT",
@@ -43,14 +43,14 @@
     "fastify": "^5.9.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@hachej/boring-workspace": "0.1.79"
+    "@hachej/boring-workspace": "0.1.81"
   },
   "dependencies": {
     "croner": "^10.0.1",
     "lucide-react": "^1.21.0",
     "postgres": "^3.4.7",
     "zod": "^3.23.0",
-    "@hachej/boring-ui-kit": "0.1.79"
+    "@hachej/boring-ui-kit": "0.1.81"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.9.1",
@@ -66,7 +66,7 @@
     "tsup": "^8.4.0",
     "typescript": "~6.0.3",
     "vitest": "^4.1.9",
-    "@hachej/boring-workspace": "0.1.79"
+    "@hachej/boring-workspace": "0.1.81"
   },
   "peerDependenciesMeta": {
     "fastify": {