@pasko70/pibo 1.1.0 → 1.2.0

package/dist/apps/chat/project-workflow-sessions.js

@@ -0,0 +1,260 @@
+import { randomUUID } from "node:crypto";
+import { isPiboThinkingLevel } from "../../core/thinking.js";
+import { PiboWebHttpError } from "../../web/http.js";
+import { hashWorkflowDefinitionJson, sanitizeWorkflowDiagnostics, } from "./workflow-persistence.js";
+import { workflowVersionPickerOptionFromCatalogRecord, } from "./workflow-catalog.js";
+const PROJECT_WORKFLOW_SESSION_CREATE_FIELDS = new Set([
+    "profile",
+    "workflowId",
+    "workflowVersion",
+    "title",
+    "inputValues",
+    "promptOverrides",
+    "model",
+    "thinkingLevel",
+    "fastMode",
+]);
+const PROJECT_WORKFLOW_SESSION_DISALLOWED_FIELDS = new Map([
+    ["agentProfileOverrides", "Agent profile overrides are not supported for V2 workflow sessions"],
+    ["profileOverrides", "Agent profile overrides are not supported for V2 workflow sessions"],
+    ["profileOverride", "Agent profile overrides are not supported for V2 workflow sessions"],
+    ["nodeProfileOverrides", "Agent profile overrides are not supported for V2 workflow sessions"],
+    ["retryLimit", "Retry limit overrides are not supported for V2 workflow sessions"],
+    ["retryLimits", "Retry limit overrides are not supported for V2 workflow sessions"],
+    ["maxRetries", "Retry limit overrides are not supported for V2 workflow sessions"],
+    ["retryCount", "Retry limit overrides are not supported for V2 workflow sessions"],
+    ["handlerOverrides", "Handler overrides are not supported for V2 workflow sessions"],
+    ["handlerOverride", "Handler overrides are not supported for V2 workflow sessions"],
+    ["adapterOverrides", "Adapter overrides are not supported for V2 workflow sessions"],
+    ["adapterOverride", "Adapter overrides are not supported for V2 workflow sessions"],
+    ["guardOverrides", "Guard overrides are not supported for V2 workflow sessions"],
+    ["guardOverride", "Guard overrides are not supported for V2 workflow sessions"],
+    ["nodeOverrides", "Arbitrary node overrides are not supported for V2 workflow sessions"],
+    ["overrides", "Arbitrary overrides are not supported for V2 workflow sessions"],
+    ["options", "Arbitrary options are not supported for V2 workflow sessions"],
+    ["arbitraryOptions", "Arbitrary options are not supported for V2 workflow sessions"],
+]);
+export function normalizeProjectWorkflowSessionConfiguration(body, definition) {
+    assertProjectWorkflowSessionCreateFields(body);
+    const inputValues = normalizeProjectWorkflowInputValues(body.inputValues);
+    const promptOverrideEligibleNodeIds = workflowPromptOverrideEligibleNodeIds(definition);
+    const promptOverrides = normalizeProjectWorkflowPromptOverrides(body.promptOverrides, promptOverrideEligibleNodeIds);
+    const model = normalizeWorkflowSessionModel(body.model);
+    const thinkingLevel = normalizeThinkingLevel(body.thinkingLevel, "thinkingLevel");
+    const fastMode = normalizeOptionalBoolean(body.fastMode, "fastMode");
+    return {
+        inputValues,
+        promptOverrides,
+        promptOverrideEligibleNodeIds,
+        overrideScopes: {
+            promptOverrides: "eligible_agent_node",
+            model: "workflow",
+            thinkingLevel: "workflow",
+            fastMode: "workflow",
+        },
+        ...(model ? { model } : {}),
+        ...(thinkingLevel ? { thinkingLevel } : {}),
+        ...(fastMode !== undefined ? { fastMode } : {}),
+    };
+}
+export function createProjectWorkflowSessionSnapshot(input) {
+    const baseDefinition = cloneJsonObject(input.baseDefinition);
+    const effectiveDefinition = applyProjectWorkflowPromptOverrides(baseDefinition, input.configuration.promptOverrides);
+    const baseDefinitionHash = hashWorkflowDefinitionJson(baseDefinition);
+    const effectiveDefinitionHash = hashWorkflowDefinitionJson(effectiveDefinition);
+    const now = new Date().toISOString();
+    return {
+        id: `wfs_${randomUUID()}`,
+        schemaVersion: 1,
+        createdAt: now,
+        createdBy: input.webSession.authSession.identity.userId,
+        projectId: input.project.id,
+        piboSessionId: input.session.id,
+        workflow: {
+            id: input.workflow.id,
+            version: input.workflow.version,
+            source: input.workflow.source,
+            title: input.workflow.title,
+            ...(input.workflow.description ? { description: input.workflow.description } : {}),
+            tags: [...input.workflow.tags],
+            baseDefinitionHash,
+            effectiveDefinitionHash,
+        },
+        baseDefinition,
+        effectiveDefinition,
+        inputValues: cloneJsonObject(input.configuration.inputValues),
+        promptOverrides: { ...input.configuration.promptOverrides },
+        overridePolicy: {
+            promptEligibility: "metadata.sessionOverrides.prompt===true-and-direct-promptTemplate",
+            eligiblePromptNodeIds: [...input.configuration.promptOverrideEligibleNodeIds],
+            modelScope: input.configuration.overrideScopes.model,
+            thinkingLevelScope: input.configuration.overrideScopes.thinkingLevel,
+            fastModeScope: input.configuration.overrideScopes.fastMode,
+        },
+        ...(input.configuration.model ? { model: input.configuration.model } : {}),
+        ...(input.configuration.thinkingLevel ? { thinkingLevel: input.configuration.thinkingLevel } : {}),
+        ...(input.configuration.fastMode !== undefined ? { fastMode: input.configuration.fastMode } : {}),
+        promptAssetPins: [],
+        validation: workflowValidationSnapshot(input.validation),
+        deletedDefinitionFallback: {
+            title: input.workflow.title,
+            workflowId: input.workflow.id,
+            workflowVersion: input.workflow.version,
+            effectiveDefinitionHash,
+        },
+    };
+}
+export function workflowVersionFromSnapshot(snapshot) {
+    return workflowVersionPickerOptionFromCatalogRecord({
+        id: snapshot.workflow.id,
+        version: snapshot.workflow.version,
+        title: snapshot.workflow.title ?? snapshot.workflow.id,
+        ...(snapshot.workflow.description ? { description: snapshot.workflow.description } : {}),
+        source: snapshot.workflow.source,
+        status: "published",
+        tags: [...snapshot.workflow.tags],
+    });
+}
+export function createProjectWorkflowRunCurrent(definition) {
+    const initialNodeIds = workflowInitialNodeIds(definition);
+    return {
+        status: "running",
+        initialNodeIds,
+        ...(initialNodeIds.length === 1 ? { nodeId: initialNodeIds[0] } : {}),
+    };
+}
+function assertProjectWorkflowSessionCreateFields(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        throw new PiboWebHttpError("Invalid JSON body", 400);
+    for (const key of Object.keys(body)) {
+        const disallowedMessage = PROJECT_WORKFLOW_SESSION_DISALLOWED_FIELDS.get(key);
+        if (disallowedMessage)
+            throw new PiboWebHttpError(disallowedMessage, 400);
+        if (!PROJECT_WORKFLOW_SESSION_CREATE_FIELDS.has(key)) {
+            throw new PiboWebHttpError(`Unsupported workflow session creation field: ${key}`, 400);
+        }
+    }
+}
+function normalizeProjectWorkflowInputValues(value) {
+    if (value === undefined || value === null)
+        return {};
+    if (!isJsonObject(value))
+        throw new PiboWebHttpError("inputValues must be a JSON object", 400);
+    return value;
+}
+function normalizeProjectWorkflowPromptOverrides(value, eligibleNodeIds) {
+    if (value === undefined || value === null)
+        return {};
+    if (!isJsonObject(value))
+        throw new PiboWebHttpError("promptOverrides must be a JSON object keyed by eligible node id", 400);
+    const eligible = new Set(eligibleNodeIds);
+    const promptOverrides = {};
+    for (const [nodeId, prompt] of Object.entries(value)) {
+        if (!nodeId.trim())
+            throw new PiboWebHttpError("promptOverrides cannot contain an empty node id", 400);
+        if (!eligible.has(nodeId)) {
+            throw new PiboWebHttpError(`Node '${nodeId}' is not eligible for prompt overrides in this workflow version`, 400);
+        }
+        if (typeof prompt !== "string") {
+            throw new PiboWebHttpError(`Prompt override for node '${nodeId}' must be a string`, 400);
+        }
+        promptOverrides[nodeId] = prompt;
+    }
+    return promptOverrides;
+}
+function normalizeWorkflowSessionModel(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new PiboWebHttpError("model must be an object", 400);
+    const keys = Object.keys(value);
+    const unsupportedKey = keys.find((key) => key !== "provider" && key !== "id");
+    if (unsupportedKey)
+        throw new PiboWebHttpError(`model contains unsupported field: ${unsupportedKey}`, 400);
+    return normalizeModelProfile(value, "model");
+}
+function normalizeOptionalBoolean(value, fieldName) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw new PiboWebHttpError(`${fieldName} must be a boolean`, 400);
+    return value;
+}
+function normalizeThinkingLevel(value, fieldName) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string" || !isPiboThinkingLevel(value)) {
+        throw new PiboWebHttpError(`${fieldName} must be one of off, minimal, low, medium, high, xhigh`, 400);
+    }
+    return value;
+}
+function normalizeModelProfile(value, fieldName) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new PiboWebHttpError(`${fieldName} must be an object`, 400);
+    }
+    const raw = value;
+    if (typeof raw.provider !== "string" || typeof raw.id !== "string") {
+        throw new PiboWebHttpError(`${fieldName} must include provider and id`, 400);
+    }
+    const provider = raw.provider.trim();
+    const id = raw.id.trim();
+    if (!provider || !id) {
+        throw new PiboWebHttpError(`${fieldName} must include provider and id`, 400);
+    }
+    return { provider, id };
+}
+function workflowPromptOverrideEligibleNodeIds(definition) {
+    const nodes = definition.nodes;
+    if (!isJsonObject(nodes))
+        return [];
+    return Object.entries(nodes)
+        .filter(([, node]) => isWorkflowPromptOverrideEligibleNode(node))
+        .map(([nodeId]) => nodeId)
+        .sort();
+}
+function isWorkflowPromptOverrideEligibleNode(value) {
+    if (!isJsonObject(value))
+        return false;
+    const metadata = isJsonObject(value.metadata) ? value.metadata : undefined;
+    const sessionOverrides = metadata && isJsonObject(metadata.sessionOverrides) ? metadata.sessionOverrides : undefined;
+    return value.kind === "agent"
+        && value.runtime === "pibo"
+        && typeof value.promptTemplate === "string"
+        && sessionOverrides?.prompt === true;
+}
+function applyProjectWorkflowPromptOverrides(definition, promptOverrides) {
+    const effectiveDefinition = cloneJsonObject(definition);
+    const nodes = isJsonObject(effectiveDefinition.nodes) ? effectiveDefinition.nodes : undefined;
+    if (!nodes)
+        return effectiveDefinition;
+    for (const [nodeId, promptTemplate] of Object.entries(promptOverrides)) {
+        const node = nodes[nodeId];
+        if (isJsonObject(node)) {
+            nodes[nodeId] = { ...node, promptTemplate };
+        }
+    }
+    return effectiveDefinition;
+}
+function workflowValidationSnapshot(validation) {
+    return {
+        ...validation.validation,
+        validatedAt: validation.validation.checkedAt,
+        diagnostics: sanitizeWorkflowDiagnostics(validation.diagnostics),
+    };
+}
+function workflowInitialNodeIds(definition) {
+    if (typeof definition.initial === "string" && definition.initial.trim())
+        return [definition.initial.trim()];
+    if (Array.isArray(definition.initial)) {
+        return definition.initial.filter((nodeId) => typeof nodeId === "string" && Boolean(nodeId.trim())).map((nodeId) => nodeId.trim());
+    }
+    return [];
+}
+function cloneJsonObject(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function isJsonObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/apps/chat/provider-auth-actions.js

@@ -0,0 +1,43 @@
+import { randomUUID } from "node:crypto";
+import { completeLogin, getLoginStatus, removeLogin, setApiKey, startLogin } from "../../auth/login-actions.js";
+import { PiboWebHttpError, responseJson } from "../../web/http.js";
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isProviderAuthAction(action) {
+    return action === "login.status" || action === "login.start" || action === "login.complete" || action === "login.apikey" || action === "logout";
+}
+export async function executeProviderAuthAction(action, params) {
+    const input = isJsonObject(params) ? params : {};
+    const provider = typeof input.provider === "string" ? input.provider : undefined;
+    if (action === "login.status")
+        return { providers: getLoginStatus(provider) };
+    if (!provider)
+        throw new PiboWebHttpError(`${action} requires params.provider`, 400);
+    if (action === "login.start")
+        return await startLogin(provider);
+    if (action === "login.complete") {
+        if (input.code !== undefined && typeof input.code !== "string")
+            throw new PiboWebHttpError("login.complete params.code must be a string when provided", 400);
+        if (typeof input.state !== "string" || input.state.length === 0)
+            throw new PiboWebHttpError("login.complete requires params.state", 400);
+        return await completeLogin(provider, input.code, input.state);
+    }
+    if (action === "login.apikey") {
+        if (typeof input.apiKey !== "string" || input.apiKey.length === 0)
+            throw new PiboWebHttpError("login.apikey requires params.apiKey", 400);
+        return setApiKey(provider, input.apiKey);
+    }
+    if (action === "logout")
+        return removeLogin(provider);
+    throw new PiboWebHttpError(`Unsupported provider auth action ${action}`, 400);
+}
+export function providerAuthActionResponse(input) {
+    return responseJson({
+        type: "execution_result",
+        piboSessionId: input.piboSessionId ?? "",
+        eventId: randomUUID(),
+        action: input.action,
+        result: input.result,
+    });
+}

package/dist/apps/chat/ralph-api.js

@@ -0,0 +1,156 @@
+import { PiboWebHttpError, readJsonBody, responseJson } from '../../web/http.js';
+import { getPiboRalphService } from '../../ralph/channel.js';
+import { listRalphJobTemplates } from '../../ralph/templates.js';
+import { isPiboThinkingLevel } from '../../core/thinking.js';
+import { normalizeRalphStopPolicy } from '../../ralph/store.js';
+import { isPiboRoomArchived } from './types/rooms.js';
+const CHAT_WEB_API_PREFIX = '/api/chat';
+function requireSameOriginJsonRequest(request) { const contentType = request.headers.get('content-type')?.split(';')[0]?.trim().toLowerCase(); if (contentType !== 'application/json')
+    throw new PiboWebHttpError('Content-Type must be application/json', 415); const origin = request.headers.get('origin'); if (!origin)
+    throw new PiboWebHttpError('Origin header is required', 403); if (origin !== new URL(request.url).origin)
+    throw new PiboWebHttpError('Origin is not allowed', 403); }
+function accessDenied(error) { throw new PiboWebHttpError(error instanceof Error ? error.message : 'Access denied', 403); }
+function normalizeString(value, field, options = {}) { if (value === undefined || value === null) {
+    if (options.required)
+        throw new PiboWebHttpError(`${field} is required`, 400);
+    return undefined;
+} if (typeof value !== 'string')
+    throw new PiboWebHttpError(`${field} must be a string`, 400); const normalized = value.trim(); if (!normalized && options.required)
+    throw new PiboWebHttpError(`${field} is required`, 400); if (options.max && normalized.length > options.max)
+    throw new PiboWebHttpError(`${field} is too long`, 400); return normalized || undefined; }
+function normalizeEnabled(value) { if (value === undefined)
+    return undefined; if (typeof value !== 'boolean')
+    throw new PiboWebHttpError('enabled must be a boolean', 400); return value; }
+function normalizeMaxIterations(value) { if (value === undefined || value === null || value === '')
+    return undefined; if (typeof value !== 'number' || !Number.isInteger(value) || value < 1)
+    throw new PiboWebHttpError('maxIterations must be a positive integer', 400); return value; }
+function normalizeStopPolicy(value) { if (value === undefined || value === null)
+    return undefined; try {
+    return normalizeRalphStopPolicy(value);
+}
+catch (error) {
+    throw new PiboWebHttpError(error instanceof Error ? error.message : 'Invalid stopPolicy', 400);
+} }
+function normalizeModelOverride(value) { if (value === undefined || value === null)
+    return undefined; if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new PiboWebHttpError('modelOverride must be an object', 400); const raw = value; if (typeof raw.provider !== 'string' || typeof raw.id !== 'string')
+    throw new PiboWebHttpError('modelOverride must include provider and id', 400); const provider = raw.provider.trim(); const id = raw.id.trim(); if (!provider || !id)
+    throw new PiboWebHttpError('modelOverride must include provider and id', 400); return { provider, id }; }
+function normalizeThinkingLevel(value) { if (value === undefined || value === null || value === '')
+    return undefined; if (typeof value !== 'string' || !isPiboThinkingLevel(value))
+    throw new PiboWebHttpError('thinkingLevel must be one of off, minimal, low, medium, high, xhigh', 400); return value; }
+function normalizeFastMode(value) { if (value === undefined || value === null)
+    return undefined; if (typeof value !== 'boolean')
+    throw new PiboWebHttpError('fastMode must be a boolean', 400); return value; }
+function normalizeTarget(value, options) { if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new PiboWebHttpError('target is required', 400); const raw = value; if (raw.kind === 'room') {
+    const roomId = normalizeString(raw.roomId, 'target.roomId', { required: true });
+    let room;
+    try {
+        room = options.roomService.requireRoom(roomId);
+    }
+    catch (error) {
+        accessDenied(error);
+    }
+    if (isPiboRoomArchived(room))
+        throw new PiboWebHttpError('Archived rooms are read-only', 403);
+    return { kind: 'room', roomId };
+} if (raw.kind === 'default-chat') {
+    options.roomService.ensureDefaultRoom({ name: 'Shared Chat' });
+    return { kind: 'default-chat' };
+} throw new PiboWebHttpError('target.kind must be room or default-chat', 400); }
+function resolveProfile(context, fallback, value) { const requested = normalizeString(value, 'profile') ?? fallback; const profile = context.channelContext.getProfiles?.().find((item) => item.name === requested || item.aliases.includes(requested)); if (!profile)
+    throw new PiboWebHttpError(`Unknown profile: ${requested}`, 400); return profile.name; }
+function jobResource(pathname) { const prefix = `${CHAT_WEB_API_PREFIX}/ralph/jobs/`; if (!pathname.startsWith(prefix))
+    return undefined; const parts = pathname.slice(prefix.length).split('/').filter(Boolean).map((part) => decodeURIComponent(part)); if (!parts[0] || parts.length > 2)
+    return undefined; if (parts[1] && !['start', 'stop', 'cancel'].includes(parts[1]))
+    return undefined; return { id: parts[0], child: parts[1] }; }
+function createPatch(body, options) { const patch = {}; const name = normalizeString(body.name, 'name', { max: 120 }); if (body.name !== undefined && name !== undefined)
+    patch.name = name; if (body.description !== undefined)
+    patch.description = normalizeString(body.description, 'description', { max: 500 }); const enabled = normalizeEnabled(body.enabled); if (enabled !== undefined)
+    patch.enabled = enabled; if (body.target !== undefined)
+    patch.target = normalizeTarget(body.target, options); if (body.profile !== undefined)
+    patch.profile = resolveProfile(options.context, options.defaultProfile, body.profile); if (body.prompt !== undefined)
+    patch.prompt = normalizeString(body.prompt, 'prompt', { required: true, max: 20_000 }); if (body.maxIterations !== undefined)
+    patch.maxIterations = normalizeMaxIterations(body.maxIterations) ?? null; if (body.stopPolicy !== undefined)
+    patch.stopPolicy = normalizeStopPolicy(body.stopPolicy) ?? null; if (body.modelOverride !== undefined)
+    patch.modelOverride = normalizeModelOverride(body.modelOverride) ?? null; if (body.thinkingLevel !== undefined)
+    patch.thinkingLevel = normalizeThinkingLevel(body.thinkingLevel) ?? null; if (body.fastMode !== undefined)
+    patch.fastMode = normalizeFastMode(body.fastMode) ?? null; if (Object.keys(patch).length === 0)
+    throw new PiboWebHttpError('No Ralph job update fields provided', 400); return patch; }
+function serializeTarget(target) { return target.kind === 'room' ? target : { kind: 'default-chat' }; }
+function serializeJob(job) { const { target, ...rest } = job; return { ...rest, target: serializeTarget(target) }; }
+function serializeRun(run) { return run; }
+export async function handleChatRalphApiRequest(options) {
+    const { request, ralphStore } = options;
+    const url = new URL(request.url);
+    if (!url.pathname.startsWith(`${CHAT_WEB_API_PREFIX}/ralph`))
+        return undefined;
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/ralph/status` && request.method === 'GET')
+        return responseJson({ status: getPiboRalphService()?.status() ?? { enabled: false, ...ralphStore.status() } });
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/ralph/conditions` && request.method === 'GET')
+        return responseJson({ conditions: options.context.channelContext.getRalphStopConditionInfos?.() ?? options.context.channelContext.getCapabilityCatalog?.().ralphStopConditions ?? [] });
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/ralph/templates` && request.method === 'GET')
+        return responseJson({ templates: listRalphJobTemplates() });
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/ralph/jobs` && request.method === 'GET')
+        return responseJson({ jobs: ralphStore.listJobs({ includeDisabled: url.searchParams.get('includeDisabled') === 'true' }).map(serializeJob) });
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/ralph/jobs` && request.method === 'POST') {
+        requireSameOriginJsonRequest(request);
+        const body = await readJsonBody(request);
+        const job = ralphStore.createJob({ name: normalizeString(body.name, 'name', { max: 120 }), description: normalizeString(body.description, 'description', { max: 500 }), enabled: normalizeEnabled(body.enabled), target: normalizeTarget(body.target, options), profile: resolveProfile(options.context, options.defaultProfile, body.profile), prompt: normalizeString(body.prompt, 'prompt', { required: true, max: 20_000 }), maxIterations: normalizeMaxIterations(body.maxIterations), stopPolicy: normalizeStopPolicy(body.stopPolicy), modelOverride: normalizeModelOverride(body.modelOverride), thinkingLevel: normalizeThinkingLevel(body.thinkingLevel), fastMode: normalizeFastMode(body.fastMode) });
+        return responseJson({ job: serializeJob(job) }, { status: 201 });
+    }
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/ralph/runs` && request.method === 'GET') {
+        const jobId = url.searchParams.get('jobId') || undefined;
+        const limit = Number(url.searchParams.get('limit') ?? '100');
+        if (jobId && !ralphStore.getJob(jobId))
+            throw new PiboWebHttpError('Ralph job not found', 404);
+        return responseJson({ runs: ralphStore.listRuns({ jobId, limit: Number.isFinite(limit) ? limit : 100 }).map(serializeRun) });
+    }
+    const resource = jobResource(url.pathname);
+    if (!resource)
+        return undefined;
+    if (resource.child && request.method === 'POST') {
+        requireSameOriginJsonRequest(request);
+        const service = getPiboRalphService();
+        if (!service)
+            throw new PiboWebHttpError('Ralph service is not running', 503);
+        if (resource.child === 'start') {
+            const run = await service.startJob(resource.id);
+            if (!run)
+                throw new PiboWebHttpError('Ralph job not found, already running, or stopped by a before-run condition', 404);
+            return responseJson({ run: serializeRun(run) }, { status: 202 });
+        }
+        if (resource.child === 'stop') {
+            const job = service.stopJob(resource.id);
+            if (!job)
+                throw new PiboWebHttpError('Ralph job not found', 404);
+            return responseJson({ job: serializeJob(job) });
+        }
+        const job = await service.cancelJob(resource.id);
+        if (!job)
+            throw new PiboWebHttpError('Ralph job not found', 404);
+        return responseJson({ job: serializeJob(job) });
+    }
+    if (resource.child)
+        return undefined;
+    if (request.method === 'GET') {
+        const job = ralphStore.getJob(resource.id);
+        if (!job)
+            throw new PiboWebHttpError('Ralph job not found', 404);
+        return responseJson({ job: serializeJob(job) });
+    }
+    if (request.method === 'PATCH') {
+        requireSameOriginJsonRequest(request);
+        const body = await readJsonBody(request);
+        const job = ralphStore.updateJob(resource.id, createPatch(body, options));
+        if (!job)
+            throw new PiboWebHttpError('Ralph job not found', 404);
+        return responseJson({ job: serializeJob(job) });
+    }
+    if (request.method === 'DELETE') {
+        requireSameOriginJsonRequest(request);
+        return responseJson({ removed: ralphStore.removeJob(resource.id) });
+    }
+    return undefined;
+}