@pikku/core 0.12.13 → 0.12.15

package/dist/wirings/workflow/pikku-workflow-service.d.ts

@@ -1,5 +1,5 @@
 import type { SerializedError } from '../../types/core.types.js';
-import type { PikkuWorkflowWire, StepState, WorkflowRun, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
+import type { PikkuWorkflowWire, StepState, WorkflowRun, WorkflowRunStatus, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
 import type { WorkflowService } from '../../services/workflow-service.js';
 import { PikkuError } from '../../errors/error-handler.js';
 /**
@@ -69,6 +69,11 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * @returns Workflow run or null if not found
      */
     abstract getRun(id: string): Promise<WorkflowRun | null>;
+    /**
+     * Get minimal workflow run status with step summaries.
+     * Used by the public API — the console addon provides the full verbose view.
+     */
+    getRunStatus(id: string): Promise<WorkflowRunStatus | null>;
     /**
      * Get workflow run history (all step attempts in chronological order)
      * @param runId - Run ID
@@ -219,7 +224,7 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * Resume a paused workflow by triggering the orchestrator
      * @param runId - Run ID
      */
-    resumeWorkflow(runId: string): Promise<void>;
+    resumeWorkflow(runId: string, workflowName?: string): Promise<void>;
     queueStepWorker(runId: string, stepName: string, rpcName: string, data: any): Promise<void>;
     /**
      * Execute a workflow sleep step completion
@@ -232,7 +237,7 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * @param runId - Run ID
      * @param retryDelay - Delay in milliseconds or duration string (optional)
      */
-    protected scheduleOrchestratorRetry(runId: string, retryDelay?: number | string): Promise<void>;
+    protected scheduleOrchestratorRetry(runId: string, retryDelay?: number | string, workflowName?: string): Promise<void>;
     /**
      * Start a new workflow run
      * Automatically detects workflow type (DSL or graph) from meta and executes accordingly
@@ -269,7 +274,14 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
     private sleepStep;
     private getSuspendStepName;
     private suspendStep;
-    createWorkflowWire(name: string, runId: string, rpcService: any): PikkuWorkflowWire;
+    createWorkflowWire(name: string, runId: string, rpcService: any, addonNamespace?: string | null): PikkuWorkflowWire;
     private verifyStepName;
     private getConfig;
+    /**
+     * Get the orchestrator queue name for a specific workflow.
+     * Checks queue meta for a per-workflow queue first (e.g. wf-orchestrator-{name}),
+     * falls back to the shared orchestrator queue.
+     */
+    protected getOrchestratorQueueName(workflowName?: string): string;
+    protected getStepWorkerQueueName(rpcName?: string): string;
 }

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -1,6 +1,33 @@
-import { runPikkuFunc } from '../../function/function-runner.js';
+import { runPikkuFunc, addFunction } from '../../function/function-runner.js';
+import { pikkuWorkflowWorkerFunc, pikkuWorkflowOrchestratorFunc, pikkuWorkflowSleeperFunc, } from './workflow-queue-workers.js';
+import { wireQueueWorker } from '../queue/queue-runner.js';
 import { getSingletonServices, getCreateWireServices, pikkuState, } from '../../pikku-state.js';
 import { getDurationInMilliseconds } from '../../time-utils.js';
+const resolveWorkflowMeta = (name) => {
+    const rootMeta = pikkuState(null, 'workflows', 'meta');
+    if (rootMeta[name]) {
+        return { meta: rootMeta[name], packageName: null, resolvedName: name };
+    }
+    const colonIndex = name.indexOf(':');
+    if (colonIndex !== -1) {
+        const namespace = name.substring(0, colonIndex);
+        const localName = name.substring(colonIndex + 1);
+        const addons = pikkuState(null, 'addons', 'packages');
+        const pkgConfig = addons?.get(namespace);
+        if (pkgConfig) {
+            const addonMeta = pikkuState(pkgConfig.package, 'workflows', 'meta');
+            if (addonMeta?.[localName]) {
+                return {
+                    meta: addonMeta[localName],
+                    packageName: pkgConfig.package,
+                    resolvedName: localName,
+                };
+            }
+        }
+    }
+    return null;
+};
+const toKebab = (s) => s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
 import { continueGraph, executeGraphStep, runWorkflowGraph, runFromMeta, } from './graph/graph-runner.js';
 import { PikkuError, addError } from '../../errors/error-handler.js';
 import { RPCNotFoundError } from '../rpc/rpc-runner.js';
@@ -88,7 +115,62 @@ export class PikkuWorkflowService {
     get logger() {
         return getSingletonServices()?.logger;
     }
-    constructor() { }
+    constructor() {
+        const functions = pikkuState(null, 'function', 'functions');
+        const functionsMeta = pikkuState(null, 'function', 'meta');
+        // Minimal meta for internal workflow functions (satisfies FunctionMeta)
+        const mkMeta = (funcId) => ({
+            pikkuFuncId: funcId,
+            sessionless: true,
+            functionType: 'helper',
+            inputSchemaName: null,
+            outputSchemaName: null,
+        });
+        const queueMeta = pikkuState(null, 'queue', 'meta');
+        const registerWorkflowFunc = (funcId, func, queueName) => {
+            if (functions.has(funcId))
+                return;
+            addFunction(funcId, func);
+            if (!queueMeta[queueName]) {
+                queueMeta[queueName] = { pikkuFuncId: funcId, name: queueName };
+            }
+            wireQueueWorker({ name: queueName, func });
+            if (!functionsMeta[funcId]) {
+                functionsMeta[funcId] = mkMeta(funcId);
+            }
+        };
+        // Register shared queue workers for monolith deployments
+        registerWorkflowFunc('pikkuWorkflowOrchestrator', { func: pikkuWorkflowOrchestratorFunc }, 'pikku-workflow-orchestrator');
+        registerWorkflowFunc('pikkuWorkflowStepWorker', { func: pikkuWorkflowWorkerFunc }, 'pikku-workflow-step-worker');
+        // Register per-workflow queue workers (root + addon packages)
+        const registerQueueWorkers = (queueMeta) => {
+            for (const [queueName, meta] of Object.entries(queueMeta)) {
+                if (functions.has(meta.pikkuFuncId))
+                    continue;
+                if (queueName.startsWith('wf-orchestrator-')) {
+                    registerWorkflowFunc(meta.pikkuFuncId, { func: pikkuWorkflowOrchestratorFunc }, queueName);
+                }
+                else if (queueName.startsWith('wf-step-')) {
+                    registerWorkflowFunc(meta.pikkuFuncId, { func: pikkuWorkflowWorkerFunc }, queueName);
+                }
+            }
+        };
+        registerQueueWorkers(pikkuState(null, 'queue', 'meta'));
+        const addons = pikkuState(null, 'addons', 'packages');
+        if (addons) {
+            for (const [, addon] of addons) {
+                const addonQueueMeta = pikkuState(addon.package, 'queue', 'meta');
+                if (addonQueueMeta) {
+                    registerQueueWorkers(addonQueueMeta);
+                }
+            }
+        }
+        if (!functions.has('pikkuWorkflowSleeper')) {
+            addFunction('pikkuWorkflowSleeper', {
+                func: pikkuWorkflowSleeperFunc,
+            });
+        }
+    }
     /**
      * Check if a run is executing inline (without queues)
      */
@@ -115,6 +197,47 @@ export class PikkuWorkflowService {
             await this.upsertWorkflowVersion(name, meta.graphHash, meta, meta.source);
         }
     }
+    /**
+     * Get minimal workflow run status with step summaries.
+     * Used by the public API — the console addon provides the full verbose view.
+     */
+    async getRunStatus(id) {
+        const run = await this.getRun(id);
+        if (!run)
+            return null;
+        const history = await this.getRunHistory(id);
+        const terminalStatuses = new Set(['completed', 'failed', 'cancelled']);
+        // Build step summaries from history (latest attempt per step)
+        const stepMap = new Map();
+        for (const step of history) {
+            const existing = stepMap.get(step.stepName);
+            if (!existing || step.updatedAt > existing.completedAt) {
+                stepMap.set(step.stepName, {
+                    status: step.status,
+                    startedAt: step.runningAt ?? step.createdAt,
+                    completedAt: step.succeededAt ?? step.failedAt,
+                });
+            }
+        }
+        const steps = [...stepMap.entries()].map(([name, s]) => ({
+            name,
+            status: s.status,
+            duration: s.startedAt && s.completedAt
+                ? s.completedAt.getTime() - s.startedAt.getTime()
+                : undefined,
+        }));
+        return {
+            id: run.id,
+            status: run.status,
+            startedAt: run.createdAt,
+            completedAt: terminalStatuses.has(run.status) ? run.updatedAt : undefined,
+            steps,
+            output: run.status === 'completed' ? run.output : undefined,
+            error: run.error
+                ? { message: run.error.message ?? 'Unknown error' }
+                : undefined,
+        };
+    }
     // ============================================================================
     // Workflow Lifecycle Methods
     // ============================================================================
@@ -122,13 +245,19 @@ export class PikkuWorkflowService {
      * Resume a paused workflow by triggering the orchestrator
      * @param runId - Run ID
      */
-    async resumeWorkflow(runId) {
+    async resumeWorkflow(runId, workflowName) {
         const queueService = this.verifyQueueService();
-        await queueService.add(this.getConfig().orchestratorQueueName, { runId });
+        if (!workflowName) {
+            const run = await this.getRun(runId);
+            workflowName = run?.workflow;
+        }
+        await queueService.add(this.getOrchestratorQueueName(workflowName), {
+            runId,
+        });
     }
     async queueStepWorker(runId, stepName, rpcName, data) {
         const queueService = this.verifyQueueService();
-        await queueService.add(this.getConfig().stepWorkerQueueName, JSON.parse(JSON.stringify({
+        await queueService.add(this.getStepWorkerQueueName(rpcName), JSON.parse(JSON.stringify({
             runId,
             stepName,
             rpcName,
@@ -149,9 +278,13 @@ export class PikkuWorkflowService {
      * @param runId - Run ID
      * @param retryDelay - Delay in milliseconds or duration string (optional)
      */
-    async scheduleOrchestratorRetry(runId, retryDelay) {
+    async scheduleOrchestratorRetry(runId, retryDelay, workflowName) {
         const queueService = this.verifyQueueService();
-        await queueService.add(this.getConfig().orchestratorQueueName, { runId }, retryDelay ? { delay: getDurationInMilliseconds(retryDelay) } : undefined);
+        if (!workflowName) {
+            const run = await this.getRun(runId);
+            workflowName = run?.workflow;
+        }
+        await queueService.add(this.getOrchestratorQueueName(workflowName), { runId }, retryDelay ? { delay: getDurationInMilliseconds(retryDelay) } : undefined);
     }
     /**
      * Start a new workflow run
@@ -160,21 +293,30 @@ export class PikkuWorkflowService {
      * @param options.startNode - Starting node ID for graph workflows (from wire config)
      */
     async startWorkflow(name, input, wire, rpcService, options) {
-        // Check meta to determine workflow type
-        const meta = pikkuState(null, 'workflows', 'meta');
-        const workflowMeta = meta[name];
+        // Resolve workflow from static meta (root or addon namespace), then dynamic DB
+        const resolved = resolveWorkflowMeta(name);
+        let workflowMeta = resolved?.meta;
+        const packageName = resolved?.packageName ?? null;
+        if (!workflowMeta) {
+            const dynamicWorkflows = await this.getAIGeneratedWorkflows();
+            const match = dynamicWorkflows.find((w) => w.workflowName === name);
+            if (match?.graph) {
+                workflowMeta = match.graph;
+            }
+        }
         if (!workflowMeta) {
             throw new WorkflowNotFoundError(name);
         }
-        if (workflowMeta.source === 'graph' || workflowMeta.source === 'ai-agent') {
+        if (workflowMeta.source === 'graph' ||
+            workflowMeta.source === 'dynamic-workflow') {
             const shouldInline = options?.inline ||
                 workflowMeta.inline ||
                 !getSingletonServices()?.queueService;
-            return runWorkflowGraph(this, name, input, rpcService, shouldInline, options?.startNode, wire);
+            return runWorkflowGraph(this, name, input, rpcService, shouldInline, options?.startNode, wire, workflowMeta);
         }
         // DSL workflow - check registration exists
-        const registrations = pikkuState(null, 'workflows', 'registrations');
-        const workflow = registrations.get(name);
+        const registrations = pikkuState(packageName, 'workflows', 'registrations');
+        const workflow = registrations.get(resolved?.resolvedName ?? name);
         if (!workflow) {
             throw new WorkflowNotFoundError(name);
         }
@@ -231,15 +373,17 @@ export class PikkuWorkflowService {
         if (!run) {
             throw new WorkflowRunNotFoundError(runId);
         }
-        const meta = pikkuState(null, 'workflows', 'meta');
-        const workflowMeta = meta[run.workflow];
+        const resolved = resolveWorkflowMeta(run.workflow);
+        const workflowMeta = resolved?.meta;
+        const pkgName = resolved?.packageName ?? null;
         if (run.graphHash &&
             workflowMeta?.graphHash &&
             run.graphHash !== workflowMeta.graphHash) {
             await this.runVersionMismatchFallback(run, workflowMeta, rpcService);
             return;
         }
-        if (workflowMeta?.source === 'graph') {
+        if (workflowMeta?.source === 'graph' ||
+            workflowMeta?.source === 'dynamic-workflow') {
             await continueGraph(this, runId, run.workflow);
             const updatedRun = await this.getRun(runId);
             if (updatedRun?.status === 'completed') {
@@ -251,15 +395,36 @@ export class PikkuWorkflowService {
             }
             return;
         }
-        const registrations = pikkuState(null, 'workflows', 'registrations');
-        const workflow = registrations.get(run.workflow);
+        if (!workflowMeta) {
+            const dynamicWorkflows = await this.getAIGeneratedWorkflows();
+            const match = dynamicWorkflows.find((w) => w.workflowName === run.workflow);
+            if (match?.graph) {
+                await continueGraph(this, runId, run.workflow, match.graph);
+                const updatedRun = await this.getRun(runId);
+                if (updatedRun?.status === 'completed') {
+                    await this.onChildWorkflowCompleted(updatedRun, updatedRun.output);
+                }
+                else if (updatedRun?.status === 'failed' ||
+                    updatedRun?.status === 'cancelled') {
+                    await this.onChildWorkflowFailed(updatedRun, new Error(updatedRun.error?.message || 'Child workflow failed'));
+                }
+                return;
+            }
+        }
+        const registrations = pikkuState(pkgName, 'workflows', 'registrations');
+        const workflow = registrations.get(resolved?.resolvedName ?? run.workflow);
         if (!workflow) {
             throw new WorkflowNotFoundError(run.workflow);
         }
         await this.withRunLock(runId, async () => {
-            const workflowWire = this.createWorkflowWire(run.workflow, runId, rpcService);
+            const addonNs = run.workflow.includes(':')
+                ? run.workflow.substring(0, run.workflow.indexOf(':'))
+                : null;
+            const workflowWire = this.createWorkflowWire(run.workflow, runId, rpcService, addonNs);
+            workflowWire.pikkuUserId = run.wire?.pikkuUserId;
             const wire = {
                 workflow: workflowWire,
+                pikkuUserId: run.wire?.pikkuUserId,
                 session: rpcService.wire?.session,
                 rpc: rpcService.wire?.rpc,
             };
@@ -269,6 +434,7 @@ export class PikkuWorkflowService {
                     wire,
                     createWireServices: getCreateWireServices(),
                     data: () => run.input,
+                    packageName: pkgName ?? undefined,
                 });
                 await this.updateRunStatus(runId, 'completed', result);
                 await this.onChildWorkflowCompleted(run, result);
@@ -374,7 +540,7 @@ export class PikkuWorkflowService {
                 const meta = pikkuState(null, 'workflows', 'meta');
                 const workflowMeta = meta[run.workflow];
                 const isGraphWorkflow = workflowMeta?.source === 'graph' ||
-                    workflowMeta?.source === 'ai-agent';
+                    workflowMeta?.source === 'dynamic-workflow';
                 if (isGraphWorkflow &&
                     workflowMeta?.nodes &&
                     stepName in workflowMeta.nodes) {
@@ -512,7 +678,7 @@ export class PikkuWorkflowService {
             // Map step retry options to queue job options
             const retries = stepOptions?.retries ?? 0;
             const retryDelay = stepOptions?.retryDelay;
-            await getSingletonServices().queueService.add(this.getConfig().stepWorkerQueueName, JSON.parse(JSON.stringify({
+            await getSingletonServices().queueService.add(this.getStepWorkerQueueName(rpcName), JSON.parse(JSON.stringify({
                 runId,
                 stepName,
                 rpcName,
@@ -756,7 +922,7 @@ export class PikkuWorkflowService {
             throw new WorkflowSuspendedException(runId, reason);
         });
     }
-    createWorkflowWire(name, runId, rpcService) {
+    createWorkflowWire(name, runId, rpcService, addonNamespace) {
         const workflowWire = {
             name,
             runId,
@@ -765,7 +931,10 @@ export class PikkuWorkflowService {
             do: async (stepName, rpcNameOrFn, dataOrOptions, options) => {
                 this.verifyStepName(stepName);
                 if (typeof rpcNameOrFn === 'string') {
-                    return await this.rpcStep(runId, stepName, rpcNameOrFn, dataOrOptions, rpcService, options);
+                    const resolvedRpcName = addonNamespace && !rpcNameOrFn.includes(':')
+                        ? `${addonNamespace}:${rpcNameOrFn}`
+                        : rpcNameOrFn;
+                    return await this.rpcStep(runId, stepName, resolvedRpcName, dataOrOptions, rpcService, options);
                 }
                 else {
                     return await this.inlineStep(runId, stepName, rpcNameOrFn, dataOrOptions);
@@ -798,4 +967,29 @@ export class PikkuWorkflowService {
             sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowSleeper',
         };
     }
+    /**
+     * Get the orchestrator queue name for a specific workflow.
+     * Checks queue meta for a per-workflow queue first (e.g. wf-orchestrator-{name}),
+     * falls back to the shared orchestrator queue.
+     */
+    getOrchestratorQueueName(workflowName) {
+        if (workflowName) {
+            const perWorkflow = `wf-orchestrator-${toKebab(workflowName)}`;
+            const registrations = pikkuState(null, 'queue', 'registrations');
+            if (registrations.has(perWorkflow)) {
+                return perWorkflow;
+            }
+        }
+        return this.getConfig().orchestratorQueueName;
+    }
+    getStepWorkerQueueName(rpcName) {
+        if (rpcName) {
+            const perStep = `wf-step-${toKebab(rpcName)}`;
+            const registrations = pikkuState(null, 'queue', 'registrations');
+            if (registrations.has(perStep)) {
+                return perStep;
+            }
+        }
+        return this.getConfig().stepWorkerQueueName;
+    }
 }

package/dist/wirings/workflow/workflow-queue-workers.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Queue worker functions for workflow orchestration.
+ *
+ * These are registered as queue consumers by the codegen pipeline
+ * (injected into queue meta when workflows exist). They provide
+ * the runtime implementations that process queued workflow jobs.
+ */
+import type { PikkuRPC } from '../rpc/rpc-types.js';
+export interface WorkflowStepInput {
+    runId: string;
+    stepName: string;
+    rpcName: string;
+    data: unknown;
+}
+export interface PikkuWorkflowOrchestratorInput {
+    runId: string;
+}
+export interface PikkuWorkflowSleeperInput {
+    runId: string;
+    stepId: string;
+}
+/**
+ * Step worker — executes individual workflow steps dispatched via queue.
+ * The orchestrator queues steps here when they're async (not inline).
+ */
+export declare function pikkuWorkflowWorkerFunc(_services: Record<string, unknown>, { runId, stepName, rpcName, data }: WorkflowStepInput, { rpc }: {
+    rpc: PikkuRPC;
+}): Promise<void>;
+/**
+ * Orchestrator — resumes workflow execution after an async step completes.
+ * Called when a step worker finishes and the workflow needs to continue.
+ */
+export declare function pikkuWorkflowOrchestratorFunc(_services: Record<string, unknown>, { runId }: PikkuWorkflowOrchestratorInput, { rpc }: {
+    rpc: PikkuRPC;
+}): Promise<void>;
+/**
+ * Sleeper — wakes a workflow after a workflow.sleep() duration expires.
+ * Triggered by a delayed queue message or scheduler callback.
+ */
+export declare function pikkuWorkflowSleeperFunc(_services: Record<string, unknown>, { runId, stepId }: PikkuWorkflowSleeperInput): Promise<void>;

package/dist/wirings/workflow/workflow-queue-workers.js

@@ -0,0 +1,41 @@
+/**
+ * Queue worker functions for workflow orchestration.
+ *
+ * These are registered as queue consumers by the codegen pipeline
+ * (injected into queue meta when workflows exist). They provide
+ * the runtime implementations that process queued workflow jobs.
+ */
+import { getSingletonServices } from '../../pikku-state.js';
+/**
+ * Step worker — executes individual workflow steps dispatched via queue.
+ * The orchestrator queues steps here when they're async (not inline).
+ */
+export async function pikkuWorkflowWorkerFunc(_services, { runId, stepName, rpcName, data }, { rpc }) {
+    const services = getSingletonServices();
+    if (!services?.workflowService) {
+        throw new Error(`Workflow service not initialized: cannot execute workflow step for runId ${runId}, stepName ${stepName}`);
+    }
+    await services.workflowService.executeWorkflowStep(runId, stepName, rpcName, data, rpc);
+}
+/**
+ * Orchestrator — resumes workflow execution after an async step completes.
+ * Called when a step worker finishes and the workflow needs to continue.
+ */
+export async function pikkuWorkflowOrchestratorFunc(_services, { runId }, { rpc }) {
+    const services = getSingletonServices();
+    if (!services?.workflowService) {
+        throw new Error(`Workflow service not initialized: cannot orchestrate workflow for runId ${runId}`);
+    }
+    await services.workflowService.orchestrateWorkflow(runId, rpc);
+}
+/**
+ * Sleeper — wakes a workflow after a workflow.sleep() duration expires.
+ * Triggered by a delayed queue message or scheduler callback.
+ */
+export async function pikkuWorkflowSleeperFunc(_services, { runId, stepId }) {
+    const services = getSingletonServices();
+    if (!services?.workflowService) {
+        throw new Error(`Workflow service not initialized: cannot execute workflow sleep completed for runId ${runId}, stepId ${stepId}`);
+    }
+    await services.workflowService.executeWorkflowSleepCompleted(runId, stepId);
+}

package/dist/wirings/workflow/workflow.types.d.ts

@@ -8,6 +8,8 @@ export interface WorkflowRunWire {
     id?: string;
     parentRunId?: string;
     parentStepId?: string;
+    /** Pikku user ID propagated from the originating request for credential resolution */
+    pikkuUserId?: string;
 }
 export interface WorkflowServiceConfig {
     retries: number;
@@ -88,6 +90,21 @@ export interface StepState {
     /** Timestamp when step failed */
     failedAt?: Date;
 }
+export interface WorkflowRunStatus {
+    id: string;
+    status: WorkflowStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    steps: Array<{
+        name: string;
+        status: StepStatus;
+        duration?: number;
+    }>;
+    output?: unknown;
+    error?: {
+        message: string;
+    };
+}
 export interface WorkflowRunService {
     listRuns(options?: {
         workflowName?: string;
@@ -168,6 +185,7 @@ export type WorkflowsMeta = Record<string, CommonWireMeta & {
     context?: WorkflowContext;
     dsl?: boolean;
     inline?: boolean;
+    expose?: boolean;
 }>;
 /**
  * Unified workflow runtime meta (used by runtime to execute workflows)
@@ -180,7 +198,7 @@ export interface WorkflowRuntimeMeta {
     /** Pikku function name (for execution) */
     pikkuFuncId: string;
     /** Source type: 'dsl' (serializable), 'complex' (has inline steps), 'graph' */
-    source: 'dsl' | 'complex' | 'graph' | 'ai-agent';
+    source: 'dsl' | 'complex' | 'graph' | 'dynamic-workflow';
     /** Optional description */
     description?: string;
     /** Tags for organization */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.13",
+  "version": "0.12.15",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -25,6 +25,7 @@
     "./channel/local": "./dist/wirings/channel/local/index.js",
     "./channel/serverless": "./dist/wirings/channel/serverless/index.js",
     "./http": "./dist/wirings/http/index.js",
+    "./remote": "./dist/remote.js",
     "./queue": "./dist/wirings/queue/index.js",
     "./scheduler": "./dist/wirings/scheduler/index.js",
     "./trigger": "./dist/wirings/trigger/index.js",
@@ -41,6 +42,7 @@
     "./oauth2": "./dist/wirings/oauth2/index.js",
     "./errors": "./dist/errors/index.js",
     "./services": "./dist/services/index.js",
+    "./services/local-meta": "./dist/services/meta-service.js",
     "./services/local-content": "./dist/services/local-content.js",
     "./services/gopass-secrets": "./dist/services/gopass-secrets.js",
     "./crypto-utils": "./dist/crypto-utils.js",
@@ -52,6 +54,7 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "cookie": "^1.1.1",
+    "json-schema": "^0.4.0",
     "path-to-regexp": "^8.3.0",
     "picoquery": "^2.5.0"
   },

package/src/errors/errors.ts

@@ -15,6 +15,18 @@ addError(PikkuMissingMetaError, {
   message: 'Required metadata is missing',
 })
 
+export class MissingServiceError extends PikkuError {}
+addError(MissingServiceError, {
+  status: 500,
+  message: 'A required service is not configured',
+})
+
+export class LocalEnvironmentOnlyError extends PikkuError {}
+addError(LocalEnvironmentOnlyError, {
+  status: 403,
+  message: 'This operation is only available in local development mode',
+})
+
 /**
  * The server cannot or will not process the request due to client error (e.g., malformed request syntax).
  * @group Error
@@ -76,6 +88,38 @@ addError(ForbiddenError, {
     'The client does not have permission to access the requested resource.',
 })
 
+/**
+ * A required credential is missing. The payload contains metadata
+ * about the credential so the client can initiate a connect flow.
+ * @group Error
+ */
+export class MissingCredentialError extends PikkuError {
+  public payload: {
+    error: 'missing_credential'
+    credentialName: string
+    credentialType: 'oauth2' | 'apikey'
+    connectUrl?: string
+  }
+
+  constructor(
+    credentialName: string,
+    credentialType: 'oauth2' | 'apikey',
+    connectUrl?: string
+  ) {
+    super(`Missing credential: ${credentialName}`)
+    this.payload = {
+      error: 'missing_credential',
+      credentialName,
+      credentialType,
+      connectUrl,
+    }
+  }
+}
+addError(MissingCredentialError, {
+  status: 403,
+  message: 'A required credential is not configured.',
+})
+
 /**
  * The session is readonly and cannot access a non-readonly function.
  * @group Error