@myagentroam/node 0.9.126 → 0.9.128

package/dist/connector.js

@@ -66,6 +66,8 @@ import { ScheduledSessionCoordinator } from './service/scheduled-session-coordin
 import { ScheduledSessionStore } from './service/scheduled-session-store.js';
 import { ScheduledRunAuthorizationControl } from './service/scheduled-run-authorization-control.js';
 import { ScheduledTaskMcpServer } from './service/scheduled-task-mcp-server.js';
+import { MailNotificationControl } from './service/mail-notification-control.js';
+import { MailNotificationMcpServer, resolveMailNotificationCapability } from './service/mail-notification-mcp-server.js';
 import { SessionCatalogService } from './service/session-catalog-service.js';
 import { SessionCommandService } from './service/session-command-service.js';
 import { SessionPresentationService } from './service/session-presentation-service.js';
@@ -157,6 +159,7 @@ export class NodeConnector {
     controlChannel;
     controlMessages;
     scheduledRunAuthorization;
+    mailNotificationControl = new MailNotificationControl((envelope) => this.sendEnvelope(envelope));
     scheduledSessions;
     nodeRequests;
     connectionLifecycle;
@@ -288,6 +291,7 @@ export class NodeConnector {
             throw new Error('SCHEDULE_SERVICE_UNAVAILABLE');
         return this.sessionScheduleService.createFromMcp(input);
     }, (sessionId) => this.runtime.getAgentSession(sessionId)?.externalSessionId ?? sessionId);
+    mailNotificationMcpServer = new MailNotificationMcpServer((capability) => resolveMailNotificationCapability(this.runtime, capability), (request) => this.mailNotificationControl.request(request));
     runnerUsageReader;
     terminalManager;
     upgradeCoordinator;
@@ -343,9 +347,15 @@ export class NodeConnector {
                 return;
             const store = new ScheduledSessionStore(this.database.raw);
             store.finish(run.clientMessageId, status === 'SUCCEEDED' ? 'SUCCEEDED' : 'FAILED', status === 'SUCCEEDED' ? undefined : `SCHEDULE_RUN_${status}`, run.id);
-            if (status !== 'SUCCEEDED') {
-                const task = store.get(run.sessionId);
-                if (task !== undefined)
+            const task = store.getById(run.clientMessageId.split(':', 1)[0]);
+            if (task !== undefined) {
+                if (task.notifyOnTerminal)
+                    this.publishScheduledTaskNotification(task, run.clientMessageId, {
+                        kind: 'SCHEDULE_TERMINAL',
+                        outcome: status,
+                        runId: run.id
+                    });
+                else if (status !== 'SUCCEEDED')
                     this.emitScheduledNotification(task, run.clientMessageId, `SCHEDULE_RUN_${status}`, 'FAILED');
             }
         },
@@ -422,6 +432,7 @@ export class NodeConnector {
             this.goalExecutionProgress.delete(executionId);
             this.goalMcpServer.revoke(executionId);
             this.scheduledTaskMcpServer.revoke(executionId);
+            this.mailNotificationMcpServer.revoke(executionId);
             this.continuousRunCoordinator.remove(executionId);
         }
     });
@@ -831,6 +842,34 @@ export class NodeConnector {
                     },
                     secrets: resolved.secrets
                 };
+            },
+            mailMcp: async (input) => {
+                const run = this.runtime.getRun(input.runId);
+                if (run?.initiatedByUserId === undefined)
+                    return undefined;
+                const resolved = await this.mailNotificationMcpServer.installation({
+                    executionId: input.runId,
+                    sessionId: input.sessionId,
+                    workspaceId: input.workspaceId,
+                    userId: run.initiatedByUserId,
+                    source: run.source === 'SCHEDULED' ? 'SCHEDULED' : 'MANUAL'
+                });
+                return {
+                    installation: {
+                        targetKind: 'WORKSPACE',
+                        targetId: input.workspaceId,
+                        catalogEntryId: 'mar-internal-mail',
+                        serverName: 'mar_notification',
+                        displayName: 'MAR email notification',
+                        version: '1.0.0',
+                        enabled: true,
+                        runtime: { transport: 'HTTP', url: 'https://127.0.0.1.invalid/mcp', headers: {} },
+                        configuration: resolved.installation,
+                        installedAt: Date.now(),
+                        ...resolved.installation
+                    },
+                    secrets: resolved.secrets
+                };
             }
         });
         this.workspaceQueueWorkbenchService = new WorkspaceQueueWorkbenchService({
@@ -1191,6 +1230,8 @@ export class NodeConnector {
                 this.directTransferService?.close();
                 this.runtimeCredentials.disconnected();
                 this.scheduledRunAuthorization.disconnected();
+                this.mailNotificationControl.disconnected();
+                this.mailNotificationMcpServer.revokeAll();
                 this.terminalChannel.disconnect();
                 if (code === 4000 && reason === 'NODE_CONNECTION_REPLACED')
                     nodeLog('node.connection.replaced', {
@@ -1209,6 +1250,7 @@ export class NodeConnector {
             handleNodeRequest: (envelope) => this.nodeRequests.handle(envelope),
             handleRuntimeCredentialResponse: (envelope) => this.runtimeCredentials.handle(envelope),
             handleScheduledRunAuthorizeResponse: (envelope) => this.scheduledRunAuthorization.handle(envelope),
+            handleMailNotificationResponse: (envelope) => this.mailNotificationControl.handle(envelope),
             handleDirectTransfer: (envelope) => this.handleDirectTransfer(envelope),
             handleTerminalDirect: (envelope) => this.handleTerminalDirect(envelope),
             reconcileRuns: (envelope) => this.runEventBridge.reconcile(envelope),
@@ -1271,6 +1313,7 @@ export class NodeConnector {
             onConnected: () => {
                 this.runtimeCredentials.connected();
                 this.scheduledRunAuthorization.connected();
+                this.mailNotificationControl.connected();
                 this.recentRunProjectionService.publishSnapshot();
             }
         });
@@ -1923,6 +1966,8 @@ export class NodeConnector {
         this.runtimeCredentials.close();
         this.scheduledSessions.stop();
         this.scheduledRunAuthorization.close();
+        this.mailNotificationControl.close();
+        const mailMcpDrain = this.mailNotificationMcpServer.close();
         this.directTransferService?.dispose();
         this.directTransferService = undefined;
         this.controlChannel.stop();
@@ -1934,7 +1979,8 @@ export class NodeConnector {
             terminalDrain,
             uploadDrain,
             goalMcpDrain,
-            scheduledMcpDrain
+            scheduledMcpDrain,
+            mailMcpDrain
         ]);
         this.stopping = (async () => {
             try {
@@ -1977,24 +2023,32 @@ export class NodeConnector {
             }
         });
     };
-    emitScheduledNotification = (task, occurrenceId, code, status) => {
+    emitScheduledNotification = (task, occurrenceId, code, status) => this.publishScheduledTaskNotification(task, occurrenceId, {
+        kind: status === 'FAILED' ? 'SCHEDULE_FAILED' : 'SCHEDULE_SKIPPED',
+        code
+    });
+    publishScheduledTaskNotification = (task, occurrenceId, event) => {
         const occurredAt = Date.now();
+        const recipient = (this.database === undefined
+            ? undefined
+            : new ScheduledSessionStore(this.database.raw).getById(task.id))?.ownerUserId ?? task.ownerUserId;
         const session = this.runtime.getAgentSession(task.sessionId);
         this.emitWorkbenchEvent('conversation', {
             event: {
-                runId: occurrenceId,
+                runId: event.kind === 'SCHEDULE_TERMINAL' ? event.runId : occurrenceId,
                 sequence: 1,
                 eventType: 'notification',
                 payload: {
                     targetType: 'WORKSPACE_SESSION',
-                    userId: task.ownerUserId,
+                    userId: recipient,
                     workspaceId: task.workspaceId,
                     sessionId: task.sessionId,
                     sessionTitle: session?.customTitle ?? session?.runnerTitle ?? task.sessionId,
-                    runId: occurrenceId,
-                    notificationId: `schedule:${task.id}:${occurrenceId}`,
-                    kind: status === 'FAILED' ? 'SCHEDULE_FAILED' : 'SCHEDULE_SKIPPED',
-                    code,
+                    runId: event.kind === 'SCHEDULE_TERMINAL' ? event.runId : occurrenceId,
+                    notificationId: event.kind === 'SCHEDULE_TERMINAL'
+                        ? `schedule-terminal:${task.id}:${occurrenceId}`
+                        : `schedule:${task.id}:${occurrenceId}`,
+                    ...event,
                     occurredAt
                 },
                 createdAt: occurredAt

package/dist/database.js

@@ -6,9 +6,14 @@ import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
 import { mcpCatalogEntrySchema, mcpInstallationConfigurationSchema, mcpRuntimeDescriptorSchema } from '@myagentroam/protocol';
 import { assertNodeSchemaV13, NODE_SCHEMA_V13, NODE_SCHEMA_VERSION_V13 } from './migrations/v013.js';
 import { NODE_SCHEMA_MIGRATION_V14 } from './migrations/v014.js';
+import { NODE_SCHEMA_MIGRATION_V15 } from './migrations/v015.js';
 // Future released migrations must be contiguous, immutable and begin at v14; Demo is excluded.
-export const NODE_SCHEMA_MIGRATIONS = [NODE_SCHEMA_MIGRATION_V14];
+export const NODE_SCHEMA_MIGRATIONS = [
+    NODE_SCHEMA_MIGRATION_V14,
+    NODE_SCHEMA_MIGRATION_V15
+];
 const LEGACY_NODE_SCHEMA_V12 = NODE_SCHEMA_VERSION_V13 - 1;
+const OBSOLETE_NODE_SCHEMA_V16 = 16;
 export class NodeDatabase {
     now;
     raw;
@@ -392,6 +397,13 @@ export function migrate(database, catalog = NODE_SCHEMA_MIGRATIONS) {
     const migratedVersions = database
         .prepare('SELECT version FROM node_schema_migrations ORDER BY version')
         .all().map((row) => numberValue(row, 'version'));
+    if (latest === NODE_SCHEMA_MIGRATION_V15.version &&
+        migratedVersions.length === 4 &&
+        migratedVersions.every((version, index) => version === NODE_SCHEMA_VERSION_V13 + index) &&
+        migratedVersions.at(-1) === OBSOLETE_NODE_SCHEMA_V16) {
+        downgradeLegacyRecipientSchema(database);
+        migratedVersions.pop();
+    }
     const current = migratedVersions.at(-1);
     if (current === undefined ||
         current < NODE_SCHEMA_VERSION_V13 ||
@@ -421,6 +433,49 @@ export function migrate(database, catalog = NODE_SCHEMA_MIGRATIONS) {
     if (catalog.length > 0)
         catalog[catalog.length - 1].assert(database);
 }
+function downgradeLegacyRecipientSchema(database) {
+    const reference = new DatabaseSync(':memory:');
+    try {
+        migrate(reference, [NODE_SCHEMA_MIGRATION_V14]);
+        reference.exec(`ALTER TABLE scheduled_session_tasks
+       ADD COLUMN notify_user_id INTEGER NOT NULL DEFAULT 1 CHECK (notify_user_id > 0);
+       ${NODE_SCHEMA_MIGRATION_V15.sql}`);
+        const definitions = (source) => new Map(source
+            .prepare('SELECT type,name,sql FROM sqlite_master WHERE sql IS NOT NULL ORDER BY type,name')
+            .all()
+            .map((row) => {
+            const type = row['type'];
+            const name = row['name'];
+            const sql = row['sql'];
+            if (typeof type !== 'string' || typeof name !== 'string' || typeof sql !== 'string')
+                throw new Error('NODE_DATABASE_VERSION_UNSUPPORTED');
+            return [`${type}:${name}`, sql.replace(/\s+/gu, ' ').trim()];
+        }));
+        const expected = definitions(reference);
+        const actual = definitions(database);
+        if (expected.size !== actual.size ||
+            [...expected].some(([name, sql]) => actual.get(name) !== sql))
+            throw new Error('NODE_DATABASE_VERSION_UNSUPPORTED');
+    }
+    finally {
+        reference.close();
+    }
+    database.exec('BEGIN IMMEDIATE');
+    try {
+        if (database.prepare('SELECT 1 FROM scheduled_session_tasks LIMIT 1').get() !== undefined)
+            throw new Error('NODE_DATABASE_DOWNGRADE_UNSAFE');
+        database.exec('ALTER TABLE scheduled_session_tasks DROP COLUMN notify_user_id');
+        NODE_SCHEMA_MIGRATION_V15.assert(database);
+        database
+            .prepare('DELETE FROM node_schema_migrations WHERE version=?')
+            .run(OBSOLETE_NODE_SCHEMA_V16);
+        database.exec('COMMIT');
+    }
+    catch (error) {
+        database.exec('ROLLBACK');
+        throw error;
+    }
+}
 function mcpInstallation(row) {
     const runtime = mcpRuntimeDescriptorSchema.parse(JSON.parse(stringValue(row, 'runtime')));
     const configuration = mcpInstallationConfigurationSchema.parse(JSON.parse(stringValue(row, 'configuration')));

package/dist/migrations/v015.js

@@ -0,0 +1,12 @@
+import { NODE_SCHEMA_MIGRATION_V14 } from './v014.js';
+export const NODE_SCHEMA_MIGRATION_V15 = {
+    version: 15,
+    sql: `ALTER TABLE scheduled_session_tasks
+    ADD COLUMN notify_on_terminal INTEGER NOT NULL DEFAULT 0 CHECK (notify_on_terminal IN (0,1));`,
+    assert(database) {
+        NODE_SCHEMA_MIGRATION_V14.assert(database);
+        const columns = new Set(database.prepare('PRAGMA table_info(scheduled_session_tasks)').all().map((column) => column.name));
+        if (!columns.has('notify_on_terminal') || columns.has('notify_user_id'))
+            throw new Error('NODE_DATABASE_SCHEMA_INVALID');
+    }
+};

package/dist/runner/abstract-runner.js

@@ -173,7 +173,9 @@ function resolvedMcpServers(raw, secrets) {
         const record = value;
         if (typeof record['serverName'] !== 'string' || record['enabled'] !== true)
             continue;
-        if ((record['__marGoal'] === true || record['__marScheduled'] === true) &&
+        if ((record['__marGoal'] === true ||
+            record['__marScheduled'] === true ||
+            record['__marMail'] === true) &&
             typeof record['command'] === 'string' &&
             Array.isArray(record['args']) &&
             record['args'].every((value) => typeof value === 'string') &&
@@ -191,11 +193,16 @@ function resolvedMcpServers(raw, secrets) {
                         MAR_GOAL_MCP_ENDPOINT: record['endpoint'],
                         MAR_GOAL_MCP_TOKEN: secrets[record['secretName']]
                     }
-                    : {
-                        MAR_SCHEDULE_MCP_ENDPOINT: record['endpoint'],
-                        MAR_SCHEDULE_MCP_TOKEN: secrets[record['secretName']],
-                        MAR_SCHEDULE_MCP_READ_ONLY: record['readOnly'] === true ? '1' : '0'
-                    }
+                    : record['__marScheduled'] === true
+                        ? {
+                            MAR_SCHEDULE_MCP_ENDPOINT: record['endpoint'],
+                            MAR_SCHEDULE_MCP_TOKEN: secrets[record['secretName']],
+                            MAR_SCHEDULE_MCP_READ_ONLY: record['readOnly'] === true ? '1' : '0'
+                        }
+                        : {
+                            MAR_MAIL_MCP_ENDPOINT: record['endpoint'],
+                            MAR_MAIL_MCP_TOKEN: secrets[record['secretName']]
+                        }
             });
             continue;
         }