@agent-native/core 0.98.6 → 0.98.8

package/dist/integrations/plugin.js

@@ -26,12 +26,12 @@ import { ComputerSupervisionError } from "./computer-supervision.js";
 import { getIntegrationConfig, saveIntegrationConfig } from "./config-store.js";
 import { claimIntegrationControl } from "./controls-store.js";
 import { startGoogleDocsPoller, handlePushNotification, } from "./google-docs-poller.js";
-import { resolveDefaultIntegrationExecutionContext } from "./identity.js";
+import { IntegrationIdentityDeclinedError, resolveDefaultIntegrationExecutionContext, } from "./identity.js";
 import { disconnectIntegrationInstallation, listIntegrationInstallations, resolveIntegrationTokenBundle, updateIntegrationInstallation, upsertIntegrationInstallation, } from "./installations-store.js";
 import { forgetIntegrationMemory, integrationMemoryActions, listIntegrationMemory, rememberForIntegrationScope, } from "./integration-memory.js";
 import { extractBearerToken, signInternalToken, verifyInternalToken, } from "./internal-token.js";
 import { startPendingTasksRetryJob } from "./pending-tasks-retry-job.js";
-import { claimPendingTask, getNextPendingTaskIdForThread, insertPendingTask, MAX_PENDING_TASK_ATTEMPTS, markTaskCompleted, markTaskFailed, markTaskRetryable, } from "./pending-tasks-store.js";
+import { claimPendingTask, getNextPendingTaskIdForThread, insertPendingTask, isDuplicateEventError, MAX_PENDING_TASK_ATTEMPTS, markTaskCompleted, markTaskFailed, markTaskRetryable, } from "./pending-tasks-store.js";
 import { claimNextComputerCommand, claimNextRemoteCommand, enqueueComputerCommand, enqueueRemoteCommand as enqueueRemoteCommandRow, isRemoteCommandKind, listRemoteCommandsForOwner, updateRemoteCommandResult, } from "./remote-commands-store.js";
 import { authenticateRemoteDeviceToken, createRemoteDevice, getRemoteComputerCapabilities, getRemoteDeviceForOwner, listRemoteDevicesForOwner, revokeRemoteDeviceForOwner, toPublicRemoteDevice, unregisterRemoteDevice, updateRemoteDeviceDetails, } from "./remote-devices-store.js";
 import { listRemotePushNotificationsForOwner, listRemotePushRegistrationsForOwner, queueRemotePushNotifications, toPublicRemotePushRegistration, unregisterRemotePushRegistrationForOwner, upsertRemotePushRegistration, } from "./remote-push-store.js";
@@ -124,6 +124,14 @@ Keep responses concise — messaging platforms have character limits and users e
 
 If a task requires many steps, summarize what you did rather than streaming every detail.`;
 const REMOTE_DEVICE_ONLINE_MS = 90_000;
+// One decline reply per sender + decline reason per window: during a Slack
+// API outage every message would otherwise get another identical "try again"
+// reply. Short enough that a persistent condition still reminds the sender.
+const DECLINE_NOTICE_DEDUPE_TTL_MS = 5 * 60 * 1_000;
+const SYSTEM_NOTICE_DEDUPE_TTL_MS = 24 * 60 * 60 * 1_000;
+function systemNoticeEventKey(dedupeKey, ttlMs, now = Date.now()) {
+    return `system-notice:${dedupeKey}:${Math.floor(now / ttlMs)}`;
+}
 export async function enqueueRemoteCommand(envelope) {
     const ownerEmail = readString(envelope.ownerEmail);
     if (!ownerEmail)
@@ -458,6 +466,61 @@ export function createIntegrationsPlugin(options) {
         const initialToolNames = Object.keys(localActions);
         const h3 = getH3App(nitroApp);
         const P = `${FRAMEWORK_ROUTE_PREFIX}/integrations`;
+        async function enqueueSystemNotice(event, incoming, text, opts) {
+            if (!text.trim())
+                return;
+            const taskId = `notice-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const dedupeTtlMs = Math.max(1, opts?.dedupeTtlMs ?? SYSTEM_NOTICE_DEDUPE_TTL_MS);
+            const noticeThreadId = `system-notice:${taskId}`;
+            const payload = {
+                kind: "system-notice",
+                incoming,
+                text,
+                ...(opts?.dedupeKey ? { dedupeKey: opts.dedupeKey } : {}),
+                ...(opts?.dedupeTtlMs ? { dedupeTtlMs: opts.dedupeTtlMs } : {}),
+            };
+            try {
+                await insertPendingTask({
+                    id: taskId,
+                    platform: incoming.platform,
+                    // System notices are auxiliary delivery work, not the user's agent
+                    // run. Give each notice its own queue lane so a retrying notice cannot
+                    // block the real message task for this Slack/Telegram thread.
+                    externalThreadId: noticeThreadId,
+                    payload: JSON.stringify(payload),
+                    ownerEmail: `integration@${incoming.platform}`,
+                    externalEventKey: opts?.dedupeKey
+                        ? systemNoticeEventKey(opts.dedupeKey, dedupeTtlMs)
+                        : undefined,
+                });
+            }
+            catch (err) {
+                if (isDuplicateEventError(err))
+                    return;
+                throw err;
+            }
+            // The SQL row is the durable source of truth. This best-effort self-call
+            // only reduces latency; the recurring pending-task sweep retries a row
+            // if the serverless host freezes this webhook execution immediately.
+            let token;
+            try {
+                token = signInternalToken(taskId);
+            }
+            catch (err) {
+                if (process.env.NODE_ENV === "production")
+                    throw err;
+            }
+            void fetch(`${getBaseUrl(event)}${P}/process-task`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                },
+                body: JSON.stringify({ taskId }),
+            }).catch((err) => {
+                console.warn("[integrations] System notice dispatch failed:", err);
+            });
+        }
         async function requireSession(event) {
             const session = await getSession(event).catch(() => null);
             if (session?.email)
@@ -1234,6 +1297,23 @@ export function createIntegrationsPlugin(options) {
                     ...(task.orgId ? { orgId: task.orgId } : {}),
                     isIntegrationCaller: true,
                 }, async () => {
+                    const taskPayload = JSON.parse(task.payload);
+                    if (taskPayload.kind === "system-notice") {
+                        if (!adapter.sendSystemNotice) {
+                            throw new Error(`Platform ${task.platform} cannot deliver system notices`);
+                        }
+                        const config = await getIntegrationConfig(task.platform);
+                        const credentialContext = await credentialContextForIntegrationConfig(config);
+                        await withCredentialContext(credentialContext, () => adapter.sendSystemNotice(taskPayload.incoming, taskPayload.text, {
+                            ...(taskPayload.dedupeKey
+                                ? { dedupeKey: taskPayload.dedupeKey }
+                                : {}),
+                            ...(taskPayload.dedupeTtlMs
+                                ? { dedupeTtlMs: taskPayload.dedupeTtlMs }
+                                : {}),
+                        }));
+                        return;
+                    }
                     const resources = await loadResourcesForPrompt(task.ownerEmail, true, options?.appId, task.orgId);
                     await processIntegrationTask(task, {
                         adapter,
@@ -1907,19 +1987,41 @@ export function createIntegrationsPlugin(options) {
                 }
                 let defaultExecutionContext = null;
                 if (incoming.platform === "slack" &&
-                    incoming.conversationType === "dm") {
+                    incoming.conversationType === "dm" &&
+                    !options?.resolveExecutionContext) {
                     try {
                         defaultExecutionContext = await withCredentialContext(credentialContext, () => resolveDefaultIntegrationExecutionContext(incoming));
                     }
                     catch (err) {
-                        // An app-specific resolver may intentionally support a legacy
-                        // Slack setup. When no override exists, the branch below fails
-                        // closed instead of falling back to a service principal.
-                        if (!options?.resolveExecutionContext && !options?.resolveOwner) {
+                        // The legacy owner-only resolver predates org-bound identities
+                        // and must not turn a rejected Slack DM into an authenticated
+                        // owner run. Custom resolveExecutionContext is checked above and
+                        // skips this default ladder entirely so apps can fully own auth
+                        // without framework membership checks or identity side effects.
+                        const declined = err instanceof IntegrationIdentityDeclinedError ? err : null;
+                        if (declined) {
+                            console.warn(`[integrations] default Slack DM identity declined message:`, declined.message);
+                            if (adapter.sendSystemNotice) {
+                                try {
+                                    await enqueueSystemNotice(event, incoming, declined.userFacingMessage, {
+                                        dedupeKey: `decline:${incoming.tenantId ?? "unknown"}:${incoming.senderId ?? "unknown"}:${declined.reason}`,
+                                        dedupeTtlMs: DECLINE_NOTICE_DEDUPE_TTL_MS,
+                                    });
+                                }
+                                catch (noticeErr) {
+                                    console.warn(`[integrations] could not persist decline notice:`, noticeErr instanceof Error
+                                        ? noticeErr.message
+                                        : noticeErr);
+                                    setResponseStatus(event, 500);
+                                    return { error: "notice enqueue failed" };
+                                }
+                            }
+                        }
+                        else {
                             console.error(`[integrations] default Slack DM identity denied message:`, err);
-                            setResponseStatus(event, 200);
-                            return "ok";
                         }
+                        setResponseStatus(event, 200);
+                        return "ok";
                     }
                 }
                 let executionContext = {
@@ -1939,6 +2041,60 @@ export function createIntegrationsPlugin(options) {
                 }
                 else if (defaultExecutionContext) {
                     executionContext = defaultExecutionContext;
+                    if (defaultExecutionContext.anonymousMember) {
+                        if (!options?.allowAnonymousOrgScopedSlackDm) {
+                            const senderEmail = typeof incoming.senderEmail === "string" &&
+                                incoming.senderEmail.trim()
+                                ? incoming.senderEmail.trim()
+                                : null;
+                            const noticeText = senderEmail
+                                ? `I couldn't match your Slack account to an organization member, so I can't run this request. Ask an organization admin to add ${senderEmail}, then try again.`
+                                : "I couldn't verify your Slack account email, so I can't run this request. Ask an organization admin to reconnect Slack with the users:read.email scope, then try again.";
+                            if (adapter.sendSystemNotice) {
+                                try {
+                                    await enqueueSystemNotice(event, incoming, noticeText, {
+                                        dedupeKey: `anonymous-tier-disabled:${incoming.tenantId ?? "unknown"}:${incoming.senderId ?? "unknown"}`,
+                                    });
+                                }
+                                catch (noticeErr) {
+                                    console.warn(`[integrations] could not persist unlinked-member notice:`, noticeErr instanceof Error
+                                        ? noticeErr.message
+                                        : noticeErr);
+                                    setResponseStatus(event, 500);
+                                    return { error: "notice enqueue failed" };
+                                }
+                            }
+                            setResponseStatus(event, 200);
+                            return "ok";
+                        }
+                        // The anonymous tier must never be silent. (1) The agent run
+                        // can tell: the note rides the serialized `incoming` into the
+                        // queued task and surfaces via <integration-context>.
+                        incoming.identityNote =
+                            "Caller is an unlinked Slack workspace member running with organization-wide visibility only; personal or privately-shared data is not accessible. They can get personal access by having an admin add their Slack email to the organization (or by reconnecting Slack with the users:read.email scope).";
+                        // (2) The sender gets a one-time heads-up through the same
+                        // durable SQL queue as agent work. The self-dispatch is only a
+                        // latency optimization; the retry sweep guarantees delivery.
+                        if (adapter.sendSystemNotice) {
+                            const senderEmail = typeof incoming.senderEmail === "string" &&
+                                incoming.senderEmail.trim()
+                                ? incoming.senderEmail.trim()
+                                : null;
+                            const noticeText = senderEmail
+                                ? `Heads up: I couldn't match your Slack account to an organization member, so I can only use org-wide data. Ask an admin to add ${senderEmail} to the organization for personal access.`
+                                : "Heads up: I couldn't verify your Slack account's email, so I can only use org-wide data. Ask an admin to update the Slack connection with the users:read.email scope for personal access.";
+                            try {
+                                await enqueueSystemNotice(event, incoming, noticeText, {
+                                    dedupeKey: `anonymous-tier:${incoming.tenantId ?? "unknown"}:${incoming.senderId ?? "unknown"}`,
+                                });
+                            }
+                            catch (noticeErr) {
+                                console.warn(`[integrations] could not persist anonymous-tier notice:`, noticeErr instanceof Error ? noticeErr.message : noticeErr);
+                                setResponseStatus(event, 500);
+                                return { error: "notice enqueue failed" };
+                            }
+                        }
+                    }
                 }
                 else if (options?.resolveOwner) {
                     try {