@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/integrations/slack/slack.d.ts

@@ -0,0 +1,205 @@
+import type { ChannelHandler, ChannelHandlers, ChannelSessionResolve, ChannelSessionStart, ResolveResourceId, ResolveThreadId } from '@mastra/core/channels';
+import type { SlackAdapterChannelConfig } from '@mastra/slack';
+import type { ChannelAccountLink, ChannelAccountLinkKey, ChannelIdentityStorage } from '../../storage/domains/channel-identity/base.js';
+import type { CommentsDomain } from '../../storage/domains/comments/domain.js';
+import type { ModelDefaultsStorage } from '../../storage/domains/model-defaults/base.js';
+import type { FactoryProjectsStorage } from '../../storage/domains/projects/base.js';
+import type { SourceControlStorageHandle } from '../../storage/domains/source-control/base.js';
+import type { ExternalWorkItemSource, WorkItemsStorage } from '../../storage/domains/work-items/base.js';
+import type { FactoryChannelsConfig } from '../base.js';
+type HandlerThread = Parameters<ChannelHandler>[0];
+type HandlerMessage = Parameters<ChannelHandler>[1];
+/** Dependencies the Slack channel handlers close over, injected from the web entry. */
+interface SlackChannelDeps {
+    /**
+     * The factory's reverse-index store mapping a Slack sender to a Mastra
+     * tenant. When provided, inbound messages from an unlinked sender are not
+     * dispatched — the run only proceeds (with the sender's tenant stamped on
+     * the request context) once they've linked their account. Unlinked senders
+     * get an ephemeral "connect your account" card instead.
+     */
+    accountLinks?: ChannelIdentityStorage;
+    /**
+     * Factory projects domain. When provided (alongside `accountLinks`), a
+     * linked sender's run must also resolve to a Factory project before it
+     * dispatches: their link's default factory, else their tenant's only
+     * factory (stamped back onto the link), else a "pick a default factory"
+     * card posted in the thread and no run. Unset → no factory routing (runs
+     * dispatch as before).
+     */
+    projects?: FactoryProjectsStorage;
+    /**
+     * Storage handle of the integration that owns source control
+     * (`IntegrationContext.storage.sourceControlOwner`). Used to make new Slack
+     * threads repo-backed: when the sender is linked and their factory has a
+     * repository, the thread's resourceId becomes a Factory user-session id (repo
+     * cloned on a `slack/{threadTs}` branch) instead of the chat-only
+     * `channel:...` id. It also lets a started session read back the project it
+     * belongs to. Nothing here is provider-specific — the connection is matched
+     * by the handle's own `integrationId`. Absent (no source-control integration
+     * registered) → chat-only sessions as before.
+     */
+    sourceControl?: SourceControlStorageHandle;
+    /** Registered source-control partitions used to select the provider linked to each Factory project. */
+    sourceControls?: readonly SourceControlStorageHandle[];
+    /**
+     * Model-defaults domain. When provided, a new repo-backed session starts on
+     * the linked sender's default model before the factory's shared default. Read
+     * once, when the thread's build model is first chosen; the choice is persisted
+     * on the thread and never re-resolved. Unset → the factory default, as before.
+     */
+    modelDefaults?: ModelDefaultsStorage;
+    /**
+     * Factory work-items domain, used to find the card a Slack thread already
+     * has so an `aside` can land on it. New threads never create cards.
+     */
+    workItems?: WorkItemsStorage;
+    /**
+     * Work-item feed. With it (and `workItems`), an `aside` lands as a comment on
+     * the card the thread already has. Unset → asides stay ignored, as before.
+     */
+    feed?: Pick<CommentsDomain, 'createComment'>;
+    /** Overrides applied to the Slack channel adapter entry. */
+    adapterOptions?: SlackAdapterChannelConfig;
+}
+/** Outcome of the sender-link gate for one inbound message. */
+type LinkedSenderResult = 
+/** Gating not configured — dispatch as before account linking existed. */
+{
+    status: 'ungated';
+}
+/** Sender unlinked — Connect card posted (when possible), do not dispatch. */
+ | {
+    status: 'blocked';
+}
+/** Sender linked — their tenant plus the sender key the link lives under. */
+ | {
+    status: 'linked';
+    link: ChannelAccountLink;
+    key: ChannelAccountLinkKey;
+};
+/**
+ * Resolve the sender's account link, posting an ephemeral "connect your
+ * account" card (visible only to the sender) linking into the web UI's
+ * Slack-connect flow when they're unlinked.
+ */
+export declare function resolveLinkedSender({ thread, message, accountLinks, }: {
+    thread: HandlerThread;
+    message: HandlerMessage;
+    accountLinks?: ChannelIdentityStorage;
+}): Promise<LinkedSenderResult>;
+/** Outcome of factory routing for one linked sender's inbound message. */
+type FactoryRouteResult = 
+/** Factory routing not configured — dispatch without a factory. */
+{
+    status: 'ungated';
+}
+/** No factory resolved — prompt card posted (when possible), do not dispatch. */
+ | {
+    status: 'blocked';
+}
+/** The Factory project this sender's runs route to. */
+ | {
+    status: 'resolved';
+    factoryProjectId: string;
+};
+/**
+ * Decide which Factory project a linked sender's run belongs to:
+ *
+ * 1. The link's `defaultFactoryProjectId`, when it still exists (a stale id —
+ *    deleted factory — falls through as if unset).
+ * 2. Else, the tenant's only factory, stamped back onto the link so it shows
+ *    up (and stays editable) in Connected Accounts settings.
+ * 3. Else — zero or several factories — a "pick a default factory" card
+ *    posted publicly in the thread so Slack notifies the sender, and the run is
+ *    blocked.
+ */
+export declare function resolveFactoryForLink({ thread, link, key, accountLinks, projects, }: {
+    thread: HandlerThread;
+    link: ChannelAccountLink;
+    key: ChannelAccountLinkKey;
+    accountLinks: ChannelIdentityStorage;
+    projects?: FactoryProjectsStorage;
+}): Promise<FactoryRouteResult>;
+/**
+ * Resolve the resourceId for a NEW Slack channel thread. A linked sender whose
+ * factory has a repository gets a Factory user-session id — the controller
+ * session then materializes the repo sandbox via the factory's dynamic
+ * workspace (clone + PAT), the session shows up in the web Sessions list, and
+ * View Session deep-links land on the normal workspace route.
+ *
+ * A gated deployment refuses a thread it cannot place, rather than falling back
+ * to a chat-only session: a repo-backed thread is the whole point of the
+ * integration, and answering in a chat-only one would run the sender's request
+ * in no project, on the SDK's built-in defaults. A linked sender whose project
+ * cannot start a session gets an actionable error in Slack; the dispatch gate
+ * handles unlinked or unrouted senders before this hook runs.
+ * The hook only runs when a NEW thread is actually created (`getOrCreateThread`
+ * resolves the owner lazily), so an established conversation is never touched:
+ * it keeps its session, its model, and its history.
+ *
+ * The chat-only `channel:...` id survives for two cases where refusing would be
+ * wrong: a deployment that cannot produce a repo-backed thread at all (no
+ * account linking, no projects, or no source-control integration registered),
+ * and a message carrying no sender id. In both, a `channel:` thread is the only
+ * shape a session can take.
+ *
+ * Pure lookups only — cards for unlinked/unrouted senders are the dispatch
+ * gate's job; this hook must never post.
+ */
+export declare function createChannelResourceIdResolver(deps: SlackChannelDeps): ResolveResourceId;
+/**
+ * Thread id for a NEW Slack channel thread. Repo-backed threads take the
+ * user-session id AS their thread id, matching the web convention
+ * (FactoryStartCoordinator seeds threads with threadId = sessionId) so
+ * `/workspaces/{sessionId}/threads/{sessionId}` resolves Slack-created
+ * sessions exactly like web-created ones — no `?resourceId=` override needed.
+ * Chat-only threads keep the default random id: their `channel:...`
+ * resourceId is a memory key, not a unique thread id.
+ */
+export declare const resolveChannelThreadId: ResolveThreadId;
+/** Create channel sessions with their Factory ownership present in initial controller state. */
+export declare function createChannelSessionResolver(deps: SlackChannelDeps): ChannelSessionResolve;
+/**
+ * Apply the factory's configuration to a Slack-created session the first time
+ * its thread reaches the controller.
+ *
+ * Without this a Slack session runs on the SDK's built-in mode default
+ * (`openai/gpt-5.5`), so a factory configured for any other provider fails every
+ * message with a missing-credentials error. The web kickoff has always applied
+ * the factory default; this brings Slack to the same footing.
+ *
+ * Only repo-backed threads are configured. Their resourceId IS the Factory
+ * session id, which the source-control rows turn back into a project — a
+ * chat-only `channel:...` id names no project, so there is nothing to read.
+ *
+ * The model this session starts on is picked here, once, from the project's
+ * effective model scope for a session: the Factory default or the durable session owner's
+ * default, else the SDK's built-in model. The choice is persisted on the thread
+ * as `currentModelId`, so it outlives the process that made it.
+ *
+ * The model resolution is skipped on a session that already has a model
+ * persisted on the thread. That is the durable record of a deliberate choice —
+ * either an earlier start or a user's own switch — and re-applying a preference
+ * over it would undo the user's selection every time the process restarts.
+ */
+export declare function createChannelSessionStartHook(deps: SlackChannelDeps): ChannelSessionStart;
+/**
+ * A channel id and a `ts` name a thread only inside the workspace that issued
+ * them, so the team scopes the card's key — without it two workspaces could
+ * hold one key and an aside would land on another tenant's card.
+ */
+export declare function slackThreadSource(thread: HandlerThread, teamId?: string): ExternalWorkItemSource;
+export declare const createHandlers: (deps: SlackChannelDeps) => ChannelHandlers;
+/** Slack app credentials, passed in explicitly rather than read from env here. */
+interface SlackCredentials {
+    clientId?: string;
+    clientSecret?: string;
+    signingSecret: string;
+    botToken?: string;
+}
+export declare function createSlackChannelsConfig(deps: SlackChannelDeps & {
+    slack: SlackCredentials;
+}): FactoryChannelsConfig;
+export {};
+//# sourceMappingURL=slack.d.ts.map

package/dist/integrations/slack/slack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.d.ts","sourceRoot":"","sources":["../../../src/integrations/slack/slack.ts"],"names":[],"mappings":"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"}