@pikku/mongodb 0.12.1

package/dist/src/mongodb-channel-store.js

@@ -0,0 +1,52 @@
+import { ChannelStore } from '@pikku/core/channel';
+export class MongoDBChannelStore extends ChannelStore {
+    db;
+    initialized = false;
+    channels;
+    subscriptions;
+    constructor(db) {
+        super();
+        this.db = db;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.channels = this.db.collection('channels');
+        this.subscriptions = this.db.collection('channel_subscriptions');
+        await this.subscriptions.createIndex({ channelId: 1, topic: 1 }, { unique: true });
+        await this.subscriptions.createIndex({ topic: 1 });
+        this.initialized = true;
+    }
+    async addChannel({ channelId, channelName, openingData, }) {
+        await this.channels.insertOne({
+            _id: channelId,
+            channelName,
+            openingData: openingData || {},
+            userSession: null,
+            createdAt: new Date(),
+            lastWire: new Date(),
+        });
+    }
+    async removeChannels(channelIds) {
+        if (channelIds.length === 0)
+            return;
+        await this.channels.deleteMany({ _id: { $in: channelIds } });
+        await this.subscriptions.deleteMany({ channelId: { $in: channelIds } });
+    }
+    async setUserSession(channelId, session) {
+        await this.channels.updateOne({ _id: channelId }, { $set: { userSession: session } });
+    }
+    async getChannelAndSession(channelId) {
+        const row = await this.channels.findOne({ _id: channelId });
+        if (!row) {
+            throw new Error(`Channel not found: ${channelId}`);
+        }
+        return {
+            channelId: row._id,
+            channelName: row.channelName,
+            openingData: row.openingData ?? {},
+            session: (row.userSession ?? {}),
+        };
+    }
+    async close() { }
+}

package/dist/src/mongodb-deployment-service.d.ts

@@ -0,0 +1,17 @@
+import type { DeploymentService, DeploymentServiceConfig, DeploymentConfig, DeploymentInfo } from '@pikku/core/services';
+import type { Db } from 'mongodb';
+export declare class MongoDBDeploymentService implements DeploymentService {
+    private db;
+    private initialized;
+    private heartbeatTimer?;
+    private deploymentConfig?;
+    private heartbeatInterval;
+    private heartbeatTtl;
+    private deployments;
+    constructor(config: DeploymentServiceConfig, db: Db);
+    init(): Promise<void>;
+    start(config: DeploymentConfig): Promise<void>;
+    stop(): Promise<void>;
+    findFunction(name: string): Promise<DeploymentInfo[]>;
+    private sendHeartbeat;
+}

package/dist/src/mongodb-deployment-service.js

@@ -0,0 +1,75 @@
+import { getAllFunctionNames } from '@pikku/core/function';
+export class MongoDBDeploymentService {
+    db;
+    initialized = false;
+    heartbeatTimer;
+    deploymentConfig;
+    heartbeatInterval;
+    heartbeatTtl;
+    deployments;
+    constructor(config, db) {
+        this.db = db;
+        this.heartbeatInterval = config.heartbeatInterval ?? 10000;
+        this.heartbeatTtl = config.heartbeatTtl ?? 30000;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.deployments = this.db.collection('pikku_deployments');
+        await this.deployments.createIndex({ lastHeartbeat: 1 });
+        await this.deployments.createIndex({ functions: 1 });
+        this.initialized = true;
+    }
+    async start(config) {
+        const functions = config.functions ?? getAllFunctionNames();
+        this.deploymentConfig = { ...config, functions };
+        const now = new Date();
+        await this.deployments.updateOne({ _id: config.deploymentId }, {
+            $set: {
+                endpoint: config.endpoint,
+                lastHeartbeat: now,
+                functions,
+            },
+            $setOnInsert: {
+                _id: config.deploymentId,
+                createdAt: now,
+            },
+        }, { upsert: true });
+        this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), this.heartbeatInterval);
+    }
+    async stop() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = undefined;
+        }
+        if (this.deploymentConfig) {
+            await this.deployments.deleteOne({
+                _id: this.deploymentConfig.deploymentId,
+            });
+        }
+    }
+    async findFunction(name) {
+        const cutoff = new Date(Date.now() - this.heartbeatTtl);
+        const result = await this.deployments
+            .find({
+            functions: name,
+            lastHeartbeat: { $gt: cutoff },
+        })
+            .sort({ lastHeartbeat: -1 })
+            .toArray();
+        return result.map((row) => ({
+            deploymentId: row._id,
+            endpoint: row.endpoint,
+        }));
+    }
+    async sendHeartbeat() {
+        if (!this.deploymentConfig)
+            return;
+        try {
+            await this.deployments.updateOne({ _id: this.deploymentConfig.deploymentId }, { $set: { lastHeartbeat: new Date() } });
+        }
+        catch {
+            // Heartbeat failed, will retry on next interval
+        }
+    }
+}

package/dist/src/mongodb-eventhub-store.d.ts

@@ -0,0 +1,13 @@
+import { EventHubStore } from '@pikku/core/channel';
+import type { Db } from 'mongodb';
+export declare class MongoDBEventHubStore extends EventHubStore {
+    private db;
+    private initialized;
+    private subscriptions;
+    constructor(db: Db);
+    init(): Promise<void>;
+    getChannelIdsForTopic(topic: string): Promise<string[]>;
+    subscribe(topic: string, channelId: string): Promise<boolean>;
+    unsubscribe(topic: string, channelId: string): Promise<boolean>;
+    close(): Promise<void>;
+}

package/dist/src/mongodb-eventhub-store.js

@@ -0,0 +1,37 @@
+import { EventHubStore } from '@pikku/core/channel';
+export class MongoDBEventHubStore extends EventHubStore {
+    db;
+    initialized = false;
+    subscriptions;
+    constructor(db) {
+        super();
+        this.db = db;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.subscriptions = this.db.collection('channel_subscriptions');
+        this.initialized = true;
+    }
+    async getChannelIdsForTopic(topic) {
+        const result = await this.subscriptions
+            .find({ topic })
+            .project({ channelId: 1 })
+            .toArray();
+        return result.map((row) => row.channelId);
+    }
+    async subscribe(topic, channelId) {
+        try {
+            await this.subscriptions.updateOne({ channelId, topic }, { $setOnInsert: { channelId, topic } }, { upsert: true });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async unsubscribe(topic, channelId) {
+        const result = await this.subscriptions.deleteOne({ channelId, topic });
+        return result.deletedCount > 0;
+    }
+    async close() { }
+}

package/dist/src/mongodb-secret-service.d.ts

@@ -0,0 +1,30 @@
+import type { SecretService } from '@pikku/core/services';
+import type { Db } from 'mongodb';
+export interface MongoDBSecretServiceConfig {
+    key: string;
+    keyVersion?: number;
+    previousKey?: string;
+    audit?: boolean;
+    auditReads?: boolean;
+}
+export declare class MongoDBSecretService implements SecretService {
+    private db;
+    private initialized;
+    private key;
+    private keyVersion;
+    private previousKey?;
+    private audit;
+    private auditReads;
+    private secrets;
+    private secretsAudit;
+    constructor(db: Db, config: MongoDBSecretServiceConfig);
+    init(): Promise<void>;
+    private logAudit;
+    private getKEK;
+    getSecret(key: string): Promise<string>;
+    getSecretJSON<R = {}>(key: string): Promise<R>;
+    hasSecret(key: string): Promise<boolean>;
+    setSecretJSON(key: string, value: unknown): Promise<void>;
+    deleteSecret(key: string): Promise<void>;
+    rotateKEK(): Promise<number>;
+}

package/dist/src/mongodb-secret-service.js

@@ -0,0 +1,110 @@
+import { envelopeEncrypt, envelopeDecrypt, envelopeRewrap, } from '@pikku/core/crypto-utils';
+export class MongoDBSecretService {
+    db;
+    initialized = false;
+    key;
+    keyVersion;
+    previousKey;
+    audit;
+    auditReads;
+    secrets;
+    secretsAudit;
+    constructor(db, config) {
+        this.db = db;
+        this.key = config.key;
+        this.keyVersion = config.keyVersion ?? 1;
+        this.previousKey = config.previousKey;
+        this.audit = config.audit ?? false;
+        this.auditReads = config.auditReads ?? false;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.secrets = this.db.collection('secrets');
+        this.secretsAudit = this.db.collection('secrets_audit');
+        await this.secrets.createIndex({ _id: 1 });
+        if (this.audit) {
+            await this.secretsAudit.createIndex({ secretKey: 1 });
+        }
+        this.initialized = true;
+    }
+    async logAudit(secretKey, action) {
+        if (!this.audit)
+            return;
+        if (action === 'read' && !this.auditReads)
+            return;
+        await this.secretsAudit.insertOne({
+            _id: crypto.randomUUID(),
+            secretKey,
+            action,
+            performedAt: new Date(),
+        });
+    }
+    getKEK(version) {
+        if (version === this.keyVersion)
+            return this.key;
+        if (this.previousKey)
+            return this.previousKey;
+        throw new Error(`No KEK available for key_version ${version}`);
+    }
+    async getSecret(key) {
+        const row = await this.secrets.findOne({ _id: key });
+        if (!row)
+            throw new Error(`Secret not found: ${key}`);
+        const kek = this.getKEK(row.keyVersion);
+        const result = await envelopeDecrypt(kek, row.ciphertext, row.wrappedDek);
+        await this.logAudit(key, 'read');
+        return result;
+    }
+    async getSecretJSON(key) {
+        const raw = await this.getSecret(key);
+        return JSON.parse(raw);
+    }
+    async hasSecret(key) {
+        const count = await this.secrets.countDocuments({ _id: key }, { limit: 1 });
+        return count > 0;
+    }
+    async setSecretJSON(key, value) {
+        const plaintext = JSON.stringify(value);
+        const { ciphertext, wrappedDEK } = await envelopeEncrypt(this.key, plaintext);
+        const now = new Date();
+        await this.secrets.updateOne({ _id: key }, {
+            $set: {
+                ciphertext,
+                wrappedDek: wrappedDEK,
+                keyVersion: this.keyVersion,
+                updatedAt: now,
+            },
+            $setOnInsert: {
+                _id: key,
+                createdAt: now,
+            },
+        }, { upsert: true });
+        await this.logAudit(key, 'write');
+    }
+    async deleteSecret(key) {
+        await this.secrets.deleteOne({ _id: key });
+        await this.logAudit(key, 'delete');
+    }
+    async rotateKEK() {
+        if (!this.previousKey) {
+            throw new Error('No previousKey configured — nothing to rotate from');
+        }
+        const rows = await this.secrets
+            .find({ keyVersion: { $lt: this.keyVersion } })
+            .project({ _id: 1, wrappedDek: 1 })
+            .toArray();
+        for (const row of rows) {
+            const newWrappedDEK = await envelopeRewrap(this.previousKey, this.key, row.wrappedDek);
+            await this.secrets.updateOne({ _id: row._id }, {
+                $set: {
+                    wrappedDek: newWrappedDEK,
+                    keyVersion: this.keyVersion,
+                    updatedAt: new Date(),
+                },
+            });
+            await this.logAudit(row._id, 'rotate');
+        }
+        return rows.length;
+    }
+}

package/dist/src/mongodb-workflow-run-service.d.ts

@@ -0,0 +1,36 @@
+import type { WorkflowRun, StepState, WorkflowRunService } from '@pikku/core/workflow';
+import type { Db } from 'mongodb';
+export declare class MongoDBWorkflowRunService implements WorkflowRunService {
+    private runs;
+    private steps;
+    private stepHistory;
+    private versions;
+    constructor(db: Db);
+    listRuns(options?: {
+        workflowName?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<WorkflowRun[]>;
+    getRun(id: string): Promise<WorkflowRun | null>;
+    getRunSteps(runId: string): Promise<Array<StepState & {
+        stepName: string;
+        rpcName?: string;
+        data?: any;
+    }>>;
+    getRunHistory(runId: string): Promise<Array<StepState & {
+        stepName: string;
+    }>>;
+    getDistinctWorkflowNames(): Promise<string[]>;
+    getWorkflowVersion(name: string, graphHash: string): Promise<{
+        graph: any;
+        source: string;
+    } | null>;
+    getAIGeneratedWorkflows(agentName?: string): Promise<Array<{
+        workflowName: string;
+        graphHash: string;
+        graph: any;
+    }>>;
+    deleteRun(id: string): Promise<boolean>;
+    private mapRunRow;
+}

package/dist/src/mongodb-workflow-run-service.js

@@ -0,0 +1,146 @@
+export class MongoDBWorkflowRunService {
+    runs;
+    steps;
+    stepHistory;
+    versions;
+    constructor(db) {
+        this.runs = db.collection('workflow_runs');
+        this.steps = db.collection('workflow_step');
+        this.stepHistory = db.collection('workflow_step_history');
+        this.versions = db.collection('workflow_versions');
+    }
+    async listRuns(options) {
+        const { workflowName, status, limit = 50, offset = 0 } = options ?? {};
+        const filter = {};
+        if (workflowName)
+            filter.workflow = workflowName;
+        if (status)
+            filter.status = status;
+        const result = await this.runs
+            .find(filter)
+            .sort({ createdAt: -1 })
+            .skip(offset)
+            .limit(limit)
+            .toArray();
+        return result.map((row) => this.mapRunRow(row));
+    }
+    async getRun(id) {
+        const row = await this.runs.findOne({ _id: id });
+        if (!row)
+            return null;
+        return this.mapRunRow(row);
+    }
+    async getRunSteps(runId) {
+        const result = await this.steps
+            .find({ workflowRunId: runId })
+            .sort({ createdAt: 1 })
+            .toArray();
+        const stepIds = result.map((r) => r._id);
+        const historyCounts = await this.stepHistory
+            .aggregate([
+            { $match: { workflowStepId: { $in: stepIds } } },
+            { $group: { _id: '$workflowStepId', count: { $sum: 1 } } },
+        ])
+            .toArray();
+        const countMap = new Map(historyCounts.map((h) => [h._id, h.count]));
+        return result.map((row) => ({
+            stepId: row._id,
+            stepName: row.stepName,
+            rpcName: row.rpcName ?? undefined,
+            data: row.data ?? undefined,
+            status: row.status,
+            result: row.result ?? undefined,
+            error: row.error ?? undefined,
+            attemptCount: countMap.get(row._id) ?? 1,
+            retries: row.retries != null ? Number(row.retries) : undefined,
+            retryDelay: row.retryDelay ?? undefined,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        }));
+    }
+    async getRunHistory(runId) {
+        const steps = await this.steps.find({ workflowRunId: runId }).toArray();
+        const stepMap = new Map(steps.map((s) => [s._id, s]));
+        const stepIds = steps.map((s) => s._id);
+        const history = await this.stepHistory
+            .find({ workflowStepId: { $in: stepIds } })
+            .sort({ createdAt: 1 })
+            .toArray();
+        let attemptCounters = {};
+        return history.map((row) => {
+            const stepId = row.workflowStepId;
+            const step = stepMap.get(stepId);
+            attemptCounters[stepId] = (attemptCounters[stepId] ?? 0) + 1;
+            return {
+                stepId,
+                stepName: step.stepName,
+                status: row.status,
+                result: row.result ?? undefined,
+                error: row.error ?? undefined,
+                attemptCount: attemptCounters[stepId],
+                retries: step.retries != null ? Number(step.retries) : undefined,
+                retryDelay: step.retryDelay ?? undefined,
+                createdAt: new Date(row.createdAt),
+                updatedAt: new Date(row.createdAt),
+                runningAt: row.runningAt ? new Date(row.runningAt) : undefined,
+                scheduledAt: row.scheduledAt ? new Date(row.scheduledAt) : undefined,
+                succeededAt: row.succeededAt ? new Date(row.succeededAt) : undefined,
+                failedAt: row.failedAt ? new Date(row.failedAt) : undefined,
+            };
+        });
+    }
+    async getDistinctWorkflowNames() {
+        const result = await this.runs.distinct('workflow');
+        return result.sort();
+    }
+    async getWorkflowVersion(name, graphHash) {
+        const row = await this.versions.findOne({
+            workflowName: name,
+            graphHash,
+        });
+        if (!row)
+            return null;
+        return {
+            graph: row.graph,
+            source: row.source,
+        };
+    }
+    async getAIGeneratedWorkflows(agentName) {
+        const filter = { source: 'ai-agent', status: 'active' };
+        if (agentName) {
+            const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            filter.workflowName = { $regex: `^ai:${escaped}:` };
+        }
+        const rows = await this.versions.find(filter).toArray();
+        return rows.map((row) => ({
+            workflowName: row.workflowName,
+            graphHash: row.graphHash,
+            graph: row.graph,
+        }));
+    }
+    async deleteRun(id) {
+        const steps = await this.steps.find({ workflowRunId: id }).toArray();
+        const stepIds = steps.map((s) => s._id);
+        if (stepIds.length > 0) {
+            await this.stepHistory.deleteMany({ workflowStepId: { $in: stepIds } });
+            await this.steps.deleteMany({ workflowRunId: id });
+        }
+        const result = await this.runs.deleteOne({ _id: id });
+        return result.deletedCount > 0;
+    }
+    mapRunRow(row) {
+        return {
+            id: row._id,
+            workflow: row.workflow,
+            status: row.status,
+            input: row.input,
+            output: row.output ?? undefined,
+            error: row.error ?? undefined,
+            inline: row.inline,
+            graphHash: row.graphHash ?? undefined,
+            wire: row.wire ?? { type: 'unknown' },
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        };
+    }
+}

package/dist/src/mongodb-workflow-service.d.ts

@@ -0,0 +1,55 @@
+import type { SerializedError } from '@pikku/core';
+import { PikkuWorkflowService, type WorkflowRun, type WorkflowRunWire, type StepState, type WorkflowStatus, type WorkflowVersionStatus } from '@pikku/core/workflow';
+import type { Db } from 'mongodb';
+export declare class MongoDBWorkflowService extends PikkuWorkflowService {
+    private initialized;
+    private runService;
+    private runs;
+    private steps;
+    private stepHistory;
+    private versions;
+    constructor(db: Db);
+    init(): Promise<void>;
+    createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire): Promise<string>;
+    getRun(id: string): Promise<WorkflowRun | null>;
+    updateRunStatus(id: string, status: WorkflowStatus, output?: any, error?: SerializedError): Promise<void>;
+    insertStepState(runId: string, stepName: string, rpcName: string | null, data: any, stepOptions?: {
+        retries?: number;
+        retryDelay?: string | number;
+    }): Promise<StepState>;
+    getStepState(runId: string, stepName: string): Promise<StepState>;
+    getRunHistory(runId: string): Promise<Array<StepState & {
+        stepName: string;
+    }>>;
+    setStepRunning(stepId: string): Promise<void>;
+    setStepScheduled(stepId: string): Promise<void>;
+    private insertHistoryRecord;
+    private getTimestampFieldForStatus;
+    setStepResult(stepId: string, result: any): Promise<void>;
+    setStepError(stepId: string, error: Error): Promise<void>;
+    createRetryAttempt(stepId: string, status: 'pending' | 'running'): Promise<StepState>;
+    withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>;
+    withStepLock<T>(_runId: string, _stepName: string, fn: () => Promise<T>): Promise<T>;
+    getCompletedGraphState(runId: string): Promise<{
+        completedNodeIds: string[];
+        failedNodeIds: string[];
+        branchKeys: Record<string, string>;
+    }>;
+    getNodesWithoutSteps(runId: string, nodeIds: string[]): Promise<string[]>;
+    getNodeResults(runId: string, nodeIds: string[]): Promise<Record<string, any>>;
+    setBranchTaken(stepId: string, branchKey: string): Promise<void>;
+    updateRunState(runId: string, name: string, value: unknown): Promise<void>;
+    getRunState(runId: string): Promise<Record<string, unknown>>;
+    upsertWorkflowVersion(name: string, graphHash: string, graph: any, source: string, status?: WorkflowVersionStatus): Promise<void>;
+    updateWorkflowVersionStatus(name: string, graphHash: string, status: WorkflowVersionStatus): Promise<void>;
+    getWorkflowVersion(name: string, graphHash: string): Promise<{
+        graph: any;
+        source: string;
+    } | null>;
+    getAIGeneratedWorkflows(agentName?: string): Promise<Array<{
+        workflowName: string;
+        graphHash: string;
+        graph: any;
+    }>>;
+    close(): Promise<void>;
+}