@agent-native/core 0.136.4 → 0.137.0

package/corpus/templates/factory/server/connectors/slack.ts

@@ -26,9 +26,35 @@ export interface ChannelHistoryResult {
   next_cursor?: string;
 }
 
+export interface ThreadRepliesResult {
+  messages: SlackMessage[];
+  has_more: boolean;
+  next_cursor?: string;
+}
+
+export interface SlackReactionResult {
+  added: boolean;
+  already_present: boolean;
+}
+
+export interface SlackPostMessageResult {
+  ok?: boolean;
+  error?: string;
+  channel: string;
+  ts: string;
+  message?: SlackMessage;
+}
+
 const cache = new Map<string, { value: unknown; expiresAt: number }>();
 const cacheTtlMs = 120_000;
 
+function invalidateWorkspaceCache(workspace: Workspace): void {
+  const prefix = `${workspace}:`;
+  for (const key of cache.keys()) {
+    if (key.startsWith(prefix)) cache.delete(key);
+  }
+}
+
 async function getToken(
   workspace: Workspace,
   tokenResolver?: SlackTokenResolver,
@@ -60,12 +86,40 @@ async function slackApi<T>(
       `Slack API error ${response.status}: ${await response.text()}`,
     );
   const data = (await response.json()) as T & { ok?: boolean; error?: string };
-  if (data.ok === false)
+  if (data.ok !== true)
     throw new Error(`Slack API error: ${data.error ?? "unknown_error"}`);
   cache.set(cacheKey, { value: data, expiresAt: Date.now() + cacheTtlMs });
   return data;
 }
 
+async function slackWrite<T extends { ok?: boolean; error?: string }>(
+  workspace: Workspace,
+  method: string,
+  body: Record<string, string>,
+  tokenResolver?: SlackTokenResolver,
+): Promise<T> {
+  const token = await getToken(workspace, tokenResolver);
+  const response = await fetch(`https://slack.com/api/${method}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json; charset=utf-8",
+    },
+    body: JSON.stringify(body),
+  });
+  if (!response.ok)
+    throw new Error(
+      `Slack API error ${response.status}: ${await response.text()}`,
+    );
+  const data = (await response.json()) as T;
+  if (data.ok !== true)
+    throw new Error(`Slack API error: ${data.error ?? "unknown_error"}`);
+  // A successful reaction or message write makes cached reads stale. This is
+  // especially important when a retry follows a partially recorded handoff.
+  invalidateWorkspaceCache(workspace);
+  return data;
+}
+
 export async function getChannelHistory(
   workspace: Workspace,
   channelId: string,
@@ -83,7 +137,10 @@ export async function getChannelHistory(
       messages?: SlackMessage[];
       has_more?: boolean;
     }>(workspace, "conversations.history", params, tokenResolver);
-    const messages = data.messages ?? [];
+    if (!Array.isArray(data.messages)) {
+      throw new Error("Slack history response is missing messages.");
+    }
+    const messages = data.messages;
     return {
       messages,
       has_more: Boolean(data.has_more),
@@ -100,13 +157,19 @@ export async function getChannelHistory(
       },
       body: JSON.stringify({ channel: channelId }),
     });
-    const joinedData = (await joined.json()) as { ok?: boolean };
-    if (!joinedData.ok) throw error;
+    const joinedData = (await joined.json()) as {
+      ok?: boolean;
+      error?: string;
+    };
+    if (joinedData.ok !== true) throw error;
     const data = await slackApi<{
       messages?: SlackMessage[];
       has_more?: boolean;
     }>(workspace, "conversations.history", params, tokenResolver);
-    const messages = data.messages ?? [];
+    if (!Array.isArray(data.messages)) {
+      throw new Error("Slack history response is missing messages.");
+    }
+    const messages = data.messages;
     return {
       messages,
       has_more: Boolean(data.has_more),
@@ -115,6 +178,71 @@ export async function getChannelHistory(
   }
 }
 
+export async function getThread(
+  workspace: Workspace,
+  channelId: string,
+  threadTs: string,
+  limit = 100,
+  cursor?: string,
+  tokenResolver?: SlackTokenResolver,
+): Promise<ThreadRepliesResult> {
+  const params: Record<string, string> = {
+    channel: channelId,
+    ts: threadTs,
+    limit: String(Math.min(Math.max(limit, 1), 100)),
+  };
+  if (cursor) params.cursor = cursor;
+  const data = await slackApi<{
+    messages?: SlackMessage[];
+    has_more?: boolean;
+    response_metadata?: { next_cursor?: string };
+  }>(workspace, "conversations.replies", params, tokenResolver);
+  if (!Array.isArray(data.messages)) {
+    throw new Error("Slack thread response is missing messages.");
+  }
+  return {
+    messages: data.messages,
+    has_more: Boolean(data.has_more),
+    next_cursor: data.response_metadata?.next_cursor || undefined,
+  };
+}
+
+export async function addEyesReaction(
+  workspace: Workspace,
+  channelId: string,
+  timestamp: string,
+  tokenResolver?: SlackTokenResolver,
+): Promise<SlackReactionResult> {
+  try {
+    await slackWrite(
+      workspace,
+      "reactions.add",
+      { channel: channelId, timestamp, name: "eyes" },
+      tokenResolver,
+    );
+    return { added: true, already_present: false };
+  } catch (error) {
+    if (!String(error).includes("already_reacted")) throw error;
+    return { added: false, already_present: true };
+  }
+}
+
+export async function postThreadReply(
+  workspace: Workspace,
+  channelId: string,
+  threadTs: string,
+  text: string,
+  tokenResolver?: SlackTokenResolver,
+): Promise<SlackPostMessageResult> {
+  const data = await slackWrite<SlackPostMessageResult>(
+    workspace,
+    "chat.postMessage",
+    { channel: channelId, thread_ts: threadTs, text },
+    tokenResolver,
+  );
+  return data;
+}
+
 export async function getTeamInfo(
   workspace: Workspace,
   tokenResolver?: SlackTokenResolver,

package/corpus/templates/factory/server/db/schema.ts

@@ -114,6 +114,12 @@ export const triageConfig = table("factory_config", {
   lastSlackTs: text("last_slack_ts"),
   slackHistoryCursor: text("slack_history_cursor"),
   repository: text("repository"),
+  githubPollingEnabled: integer("github_polling_enabled").notNull().default(0),
+  sentryPollingEnabled: integer("sentry_polling_enabled").notNull().default(0),
+  sentryOrgSlug: text("sentry_org_slug"),
+  sentryProjectSlug: text("sentry_project_slug"),
+  sentryEnvironment: text("sentry_environment"),
+  lastSentrySeenAt: text("last_sentry_seen_at"),
   createdAt: text("created_at").notNull().default(now()),
   updatedAt: text("updated_at").notNull().default(now()),
   ownerEmail: text("owner_email").notNull(),

package/corpus/templates/factory/server/lib/require-factory-automation.ts

@@ -0,0 +1,65 @@
+import type { ActionRunContext } from "@agent-native/core/action";
+import { listAutomationDefinitions } from "@agent-native/core/triggers";
+
+import type { WorkspaceMemberIdentity } from "./require-workspace-member.js";
+
+const FACTORY_AUTOMATION_NAMES = {
+  builderDispatch: new Set([
+    "factory-slack-feedback",
+    "factory-sentry-errors",
+    "factory-github-issues",
+  ]),
+  governance: new Set(["factory-pr-governance"]),
+  sourcePolling: new Set([
+    "factory-slack-feedback",
+    "factory-sentry-errors",
+    "factory-github-issues",
+    "factory-pr-governance",
+  ]),
+} as const;
+
+export type FactoryAutomationRole = keyof typeof FACTORY_AUTOMATION_NAMES;
+
+function workspaceOwnerEmail(): string | undefined {
+  const email = process.env.WORKSPACE_OWNER_EMAIL?.trim().toLowerCase(); // guard:allow-env-credential - deployment owner identity, not a user credential
+  if (!email || /[\r\n]/.test(email)) return undefined;
+  return email;
+}
+
+export async function requireFactoryAutomation(
+  context: ActionRunContext | undefined,
+  identity: Pick<WorkspaceMemberIdentity, "userEmail" | "orgId">,
+  role: FactoryAutomationRole,
+): Promise<void> {
+  if (context?.caller !== "automation") {
+    throw new Error("This action is only available to Factory automations.");
+  }
+  const lineage = context.automation;
+  const expectedNames = FACTORY_AUTOMATION_NAMES[role];
+  if (!lineage || !expectedNames.has(lineage.triggerName)) {
+    throw new Error(
+      "The action was not invoked by a governed Factory automation.",
+    );
+  }
+
+  const definition = (
+    await listAutomationDefinitions(
+      { userEmail: identity.userEmail, orgId: identity.orgId },
+      "organization",
+    )
+  ).find((entry) => entry.resource.id === lineage.triggerId);
+  const ownerEmail = workspaceOwnerEmail();
+  if (
+    !definition ||
+    definition.name !== lineage.triggerName ||
+    definition.meta.domain !== "factory" ||
+    definition.meta.orgId !== identity.orgId ||
+    definition.meta.runAs !== "creator" ||
+    !ownerEmail ||
+    definition.meta.createdBy?.trim().toLowerCase() !== ownerEmail
+  ) {
+    throw new Error(
+      "The action was not invoked by a governed Factory automation.",
+    );
+  }
+}

package/corpus/templates/factory/server/plugins/agent-chat.ts

@@ -17,7 +17,14 @@ const INITIAL_TOOL_NAMES = [
   "list-triage-items",
   "get-triage-item",
   "poll-slack-channel",
+  "get-slack-feedback-context",
+  "poll-github-sources",
+  "poll-sentry-errors",
   "evaluate-triage-item",
+  "start-builder-for-item",
+  "govern-agent-native-pull-request",
+  "babysit-pull-request",
+  "approve-factory-item",
   "list-triage-rules",
   "get-triage-config",
   "navigate",
@@ -31,16 +38,18 @@ const options = {
   resolveOrgId: async (event) => (await getOrgContext(event)).orgId,
   systemPrompt: `You are the Factory agent.
 
-Factory is a visual factory builder. It observes Slack feedback and pull-request
-evidence, renders the current factory graph, and helps a human decide where agents
-should act. Use the Factory actions as the source of truth. When a user asks to
+Factory is a visual factory builder. It observes Slack feedback, GitHub issues,
+Sentry errors, and pull-request evidence, renders the current factory graph, and
+executes only the explicit automation prompts that are stored in the organization.
+Use the Factory actions as the source of truth. When a user asks to
 create or change a factory, first inspect the current graph, then propose a complete
 versioned graph through save-factory-graph with source=ai and a concise changeSummary.
 Never hide a graph change in prose: the visual map and the saved graph must agree.
-The graph is currently a reviewable blueprint, not the runtime router: enabled
-triage rules are evaluated in parallel against the same evidence. Do not claim that
-an edge changes execution. For rule or guard changes, use the triage rule actions
-and preserve normalizeTriagePolicyGuards; do not encode policy in graph JSON.
+The graph is currently a reviewable blueprint, not the runtime router: automation
+markdown resources are the runtime prompts, while enabled triage rules are evaluated
+in parallel against the same evidence. Do not claim that an edge changes execution.
+For rule or guard changes, use the triage rule actions and preserve
+normalizeTriagePolicyGuards; do not encode policy in graph JSON.
 Use add-factory-comment for durable comments attached to the selected node or edge.
 Explain the evidence and guard results before proposing work.
 When discussing agent failures, preserve these measured taxonomy labels exactly:
@@ -49,10 +58,19 @@ overloaded_error, and Missing provider authentication. Always inspect interactiv
 and scheduled job populations separately; scheduled runs have ids beginning with
 job- and must not be hidden by an interactive-only query.
 Never bypass a hard guard or claim that a provider action happened without a
-durable run record and a confirmed terminal callback. When a user says to do it
-now, use the approval action, which records the approver and applies the rule's
-configured executor policy. Keep Slack replies concise and link to the Factory
- item when a review is needed.`,
+durable run record and a confirmed terminal callback. A clear bug means concrete
+broken behavior, reproducible failure, error, regression, stuck run, incorrect
+result, or a specific failing path with enough evidence to investigate. Feature
+requests, broad UX suggestions, vague questions, and incomplete context stay
+manual. Clips, Design, and Content are fully owner-managed: never react, tag
+Builder, auto-approve, or auto-merge those items. Slack clear bugs use the
+thread-preserving start-builder-for-item flow; GitHub and Sentry clear bugs use
+the Builder agent-run flow. For pull requests, auto-approval requires an internal
+BuilderIO author, a clear bug, passing CI, and handled review feedback. Auto-merge
+also requires a verified Factory Builder run. When a user says to do a review-gated
+item now, use the explicit approval action, which records the approver and applies
+the rule's configured executor policy. Keep Slack replies concise and link to the
+Factory item when a review is needed.`,
 } satisfies AgentChatPluginOptions;
 
 export default createAgentChatPlugin(options);

package/corpus/templates/factory/server/plugins/auth.ts

@@ -1,6 +1,7 @@
 import { createAuthPlugin } from "@agent-native/core/server";
 
 export default createAuthPlugin({
+  googleOnly: true,
   marketing: {
     appName: "Factory",
     tagline:

package/corpus/templates/factory/server/plugins/factory-migrations.ts

@@ -236,6 +236,18 @@ const migrations = [
         ON factory_comments (org_id, factory_id, created_at);
     `,
   },
+  {
+    version: 16,
+    name: "factory-source-polling-settings",
+    sql: `
+      ALTER TABLE factory_config ADD COLUMN github_polling_enabled INTEGER NOT NULL DEFAULT 0;
+      ALTER TABLE factory_config ADD COLUMN sentry_polling_enabled INTEGER NOT NULL DEFAULT 0;
+      ALTER TABLE factory_config ADD COLUMN sentry_org_slug TEXT;
+      ALTER TABLE factory_config ADD COLUMN sentry_project_slug TEXT;
+      ALTER TABLE factory_config ADD COLUMN sentry_environment TEXT;
+      ALTER TABLE factory_config ADD COLUMN last_sentry_seen_at TEXT;
+    `,
+  },
 ];
 
 export const runFactoryMigrations = runMigrations(migrations, {