@agent-native/core 0.136.3 → 0.136.5

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

package/dist/jobs/scheduler.js

@@ -2,6 +2,7 @@ import { resourceGetByPath, resourceListAllOwners, resourcePutIfCurrent, } from
 import { backgroundRunCutOffReason, isBackgroundAutomationRunActive, resolveBackgroundAutomationIdentity, runBackgroundAutomation, } from "./background-automation-runner.js";
 import { nextOccurrence, isValidCron, describeCron, effectiveTimezone, } from "./cron.js";
 import { buildJobResourceContent, parseJobResource, } from "./frontmatter.js";
+import { claimAutomationRun, finishAutomationRun, getAutomationRun, } from "./run-history.js";
 // ─── Frontmatter parsing ────────────────────────────────────────────────────
 export { classifyJobFrontmatter, classifyJobResource, normalizeJobMcpTools, parseJobResource, } from "./frontmatter.js";
 export function parseJobFrontmatter(content) {
@@ -128,7 +129,7 @@ export async function processRecurringJobs(deps) {
     }
 }
 export const jobRunCutOffReason = backgroundRunCutOffReason;
-async function executeJob(resource, meta, body, deps, now) {
+async function executeJob(resource, meta, body, deps, now, options = {}) {
     const jobName = resource.path.replace(/^jobs\//, "").replace(/\.md$/, "");
     const jobContext = {
         name: jobName,
@@ -156,17 +157,36 @@ async function executeJob(resource, meta, body, deps, now) {
         meta.lastError = identity.reason;
         if (!alreadyRecorded)
             await updateResource(resource, meta, body);
-        return;
+        if (options.historyId) {
+            await finishAutomationRun(options.historyId, "error", `Automation did not run: ${identity.reason}. No delivery was confirmed.`);
+        }
+        return { status: "skipped", error: identity.reason };
     }
     const jobUserEmail = identity.identity.userEmail;
     const jobOrgId = identity.identity.orgId;
+    // Manual runs use the same resource row as scheduled runs for concurrency
+    // protection. The check is paired with the conditional write below: two
+    // requests that read the same idle snapshot cannot both claim it.
+    if (options.manual && isBackgroundAutomationRunActive(meta, now)) {
+        const error = "The automation is already running.";
+        if (options.historyId) {
+            await finishAutomationRun(options.historyId, "error", `${error} No delivery was confirmed.`);
+        }
+        return { status: "skipped", error };
+    }
     // Mark as running
     meta.lastRun = now.toISOString();
     meta.lastStatus = "running";
     meta.lastError = undefined;
     if (!(await updateResource(resource, meta, body))) {
         console.log(`[recurring-jobs] "${resource.path}" changed before it could start; dropping this tick.`);
-        return;
+        if (options.historyId) {
+            await finishAutomationRun(options.historyId, "error", "The automation changed before the run could start. No delivery was confirmed.");
+        }
+        return {
+            status: "error",
+            error: "The automation changed before the run could start.",
+        };
     }
     const requestContext = meta.originScopeId && meta.deliveryPlatform && meta.deliveryDestination
         ? {
@@ -193,33 +213,74 @@ async function executeJob(resource, meta, body, deps, now) {
         }
         : undefined;
     try {
-        await runBackgroundAutomation({
+        const result = await runBackgroundAutomation({
             automation: jobContext,
             ownerEmail: jobUserEmail,
             orgId: jobOrgId,
-            prompt: `[Recurring Job: ${jobName}]\nSchedule: ${describeCron(meta.schedule, effectiveTimezone(meta.timezone))}\n\nExecute the following job instructions:\n\n${body}`,
-            threadTitle: `Job: ${jobName} — ${now.toLocaleDateString()}`,
-            runIdPrefix: `job-${jobName}`,
-            usageLabel: `recurring-job:${jobName}`,
+            prompt: options.manual
+                ? `[Manual Automation Run: ${jobName}]\nThis run was explicitly started by the automation owner. Execute the following instructions now:\n\n${body}`
+                : `[Recurring Job: ${jobName}]\nSchedule: ${describeCron(meta.schedule, effectiveTimezone(meta.timezone))}\n\nExecute the following job instructions:\n\n${body}`,
+            threadTitle: `${options.manual ? "Automation" : "Job"}: ${jobName} — ${now.toLocaleDateString()}`,
+            runIdPrefix: `${options.manual ? "manual" : "job"}-${jobName}`,
+            usageLabel: `${options.manual ? "manual-automation" : "recurring-job"}:${jobName}`,
             requestContext,
+            ...(options.historyId ? { historyId: options.historyId } : {}),
+            actionCaller: "automation",
         }, deps);
         await recordExecutionOutcome(resource, {
             lastRun: meta.lastRun,
             lastStatus: "success",
             lastError: undefined,
+            advanceSchedule: options.advanceSchedule,
         });
         console.log(`[recurring-jobs] Job "${jobName}" completed.`);
+        return { status: "success", runId: result.runId };
     }
     catch (err) {
         const lastError = err instanceof Error ? err.message.slice(0, 200) : "Unknown error";
+        const reportedError = `${lastError}. No delivery was confirmed.`;
         await recordExecutionOutcome(resource, {
             lastRun: meta.lastRun,
             lastStatus: "error",
-            lastError,
+            lastError: reportedError,
+            advanceSchedule: options.advanceSchedule,
         });
-        console.error(`[recurring-jobs] Job "${jobName}" failed:`, lastError);
+        console.error(`[recurring-jobs] Job "${jobName}" failed:`, reportedError);
+        return { status: "error", error: reportedError };
     }
 }
+/** Execute one stored automation without changing its scheduled next run. */
+export async function runJobNow(owner, name, deps, options = {}) {
+    const path = `jobs/${name}.md`;
+    const resource = await resourceGetByPath(owner, path);
+    if (!resource)
+        throw new Error(`Automation "${name}" not found.`);
+    const { meta, body } = parseJobFrontmatter(resource.content);
+    if (!body.trim())
+        throw new Error(`Automation "${name}" has no instructions.`);
+    return executeJob(resource, meta, body, deps, new Date(), {
+        advanceSchedule: false,
+        historyId: options.historyId,
+        manual: true,
+    });
+}
+/** Process a durable run-now history row exactly once in the background worker. */
+export async function runQueuedAutomation(historyId, deps) {
+    const queued = await getAutomationRun(historyId);
+    if (!queued)
+        throw new Error(`Automation run "${historyId}" not found.`);
+    if (!(await claimAutomationRun(historyId))) {
+        return { skipped: true };
+    }
+    const result = await runJobNow(queued.owner, queued.automation, deps, {
+        historyId,
+    });
+    return {
+        skipped: false,
+        ...(result.runId ? { runId: result.runId } : {}),
+        ...(result.error ? { error: result.error } : {}),
+    };
+}
 async function updateResource(resource, meta, body) {
     const content = buildJobContent(meta, body);
     const written = await resourcePutIfCurrent({
@@ -256,8 +317,11 @@ async function recordExecutionOutcome(resource, outcome) {
         return;
     }
     const current = parseJobResource(latest.content);
-    const meta = { ...current.meta, ...outcome };
-    if (meta.schedule && isValidCron(meta.schedule)) {
+    const { advanceSchedule, ...execution } = outcome;
+    const meta = { ...current.meta, ...execution };
+    if (advanceSchedule !== false &&
+        meta.schedule &&
+        isValidCron(meta.schedule)) {
         // Measured from completion so a long run cannot immediately re-fire.
         meta.nextRun = nextOccurrence(meta.schedule, new Date(), meta.timezone).toISOString();
     }

package/dist/localization/default-messages.d.ts

@@ -57,6 +57,11 @@ declare const messages: {
         scopeLabel: string;
         scopePersonal: string;
         scopeWorkspace: string;
+        testStoredValue: string;
+        candidateValueWorking: string;
+        storedValueWorking: string;
+        invalid: string;
+        testFailed: string;
         scopePersonalDescription: string;
         scopeWorkspaceDescription: string;
     };
@@ -562,6 +567,9 @@ declare const messages: {
         eventTrigger: string;
         deleteAutomationTitle: string;
         deleteAutomationDescription: string;
+        runNow: string;
+        runNowTitle: string;
+        runNowDescription: string;
         automationDetails: string;
         automationEventDetails: string;
         condition: string;

package/dist/localization/default-messages.js

@@ -62,6 +62,11 @@ const messages = {
         scopeLabel: "Scope",
         scopePersonal: "Personal",
         scopeWorkspace: "Workspace",
+        testStoredValue: "Test",
+        candidateValueWorking: "New value works",
+        storedValueWorking: "Working",
+        invalid: "Invalid",
+        testFailed: "Test failed",
         scopePersonalDescription: "Only your own signed-in sessions use this key. Integration, webhook, scheduled job, automation, and agent-to-agent runs sign in as their owner rather than as you, so they cannot read it.",
         scopeWorkspaceDescription: "Everyone in this workspace uses this key, including integration, webhook, scheduled job, automation, and agent-to-agent runs.",
     },
@@ -567,6 +572,9 @@ const messages = {
         eventTrigger: "Event-triggered",
         deleteAutomationTitle: "Delete automation?",
         deleteAutomationDescription: "This permanently removes the automation and cannot be undone.",
+        runNow: "Run now",
+        runNowTitle: "Run automation now?",
+        runNowDescription: "This runs the automation's real actions immediately. It may send messages or change data, and it will not change the next scheduled run.",
         automationDetails: "Automation details",
         automationEventDetails: "Runs when {{event}}.",
         condition: "Condition",

package/dist/notifications/routes.d.ts

@@ -16,19 +16,19 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     error?: undefined;
     ok?: undefined;
 } | {
-    count?: undefined;
     updated: number;
     error?: undefined;
     ok?: undefined;
-} | {
     count?: undefined;
+} | {
     updated?: undefined;
     error: string;
     ok?: undefined;
-} | {
     count?: undefined;
+} | {
     updated?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
+    count?: undefined;
 }>>;
 //# sourceMappingURL=routes.d.ts.map

package/dist/observability/routes.d.ts

@@ -41,16 +41,16 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
+    error?: undefined;
     ok?: undefined;
 } | {
     summary?: undefined;
@@ -59,10 +59,10 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     error: any;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;
 //# sourceMappingURL=routes.d.ts.map

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,10 +75,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    message?: undefined;
-    id?: undefined;
-    found?: undefined;
     deleted?: undefined;
+    found?: undefined;
     providers: {
         id: string;
         label: string;
@@ -91,42 +89,44 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     count: number;
     provider?: undefined;
     registered?: undefined;
+    id?: undefined;
     label?: undefined;
-} | {
     message?: undefined;
-    id?: undefined;
+} | {
     deleted?: undefined;
-    providers?: undefined;
     count?: undefined;
+    providers?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
+    id?: undefined;
     label?: undefined;
-} | {
     message?: undefined;
+} | {
     deleted?: undefined;
-    providers?: undefined;
     count?: undefined;
+    providers?: undefined;
     provider?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
-} | {
     message?: undefined;
+} | {
+    count?: undefined;
     found?: undefined;
     providers?: undefined;
-    count?: undefined;
     provider?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
+    message?: undefined;
 } | {
-    found?: undefined;
     deleted?: undefined;
-    providers?: undefined;
     count?: undefined;
+    found?: undefined;
+    providers?: undefined;
     provider?: undefined;
     registered: boolean;
     id: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -329,9 +329,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         label?: undefined;
         message?: undefined;
     } | {
-        count?: undefined;
         id?: undefined;
         deleted?: undefined;
+        count?: undefined;
         providers?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
@@ -339,9 +339,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         label?: undefined;
         message?: undefined;
     } | {
-        count?: undefined;
         provider?: undefined;
         deleted?: undefined;
+        count?: undefined;
         providers?: undefined;
         found: boolean;
         id: string;
@@ -349,9 +349,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         label?: undefined;
         message?: undefined;
     } | {
-        count?: undefined;
         provider?: undefined;
         found?: undefined;
+        count?: undefined;
         providers?: undefined;
         deleted: boolean;
         id: string;
@@ -359,10 +359,10 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         label?: undefined;
         message?: undefined;
     } | {
-        count?: undefined;
         provider?: undefined;
         deleted?: undefined;
         found?: undefined;
+        count?: undefined;
         providers?: undefined;
         registered: boolean;
         id: string;

package/dist/provider-api/corpus-jobs.d.ts

@@ -73,6 +73,7 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     offset?: unknown;
     limit?: unknown;
 }, {
+    deleted?: undefined;
     jobs: {
         id: string;
         name: string;
@@ -83,7 +84,6 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
         updatedAt: string;
     }[];
     total: number;
-    deleted?: undefined;
     jobId?: undefined;
 } | {
     jobs?: undefined;
@@ -91,9 +91,9 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     deleted: boolean;
     jobId: string;
 } | {
+    deleted?: undefined;
     jobs?: undefined;
     total?: undefined;
-    deleted?: undefined;
     jobId?: undefined;
     hits: Record<string, unknown>[];
     offset: number;

package/dist/secrets/routes.d.ts

@@ -34,29 +34,29 @@ export declare function createListSecretsHandler(): import("h3").EventHandlerWit
 /** POST /_agent-native/secrets/:key — write a secret. */
 export declare function createWriteSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    status?: undefined;
     ok?: undefined;
+    status?: undefined;
 } | {
     error?: undefined;
     ok: boolean;
     status: string;
 } | {
+    ok?: undefined;
     error: string;
     removed?: undefined;
-    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;
     removed: boolean;
 }>>;
 /**
- * POST /_agent-native/secrets/:key/test — re-run the validator against the
- * current stored value without changing anything. Useful for the "Test" button.
+ * POST /_agent-native/secrets/:key/test — validate an optional candidate value
+ * or the current stored value without changing anything.
  */
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    ok?: undefined;
     error: string;
     note?: undefined;
-    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/secrets/routes.js

@@ -277,8 +277,8 @@ async function handleDelete(event, secret) {
     return { ok: true, removed };
 }
 /**
- * POST /_agent-native/secrets/:key/test — re-run the validator against the
- * current stored value without changing anything. Useful for the "Test" button.
+ * POST /_agent-native/secrets/:key/test — validate an optional candidate value
+ * or the current stored value without changing anything.
  */
 export function createTestSecretHandler() {
     return defineEventHandler(async (event) => {
@@ -301,25 +301,49 @@ export function createTestSecretHandler() {
             const has = await hasOAuthSecretForEvent(event, secret).catch(() => false);
             return { ok: has };
         }
-        if (!secret.validator) {
-            return { ok: true, note: "No validator registered" };
+        const body = (await readBody(event).catch(() => ({})));
+        const hasCandidateValue = Object.hasOwn(body, "value");
+        const candidateValue = typeof body.value === "string" ? body.value.trim() : undefined;
+        if (hasCandidateValue && !candidateValue) {
+            setResponseStatus(event, 400);
+            return { error: "value must be a non-empty string" };
         }
-        const { scopeId } = await resolveScopeId(event, secret.scope);
+        const { scopeId, reason } = await resolveScopeId(event, secret.scope);
         if (!scopeId) {
             setResponseStatus(event, 401);
-            return { error: "Unable to resolve scope" };
+            return { error: reason ?? "Unable to resolve scope" };
         }
-        const stored = await readAppSecret({
-            key: secret.key,
-            scope: secret.scope,
-            scopeId,
-        });
-        if (!stored) {
-            setResponseStatus(event, 404);
-            return { error: "No value stored" };
+        if (secret.scope === "workspace" &&
+            !(await canMutateWorkspaceScope(event, scopeId))) {
+            setResponseStatus(event, 403);
+            return {
+                error: "Only organization owners and admins can set workspace-scoped secrets",
+            };
+        }
+        if (secret.scope === "org" && !(await canMutateOrgScope(event, scopeId))) {
+            setResponseStatus(event, 403);
+            return {
+                error: "Only organization owners and admins can set org-scoped secrets",
+            };
+        }
+        if (!secret.validator) {
+            return { ok: true, note: "No validator registered" };
+        }
+        let value = candidateValue;
+        if (!value) {
+            const stored = await readAppSecret({
+                key: secret.key,
+                scope: secret.scope,
+                scopeId,
+            });
+            if (!stored) {
+                setResponseStatus(event, 404);
+                return { error: "No value stored" };
+            }
+            value = stored.value;
         }
         try {
-            const result = await secret.validator(stored.value);
+            const result = await secret.validator(value);
             const ok = typeof result === "boolean" ? result : result?.ok === true;
             if (!ok) {
                 const err = typeof result === "object" && result && result.error
@@ -327,7 +351,7 @@ export function createTestSecretHandler() {
                     : "Validator rejected the value";
                 return {
                     ok: false,
-                    error: redactSecretFromMessage(err, stored.value),
+                    error: redactSecretFromMessage(err, value),
                 };
             }
             return { ok: true };
@@ -338,7 +362,7 @@ export function createTestSecretHandler() {
                 : "Validator threw";
             return {
                 ok: false,
-                error: redactSecretFromMessage(message, stored.value),
+                error: redactSecretFromMessage(message, value),
             };
         }
     });

package/dist/server/action-discovery.js

@@ -540,6 +540,10 @@ export async function mergeCoreSharingActions(registry) {
             "manage-recurring-job",
             () => import("../jobs/actions/manage-recurring-job.js"),
         ],
+        [
+            "run-automation-now",
+            () => import("../jobs/actions/run-automation-now.js"),
+        ],
         [
             "list-automation-runs",
             () => import("../jobs/actions/list-automation-runs.js"),