@myagentroam/node 0.9.126 → 0.9.127

package/dist/service/mail-notification-control.js

@@ -0,0 +1,69 @@
+import { createEnvelope, mailNotificationRequestSchema, mailNotificationResponseSchema } from '@myagentroam/protocol';
+export class MailNotificationControl {
+    sendEnvelope;
+    pending = new Map();
+    generation = 0;
+    connectedToServer = false;
+    closed = false;
+    constructor(sendEnvelope) {
+        this.sendEnvelope = sendEnvelope;
+    }
+    connected() {
+        this.disconnected();
+        this.connectedToServer = true;
+    }
+    disconnected() {
+        this.connectedToServer = false;
+        this.generation++;
+        for (const pending of [...this.pending.values()])
+            pending.reject(new Error('MAIL_DELIVERY_UNCERTAIN'));
+    }
+    close() {
+        this.closed = true;
+        this.disconnected();
+    }
+    handle(envelope) {
+        if (envelope.type !== 'mail.notification.response')
+            return false;
+        const pending = envelope.replyTo === undefined ? undefined : this.pending.get(envelope.replyTo);
+        if (pending === undefined || pending.generation !== this.generation)
+            return true;
+        const parsed = mailNotificationResponseSchema.safeParse(envelope.payload);
+        if (!parsed.success)
+            pending.reject(new Error('MAIL_RESPONSE_INVALID'));
+        else if ('error' in parsed.data)
+            pending.reject(new Error(parsed.data.error.code));
+        else
+            pending.resolve();
+        return true;
+    }
+    request(input) {
+        if (!this.connectedToServer || this.closed)
+            return Promise.reject(new Error('MAIL_SERVER_UNAVAILABLE'));
+        const envelope = createEnvelope('mail.notification.send', mailNotificationRequestSchema.parse(input));
+        return new Promise((resolve, reject) => {
+            const settle = (action) => {
+                const pending = this.pending.get(envelope.id);
+                if (pending === undefined)
+                    return;
+                clearTimeout(pending.timer);
+                this.pending.delete(envelope.id);
+                action();
+            };
+            const timer = setTimeout(() => settle(() => reject(new Error('MAIL_DELIVERY_UNCERTAIN'))), 30_000);
+            timer.unref();
+            this.pending.set(envelope.id, {
+                generation: this.generation,
+                resolve: () => settle(resolve),
+                reject: (error) => settle(() => reject(error)),
+                timer
+            });
+            try {
+                this.sendEnvelope(envelope);
+            }
+            catch {
+                settle(() => reject(new Error('MAIL_SERVER_UNAVAILABLE')));
+            }
+        });
+    }
+}

package/dist/service/mail-notification-mcp-server.js

@@ -0,0 +1,150 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { mailNotificationRequestSchema } from '@myagentroam/protocol';
+export class MailNotificationMcpServer {
+    resolve;
+    send;
+    capabilities = new Map();
+    sockets = new Set();
+    endpoint = process.platform === 'win32'
+        ? `\\\\.\\pipe\\mar-mail-${process.pid}-${randomUUID()}`
+        : join(tmpdir(), `mar-mail-${process.pid}-${randomUUID()}.sock`);
+    listening;
+    constructor(resolve, send) {
+        this.resolve = resolve;
+        this.send = send;
+    }
+    async installation(capability) {
+        await this.listen();
+        const token = randomBytes(32).toString('base64url');
+        const secretName = `MAR_MAIL_MCP_${randomBytes(16).toString('hex').toUpperCase()}`;
+        this.capabilities.set(token, capability);
+        return {
+            installation: {
+                __marMail: true,
+                serverName: 'mar_notification',
+                enabled: true,
+                command: process.execPath,
+                args: mailMcpStdioArgs(),
+                endpoint: this.endpoint,
+                secretName
+            },
+            secrets: { [secretName]: token }
+        };
+    }
+    revoke(executionId) {
+        for (const [token, capability] of this.capabilities)
+            if (capability.executionId === executionId)
+                this.capabilities.delete(token);
+    }
+    revokeAll() {
+        this.capabilities.clear();
+    }
+    async close() {
+        if (this.listening === undefined)
+            return;
+        const server = await this.listening;
+        this.revokeAll();
+        const closed = new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))));
+        for (const socket of this.sockets)
+            socket.destroy();
+        await closed;
+        if (process.platform !== 'win32')
+            await unlink(this.endpoint).catch(() => undefined);
+    }
+    listen() {
+        this.listening ??= new Promise((resolve, reject) => {
+            const server = createServer((socket) => this.handle(socket));
+            server.once('error', reject);
+            server.listen(this.endpoint, () => resolve(server));
+        });
+        return this.listening;
+    }
+    handle(socket) {
+        this.sockets.add(socket);
+        socket.once('close', () => this.sockets.delete(socket));
+        let body = '';
+        let received = false;
+        socket.setEncoding('utf8');
+        socket.on('data', (chunk) => {
+            if (received)
+                return;
+            body += chunk;
+            if (body.length > 16_000) {
+                socket.destroy();
+                return;
+            }
+            if (body.includes('\n')) {
+                received = true;
+                void this.respond(socket, body.slice(0, body.indexOf('\n')));
+            }
+        });
+    }
+    async respond(socket, body) {
+        try {
+            const request = JSON.parse(body);
+            const capability = typeof request['token'] === 'string' ? this.capabilities.get(request['token']) : undefined;
+            if (capability === undefined)
+                throw new Error('MAIL_CAPABILITY_INVALID');
+            const current = this.resolve(capability);
+            if (current === undefined)
+                throw new Error('MAIL_CAPABILITY_STALE');
+            if (request['tool'] !== 'mar_send_email_notification')
+                throw new Error('MAIL_TOOL_INVALID');
+            const args = request['arguments'];
+            if (args === null || typeof args !== 'object' || Array.isArray(args))
+                throw new Error('MAIL_INPUT_INVALID');
+            const { templateId, recipientEmail, message, callId } = args;
+            if ((templateId !== undefined && typeof templateId !== 'string') ||
+                typeof recipientEmail !== 'string' ||
+                typeof message !== 'string' ||
+                typeof callId !== 'string')
+                throw new Error('MAIL_INPUT_INVALID');
+            const parsed = mailNotificationRequestSchema.safeParse({
+                ...current,
+                templateId: templateId ?? '',
+                recipientEmail,
+                message,
+                callId
+            });
+            if (!parsed.success)
+                throw new Error('MAIL_INPUT_INVALID');
+            await this.send(parsed.data);
+            socket.end(`${JSON.stringify({ result: { accepted: true } })}\n`);
+        }
+        catch (error) {
+            const code = error instanceof Error && /^MAIL_[A-Z0-9_]+$/u.test(error.message)
+                ? error.message
+                : 'MAIL_DELIVERY_UNCERTAIN';
+            socket.end(`${JSON.stringify({ error: code })}\n`);
+        }
+    }
+}
+export function resolveMailNotificationCapability(runtime, capability) {
+    const run = runtime.getRun(capability.executionId);
+    const session = runtime.getAgentSession(capability.sessionId);
+    if (run === undefined ||
+        session === undefined ||
+        ['SUCCEEDED', 'FAILED', 'INTERRUPTED'].includes(run.status) ||
+        runtime.currentExecutionId(run.id) !== capability.executionId ||
+        run.sessionId !== session.id ||
+        run.workspaceId !== capability.workspaceId ||
+        run.initiatedByUserId !== capability.userId ||
+        (run.source === 'SCHEDULED' ? 'SCHEDULED' : 'MANUAL') !== capability.source)
+        return undefined;
+    return { ...capability, sessionId: session.id };
+}
+function mailMcpStdioArgs() {
+    const javascript = fileURLToPath(new URL('./mail-notification-mcp-stdio.js', import.meta.url));
+    if (existsSync(javascript))
+        return [javascript];
+    const typescript = fileURLToPath(new URL('./mail-notification-mcp-stdio.ts', import.meta.url));
+    if (!existsSync(typescript))
+        throw new Error('MAIL_MCP_STDIO_ENTRY_UNAVAILABLE');
+    return ['--import', import.meta.resolve('tsx'), typescript];
+}

package/dist/service/mail-notification-mcp-stdio.js

@@ -0,0 +1,56 @@
+import { randomUUID } from 'node:crypto';
+import { connect } from 'node:net';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+const endpoint = process.env['MAR_MAIL_MCP_ENDPOINT'];
+const token = process.env['MAR_MAIL_MCP_TOKEN'];
+if (endpoint === undefined || token === undefined)
+    throw new Error('MAIL_CAPABILITY_INVALID');
+const server = new McpServer({ name: 'mar_notification', version: '1.0.0' });
+server.registerTool('mar_send_email_notification', {
+    description: 'Send a notification email to the specified recipient from this MAR-managed Workspace conversation. The Agent works with files and tools on the authorized MAR Node; the MAR Server sends email using its administrator-configured SMTP account. This is not the browser or Node local email account, nor a repository cron/CI notification. This tool cannot access SMTP credentials. Omit the template to use the built-in notification template in the sender’s preferred language; optionally select notification-en-US or notification-zh-CN. Each call may send a real email; do not retry after an uncertain result.',
+    inputSchema: {
+        templateId: z
+            .string()
+            .max(64)
+            .optional()
+            .describe('Optional built-in NOTIFICATION template ID; omitted or empty uses the sender’s preferred language.'),
+        recipientEmail: z.string().min(3).max(320).describe('Single recipient email address.'),
+        message: z.string().min(1).max(4000).describe('Notification text for {{message}}.')
+    }
+}, async (args) => {
+    const value = await request({ ...args, callId: randomUUID() });
+    return { content: [{ type: 'text', text: JSON.stringify(value) }] };
+});
+await server.connect(new StdioServerTransport());
+function request(args) {
+    return new Promise((resolve, reject) => {
+        const socket = connect(endpoint);
+        let body = '';
+        socket.setEncoding('utf8');
+        socket.once('connect', () => socket.write(`${JSON.stringify({ token, tool: 'mar_send_email_notification', arguments: args })}\n`));
+        socket.on('data', (chunk) => {
+            body += chunk;
+            if (body.length > 16_000)
+                socket.destroy(new Error('MAIL_RESPONSE_INVALID'));
+        });
+        socket.once('error', reject);
+        socket.once('end', () => {
+            try {
+                if (body.length === 0)
+                    throw new Error('MAIL_DELIVERY_UNCERTAIN');
+                const payload = JSON.parse(body);
+                if (payload.error !== undefined)
+                    reject(new Error(payload.error));
+                else
+                    resolve(payload.result);
+            }
+            catch (error) {
+                reject(error instanceof Error && error.message === 'MAIL_DELIVERY_UNCERTAIN'
+                    ? error
+                    : new Error('MAIL_RESPONSE_INVALID'));
+            }
+        });
+    });
+}

package/dist/service/mcp-node-operation-service.js

@@ -39,7 +39,13 @@ export class McpNodeOperationService {
             status: 'CURRENT',
             installedAt: installation.installedAt
         }));
-        return mcpTargetInspectionSchema.parse({ targetKind, installations });
+        return mcpTargetInspectionSchema.parse({
+            targetKind,
+            installations,
+            ...(targetKind === 'WORKSPACE'
+                ? { executionBuiltIns: ['mar_schedule', 'mar_notification'] }
+                : {})
+        });
     }
     async install(targetKind, targetId, raw) {
         if (!isRecord(raw))

package/dist/service/node-control-message-service.js

@@ -37,6 +37,8 @@ export class NodeControlMessageService {
             return;
         if (this.options.handleScheduledRunAuthorizeResponse?.(envelope) === true)
             return;
+        if (this.options.handleMailNotificationResponse?.(envelope) === true)
+            return;
         if (envelope.type.startsWith('direct.') &&
             this.options.handleDirectTransfer?.(envelope) === true)
             return;

package/dist/service/scheduled-session-store.js

@@ -40,6 +40,7 @@ export class ScheduledSessionStore {
             workspaceId: input.workspaceId,
             runner: input.runner,
             ownerUserId: input.ownerUserId,
+            notifyOnTerminal: input.notifyOnTerminal ?? false,
             cron: input.cron,
             timezone: input.timezone,
             objective: input.objective.trim(),
@@ -52,9 +53,9 @@ export class ScheduledSessionStore {
         };
         this.database
             .prepare(`INSERT INTO scheduled_session_tasks
-        (id,session_id,workspace_id,runner,owner_user_id,objective,cron,timezone,enabled,revision,next_run_at,created_at,updated_at)
-        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)`)
-            .run(task.id, task.sessionId, task.workspaceId, task.runner, task.ownerUserId, task.objective, task.cron, task.timezone, task.enabled ? 1 : 0, 1, task.nextRunAt, now, now);
+        (id,session_id,workspace_id,runner,owner_user_id,notify_on_terminal,objective,cron,timezone,enabled,revision,next_run_at,created_at,updated_at)
+        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+            .run(task.id, task.sessionId, task.workspaceId, task.runner, task.ownerUserId, task.notifyOnTerminal ? 1 : 0, task.objective, task.cron, task.timezone, task.enabled ? 1 : 0, 1, task.nextRunAt, now, now);
         return task;
     }
     update(sessionId, expectedRevision, patch) {
@@ -63,11 +64,15 @@ export class ScheduledSessionStore {
             throw new Error('SCHEDULE_NOT_FOUND');
         if (current.revision !== expectedRevision)
             throw new Error('SCHEDULE_REVISION_CONFLICT');
+        if (patch.ownerUserId !== undefined &&
+            (!Number.isSafeInteger(patch.ownerUserId) || patch.ownerUserId < 1))
+            throw new Error('SCHEDULE_OWNER_INVALID');
         const objective = patch.objective ?? current.objective;
         const cron = patch.cron ?? current.cron;
         const timezone = patch.timezone ?? current.timezone;
         validate(objective, cron, timezone);
         const enabled = patch.enabled ?? current.enabled;
+        const ownerUserId = patch.ownerUserId ?? current.ownerUserId;
         const nextRunAt = enabled
             ? patch.enabled === true || patch.cron !== undefined || patch.timezone !== undefined
                 ? nextScheduledAt(cron, timezone, this.now())
@@ -75,9 +80,9 @@ export class ScheduledSessionStore {
             : null;
         const now = this.now();
         const result = this.database
-            .prepare(`UPDATE scheduled_session_tasks SET objective=?,cron=?,timezone=?,enabled=?,revision=?,next_run_at=?,updated_at=?
+            .prepare(`UPDATE scheduled_session_tasks SET objective=?,cron=?,timezone=?,enabled=?,owner_user_id=?,notify_on_terminal=?,revision=?,next_run_at=?,updated_at=?
         WHERE session_id=? AND revision=?`)
-            .run(objective.trim(), cron, timezone, enabled ? 1 : 0, expectedRevision + 1, nextRunAt, now, sessionId, expectedRevision);
+            .run(objective.trim(), cron, timezone, enabled ? 1 : 0, ownerUserId, (patch.notifyOnTerminal ?? current.notifyOnTerminal) ? 1 : 0, expectedRevision + 1, nextRunAt, now, sessionId, expectedRevision);
         if (result.changes !== 1)
             throw new Error('SCHEDULE_REVISION_CONFLICT');
         this.database
@@ -193,7 +198,8 @@ export class ScheduledSessionStore {
                         ? {}
                         : { objective: proposal['objective'] }),
                     ...(proposal['cron'] === null ? {} : { cron: proposal['cron'] }),
-                    ...(proposal['timezone'] === null ? {} : { timezone: proposal['timezone'] })
+                    ...(proposal['timezone'] === null ? {} : { timezone: proposal['timezone'] }),
+                    ownerUserId
                 })
                 : task;
             this.database
@@ -222,6 +228,7 @@ function taskFromRow(row) {
         workspaceId: row['workspace_id'],
         runner: row['runner'],
         ownerUserId: Number(row['owner_user_id']),
+        notifyOnTerminal: row['notify_on_terminal'] === 1,
         objective: row['objective'],
         cron: row['cron'],
         timezone: row['timezone'],

package/dist/service/scheduled-task-mcp-server.js

@@ -144,7 +144,10 @@ export class ScheduledTaskMcpServer {
                 ...(cron === undefined ? {} : { cron: cron })
             };
             if (capability.actorUserId === task.ownerUserId) {
-                const updated = this.store().update(task.sessionId, task.revision, patch);
+                const updated = this.store().update(task.sessionId, task.revision, {
+                    ...patch,
+                    ownerUserId: capability.actorUserId
+                });
                 this.#capabilities.set(request.token, {
                     ...capability,
                     revision: updated.revision

package/dist/service/session-schedule-service.js

@@ -48,12 +48,14 @@ export class SessionScheduleService {
         const current = store.get(sessionId);
         const objective = input.objective;
         const cron = input.cron;
+        const notifyOnTerminal = input.notifyOnTerminal;
         const timezone = current === undefined ? nodeTimezone() : undefined;
         if ((objective !== undefined &&
             (typeof objective !== 'string' ||
                 objective.trim().length < 1 ||
                 objective.trim().length > 20_000)) ||
             (cron !== undefined && typeof cron !== 'string') ||
+            (notifyOnTerminal !== undefined && typeof notifyOnTerminal !== 'boolean') ||
             input.timezone !== undefined ||
             (input.enabled !== undefined && typeof input.enabled !== 'boolean'))
             throw new Error('SCHEDULE_INVALID');
@@ -82,6 +84,7 @@ export class SessionScheduleService {
                 workspaceId: session.workspaceId,
                 runner: session.runner,
                 ownerUserId: actor,
+                ...(notifyOnTerminal === undefined ? {} : { notifyOnTerminal }),
                 objective: objective,
                 cron: cron,
                 timezone: timezone,
@@ -91,7 +94,9 @@ export class SessionScheduleService {
                 ...(objective === undefined ? {} : { objective: objective }),
                 ...(cron === undefined ? {} : { cron: cron }),
                 ...(timezone === undefined ? {} : { timezone: timezone }),
-                ...(input.enabled === undefined ? {} : { enabled: input.enabled })
+                ...(input.enabled === undefined ? {} : { enabled: input.enabled }),
+                ownerUserId: actor,
+                ...(notifyOnTerminal === undefined ? {} : { notifyOnTerminal })
             });
         const updated = this.options.runtime.getAgentSession(session.id) ?? session;
         this.options.emitSession(updated);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.126",
+  "version": "0.9.127",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -30,9 +30,9 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.126",
-    "@myagentroam/protocol": "0.9.126",
-    "@myagentroam/code-navigation": "0.9.126"
+    "@myagentroam/agent": "0.9.127",
+    "@myagentroam/code-navigation": "0.9.127",
+    "@myagentroam/protocol": "0.9.127"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"