@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

package/apps/app-lifeops/src/lifeops/service-mixin-workflows.js

@@ -0,0 +1,411 @@
+import { LIFEOPS_WORKFLOW_STATUSES } from "@elizaos/shared/contracts/lifeops";
+import { computeNextCronRunAtMs } from "@elizaos/agent/triggers/scheduling";
+import { createLifeOpsWorkflowDefinition, createLifeOpsWorkflowRun, } from "./repository.js";
+import { fail, normalizeIsoString, normalizeOptionalBoolean, normalizeEnumValue, requireNonEmptyString, } from "./service-normalize.js";
+import { normalizeWorkflowTriggerType, normalizeWorkflowSchedule, normalizeWorkflowPermissionPolicy, } from "./service-normalize-connector.js";
+import { normalizeWorkflowActionPlan, } from "./service-normalize-task.js";
+import { isRecord, normalizeOptionalRecord, requireRecord, } from "./service-helpers-misc.js";
+import { summarizeWorkflowValue, parseWorkflowSchedulerState, } from "./service-helpers-browser.js";
+import { addMinutes } from "./time.js";
+import { LifeOpsServiceError } from "./service-types.js";
+/** @internal */
+export function withWorkflows(Base) {
+    class LifeOpsWorkflowsServiceMixin extends Base {
+        readWorkflowSchedulerState(workflow) {
+            return parseWorkflowSchedulerState(isRecord(workflow.metadata) ? workflow.metadata.lifeopsScheduler : null);
+        }
+        computeWorkflowNextDueAt(workflow, cursorIso) {
+            if (workflow.triggerType !== "schedule") {
+                return null;
+            }
+            const schedule = workflow.schedule;
+            if (schedule.kind === "manual") {
+                return null;
+            }
+            if (schedule.kind === "once") {
+                return cursorIso ? null : schedule.runAt;
+            }
+            if (schedule.kind === "interval") {
+                const baseIso = cursorIso ?? workflow.createdAt;
+                return addMinutes(new Date(baseIso), schedule.everyMinutes).toISOString();
+            }
+            const baseMs = cursorIso
+                ? Date.parse(cursorIso)
+                : Date.parse(workflow.createdAt) - 60_000;
+            const nextRunMs = computeNextCronRunAtMs(schedule.cronExpression, baseMs, schedule.timezone);
+            return nextRunMs === null ? null : new Date(nextRunMs).toISOString();
+        }
+        withWorkflowSchedulerState(workflow, state) {
+            const metadata = { ...workflow.metadata };
+            if (state) {
+                metadata.lifeopsScheduler = state;
+            }
+            else {
+                delete metadata.lifeopsScheduler;
+            }
+            return {
+                ...workflow,
+                metadata,
+                updatedAt: new Date().toISOString(),
+            };
+        }
+        initializeWorkflowSchedulerState(workflow) {
+            const nextDueAt = this.computeWorkflowNextDueAt(workflow);
+            const currentState = this.readWorkflowSchedulerState(workflow);
+            const targetState = workflow.triggerType !== "schedule" || workflow.schedule.kind === "manual"
+                ? null
+                : {
+                    managedBy: "task_worker",
+                    nextDueAt,
+                    lastDueAt: null,
+                    lastRunId: null,
+                    lastRunStatus: null,
+                    updatedAt: new Date().toISOString(),
+                };
+            if ((currentState === null && targetState === null) ||
+                (currentState &&
+                    targetState &&
+                    currentState.nextDueAt === targetState.nextDueAt &&
+                    currentState.lastDueAt === targetState.lastDueAt &&
+                    currentState.lastRunId === targetState.lastRunId &&
+                    currentState.lastRunStatus === targetState.lastRunStatus)) {
+                return workflow;
+            }
+            return this.withWorkflowSchedulerState(workflow, targetState);
+        }
+        async runDueWorkflows(args) {
+            const nowMs = Date.parse(args.now);
+            const workflows = await this.repository.listWorkflows(this.agentId());
+            const runs = [];
+            for (const workflow of workflows) {
+                if (runs.length >= args.limit) {
+                    break;
+                }
+                if (workflow.status !== "active" ||
+                    workflow.triggerType !== "schedule" ||
+                    workflow.schedule.kind === "manual") {
+                    continue;
+                }
+                let nextWorkflow = workflow;
+                const existingSchedulerState = this.readWorkflowSchedulerState(nextWorkflow);
+                let schedulerState = existingSchedulerState ??
+                    {
+                        managedBy: "task_worker",
+                        nextDueAt: this.computeWorkflowNextDueAt(nextWorkflow),
+                        lastDueAt: null,
+                        lastRunId: null,
+                        lastRunStatus: null,
+                        updatedAt: new Date().toISOString(),
+                    };
+                let stateChanged = existingSchedulerState === null;
+                while (runs.length < args.limit &&
+                    schedulerState.nextDueAt &&
+                    Date.parse(schedulerState.nextDueAt) <= nowMs) {
+                    const dueAt = schedulerState.nextDueAt;
+                    const { run, error } = await this.executeWorkflowDefinition(nextWorkflow, {
+                        startedAt: dueAt,
+                        confirmBrowserActions: false,
+                        request: {
+                            scheduledExecution: true,
+                        },
+                    });
+                    runs.push(run);
+                    await this.emitWorkflowRunNudge(nextWorkflow, run);
+                    schedulerState = {
+                        managedBy: "task_worker",
+                        nextDueAt: this.computeWorkflowNextDueAt(nextWorkflow, dueAt),
+                        lastDueAt: dueAt,
+                        lastRunId: run.id,
+                        lastRunStatus: run.status,
+                        updatedAt: new Date().toISOString(),
+                    };
+                    stateChanged = true;
+                    if (error) {
+                        this.logLifeOpsError("workflow_scheduled_execution", error, {
+                            workflowId: nextWorkflow.id,
+                            workflowRunId: run.id,
+                            dueAt,
+                        });
+                    }
+                }
+                if (stateChanged) {
+                    nextWorkflow = this.withWorkflowSchedulerState(nextWorkflow, schedulerState);
+                    await this.repository.updateWorkflow(nextWorkflow);
+                }
+            }
+            return runs;
+        }
+        async listWorkflows() {
+            const workflows = await this.repository.listWorkflows(this.agentId());
+            const records = [];
+            for (const definition of workflows) {
+                records.push({
+                    definition,
+                    runs: await this.repository.listWorkflowRuns(this.agentId(), definition.id),
+                });
+            }
+            return records;
+        }
+        async getWorkflow(workflowId) {
+            const definition = await this.getWorkflowDefinition(workflowId);
+            return {
+                definition,
+                runs: await this.repository.listWorkflowRuns(this.agentId(), workflowId),
+            };
+        }
+        async createWorkflow(request) {
+            const triggerType = normalizeWorkflowTriggerType(request.triggerType);
+            const ownership = this.normalizeOwnership(request.ownership);
+            let definition = createLifeOpsWorkflowDefinition({
+                agentId: this.agentId(),
+                ...ownership,
+                title: requireNonEmptyString(request.title, "title"),
+                triggerType,
+                schedule: normalizeWorkflowSchedule(request.schedule, triggerType),
+                actionPlan: normalizeWorkflowActionPlan(request.actionPlan),
+                permissionPolicy: normalizeWorkflowPermissionPolicy(request.permissionPolicy),
+                status: request.status === undefined
+                    ? "active"
+                    : normalizeEnumValue(request.status, "status", LIFEOPS_WORKFLOW_STATUSES),
+                createdBy: request.createdBy === undefined
+                    ? "user"
+                    : normalizeEnumValue(request.createdBy, "createdBy", [
+                        "agent",
+                        "user",
+                        "workflow",
+                        "connector",
+                    ]),
+                metadata: normalizeOptionalRecord(request.metadata, "metadata") ?? {},
+            });
+            definition = this.initializeWorkflowSchedulerState(definition);
+            await this.repository.createWorkflow(definition);
+            await this.recordWorkflowAudit("workflow_created", definition.id, "user", "workflow created", { request }, {
+                triggerType: definition.triggerType,
+                status: definition.status,
+            });
+            return {
+                definition,
+                runs: [],
+            };
+        }
+        async updateWorkflow(workflowId, request) {
+            const current = await this.getWorkflowDefinition(workflowId);
+            const ownership = this.normalizeOwnership(request.ownership, current);
+            const nextTriggerType = request.triggerType === undefined
+                ? current.triggerType
+                : normalizeWorkflowTriggerType(request.triggerType);
+            let nextDefinition = {
+                ...current,
+                ...ownership,
+                title: request.title === undefined
+                    ? current.title
+                    : requireNonEmptyString(request.title, "title"),
+                triggerType: nextTriggerType,
+                schedule: request.schedule === undefined
+                    ? current.schedule
+                    : normalizeWorkflowSchedule(request.schedule, nextTriggerType),
+                actionPlan: request.actionPlan === undefined
+                    ? current.actionPlan
+                    : normalizeWorkflowActionPlan(request.actionPlan),
+                permissionPolicy: normalizeWorkflowPermissionPolicy(request.permissionPolicy, current.permissionPolicy),
+                status: request.status === undefined
+                    ? current.status
+                    : normalizeEnumValue(request.status, "status", LIFEOPS_WORKFLOW_STATUSES),
+                metadata: request.metadata === undefined
+                    ? current.metadata
+                    : {
+                        ...current.metadata,
+                        ...requireRecord(request.metadata, "metadata"),
+                    },
+                updatedAt: new Date().toISOString(),
+            };
+            if (request.triggerType !== undefined ||
+                request.schedule !== undefined ||
+                this.readWorkflowSchedulerState(nextDefinition) === null) {
+                nextDefinition = this.initializeWorkflowSchedulerState(nextDefinition);
+            }
+            await this.repository.updateWorkflow(nextDefinition);
+            await this.recordWorkflowAudit("workflow_updated", nextDefinition.id, "user", "workflow updated", { request }, {
+                triggerType: nextDefinition.triggerType,
+                status: nextDefinition.status,
+            });
+            return this.getWorkflow(nextDefinition.id);
+        }
+        async executeWorkflowDefinition(definition, args) {
+            const internalUrl = new URL("http://127.0.0.1/");
+            const outputs = {};
+            const steps = [];
+            let status = "success";
+            try {
+                for (const [index, step] of definition.actionPlan.steps.entries()) {
+                    let value;
+                    if (step.kind === "create_task") {
+                        const created = await this.createDefinition({
+                            ...step.request,
+                            ownership: step.request.ownership ?? {
+                                domain: definition.domain,
+                                subjectType: definition.subjectType,
+                                subjectId: definition.subjectId,
+                                visibilityScope: definition.visibilityScope,
+                                contextPolicy: definition.contextPolicy,
+                            },
+                        });
+                        value = {
+                            definitionId: created.definition.id,
+                            title: created.definition.title,
+                            reminderPlanId: created.reminderPlan?.id ?? null,
+                        };
+                    }
+                    else if (step.kind === "relock_website_access") {
+                        value = await this.relockWebsiteAccessGroup(step.request.groupKey, new Date(args.startedAt));
+                    }
+                    else if (step.kind === "resolve_website_access_callback") {
+                        value = await this.resolveWebsiteAccessCallback(step.request.callbackKey, new Date(args.startedAt));
+                    }
+                    else if (step.kind === "get_calendar_feed") {
+                        value = await this.getCalendarFeed(internalUrl, step.request ?? {}, new Date(args.startedAt));
+                    }
+                    else if (step.kind === "get_gmail_triage") {
+                        value = await this.getGmailTriage(internalUrl, step.request ?? {}, new Date(args.startedAt));
+                    }
+                    else if (step.kind === "summarize") {
+                        const sourceValue = (step.sourceKey ? outputs[step.sourceKey] : steps.at(-1)?.value) ??
+                            null;
+                        value = {
+                            text: summarizeWorkflowValue(sourceValue, step.prompt),
+                        };
+                    }
+                    else {
+                        if (!definition.permissionPolicy.allowBrowserActions) {
+                            value = {
+                                blocked: true,
+                                reason: "browser_actions_disabled",
+                            };
+                        }
+                        else {
+                            const session = await this.createBrowserSessionInternal({
+                                workflowId: definition.id,
+                                title: step.sessionTitle,
+                                actions: step.actions,
+                                ownership: {
+                                    domain: definition.domain,
+                                    subjectType: definition.subjectType,
+                                    subjectId: definition.subjectId,
+                                    visibilityScope: definition.visibilityScope,
+                                    contextPolicy: definition.contextPolicy,
+                                },
+                            });
+                            if (session.awaitingConfirmationForActionId &&
+                                !definition.permissionPolicy.trustedBrowserActions &&
+                                !args.confirmBrowserActions) {
+                                value = {
+                                    sessionId: session.id,
+                                    status: session.status,
+                                    requiresConfirmation: true,
+                                };
+                            }
+                            else {
+                                const updated = {
+                                    ...session,
+                                    status: "queued",
+                                    awaitingConfirmationForActionId: null,
+                                    updatedAt: new Date().toISOString(),
+                                };
+                                await this.repository.updateBrowserSession(updated);
+                                await this.recordBrowserAudit("browser_session_updated", updated.id, "browser session started", {
+                                    workflowId: definition.id,
+                                }, {
+                                    status: updated.status,
+                                });
+                                value = {
+                                    sessionId: updated.id,
+                                    status: updated.status,
+                                    requiresConfirmation: false,
+                                };
+                            }
+                        }
+                    }
+                    const stepRecord = {
+                        index,
+                        kind: step.kind,
+                        resultKey: step.resultKey ?? null,
+                        value,
+                    };
+                    if (step.resultKey) {
+                        outputs[step.resultKey] = value;
+                    }
+                    steps.push(stepRecord);
+                }
+            }
+            catch (error) {
+                status = "failed";
+                steps.push({
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                const audit = await this.recordWorkflowAudit("workflow_run", definition.id, "workflow", "workflow run failed", {
+                    request: args.request,
+                }, {
+                    status,
+                    steps,
+                });
+                const run = createLifeOpsWorkflowRun({
+                    agentId: this.agentId(),
+                    workflowId: definition.id,
+                    startedAt: args.startedAt,
+                    finishedAt: new Date().toISOString(),
+                    status,
+                    result: { steps, outputs },
+                    auditRef: audit.id,
+                });
+                await this.repository.createWorkflowRun(run);
+                return {
+                    run,
+                    error,
+                };
+            }
+            const audit = await this.recordWorkflowAudit("workflow_run", definition.id, "workflow", "workflow run succeeded", {
+                request: args.request,
+            }, {
+                status,
+                steps,
+            });
+            const run = createLifeOpsWorkflowRun({
+                agentId: this.agentId(),
+                workflowId: definition.id,
+                startedAt: args.startedAt,
+                finishedAt: new Date().toISOString(),
+                status,
+                result: { steps, outputs },
+                auditRef: audit.id,
+            });
+            await this.repository.createWorkflowRun(run);
+            return {
+                run,
+                error: null,
+            };
+        }
+        async runWorkflow(workflowId, request = {}) {
+            const definition = await this.getWorkflowDefinition(workflowId);
+            if (definition.status !== "active") {
+                fail(409, `workflow cannot run from status ${definition.status}`);
+            }
+            const startedAt = request.now === undefined
+                ? new Date().toISOString()
+                : normalizeIsoString(request.now, "now");
+            const confirmBrowserActions = normalizeOptionalBoolean(request.confirmBrowserActions, "confirmBrowserActions") ?? false;
+            const result = await this.executeWorkflowDefinition(definition, {
+                startedAt,
+                confirmBrowserActions,
+                request: request,
+            });
+            if (result.error instanceof LifeOpsServiceError) {
+                throw result.error;
+            }
+            if (result.error) {
+                throw result.error;
+            }
+            return result.run;
+        }
+    }
+    return LifeOpsWorkflowsServiceMixin;
+}

package/apps/app-lifeops/src/lifeops/service-mixin-x-read.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=service-mixin-x-read.d.ts.map

package/apps/app-lifeops/src/lifeops/service-mixin-x-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-mixin-x-read.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service-mixin-x-read.ts"],"names":[],"mappings":""}

package/apps/app-lifeops/src/lifeops/service-mixin-x-read.js

@@ -0,0 +1,190 @@
+// @ts-nocheck — mixin: type safety is enforced on the composed class
+import crypto from "node:crypto";
+import { fail } from "./service-normalize.js";
+import { readXPosterCredentialsFromEnv } from "./x-poster.js";
+import { pullXFeed, readXDms, searchX, XReadError, } from "./x-reader.js";
+function toReaderCredentials() {
+    const posterCreds = readXPosterCredentialsFromEnv();
+    if (!posterCreds)
+        return null;
+    const userId = (process.env.TWITTER_USER_ID ?? "").trim();
+    return {
+        apiKey: posterCreds.apiKey,
+        apiSecret: posterCreds.apiSecretKey,
+        accessToken: posterCreds.accessToken,
+        accessTokenSecret: posterCreds.accessTokenSecret,
+        userId: userId.length > 0 ? userId : undefined,
+    };
+}
+function rawDmToLifeOpsXDm(args) {
+    return {
+        id: crypto.randomUUID(),
+        agentId: args.agentId,
+        externalDmId: args.raw.id,
+        conversationId: args.raw.conversationId,
+        senderHandle: args.raw.senderHandle,
+        senderId: args.raw.senderId,
+        isInbound: args.raw.isInbound,
+        text: args.raw.text,
+        receivedAt: args.raw.createdAt,
+        readAt: null,
+        repliedAt: null,
+        metadata: args.raw.metadata,
+        syncedAt: args.syncedAt,
+        updatedAt: args.syncedAt,
+    };
+}
+function rawFeedItemToLifeOpsXFeedItem(args) {
+    return {
+        id: crypto.randomUUID(),
+        agentId: args.agentId,
+        externalTweetId: args.raw.id,
+        authorHandle: args.raw.authorHandle,
+        authorId: args.raw.authorId,
+        text: args.raw.text,
+        createdAtSource: args.raw.createdAt,
+        feedType: args.feedType,
+        metadata: args.raw.metadata,
+        syncedAt: args.syncedAt,
+        updatedAt: args.syncedAt,
+    };
+}
+function translateXReadError(operation, error) {
+    if (error instanceof XReadError) {
+        const status = error.category === "auth"
+            ? 409
+            : error.category === "not_found"
+                ? 404
+                : error.category === "rate_limit"
+                    ? 429
+                    : error.status ?? 502;
+        const message = error.category === "rate_limit" && error.retryAfterSeconds
+            ? `${error.message} (retry after ${error.retryAfterSeconds}s)`
+            : error.message;
+        fail(status, `[${operation}] ${message}`);
+    }
+    throw error;
+}
+/** @internal */
+export function withXRead(Base) {
+    class LifeOpsXReadServiceMixin extends Base {
+        async syncXDms(opts = {}) {
+            // Ensures the X connector has been configured.
+            await this.requireXGrant();
+            const credentials = toReaderCredentials();
+            if (!credentials) {
+                fail(409, "X credentials are not configured.");
+            }
+            let page;
+            try {
+                page = await readXDms(credentials, { limit: opts.limit });
+            }
+            catch (error) {
+                translateXReadError("x_read_dms", error);
+            }
+            const syncedAt = new Date().toISOString();
+            for (const raw of page.items) {
+                await this.repository.upsertXDm(rawDmToLifeOpsXDm({
+                    agentId: this.agentId(),
+                    raw,
+                    syncedAt,
+                }));
+            }
+            await this.repository.upsertXSyncState({
+                id: `${this.agentId()}:x:dms`,
+                agentId: this.agentId(),
+                feedType: "home_timeline",
+                lastCursor: page.nextCursor,
+                syncedAt,
+                updatedAt: syncedAt,
+            });
+            return { synced: page.items.length };
+        }
+        async syncXFeed(feedType, opts = {}) {
+            await this.requireXGrant();
+            const credentials = toReaderCredentials();
+            if (!credentials) {
+                fail(409, "X credentials are not configured.");
+            }
+            let page;
+            try {
+                page = await pullXFeed(credentials, feedType, {
+                    limit: opts.limit,
+                    query: opts.query,
+                });
+            }
+            catch (error) {
+                translateXReadError(`x_read_feed_${feedType}`, error);
+            }
+            const syncedAt = new Date().toISOString();
+            for (const raw of page.items) {
+                await this.repository.upsertXFeedItem(rawFeedItemToLifeOpsXFeedItem({
+                    agentId: this.agentId(),
+                    feedType,
+                    raw,
+                    syncedAt,
+                }));
+            }
+            await this.repository.upsertXSyncState({
+                id: `${this.agentId()}:x:${feedType}`,
+                agentId: this.agentId(),
+                feedType,
+                lastCursor: page.nextCursor,
+                syncedAt,
+                updatedAt: syncedAt,
+            });
+            return { synced: page.items.length };
+        }
+        async searchXPosts(query, opts = {}) {
+            await this.requireXGrant();
+            const credentials = toReaderCredentials();
+            if (!credentials) {
+                fail(409, "X credentials are not configured.");
+            }
+            const trimmed = (query ?? "").trim();
+            if (trimmed.length === 0) {
+                fail(400, "searchXPosts requires a non-empty query.");
+            }
+            let page;
+            try {
+                page = await searchX(credentials, trimmed, { limit: opts.limit });
+            }
+            catch (error) {
+                translateXReadError("x_search", error);
+            }
+            const syncedAt = new Date().toISOString();
+            const items = [];
+            for (const raw of page.items) {
+                const item = rawFeedItemToLifeOpsXFeedItem({
+                    agentId: this.agentId(),
+                    feedType: "search",
+                    raw,
+                    syncedAt,
+                });
+                await this.repository.upsertXFeedItem(item);
+                items.push(item);
+            }
+            return items;
+        }
+        async getXDms(opts = {}) {
+            return this.repository.listXDms(this.agentId(), opts);
+        }
+        async getXFeedItems(feedType, opts = {}) {
+            return this.repository.listXFeedItems(this.agentId(), feedType, opts);
+        }
+        /**
+         * Pull and return only inbound X DMs (messages the authenticated user received,
+         * not sent). Performs a live sync against the X API, persists the results, and
+         * then returns the inbound subset from the local store.
+         *
+         * Callers that want the full conversation including outbound messages should
+         * call `syncXDms()` followed by `getXDms()` directly.
+         */
+        async readXInboundDms(opts = {}) {
+            await this.syncXDms(opts);
+            const all = await this.repository.listXDms(this.agentId(), opts);
+            return all.filter((dm) => dm.isInbound);
+        }
+    }
+    return LifeOpsXReadServiceMixin;
+}

package/apps/app-lifeops/src/lifeops/service-mixin-x.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=service-mixin-x.d.ts.map

package/apps/app-lifeops/src/lifeops/service-mixin-x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-mixin-x.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service-mixin-x.ts"],"names":[],"mappings":""}