@pellux/goodvibes-daemon-sdk 0.18.3

package/dist/remote-routes.js

@@ -0,0 +1,238 @@
+import { jsonErrorResponse } from './error-response.js';
+import { serializableJsonResponse } from './route-helpers.js';
+export function createDaemonRemoteRouteHandlers(context) {
+    return {
+        getRemotePairRequests: () => Response.json({ requests: context.distributedRuntime.listPairRequests() }),
+        approveRemotePairRequest: async (requestId, request) => handleApproveRemotePairRequest(context, requestId, request),
+        rejectRemotePairRequest: async (requestId, request) => handleRejectRemotePairRequest(context, requestId, request),
+        getRemotePeers: () => Response.json({ peers: context.distributedRuntime.listPeers() }),
+        rotateRemotePeerToken: async (peerId, request) => handleRotateRemotePeerToken(context, peerId, request),
+        revokeRemotePeerToken: async (peerId, request) => handleRevokeRemotePeerToken(context, peerId, request),
+        disconnectRemotePeer: async (peerId, request) => handleDisconnectRemotePeer(context, peerId, request),
+        getRemoteWork: () => Response.json({ work: context.distributedRuntime.listWork() }),
+        invokeRemotePeer: async (peerId, request) => handleInvokeRemotePeer(context, peerId, request),
+        cancelRemoteWork: async (workId, request) => handleCancelRemoteWork(context, workId, request),
+        getRemoteNodeHostContract: () => serializableJsonResponse({ contract: context.distributedRuntime.getNodeHostContract() }),
+    };
+}
+export async function handleRemotePairRequest(context, req) {
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const peerKind = body.peerKind === 'device' ? 'device' : 'node';
+    const label = typeof body.label === 'string' ? body.label.trim() : '';
+    if (!label) {
+        return Response.json({ error: 'Missing remote peer label' }, { status: 400 });
+    }
+    const created = await context.distributedRuntime.requestPairing({
+        peerKind,
+        requestedId: typeof body.requestedId === 'string' ? body.requestedId : undefined,
+        label,
+        platform: typeof body.platform === 'string' ? body.platform : undefined,
+        deviceFamily: typeof body.deviceFamily === 'string' ? body.deviceFamily : undefined,
+        version: typeof body.version === 'string' ? body.version : undefined,
+        clientMode: typeof body.clientMode === 'string' ? body.clientMode : undefined,
+        capabilities: Array.isArray(body.capabilities) ? body.capabilities.filter((value) => typeof value === 'string') : [],
+        commands: Array.isArray(body.commands) ? body.commands.filter((value) => typeof value === 'string') : [],
+        metadata: typeof body.metadata === 'object' && body.metadata !== null ? body.metadata : {},
+        requestedBy: 'remote',
+        remoteAddress: req.headers.get('x-forwarded-for') ?? undefined,
+        ttlMs: typeof body.ttlMs === 'number' ? body.ttlMs : undefined,
+    });
+    return Response.json(created, { status: 201 });
+}
+export async function handleRemotePairVerify(context, req) {
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const requestId = typeof body.requestId === 'string' ? body.requestId : '';
+    const challenge = typeof body.challenge === 'string' ? body.challenge : '';
+    if (!requestId || !challenge) {
+        return Response.json({ error: 'Missing requestId or challenge' }, { status: 400 });
+    }
+    const verified = await context.distributedRuntime.verifyPairRequest(requestId, challenge, {
+        remoteAddress: req.headers.get('x-forwarded-for') ?? undefined,
+        metadata: typeof body.metadata === 'object' && body.metadata !== null ? body.metadata : {},
+    });
+    return verified
+        ? Response.json(verified)
+        : Response.json({ error: 'Pair request not approved, expired, or invalid' }, { status: 404 });
+}
+export async function handleRemotePeerHeartbeat(context, req) {
+    const auth = await context.requireRemotePeer(req, 'remote:heartbeat');
+    if (auth instanceof Response)
+        return auth;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const peer = await context.distributedRuntime.heartbeatPeer(auth, {
+        remoteAddress: req.headers.get('x-forwarded-for') ?? undefined,
+        capabilities: Array.isArray(body.capabilities) ? body.capabilities.filter((value) => typeof value === 'string') : undefined,
+        commands: Array.isArray(body.commands) ? body.commands.filter((value) => typeof value === 'string') : undefined,
+        version: typeof body.version === 'string' ? body.version : undefined,
+        clientMode: typeof body.clientMode === 'string' ? body.clientMode : undefined,
+        metadata: typeof body.metadata === 'object' && body.metadata !== null ? body.metadata : {},
+    });
+    return Response.json({ peer });
+}
+export async function handleRemotePeerWorkPull(context, req) {
+    const auth = await context.requireRemotePeer(req, 'remote:pull');
+    if (auth instanceof Response)
+        return auth;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const work = await context.distributedRuntime.claimWork(auth, {
+        maxItems: typeof body.maxItems === 'number' ? body.maxItems : undefined,
+        leaseMs: typeof body.leaseMs === 'number' ? body.leaseMs : undefined,
+    });
+    return Response.json({ work });
+}
+export async function handleRemotePeerWorkComplete(context, workId, req) {
+    const auth = await context.requireRemotePeer(req, 'remote:complete');
+    if (auth instanceof Response)
+        return auth;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const work = await context.distributedRuntime.completeWork(auth, workId, {
+        status: body.status === 'failed' || body.status === 'cancelled' ? body.status : body.status === 'completed' ? 'completed' : undefined,
+        result: body.result,
+        error: typeof body.error === 'string' ? body.error : undefined,
+        metadata: typeof body.metadata === 'object' && body.metadata !== null ? body.metadata : {},
+    });
+    return work
+        ? Response.json({ work })
+        : Response.json({ error: 'Unknown or unclaimed remote work item' }, { status: 404 });
+}
+function operatorActor(context, req) {
+    return context.authToken ? 'shared-token' : context.requireAuthenticatedSession(req)?.username ?? 'operator';
+}
+async function handleApproveRemotePairRequest(context, requestId, req) {
+    const admin = context.requireAdmin(req);
+    if (admin)
+        return admin;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const approved = await context.distributedRuntime.approvePairRequest(requestId, {
+        actor: operatorActor(context, req),
+        note: typeof body.note === 'string' ? body.note : undefined,
+        label: typeof body.label === 'string' ? body.label : undefined,
+        metadata: typeof body.metadata === 'object' && body.metadata !== null ? body.metadata : {},
+    });
+    return approved
+        ? Response.json(approved)
+        : Response.json({ error: 'Unknown remote pair request' }, { status: 404 });
+}
+async function handleRejectRemotePairRequest(context, requestId, req) {
+    const admin = context.requireAdmin(req);
+    if (admin)
+        return admin;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const rejected = await context.distributedRuntime.rejectPairRequest(requestId, {
+        actor: operatorActor(context, req),
+        note: typeof body.note === 'string' ? body.note : undefined,
+    });
+    return rejected
+        ? Response.json(rejected)
+        : Response.json({ error: 'Unknown remote pair request' }, { status: 404 });
+}
+async function handleRotateRemotePeerToken(context, peerId, req) {
+    const admin = context.requireAdmin(req);
+    if (admin)
+        return admin;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const rotated = await context.distributedRuntime.rotatePeerToken(peerId, {
+        actor: operatorActor(context, req),
+        label: typeof body.label === 'string' ? body.label : undefined,
+        scopes: Array.isArray(body.scopes) ? body.scopes.filter((value) => typeof value === 'string') : undefined,
+    });
+    return rotated
+        ? Response.json(rotated)
+        : Response.json({ error: 'Unknown distributed peer' }, { status: 404 });
+}
+async function handleRevokeRemotePeerToken(context, peerId, req) {
+    const admin = context.requireAdmin(req);
+    if (admin)
+        return admin;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const peer = await context.distributedRuntime.revokePeerToken(peerId, {
+        actor: operatorActor(context, req),
+        tokenId: typeof body.tokenId === 'string' ? body.tokenId : undefined,
+        note: typeof body.note === 'string' ? body.note : undefined,
+    });
+    return peer
+        ? Response.json({ peer })
+        : Response.json({ error: 'Unknown distributed peer' }, { status: 404 });
+}
+async function handleDisconnectRemotePeer(context, peerId, req) {
+    const admin = context.requireAdmin(req);
+    if (admin)
+        return admin;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const peer = await context.distributedRuntime.disconnectPeer(peerId, {
+        actor: operatorActor(context, req),
+        note: typeof body.note === 'string' ? body.note : undefined,
+        requeueClaimedWork: typeof body.requeueClaimedWork === 'boolean' ? body.requeueClaimedWork : undefined,
+    });
+    return peer
+        ? Response.json({ peer })
+        : Response.json({ error: 'Unknown distributed peer' }, { status: 404 });
+}
+async function handleInvokeRemotePeer(context, peerId, req) {
+    const admin = context.requireAdmin(req);
+    if (admin)
+        return admin;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const command = typeof body.command === 'string' ? body.command.trim() : '';
+    if (!command) {
+        return Response.json({ error: 'Missing remote invoke command' }, { status: 400 });
+    }
+    try {
+        const invoked = await context.distributedRuntime.invokePeer({
+            peerId,
+            command,
+            payload: body.payload,
+            priority: body.priority === 'high' || body.priority === 'default' ? body.priority : 'normal',
+            actor: operatorActor(context, req),
+            waitMs: typeof body.waitMs === 'number' ? body.waitMs : undefined,
+            timeoutMs: typeof body.timeoutMs === 'number' ? body.timeoutMs : undefined,
+            sessionId: typeof body.sessionId === 'string' ? body.sessionId : undefined,
+            routeId: typeof body.routeId === 'string' ? body.routeId : undefined,
+            automationRunId: typeof body.automationRunId === 'string' ? body.automationRunId : undefined,
+            automationJobId: typeof body.automationJobId === 'string' ? body.automationJobId : undefined,
+            approvalId: typeof body.approvalId === 'string' ? body.approvalId : undefined,
+            metadata: typeof body.metadata === 'object' && body.metadata !== null ? body.metadata : {},
+        });
+        return Response.json(invoked, { status: 202 });
+    }
+    catch (error) {
+        return jsonErrorResponse(error, { status: 404 });
+    }
+}
+async function handleCancelRemoteWork(context, workId, req) {
+    const admin = context.requireAdmin(req);
+    if (admin)
+        return admin;
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const work = await context.distributedRuntime.cancelWork(workId, {
+        actor: operatorActor(context, req),
+        reason: typeof body.reason === 'string' ? body.reason : undefined,
+    });
+    return work
+        ? Response.json({ work })
+        : Response.json({ error: 'Unknown remote work item' }, { status: 404 });
+}

package/dist/remote.d.ts

@@ -0,0 +1,3 @@
+import type { DaemonApiRouteHandlers } from './context.js';
+export declare function dispatchRemoteRoutes(req: Request, handlers: Pick<DaemonApiRouteHandlers, 'getRemote' | 'getRemotePairRequests' | 'approveRemotePairRequest' | 'rejectRemotePairRequest' | 'getRemotePeers' | 'rotateRemotePeerToken' | 'revokeRemotePeerToken' | 'disconnectRemotePeer' | 'getRemoteWork' | 'invokeRemotePeer' | 'cancelRemoteWork'>): Promise<Response | null>;
+//# sourceMappingURL=remote.d.ts.map

package/dist/remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../src/remote.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE3D,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,IAAI,CACZ,sBAAsB,EACpB,WAAW,GACX,uBAAuB,GACvB,0BAA0B,GAC1B,yBAAyB,GACzB,gBAAgB,GAChB,uBAAuB,GACvB,uBAAuB,GACvB,sBAAsB,GACtB,eAAe,GACf,kBAAkB,GAClB,kBAAkB,CACrB,GACA,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CA6B1B"}

package/dist/remote.js

@@ -0,0 +1,35 @@
+export async function dispatchRemoteRoutes(req, handlers) {
+    const url = new URL(req.url);
+    const { pathname } = url;
+    const method = req.method;
+    if (pathname === '/api/remote' && method === 'GET')
+        return handlers.getRemote();
+    if (pathname === '/api/remote/pair/requests' && method === 'GET')
+        return handlers.getRemotePairRequests();
+    const pairActionMatch = pathname.match(/^\/api\/remote\/pair\/requests\/([^/]+)\/(approve|reject)$/);
+    if (pairActionMatch && method === 'POST') {
+        return pairActionMatch[2] === 'approve'
+            ? handlers.approveRemotePairRequest(pairActionMatch[1], req)
+            : handlers.rejectRemotePairRequest(pairActionMatch[1], req);
+    }
+    if (pathname === '/api/remote/peers' && method === 'GET')
+        return handlers.getRemotePeers();
+    const peerTokenActionMatch = pathname.match(/^\/api\/remote\/peers\/([^/]+)\/token\/(rotate|revoke)$/);
+    if (peerTokenActionMatch && method === 'POST') {
+        return peerTokenActionMatch[2] === 'rotate'
+            ? handlers.rotateRemotePeerToken(peerTokenActionMatch[1], req)
+            : handlers.revokeRemotePeerToken(peerTokenActionMatch[1], req);
+    }
+    const peerDisconnectMatch = pathname.match(/^\/api\/remote\/peers\/([^/]+)\/disconnect$/);
+    if (peerDisconnectMatch && method === 'POST')
+        return handlers.disconnectRemotePeer(peerDisconnectMatch[1], req);
+    const peerInvokeMatch = pathname.match(/^\/api\/remote\/peers\/([^/]+)\/invoke$/);
+    if (peerInvokeMatch && method === 'POST')
+        return handlers.invokeRemotePeer(peerInvokeMatch[1], req);
+    if (pathname === '/api/remote/work' && method === 'GET')
+        return handlers.getRemoteWork();
+    const workCancelMatch = pathname.match(/^\/api\/remote\/work\/([^/]+)\/cancel$/);
+    if (workCancelMatch && method === 'POST')
+        return handlers.cancelRemoteWork(workCancelMatch[1], req);
+    return null;
+}

package/dist/route-helpers.d.ts

@@ -0,0 +1,11 @@
+export type JsonRecord = Record<string, unknown>;
+export declare function isJsonRecord(value: unknown): value is JsonRecord;
+export declare function toSerializableJson(value: unknown, stack?: Map<object, string>, path?: string): unknown;
+export declare function serializableJsonResponse(body: unknown, init?: ResponseInit): Response;
+export declare function scopeMatches(granted: string, required: string): boolean;
+export declare function missingScopes(grantedScopes: readonly string[] | undefined, requiredScopes: readonly string[]): string[];
+export type ChannelLifecycleAction = 'inspect' | 'setup' | 'retest' | 'connect' | 'disconnect' | 'start' | 'stop' | 'login' | 'logout' | 'wait_login';
+export type ChannelConversationKind = 'direct' | 'group' | 'channel' | 'thread' | 'service';
+export declare function readChannelLifecycleAction(value: unknown): ChannelLifecycleAction | null;
+export declare function readChannelConversationKind(value: unknown): ChannelConversationKind | null;
+//# sourceMappingURL=route-helpers.d.ts.map

package/dist/route-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-helpers.d.ts","sourceRoot":"","sources":["../src/route-helpers.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,sBAA4B,EAAE,IAAI,SAAM,GAAG,OAAO,CAiBzG;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,QAAQ,CAErF;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAMvE;AAED,wBAAgB,aAAa,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EAAE,cAAc,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAGvH;AAED,MAAM,MAAM,sBAAsB,GAC9B,SAAS,GACT,OAAO,GACP,QAAQ,GACR,SAAS,GACT,YAAY,GACZ,OAAO,GACP,MAAM,GACN,OAAO,GACP,QAAQ,GACR,YAAY,CAAC;AAEjB,MAAM,MAAM,uBAAuB,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE5F,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,GAAG,IAAI,CAaxF;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAI1F"}

package/dist/route-helpers.js

@@ -0,0 +1,54 @@
+export function isJsonRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function toSerializableJson(value, stack = new Map(), path = '$') {
+    if (!value || typeof value !== 'object')
+        return value;
+    const prior = stack.get(value);
+    if (prior) {
+        return { $ref: prior };
+    }
+    const next = new Map(stack);
+    next.set(value, path);
+    if (Array.isArray(value)) {
+        return value.map((entry, index) => toSerializableJson(entry, next, `${path}[${index}]`));
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+        key,
+        toSerializableJson(entry, next, `${path}.${key}`),
+    ]));
+}
+export function serializableJsonResponse(body, init) {
+    return Response.json(toSerializableJson(body), init);
+}
+export function scopeMatches(granted, required) {
+    if (granted === '*' || granted === required)
+        return true;
+    if (granted.endsWith(':*')) {
+        return required.startsWith(granted.slice(0, -1));
+    }
+    return false;
+}
+export function missingScopes(grantedScopes, requiredScopes) {
+    const granted = grantedScopes ?? [];
+    return requiredScopes.filter((required) => !granted.some((entry) => scopeMatches(entry, required)));
+}
+export function readChannelLifecycleAction(value) {
+    return value === 'inspect'
+        || value === 'setup'
+        || value === 'retest'
+        || value === 'connect'
+        || value === 'disconnect'
+        || value === 'start'
+        || value === 'stop'
+        || value === 'login'
+        || value === 'logout'
+        || value === 'wait_login'
+        ? value
+        : null;
+}
+export function readChannelConversationKind(value) {
+    return value === 'direct' || value === 'group' || value === 'channel' || value === 'thread' || value === 'service'
+        ? value
+        : null;
+}

package/dist/runtime-automation-routes.d.ts

@@ -0,0 +1,4 @@
+import type { DaemonApiRouteHandlers } from './context.js';
+import type { DaemonRuntimeRouteContext } from './runtime-route-types.js';
+export declare function createDaemonRuntimeAutomationRouteHandlers(context: DaemonRuntimeRouteContext): Pick<DaemonApiRouteHandlers, 'getAutomationJobs' | 'postAutomationJob' | 'getAutomationRuns' | 'getAutomationRun' | 'getAutomationHeartbeat' | 'postAutomationHeartbeat' | 'automationRunAction' | 'patchAutomationJob' | 'deleteAutomationJob' | 'setAutomationJobEnabled' | 'runAutomationJobNow' | 'getSchedules' | 'postSchedule' | 'deleteSchedule' | 'setScheduleEnabled' | 'runScheduleNow'>;
+//# sourceMappingURL=runtime-automation-routes.d.ts.map

package/dist/runtime-automation-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-automation-routes.d.ts","sourceRoot":"","sources":["../src/runtime-automation-routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAG1E,wBAAgB,0CAA0C,CACxD,OAAO,EAAE,yBAAyB,GACjC,IAAI,CACL,sBAAsB,EACpB,mBAAmB,GACnB,mBAAmB,GACnB,mBAAmB,GACnB,kBAAkB,GAClB,wBAAwB,GACxB,yBAAyB,GACzB,qBAAqB,GACrB,oBAAoB,GACpB,qBAAqB,GACrB,yBAAyB,GACzB,qBAAqB,GACrB,cAAc,GACd,cAAc,GACd,gBAAgB,GAChB,oBAAoB,GACpB,gBAAgB,CACnB,CAmBA"}

package/dist/runtime-automation-routes.js

@@ -0,0 +1,165 @@
+import { jsonErrorResponse } from './error-response.js';
+export function createDaemonRuntimeAutomationRouteHandlers(context) {
+    return {
+        getAutomationJobs: () => Response.json({ jobs: context.automationManager.listJobs() }),
+        postAutomationJob: async (request) => handlePostSchedule(context, request),
+        getAutomationRuns: () => Response.json({ runs: context.automationManager.listRuns() }),
+        getAutomationRun: (runId) => handleGetAutomationRun(context, runId),
+        getAutomationHeartbeat: () => Response.json({ pending: [] }),
+        postAutomationHeartbeat: async (request) => handlePostAutomationHeartbeat(context, request),
+        automationRunAction: async (runId, action, request) => handleAutomationRunAction(context, runId, action, request),
+        patchAutomationJob: async (jobId, request) => handlePatchSchedule(context, jobId, request),
+        deleteAutomationJob: async (jobId) => handleDeleteSchedule(context, jobId),
+        setAutomationJobEnabled: async (jobId, enabled) => handleSetScheduleEnabled(context, jobId, enabled),
+        runAutomationJobNow: async (jobId) => handleRunScheduleNow(context, jobId),
+        getSchedules: () => handleGetSchedules(context),
+        postSchedule: (request) => handlePostSchedule(context, request),
+        deleteSchedule: async (scheduleId) => handleDeleteSchedule(context, scheduleId),
+        setScheduleEnabled: (scheduleId, enabled) => handleSetScheduleEnabled(context, scheduleId, enabled),
+        runScheduleNow: (scheduleId) => handleRunScheduleNow(context, scheduleId),
+    };
+}
+function handleGetSchedules(context) {
+    const jobs = context.automationManager.listJobs();
+    const runs = context.automationManager.listRuns().slice(0, 50);
+    return Response.json({ jobs, runs });
+}
+async function handlePostSchedule(context, req) {
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const prompt = typeof body.prompt === 'string' ? body.prompt.trim() : undefined;
+    const kind = typeof body.kind === 'string' ? body.kind : 'cron';
+    const cron = typeof body.cron === 'string' ? body.cron : undefined;
+    const every = typeof body.every === 'string' ? body.every : undefined;
+    const at = typeof body.at === 'string' || typeof body.at === 'number' ? body.at : undefined;
+    const timezone = typeof body.timezone === 'string' ? body.timezone : undefined;
+    if (!prompt) {
+        return Response.json({ error: 'Missing required field: prompt (string)' }, { status: 400 });
+    }
+    if (prompt.length > 10_000) {
+        return Response.json({ error: 'prompt exceeds maximum length of 10000 characters' }, { status: 400 });
+    }
+    try {
+        const fallbackModelsSource = body.fallbackModels ?? body.fallbacks;
+        const fallbackModels = Array.isArray(fallbackModelsSource)
+            ? fallbackModelsSource.filter((value) => typeof value === 'string')
+            : undefined;
+        const schedule = kind === 'every'
+            ? context.normalizeEverySchedule(every ?? '')
+            : kind === 'at'
+                ? context.normalizeAtSchedule(typeof at === 'number' ? at : Date.parse(String(at)))
+                : context.normalizeCronSchedule(cron ?? '', timezone, body.staggerMs ?? body.stagger);
+        const job = await context.automationManager.createJob({
+            name: typeof body.name === 'string' ? body.name : prompt.slice(0, 40),
+            prompt,
+            schedule,
+            description: prompt,
+            model: typeof body.model === 'string' ? body.model : undefined,
+            provider: typeof body.provider === 'string' ? body.provider : undefined,
+            fallbackModels,
+            template: typeof body.template === 'string' ? body.template : undefined,
+            target: typeof body.target === 'object' && body.target !== null ? body.target : undefined,
+            reasoningEffort: body.reasoningEffort,
+            thinking: typeof body.thinking === 'string' ? body.thinking : undefined,
+            wakeMode: body.wakeMode,
+            timeoutMs: typeof body.timeoutMs === 'number' ? body.timeoutMs : undefined,
+            toolAllowlist: Array.isArray(body.toolAllowlist) ? body.toolAllowlist.filter((value) => typeof value === 'string') : undefined,
+            autoApprove: typeof body.autoApprove === 'boolean' ? body.autoApprove : undefined,
+            allowUnsafeExternalContent: typeof body.allowUnsafeExternalContent === 'boolean' ? body.allowUnsafeExternalContent : undefined,
+            externalContentSource: body.externalContentSource,
+            lightContext: typeof body.lightContext === 'boolean' ? body.lightContext : undefined,
+            delivery: typeof body.delivery === 'object' && body.delivery !== null ? body.delivery : undefined,
+            failure: typeof body.failure === 'object' && body.failure !== null ? body.failure : undefined,
+            enabled: body.enabled !== false,
+            deleteAfterRun: typeof body.deleteAfterRun === 'boolean' ? body.deleteAfterRun : undefined,
+        });
+        return Response.json(job, { status: 201 });
+    }
+    catch (e) {
+        return jsonErrorResponse(e, { status: 400, fallbackMessage: 'Failed to create schedule' });
+    }
+}
+async function handlePatchSchedule(context, id, req) {
+    const job = findAutomationJob(context, id);
+    if (!job)
+        return Response.json({ error: `Schedule not found: ${id}` }, { status: 404 });
+    const body = await context.parseJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    try {
+        const updated = await context.automationManager.updateJob(job.id, body);
+        return updated
+            ? Response.json(updated)
+            : Response.json({ error: `Schedule not found: ${id}` }, { status: 404 });
+    }
+    catch (error) {
+        return jsonErrorResponse(error, { status: 400, fallbackMessage: 'Failed to update schedule' });
+    }
+}
+async function handleDeleteSchedule(context, id) {
+    const job = findAutomationJob(context, id);
+    if (!job)
+        return Response.json({ error: `Schedule not found: ${id}` }, { status: 404 });
+    await context.automationManager.removeJob(job.id);
+    return Response.json({ removed: true, id: job.id });
+}
+async function handleSetScheduleEnabled(context, id, enabled) {
+    const job = findAutomationJob(context, id);
+    if (!job)
+        return Response.json({ error: `Schedule not found: ${id}` }, { status: 404 });
+    const updated = await context.automationManager.setEnabled(job.id, enabled);
+    return Response.json(updated ?? { id: job.id, enabled });
+}
+async function handleRunScheduleNow(context, id) {
+    const job = findAutomationJob(context, id);
+    if (!job)
+        return Response.json({ error: `Schedule not found: ${id}` }, { status: 404 });
+    try {
+        const run = await context.automationManager.runNow(job.id);
+        return Response.json({ jobId: job.id, runId: run.id, agentId: run.agentId, status: run.status });
+    }
+    catch (e) {
+        return jsonErrorResponse(e, { status: 500, fallbackMessage: 'Failed to run schedule' });
+    }
+}
+async function handlePostAutomationHeartbeat(context, req) {
+    const body = await context.parseOptionalJsonBody(req);
+    if (body instanceof Response)
+        return body;
+    const result = await context.automationManager.triggerHeartbeat({
+        source: body && typeof body.source === 'string' ? body.source : 'api',
+    });
+    return Response.json(result);
+}
+async function handleAutomationRunAction(context, runId, action, req) {
+    if (action === 'cancel') {
+        const body = await context.parseOptionalJsonBody(req);
+        const reason = body instanceof Response
+            ? 'operator-cancelled'
+            : body && typeof body.reason === 'string'
+                ? body.reason
+                : 'operator-cancelled';
+        const run = await context.automationManager.cancelRun(runId, reason);
+        return run
+            ? context.recordApiResponse(req, `/api/automation/runs/${runId}/${action}`, Response.json({ run }))
+            : context.recordApiResponse(req, `/api/automation/runs/${runId}/${action}`, Response.json({ error: 'Unknown automation run' }, { status: 404 }));
+    }
+    try {
+        const run = await context.automationManager.retryRun(runId);
+        return context.recordApiResponse(req, `/api/automation/runs/${runId}/${action}`, Response.json({ run }, { status: 202 }));
+    }
+    catch (error) {
+        return context.recordApiResponse(req, `/api/automation/runs/${runId}/${action}`, jsonErrorResponse(error, { status: 400, fallbackMessage: 'Failed to retry automation run' }));
+    }
+}
+function handleGetAutomationRun(context, runId) {
+    const run = context.automationManager.getRun(runId);
+    if (!run) {
+        return Response.json({ error: 'Unknown automation run' }, { status: 404 });
+    }
+    return Response.json({ run, deliveries: [] });
+}
+function findAutomationJob(context, id) {
+    return context.automationManager.listJobs().find((entry) => entry.id === id || entry.id.startsWith(id));
+}