@agent-native/core 0.136.2 → 0.136.4

package/dist/client/agent-page/AgentJobsTab.js

@@ -10,7 +10,7 @@ import { AgentEmptyState } from "./AgentEmptyState.js";
 import { AgentTabFrame } from "./AgentTabFrame.js";
 import { AutomationDetailsDialog, } from "./AutomationDetailsDialog.js";
 import { AutomationScheduleDialog } from "./AutomationScheduleDialog.js";
-import { useAutomations, useManageAutomation, useManageRecurringJob, useRecurringJobs, } from "./use-jobs.js";
+import { useAutomations, useManageAutomation, useManageRecurringJob, useRunAutomationNow, useRecurringJobs, } from "./use-jobs.js";
 function listRecurringJobs(jobs) {
     return jobs.map((resource) => ({
         kind: "recurring",
@@ -107,9 +107,11 @@ export function AgentJobsTab({ canManageOrg = false }) {
     const personalAutomationsMutation = useManageAutomation("user");
     const organizationJobsMutation = useManageRecurringJob("org");
     const organizationAutomationsMutation = useManageAutomation("org");
+    const runAutomationMutation = useRunAutomationNow();
     const [deleteTarget, setDeleteTarget] = useState(null);
     const [detailsTarget, setDetailsTarget] = useState(null);
     const [scheduleTarget, setScheduleTarget] = useState(null);
+    const [runTarget, setRunTarget] = useState(null);
     const formatDateTime = (value) => {
         if (!value || Number.isNaN(new Date(value).getTime()))
             return null;
@@ -210,7 +212,7 @@ export function AgentJobsTab({ canManageOrg = false }) {
                                                         : t("jobs.paused", { defaultValue: "Paused" }) }), resource.lastStatus ? (_jsx("span", { className: "rounded-full bg-muted px-2 py-0.5 text-[10px] font-medium text-muted-foreground", children: resource.lastStatus })) : null] }), _jsx("p", { className: "mt-1 text-sm text-muted-foreground", children: triggerDescription }), _jsx("p", { className: "mt-1 line-clamp-2 text-xs text-muted-foreground/80", children: instructions }), lastRun || nextRun || lastCheck ? (_jsxs("div", { className: "mt-2 flex flex-wrap gap-x-4 gap-y-1 text-[11px] text-muted-foreground", children: [nextRun ? (_jsxs("span", { children: [t("jobs.nextRun", { defaultValue: "Next run" }), ":", " ", nextRun] })) : null, _jsxs("span", { children: [t("jobs.lastRun", { defaultValue: "Last run" }), ":", " ", lastRun ??
                                                             t("jobs.neverRan", { defaultValue: "Never" })] }), !lastRun && lastCheck ? (_jsxs("span", { children: [t("jobs.lastChecked", {
                                                             defaultValue: "Last checked",
-                                                        }), ": ", lastCheck] })) : null] })) : null, resource.lastError ? (_jsxs("p", { className: "mt-2 flex items-start gap-1.5 text-[11px] text-destructive", children: [_jsx(IconAlertTriangle, { className: "mt-px size-3 shrink-0" }), _jsx("span", { className: "min-w-0 break-words", children: resource.lastError })] })) : null] }), _jsxs("div", { className: "flex shrink-0 items-center gap-1", children: [_jsxs(Button, { type: "button", variant: "ghost", size: "sm", className: "cursor-pointer px-2 text-xs", onClick: () => setDetailsTarget(entry), children: [_jsx(IconEye, { className: "size-3.5" }), t("jobs.details", { defaultValue: "Details" })] }), resource.canUpdate ? (_jsxs(_Fragment, { children: [entry.triggerType === "schedule" ? (_jsxs(Button, { type: "button", variant: "ghost", size: "sm", className: "cursor-pointer px-2 text-xs", disabled: mutationPending, onClick: () => setScheduleTarget(entry), children: [_jsx(IconPencil, { className: "size-3.5" }), t("jobs.edit", { defaultValue: "Edit" })] })) : null, _jsxs(Button, { type: "button", variant: "ghost", size: "sm", className: "cursor-pointer px-2 text-xs", disabled: mutationPending, onClick: () => mutateEntry(entry, "update", {
+                                                        }), ": ", lastCheck] })) : null] })) : null, resource.lastError ? (_jsxs("p", { className: "mt-2 flex items-start gap-1.5 text-[11px] text-destructive", children: [_jsx(IconAlertTriangle, { className: "mt-px size-3 shrink-0" }), _jsx("span", { className: "min-w-0 break-words", children: resource.lastError })] })) : null] }), _jsxs("div", { className: "flex shrink-0 items-center gap-1", children: [_jsxs(Button, { type: "button", variant: "ghost", size: "sm", className: "cursor-pointer px-2 text-xs", onClick: () => setDetailsTarget(entry), children: [_jsx(IconEye, { className: "size-3.5" }), t("jobs.details", { defaultValue: "Details" })] }), resource.canUpdate ? (_jsxs(_Fragment, { children: [_jsxs(Button, { type: "button", variant: "ghost", size: "sm", className: "cursor-pointer px-2 text-xs", disabled: mutationPending || runAutomationMutation.isPending, onClick: () => setRunTarget(entry), children: [_jsx(IconPlayerPlay, { className: "size-3.5" }), t("jobs.runNow", { defaultValue: "Run now" })] }), entry.triggerType === "schedule" ? (_jsxs(Button, { type: "button", variant: "ghost", size: "sm", className: "cursor-pointer px-2 text-xs", disabled: mutationPending, onClick: () => setScheduleTarget(entry), children: [_jsx(IconPencil, { className: "size-3.5" }), t("jobs.edit", { defaultValue: "Edit" })] })) : null, _jsxs(Button, { type: "button", variant: "ghost", size: "sm", className: "cursor-pointer px-2 text-xs", disabled: mutationPending, onClick: () => mutateEntry(entry, "update", {
                                                         enabled: !resource.enabled,
                                                     }), children: [resource.enabled ? (_jsx(IconPlayerPause, { className: "size-3.5" })) : (_jsx(IconPlayerPlay, { className: "size-3.5" })), resource.enabled
                                                             ? t("jobs.pause", { defaultValue: "Pause" })
@@ -221,7 +223,8 @@ export function AgentJobsTab({ canManageOrg = false }) {
     const mutationError = personalJobsMutation.error ||
         personalAutomationsMutation.error ||
         organizationJobsMutation.error ||
-        organizationAutomationsMutation.error;
+        organizationAutomationsMutation.error ||
+        runAutomationMutation.error;
     return (_jsxs(AgentTabFrame, { title: t("jobs.pageTitle", { defaultValue: "Automations" }), description: t("jobs.pageDescription", {
             defaultValue: "Manage agent tasks that run on a schedule or in response to events.",
         }), actions: _jsx(AgentAskPopover, { context: automationCreationContext(), prompt: t("jobs.automationPrompt", {
@@ -268,7 +271,19 @@ export function AgentJobsTab({ canManageOrg = false }) {
                                         if (!deleteTarget)
                                             return;
                                         mutateEntry(deleteTarget, "delete", undefined, () => setDeleteTarget(null));
-                                    }, children: [mutationPending ? (_jsx(IconLoader2, { className: "size-4 animate-spin" })) : null, t("jobs.delete", { defaultValue: "Delete" })] })] })] }) }), detailsTarget ? (_jsx(AutomationDetailsDialog, { open: true, name: detailsTarget.resource.name, scope: detailsTarget.resource.scope === "organization" ? "org" : "user", triggerSummary: describeTrigger(detailsTarget, t), fields: detailsFields(detailsTarget, t, formatDateTime), condition: detailsTarget.kind === "automation"
+                                    }, children: [mutationPending ? (_jsx(IconLoader2, { className: "size-4 animate-spin" })) : null, t("jobs.delete", { defaultValue: "Delete" })] })] })] }) }), _jsx(Dialog, { open: runTarget !== null, onOpenChange: (open) => {
+                    if (!open && !runAutomationMutation.isPending)
+                        setRunTarget(null);
+                }, children: _jsxs(DialogContent, { children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { children: t("jobs.runNowTitle", { defaultValue: "Run automation now?" }) }), _jsx(DialogDescription, { children: t("jobs.runNowDescription", {
+                                        defaultValue: "This runs the automation's real actions immediately. It may send messages or change data, and it will not change the next scheduled run.",
+                                    }) })] }), runAutomationMutation.error ? (_jsx("p", { className: "text-sm text-destructive", children: runAutomationMutation.error.message })) : null, _jsxs(DialogFooter, { children: [_jsx(Button, { type: "button", variant: "outline", className: "cursor-pointer", disabled: runAutomationMutation.isPending, onClick: () => setRunTarget(null), children: t("jobs.cancel", { defaultValue: "Cancel" }) }), _jsxs(Button, { type: "button", className: "cursor-pointer", disabled: runAutomationMutation.isPending, onClick: () => {
+                                        if (!runTarget)
+                                            return;
+                                        runAutomationMutation.mutate({
+                                            name: runTarget.resource.name,
+                                            scope: runTarget.resource.scope,
+                                        }, { onSuccess: () => setRunTarget(null) });
+                                    }, children: [runAutomationMutation.isPending ? (_jsx(IconLoader2, { className: "size-4 animate-spin" })) : (_jsx(IconPlayerPlay, { className: "size-4" })), t("jobs.runNow", { defaultValue: "Run now" })] })] })] }) }), detailsTarget ? (_jsx(AutomationDetailsDialog, { open: true, name: detailsTarget.resource.name, scope: detailsTarget.resource.scope === "organization" ? "org" : "user", triggerSummary: describeTrigger(detailsTarget, t), fields: detailsFields(detailsTarget, t, formatDateTime), condition: detailsTarget.kind === "automation"
                     ? detailsTarget.resource.condition
                     : null, instructions: detailsTarget.kind === "automation"
                     ? detailsTarget.resource.body

package/dist/client/agent-page/use-jobs.d.ts

@@ -55,6 +55,15 @@ export type ManageJobInput = {
     timezone?: string;
 };
 export type ManageAutomationInput = ManageJobInput;
+export interface RunAutomationNowInput {
+    name: string;
+    scope: "personal" | "organization";
+}
+export interface RunAutomationNowResult {
+    queued: true;
+    runId: string;
+    automationRunId: string;
+}
 export interface AutomationRun {
     id: string;
     automation: string;
@@ -78,5 +87,6 @@ export declare function useManageAutomation(scope: JobsScope): import("@tanstack
     name: string;
     enabled?: boolean;
 }, Error, ManageJobInput, unknown>;
+export declare function useRunAutomationNow(): import("@tanstack/react-query").UseMutationResult<RunAutomationNowResult, Error, RunAutomationNowInput, unknown>;
 export declare function useAutomationRuns(scope: JobsScope, name: string | null, active: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<AutomationRun[]>, Error>;
 //# sourceMappingURL=use-jobs.d.ts.map

package/dist/client/agent-page/use-jobs.js

@@ -68,6 +68,27 @@ export function useManageAutomation(scope) {
         },
     });
 }
+export function useRunAutomationNow() {
+    const queryClient = useQueryClient();
+    return useActionMutation("run-automation-now", {
+        onSuccess: (_result, variables) => {
+            const scope = variables.scope === "organization" ? "organization" : "personal";
+            queryClient.invalidateQueries({
+                queryKey: [
+                    "action",
+                    "list-automation-runs",
+                    { scope, name: variables.name },
+                ],
+            });
+            queryClient.invalidateQueries({
+                queryKey: ["action", "list-automations", { scope }],
+            });
+            queryClient.invalidateQueries({
+                queryKey: ["action", "list-recurring-jobs", { scope }],
+            });
+        },
+    });
+}
 function optimisticPatch(variables) {
     const patch = {};
     if (variables.enabled !== undefined)

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -17,12 +17,12 @@ declare const _default: import("../../action.js").ActionDefinition<{
     id?: undefined;
     provider?: undefined;
 } | {
+    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
 }>;
 export default _default;
 //# sourceMappingURL=upload-image.d.ts.map

package/dist/jobs/actions/run-automation-now.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    name: string;
+    scope?: "organization" | "personal";
+}, import("../run-now.js").QueuedAutomationRun>;
+export default _default;
+//# sourceMappingURL=run-automation-now.d.ts.map

package/dist/jobs/actions/run-automation-now.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { queueAutomationRunNow } from "../run-now.js";
+export default defineAction({
+    description: "Run one personal or organization automation immediately. This is an explicit send/run action and may perform the automation's real side effects.",
+    agentTool: false,
+    schema: z.object({
+        name: z.string().min(1),
+        scope: z.enum(["personal", "organization"]).default("personal"),
+    }),
+    run: async ({ name, scope }, ctx) => {
+        if (!ctx?.userEmail)
+            throw new Error("Not authenticated.");
+        return queueAutomationRunNow({
+            userEmail: ctx.userEmail,
+            orgId: ctx.orgId,
+            scope,
+            name,
+        });
+    },
+});
+//# sourceMappingURL=run-automation-now.js.map

package/dist/jobs/background-automation-runner.d.ts

@@ -32,6 +32,8 @@ export interface BackgroundAutomationRunOptions {
     requestContext?: Omit<RequestContext, "userEmail" | "orgId">;
     actionCaller?: ActionCaller;
     actionAutomation?: ActionAutomationContext;
+    /** Reuse a history row created by a durable run-now enqueue. */
+    historyId?: string;
 }
 export interface BackgroundAutomationRunResult {
     responseText: string;

package/dist/jobs/background-automation-runner.js

@@ -152,29 +152,35 @@ export async function runBackgroundAutomation(options, deps) {
     // that cannot be written should cost us the record, not the automation.
     // Everything downstream tolerates a null id by skipping its own write.
     let historyId = null;
-    try {
-        const historyOwner = options.orgId
-            ? organizationResourceOwner(options.orgId)
-            : automation.resource.owner === "__shared__"
-                ? options.ownerEmail
-                : automation.resource.owner;
-        historyId = await startAutomationRun({
-            owner: historyOwner,
-            automation: automation.name,
-            path: automation.resource.path,
-            scope: options.orgId ? "organization" : "personal",
-            orgId: options.orgId ?? null,
-        });
+    if (options.historyId) {
+        historyId = options.historyId;
     }
-    catch (err) {
-        console.error(`[automations] Could not open a history record for "${automation.name}"; running anyway:`, err);
+    else {
+        try {
+            const historyOwner = options.orgId
+                ? organizationResourceOwner(options.orgId)
+                : automation.resource.owner === "__shared__"
+                    ? options.ownerEmail
+                    : automation.resource.owner;
+            historyId = await startAutomationRun({
+                owner: historyOwner,
+                automation: automation.name,
+                path: automation.resource.path,
+                scope: options.orgId ? "organization" : "personal",
+                orgId: options.orgId ?? null,
+            });
+        }
+        catch (err) {
+            console.error(`[automations] Could not open a history record for "${automation.name}"; running anyway:`, err);
+        }
     }
     let result;
     try {
         result = await executeBackgroundAutomation(options, deps, historyId);
     }
     catch (err) {
-        await recordRunOutcome(historyId, "error", err instanceof Error ? err.message : String(err));
+        const message = err instanceof Error ? err.message : String(err);
+        await recordRunOutcome(historyId, "error", `${message}. No delivery was confirmed.`);
         throw err;
     }
     // Outside the try: history is bookkeeping about the run, so a failure to

package/dist/jobs/run-history.d.ts

@@ -27,13 +27,27 @@ export interface StartAutomationRunInput {
     orgId?: string | null;
     runId?: string | null;
     threadId?: string | null;
+    /** A pre-created row still waiting for its background worker handoff. */
+    dispatchPending?: boolean;
 }
 /**
- * Record that an automation actually began executing. Returns the run id used
- * to close the record out. Only real executions get a row — a tick that
- * declined to run the automation must not appear in its history.
+ * Record an automation execution. Manual runs create the row before dispatch,
+ * so `dispatchPending` distinguishes that durable handoff from a run that has
+ * already entered the worker.
  */
 export declare function startAutomationRun(input: StartAutomationRunInput): Promise<string>;
+export declare function getAutomationRun(id: string): Promise<AutomationRun | null>;
+/** Claim a manually queued run exactly once before loading its automation. */
+export declare function claimAutomationRun(id: string): Promise<boolean>;
+/**
+ * Find manual handoffs that have stayed unclaimed long enough to have missed
+ * their first self-dispatch. The row is the durable queue; callers may safely
+ * redeliver it because claimAutomationRun is an atomic CAS.
+ */
+export declare function listUnclaimedAutomationRuns(options?: {
+    olderThanMs?: number;
+    limit?: number;
+}): Promise<AutomationRun[]>;
 export declare function finishAutomationRun(id: string, status: Exclude<AutomationRunStatus, "running">, error?: string): Promise<void>;
 /**
  * Attach the agent thread once it exists. The thread is created after the run

package/dist/jobs/run-history.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { getDbExec, intType, isPostgres } from "../db/client.js";
-import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
+import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 const TABLE = "automation_runs";
 const MAX_ERROR_LENGTH = 500;
 /**
@@ -8,6 +8,10 @@ const MAX_ERROR_LENGTH = 500;
  * (BACKGROUND_RUN_HARD_TIMEOUT_MS). Past this, no run is still alive.
  */
 const RUN_LIVENESS_CEILING_MS = 15 * 60_000;
+// The background worker has a shorter hard timeout than this lease. A worker
+// that dies after claiming can therefore be redelivered without overlapping a
+// still-live execution under normal runtime limits.
+const CLAIM_LEASE_MS = RUN_LIVENESS_CEILING_MS;
 /** Rows kept per automation, so a per-minute schedule cannot grow forever. */
 const RUNS_RETAINED_PER_AUTOMATION = 50;
 let _initPromise;
@@ -28,16 +32,39 @@ async function ensureTable() {
           status TEXT NOT NULL DEFAULT 'running',
           started_at ${intType()} NOT NULL,
           finished_at ${intType()},
-          error TEXT
+          error TEXT,
+          claimed_at ${intType()},
+          dispatch_pending ${intType()} NOT NULL DEFAULT 0
         )
       `;
             const indexSql = `CREATE INDEX IF NOT EXISTS idx_${TABLE}_owner_automation ON ${TABLE} (owner, automation, started_at)`;
             if (isPostgres()) {
                 await ensureTableExists(TABLE, createSql);
+                await ensureColumnExists(TABLE, "claimed_at", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS claimed_at ${intType()}`);
+                await ensureColumnExists(TABLE, "dispatch_pending", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS dispatch_pending ${intType()} NOT NULL DEFAULT 0`);
                 await ensureIndexExists(`idx_${TABLE}_owner_automation`, indexSql);
                 return;
             }
             await client.execute(createSql);
+            const { rows } = await client.execute(`PRAGMA table_info("${TABLE}")`);
+            const columns = new Set(rows.map((row) => String(row.name)));
+            for (const [name, definition] of [
+                ["claimed_at", `${intType()}`],
+                ["dispatch_pending", `${intType()} NOT NULL DEFAULT 0`],
+            ]) {
+                if (columns.has(name))
+                    continue;
+                try {
+                    await client.execute(`ALTER TABLE ${TABLE} ADD COLUMN ${name} ${definition}`);
+                }
+                catch (error) {
+                    const message = String(error?.message ?? error);
+                    if (!/duplicate column name/i.test(message) &&
+                        !/column .* already exists/i.test(message)) {
+                        throw error;
+                    }
+                }
+            }
             await client.execute(indexSql);
         })().catch((err) => {
             _initPromise = undefined;
@@ -68,16 +95,16 @@ function toRun(row, now) {
     };
 }
 /**
- * Record that an automation actually began executing. Returns the run id used
- * to close the record out. Only real executions get a row — a tick that
- * declined to run the automation must not appear in its history.
+ * Record an automation execution. Manual runs create the row before dispatch,
+ * so `dispatchPending` distinguishes that durable handoff from a run that has
+ * already entered the worker.
  */
 export async function startAutomationRun(input) {
     await ensureTable();
     const id = randomUUID();
     await getDbExec().execute({
-        sql: `INSERT INTO ${TABLE} (id, owner, automation, path, scope, org_id, run_id, thread_id, status, started_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'running', ?)`,
+        sql: `INSERT INTO ${TABLE} (id, owner, automation, path, scope, org_id, run_id, thread_id, status, started_at, dispatch_pending)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?)`,
         args: [
             id,
             input.owner,
@@ -88,11 +115,50 @@ export async function startAutomationRun(input) {
             input.runId ?? null,
             input.threadId ?? null,
             Date.now(),
+            input.dispatchPending ? 1 : 0,
         ],
     });
     await pruneAutomationRuns(input.owner, input.automation);
     return id;
 }
+export async function getAutomationRun(id) {
+    await ensureTable();
+    const result = await getDbExec().execute({
+        sql: `SELECT * FROM ${TABLE} WHERE id = ? LIMIT 1`,
+        args: [id],
+    });
+    const row = result.rows?.[0];
+    return row ? toRun(row, Date.now()) : null;
+}
+/** Claim a manually queued run exactly once before loading its automation. */
+export async function claimAutomationRun(id) {
+    await ensureTable();
+    const now = Date.now();
+    const result = await getDbExec().execute({
+        sql: `UPDATE ${TABLE} SET claimed_at = ? WHERE id = ? AND dispatch_pending = 1 AND (claimed_at IS NULL OR claimed_at <= ?) AND status = 'running'`,
+        args: [now, id, now - CLAIM_LEASE_MS],
+    });
+    return Number(result.rowsAffected ?? 0) > 0;
+}
+/**
+ * Find manual handoffs that have stayed unclaimed long enough to have missed
+ * their first self-dispatch. The row is the durable queue; callers may safely
+ * redeliver it because claimAutomationRun is an atomic CAS.
+ */
+export async function listUnclaimedAutomationRuns(options) {
+    await ensureTable();
+    const olderThanMs = Math.max(options?.olderThanMs ?? 10_000, 0);
+    const limit = Math.min(Math.max(options?.limit ?? 50, 1), 100);
+    const result = await getDbExec().execute({
+        sql: `SELECT * FROM ${TABLE}
+          WHERE dispatch_pending = 1 AND (claimed_at IS NULL OR claimed_at <= ?) AND status = 'running'
+            AND started_at <= ?
+          ORDER BY started_at ASC LIMIT ${limit}`,
+        args: [Date.now() - CLAIM_LEASE_MS, Date.now() - olderThanMs],
+    });
+    const now = Date.now();
+    return (result.rows ?? []).map((row) => toRun(row, now));
+}
 /**
  * Drop the oldest rows for one automation once it exceeds the retention cap.
  *

package/dist/jobs/run-now.d.ts

@@ -0,0 +1,20 @@
+import { type AutomationScope } from "../automations/service.js";
+export interface RunAutomationNowInput {
+    userEmail: string;
+    orgId?: string | null;
+    scope: AutomationScope;
+    name: string;
+}
+export interface QueuedAutomationRun {
+    queued: true;
+    runId: string;
+    automationRunId: string;
+}
+export declare function queueAutomationRunNow(input: RunAutomationNowInput): Promise<QueuedAutomationRun>;
+/**
+ * Recover manual rows whose first serverless handoff never reached a worker.
+ * This is intentionally a redelivery, not a second execution: the worker's
+ * claim CAS decides which request owns the run.
+ */
+export declare function redispatchUnclaimedAutomationRuns(): Promise<number>;
+//# sourceMappingURL=run-now.d.ts.map

package/dist/jobs/run-now.js

@@ -0,0 +1,99 @@
+import { AGENT_CHAT_BACKGROUND_RUN_FIELD, dispatchPathTargetsNetlifyBackgroundFunction, resolveAgentChatProcessRunDispatchPath, } from "../agent/durable-background.js";
+import { canUpdateAutomationResource, } from "../automations/service.js";
+import { isLocalDatabase } from "../db/client.js";
+import { organizationResourceOwner, resourceGetByPath, } from "../resources/store.js";
+import { fireInternalDispatch } from "../server/self-dispatch.js";
+import { parseJobResource } from "./frontmatter.js";
+import { listUnclaimedAutomationRuns, startAutomationRun, } from "./run-history.js";
+async function dispatchAutomationRun(historyId) {
+    const dispatchPath = resolveAgentChatProcessRunDispatchPath();
+    await fireInternalDispatch({
+        path: dispatchPath,
+        taskId: historyId,
+        body: {
+            [AGENT_CHAT_BACKGROUND_RUN_FIELD]: {
+                runId: historyId,
+                automationRunId: historyId,
+            },
+        },
+        ...(dispatchPathTargetsNetlifyBackgroundFunction(dispatchPath)
+            ? { awaitResponse: true, responseTimeoutMs: 5_000 }
+            : !isLocalDatabase()
+                ? { awaitResponse: true, responseTimeoutMs: 5_000 }
+                : {}),
+    });
+}
+function ownerForScope(input) {
+    if (input.scope === "personal")
+        return input.userEmail.trim().toLowerCase();
+    if (!input.orgId) {
+        throw Object.assign(new Error("An organization is required for organization automations."), { statusCode: 400 });
+    }
+    return organizationResourceOwner(input.orgId);
+}
+export async function queueAutomationRunNow(input) {
+    const name = input.name.trim();
+    if (!name || name.includes("/") || name.endsWith(".md")) {
+        throw Object.assign(new Error("A valid automation name is required."), {
+            statusCode: 400,
+        });
+    }
+    const owner = ownerForScope(input);
+    const resource = await resourceGetByPath(owner, `jobs/${name}.md`);
+    if (!resource) {
+        throw Object.assign(new Error(`Automation "${name}" not found.`), {
+            statusCode: 404,
+        });
+    }
+    if (!(await canUpdateAutomationResource(input, resource))) {
+        throw Object.assign(new Error("Only the automation's creator or an organization admin can run it."), { statusCode: 403 });
+    }
+    const { body } = parseJobResource(resource.content);
+    if (!body.trim()) {
+        throw Object.assign(new Error(`Automation "${name}" has no instructions.`), {
+            statusCode: 400,
+        });
+    }
+    // A manual-run request is a guaranteed app request even on hosts without a
+    // durable timer. Use it to recover older rows before adding the new one.
+    await redispatchUnclaimedAutomationRuns().catch((error) => {
+        console.warn("[automations] Could not sweep queued runs before run-now:", error);
+    });
+    const historyId = await startAutomationRun({
+        owner: resource.owner,
+        automation: name,
+        path: resource.path,
+        scope: input.scope,
+        orgId: input.scope === "organization" ? input.orgId : null,
+        dispatchPending: true,
+    });
+    try {
+        await dispatchAutomationRun(historyId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Background dispatch failed";
+        console.warn(`[automations] Initial run-now dispatch failed; leaving ${historyId} queued for redelivery:`, message);
+        throw error;
+    }
+    return { queued: true, runId: historyId, automationRunId: historyId };
+}
+/**
+ * Recover manual rows whose first serverless handoff never reached a worker.
+ * This is intentionally a redelivery, not a second execution: the worker's
+ * claim CAS decides which request owns the run.
+ */
+export async function redispatchUnclaimedAutomationRuns() {
+    const runs = await listUnclaimedAutomationRuns();
+    let attempted = 0;
+    for (const run of runs) {
+        try {
+            await dispatchAutomationRun(run.id);
+            attempted += 1;
+        }
+        catch (error) {
+            console.error(`[automations] Could not redeliver queued run ${run.id}:`, error);
+        }
+    }
+    return attempted;
+}
+//# sourceMappingURL=run-now.js.map

package/dist/jobs/scheduler.d.ts

@@ -27,4 +27,19 @@ export interface SchedulerDeps extends BackgroundAutomationDeps {
  */
 export declare function processRecurringJobs(deps: SchedulerDeps): Promise<void>;
 export declare const jobRunCutOffReason: typeof backgroundRunCutOffReason;
+interface JobExecutionResult {
+    status: "success" | "error" | "skipped";
+    runId?: string;
+    error?: string;
+}
+/** Execute one stored automation without changing its scheduled next run. */
+export declare function runJobNow(owner: string, name: string, deps: SchedulerDeps, options?: {
+    historyId?: string;
+}): Promise<JobExecutionResult>;
+/** Process a durable run-now history row exactly once in the background worker. */
+export declare function runQueuedAutomation(historyId: string, deps: SchedulerDeps): Promise<{
+    skipped: boolean;
+    runId?: string;
+    error?: string;
+}>;
 //# sourceMappingURL=scheduler.d.ts.map