@agent-native/core 0.136.5 → 0.137.1

package/corpus/templates/factory/actions/poll-sentry-errors.ts

@@ -0,0 +1,161 @@
+import { defineAction } from "@agent-native/core/action";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { triageConfig, triageItems } from "../server/db/schema.js";
+import { requireFactoryAutomation } from "../server/lib/require-factory-automation.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import { itemDedupeKey } from "../server/triage/ids.js";
+import { mergeTriageMetadata } from "../server/triage/metadata.js";
+import { createSentryClient } from "../server/triage/sentry-client.js";
+
+export default defineAction({
+  description:
+    "Poll bounded unresolved Sentry issues for the configured organization and record them in the Factory queue. This does not change Sentry.",
+  schema: z.object({ limit: z.number().int().min(1).max(50).default(25) }),
+  http: false,
+  run: async ({ limit }, context) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    await requireFactoryAutomation(
+      context,
+      { userEmail, orgId },
+      "sourcePolling",
+    );
+    const config = (
+      await getDb()
+        .select()
+        .from(triageConfig)
+        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
+        .limit(1)
+    )[0];
+    if (config?.sentryPollingEnabled !== 1) {
+      throw new Error("Enable Sentry polling before polling Sentry.");
+    }
+    if (!config.sentryOrgSlug) {
+      throw new Error("Configure a Sentry organization before polling Sentry.");
+    }
+    const query = [
+      "is:unresolved",
+      config.sentryProjectSlug ? `project:${config.sentryProjectSlug}` : "",
+      config.sentryEnvironment ? `environment:${config.sentryEnvironment}` : "",
+    ]
+      .filter(Boolean)
+      .join(" ");
+    const issues = await createSentryClient({
+      ownerEmail: userEmail,
+      orgId,
+      orgSlug: config.sentryOrgSlug,
+    }).listIssues(query, limit);
+    const cursor = config.lastSentrySeenAt
+      ? Date.parse(config.lastSentrySeenAt)
+      : null;
+    if (cursor !== null && Number.isNaN(cursor)) {
+      throw new Error("Stored Sentry polling cursor is not a valid timestamp.");
+    }
+    // Reconcile every bounded result by its stable Sentry issue id. Frequency
+    // ordering is not a safe timestamp cursor: an older issue can re-enter the
+    // top page after its frequency changes.
+    for (const issue of issues) {
+      const firstSeen = Date.parse(issue.firstSeen);
+      if (Number.isNaN(firstSeen))
+        throw new Error(
+          `Sentry issue ${issue.id} has an invalid firstSeen timestamp.`,
+        );
+    }
+    const observedIssues = issues;
+    const db = getDb();
+    const now = new Date().toISOString();
+
+    await db.transaction(async (tx) => {
+      for (const issue of observedIssues) {
+        const id = itemDedupeKey(
+          { source: "sentry", externalId: issue.id },
+          orgId,
+        );
+        const existing = (
+          await tx
+            .select()
+            .from(triageItems)
+            .where(and(eq(triageItems.id, id), eq(triageItems.orgId, orgId)))
+            .limit(1)
+        )[0];
+        const metadata = mergeTriageMetadata(existing?.metadataJson ?? "{}", {
+          kind: "sentry_issue",
+          sentryIssueId: issue.id,
+          shortId: issue.shortId,
+          culprit: issue.culprit,
+          level: issue.level,
+          projectSlug: issue.projectSlug,
+          errorReport: [issue.title, issue.culprit].filter(Boolean).join("\n"),
+          count: issue.count,
+          firstSeen: issue.firstSeen,
+          lastSeen: issue.lastSeen,
+        });
+        await tx
+          .insert(triageItems)
+          .values({
+            id,
+            source: "sentry",
+            externalId: issue.id,
+            sourceUrl: issue.permalink,
+            title: issue.title,
+            summary: [issue.culprit, `${issue.count} events`, issue.level]
+              .filter(Boolean)
+              .join(" · ")
+              .slice(0, 4_000),
+            status: existing?.status ?? "received",
+            risk: existing?.risk ?? "unknown",
+            coverage: existing?.coverage ?? "complete",
+            dedupeKey: id,
+            metadataJson: metadata,
+            lastSeenAt: issue.lastSeen,
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+            ownerEmail: existing?.ownerEmail ?? userEmail,
+            orgId,
+          })
+          .onConflictDoUpdate({
+            target: triageItems.id,
+            set: {
+              sourceUrl: issue.permalink,
+              title: issue.title,
+              summary: [issue.culprit, `${issue.count} events`, issue.level]
+                .filter(Boolean)
+                .join(" · ")
+                .slice(0, 4_000),
+              metadataJson: metadata,
+              lastSeenAt: issue.lastSeen,
+              updatedAt: now,
+            },
+          });
+      }
+
+      await tx
+        .update(triageConfig)
+        .set({
+          lastSentrySeenAt:
+            observedIssues.reduce<string | null>((latest, issue) => {
+              if (!latest) return issue.firstSeen;
+              return Date.parse(issue.firstSeen) > Date.parse(latest)
+                ? issue.firstSeen
+                : latest;
+            }, config.lastSentrySeenAt) ?? config.lastSentrySeenAt,
+          updatedAt: now,
+        })
+        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)));
+    });
+
+    return {
+      ok: true,
+      observed: observedIssues.length,
+      fetched: issues.length,
+      sentryOrgSlug: config.sentryOrgSlug,
+    };
+  },
+});

package/corpus/templates/factory/actions/poll-slack-channel.ts

@@ -27,9 +27,12 @@ export default defineAction({
       await db
         .select()
         .from(triageConfig)
-        .where(eq(triageConfig.id, orgId))
+        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
         .limit(1)
     )[0];
+    if (config?.pollingEnabled !== 1) {
+      throw new Error("Enable Slack polling before polling Slack.");
+    }
     const channelId = requestedChannelId ?? config?.slackChannelId;
     if (!channelId) {
       throw new Error("Configure a Slack channel before polling.");
@@ -83,7 +86,6 @@ export default defineAction({
               channelId: envelope.channelId ?? null,
               threadTs: envelope.threadTs ?? null,
               coverage: envelope.coverage,
-              metadataJson: JSON.stringify(envelope.metadata ?? {}),
               lastSeenAt: now,
               updatedAt: now,
             },

package/corpus/templates/factory/actions/run-factory-automation.ts

@@ -0,0 +1,42 @@
+import { defineAction } from "@agent-native/core/action";
+import {
+  listAutomationDefinitions,
+  queueAutomationRunNow,
+} from "@agent-native/core/triggers";
+import { z } from "zod";
+
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+
+export default defineAction({
+  description:
+    "Queue one organization-scoped Factory automation for an immediate run and return its durable run id.",
+  agentTool: false,
+  schema: z.object({
+    factoryId: z.string().trim().min(1).optional(),
+    automationId: z.string().trim().min(1),
+  }),
+  http: { method: "POST" },
+  run: async ({ automationId }, context) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const definitions = await listAutomationDefinitions(
+      { userEmail, orgId },
+      "organization",
+    );
+    const definition = definitions.find(
+      (entry) =>
+        entry.meta.domain === "factory" && entry.resource.id === automationId,
+    );
+    if (!definition) throw new Error("Factory automation not found.");
+    return queueAutomationRunNow({
+      userEmail,
+      orgId,
+      scope: "organization",
+      name: definition.name,
+    });
+  },
+});

package/corpus/templates/factory/actions/save-factory-automation.ts

@@ -0,0 +1,69 @@
+import { defineAction } from "@agent-native/core/action";
+import {
+  listAutomationDefinitions,
+  updateAutomation,
+} from "@agent-native/core/triggers";
+import { z } from "zod";
+
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+
+export default defineAction({
+  description:
+    "Edit a Factory automation's prompt, model, schedule, or enabled state in its organization-owned markdown resource.",
+  agentTool: false,
+  schema: z.object({
+    factoryId: z.string().trim().min(1).optional(),
+    automationId: z.string().trim().min(1),
+    name: z.string().trim().min(1).max(120),
+    prompt: z.string().trim().min(1).max(20_000),
+    model: z.string().trim().max(200).optional(),
+    schedule: z.string().trim().min(1).max(100),
+    enabled: z.boolean(),
+  }),
+  http: { method: "POST" },
+  run: async (
+    { automationId, name, prompt, model, schedule, enabled },
+    context,
+  ) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const definitions = await listAutomationDefinitions(
+      { userEmail, orgId },
+      "organization",
+    );
+    const definition = definitions.find(
+      (entry) =>
+        entry.meta.domain === "factory" && entry.resource.id === automationId,
+    );
+    if (!definition) throw new Error("Factory automation not found.");
+    if (definition.name !== name) {
+      throw new Error(
+        "Factory automation id and name do not refer to the same automation.",
+      );
+    }
+    const updated = await updateAutomation(
+      { userEmail, orgId },
+      {
+        name: definition.name,
+        scope: "organization",
+        body: prompt,
+        model: model?.trim() || null,
+        schedule,
+        enabled,
+      },
+    );
+    return {
+      ok: true,
+      id: definition.resource.id,
+      name: updated.name,
+      prompt: updated.body,
+      model: updated.meta.model ?? null,
+      schedule: updated.meta.schedule || null,
+      enabled: updated.meta.enabled,
+    };
+  },
+});

package/corpus/templates/factory/actions/save-triage-config.ts

@@ -12,12 +12,17 @@ const workspaceSchema = z.enum(["primary", "secondary"]);
 
 export default defineAction({
   description:
-    "Save Factory observation settings. This controls read-only Slack polling and repository metadata; it never starts an executor or changes a provider.",
+    "Save Factory source settings. This controls Slack, GitHub, and Sentry polling; organization automations decide when governed provider work may start.",
   schema: z.object({
     slackWorkspace: workspaceSchema.default("primary"),
     slackChannelId: z.string().trim().min(1).max(128).optional(),
     slackChannelName: z.string().trim().max(200).optional(),
     pollingEnabled: z.boolean().default(false),
+    githubPollingEnabled: z.boolean().default(false),
+    sentryPollingEnabled: z.boolean().default(false),
+    sentryOrgSlug: z.string().trim().max(200).optional(),
+    sentryProjectSlug: z.string().trim().max(200).optional(),
+    sentryEnvironment: z.string().trim().max(200).optional(),
     repository: z.string().trim().max(256).optional(),
   }),
   http: { method: "POST" },
@@ -27,6 +32,11 @@ export default defineAction({
       slackChannelId,
       slackChannelName,
       pollingEnabled,
+      githubPollingEnabled,
+      sentryPollingEnabled,
+      sentryOrgSlug,
+      sentryProjectSlug,
+      sentryEnvironment,
       repository,
     },
     context,
@@ -44,6 +54,11 @@ export default defineAction({
         slackChannelId: slackChannelId ?? null,
         slackChannelName: slackChannelName ?? null,
         pollingEnabled: pollingEnabled ? 1 : 0,
+        githubPollingEnabled: githubPollingEnabled ? 1 : 0,
+        sentryPollingEnabled: sentryPollingEnabled ? 1 : 0,
+        sentryOrgSlug: sentryOrgSlug ?? null,
+        sentryProjectSlug: sentryProjectSlug ?? null,
+        sentryEnvironment: sentryEnvironment ?? null,
         repository: repository ?? null,
         createdAt: now,
         updatedAt: now,
@@ -57,11 +72,22 @@ export default defineAction({
           slackChannelId: slackChannelId ?? null,
           slackChannelName: slackChannelName ?? null,
           pollingEnabled: pollingEnabled ? 1 : 0,
+          githubPollingEnabled: githubPollingEnabled ? 1 : 0,
+          sentryPollingEnabled: sentryPollingEnabled ? 1 : 0,
+          sentryOrgSlug: sentryOrgSlug ?? null,
+          sentryProjectSlug: sentryProjectSlug ?? null,
+          sentryEnvironment: sentryEnvironment ?? null,
           repository: repository ?? null,
           updatedAt: now,
           ownerEmail: userEmail,
         },
       });
-    return { ok: true, pollingEnabled, slackChannelId: slackChannelId ?? null };
+    return {
+      ok: true,
+      pollingEnabled,
+      githubPollingEnabled,
+      sentryPollingEnabled,
+      slackChannelId: slackChannelId ?? null,
+    };
   },
 });