@myagentroam/node 0.9.125 → 0.9.127

package/dist/codex-app-server.js

@@ -139,6 +139,36 @@ export class CodexAppServerClient {
         this.lifecycleRevision += 1;
         this.stopManaged();
     }
+    async stopAndWait() {
+        const child = this.child;
+        if (child === undefined) {
+            this.stop();
+            return;
+        }
+        const exited = new Promise((resolve, reject) => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                resolve();
+            else {
+                let forcedTimeout;
+                const onExit = () => {
+                    clearTimeout(timeout);
+                    if (forcedTimeout !== undefined)
+                        clearTimeout(forcedTimeout);
+                    resolve();
+                };
+                const timeout = setTimeout(() => {
+                    child.kill('SIGKILL');
+                    forcedTimeout = setTimeout(() => {
+                        child.off('exit', onExit);
+                        reject(new Error('CODEX_APP_SERVER_STOP_TIMEOUT'));
+                    }, 2_000);
+                }, 2_000);
+                child.once('exit', onExit);
+            }
+        });
+        this.stop();
+        await exited;
+    }
     stopManaged() {
         this.transport?.destroy();
         this.transport = undefined;

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;
         }

package/dist/runner/codex-runner.js

@@ -3,7 +3,6 @@ import { AbstractRunner } from './abstract-runner.js';
 import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
-import { createHash } from 'node:crypto';
 import { discoverAllNativeSessions } from '../native-session-history.js';
 import { readCodexNativeContextUsage } from '../native-session-history.js';
 import { codexThreadCwd, deduplicateDirectSessions, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
@@ -20,7 +19,6 @@ export class CodexRunner extends AbstractRunner {
     discoveryScope = 'ALL_WORKSPACES';
     execution = new CodexExecutionState();
     fastEnabled = false;
-    environmentClients = new Map();
     runClients = new Map();
     notificationListeners = new Set();
     clientNotificationDisposers = new Map();
@@ -318,13 +316,14 @@ export class CodexRunner extends AbstractRunner {
         return this.profileCache;
     }
     async resumeExternal(external, context) {
+        const threadId = external.externalSessionId;
         if (external.runner !== this.name ||
             external.nativeControl !== 'EXTERNAL' ||
-            external.externalSessionId === null ||
+            threadId === null ||
             !context.available)
             return { failureCode: 'RUNNER_UNAVAILABLE' };
         try {
-            await this.resumeThread(external.externalSessionId, external.cwd);
+            await this.withTemporaryClient((client) => client.resumeThread(threadId, external.cwd));
             const projection = context.projectionFor(external);
             if (projection !== undefined) {
                 const promoted = context.promote(projection.id);
@@ -437,7 +436,7 @@ export class CodexRunner extends AbstractRunner {
     onNotification(listener) {
         this.notificationListeners.add(listener);
         this.attachNotifications(this.client);
-        for (const { client } of this.environmentClients.values())
+        for (const client of this.runClients.values())
             this.attachNotifications(client);
         return () => this.notificationListeners.delete(listener);
     }
@@ -459,8 +458,7 @@ export class CodexRunner extends AbstractRunner {
         if (!isCodexRolloutMissingError(error))
             return false;
         const client = this.clientFor(runId);
-        const entry = [...this.environmentClients.values()].find((value) => value.client === client);
-        if (entry !== undefined && [...entry.runIds].some((activeRunId) => activeRunId !== runId))
+        if ([...this.runClients].some(([activeRunId, activeClient]) => activeRunId !== runId && activeClient === client))
             return false;
         if ([...this.execution.runs].some(([activeRunId]) => activeRunId !== runId && this.runClients.get(activeRunId) === client))
             return false;
@@ -469,20 +467,12 @@ export class CodexRunner extends AbstractRunner {
         return true;
     }
     prepareEnvironment(environment, runId) {
-        const fingerprint = createHash('sha256')
-            .update(JSON.stringify(Object.entries(environment).sort(([left], [right]) => left.localeCompare(right))))
-            .digest('base64url');
-        const existing = this.environmentClients.get(fingerprint);
-        if (existing !== undefined) {
-            existing.runIds.add(runId);
-            this.runClients.set(runId, existing.client);
+        if (this.runClients.has(runId))
             return;
-        }
         const client = this.runClientFactory();
         if (Object.keys(environment).length > 0)
             client.configureEnvironment(environment);
         this.attachNotifications(client);
-        this.environmentClients.set(fingerprint, { client, runIds: new Set([runId]) });
         this.runClients.set(runId, client);
     }
     releaseEnvironment(runId) {
@@ -490,19 +480,10 @@ export class CodexRunner extends AbstractRunner {
         if (client === undefined)
             return;
         this.runClients.delete(runId);
-        for (const [fingerprint, entry] of this.environmentClients) {
-            if (entry.client !== client)
-                continue;
-            entry.runIds.delete(runId);
-            if (entry.runIds.size === 0) {
-                this.environmentClients.delete(fingerprint);
-                if (client !== this.client) {
-                    this.detachNotifications(client);
-                    client.stop();
-                    client.clearEnvironment();
-                }
-            }
-            return;
+        if (client !== this.client && ![...this.runClients.values()].includes(client)) {
+            this.detachNotifications(client);
+            client.stop();
+            client.clearEnvironment();
         }
     }
     stop() {
@@ -510,13 +491,12 @@ export class CodexRunner extends AbstractRunner {
         for (const profileClient of this.profileClients)
             profileClient.stop();
         this.profileClients.clear();
-        for (const { client } of this.environmentClients.values())
+        for (const client of new Set(this.runClients.values()))
             if (client !== this.client) {
                 this.detachNotifications(client);
                 client.stop();
                 client.clearEnvironment();
             }
-        this.environmentClients.clear();
         this.runClients.clear();
         this.client.stop();
         if (this.profileCacheTimer !== undefined)
@@ -530,6 +510,17 @@ export class CodexRunner extends AbstractRunner {
     clientFor(runId) {
         return runId === undefined ? this.client : (this.runClients.get(runId) ?? this.client);
     }
+    async withTemporaryClient(operation) {
+        const client = this.runClientFactory();
+        try {
+            await client.start();
+            return await operation(client);
+        }
+        finally {
+            if (client !== this.client)
+                await client.stopAndWait();
+        }
+    }
     attachNotifications(client) {
         if (this.clientNotificationDisposers.has(client))
             return;
@@ -558,16 +549,18 @@ export class CodexRunner extends AbstractRunner {
         return this.client.forkThread(threadId, cwd, lastTurnId, configuration);
     }
     async forkNative(session, boundary, title) {
-        if (session.externalSessionId === null)
+        const threadId = session.externalSessionId;
+        if (threadId === null)
             throw new Error('SESSION_REWIND_UNAVAILABLE');
-        await this.start();
         const configuration = { model: session.model, effort: session.effort, access: session.access };
-        const result = boundary === null
-            ? await this.startThread(session.cwd, configuration)
-            : await this.forkThread(session.externalSessionId, session.cwd, boundary, configuration);
-        const threadId = extractId(result, 'thread');
-        await this.setThreadName(threadId, title);
-        return threadId;
+        return this.withTemporaryClient(async (client) => {
+            const result = boundary === null
+                ? await client.startThread(session.cwd, configuration)
+                : await client.forkThread(threadId, session.cwd, boundary, configuration);
+            const forkedThreadId = extractId(result, 'thread');
+            await client.setThreadName(forkedThreadId, title);
+            return forkedThreadId;
+        });
     }
     resumeThread(threadId, cwd, configuration, runId) {
         return this.clientFor(runId).resumeThread(threadId, cwd, configuration);