@agent-native/core 0.132.1 → 0.133.0

package/corpus/templates/factory/server/lib/require-workspace-member.ts

@@ -0,0 +1,55 @@
+import type { ActionRunContext } from "@agent-native/core/action";
+import { orgMembers, resolveOrgIdForEmail } from "@agent-native/core/org";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server/request-context";
+import { and, eq, sql } from "drizzle-orm";
+
+import { getDb } from "../db/index.js";
+
+export type WorkspaceMemberIdentity = {
+  userEmail: string;
+  orgId: string;
+  role: string;
+};
+
+export type WorkspaceMemberIdentityInput = {
+  userEmail: string;
+  orgId?: string | null;
+};
+
+export function workspaceMemberIdentityFromContext(
+  context?: Pick<ActionRunContext, "userEmail" | "orgId">,
+): WorkspaceMemberIdentityInput | undefined {
+  if (!context?.userEmail) return undefined;
+  return { userEmail: context.userEmail, orgId: context.orgId };
+}
+
+export async function requireWorkspaceMember(
+  identity?: WorkspaceMemberIdentityInput,
+): Promise<WorkspaceMemberIdentity> {
+  const userEmail = (identity?.userEmail ?? getRequestUserEmail())
+    ?.trim()
+    .toLowerCase();
+  if (!userEmail) throw new Error("Authentication required");
+
+  const requestOrgId = identity?.orgId?.trim() || getRequestOrgId()?.trim();
+  const orgId = requestOrgId || (await resolveOrgIdForEmail(userEmail));
+  if (!orgId) throw new Error("Active workspace organization required");
+
+  const rows = await getDb()
+    .select({ role: orgMembers.role })
+    .from(orgMembers)
+    .where(
+      and(
+        eq(orgMembers.orgId, orgId),
+        eq(sql`lower(${orgMembers.email})`, userEmail),
+      ),
+    )
+    .limit(1);
+
+  if (!rows[0]) throw new Error("Workspace membership required");
+
+  return { userEmail, orgId, role: rows[0].role };
+}

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

@@ -0,0 +1,15 @@
+import { runAuthGuard } from "@agent-native/core/server";
+/**
+ * Global auth middleware — runs for ALL requests (page routes, API routes,
+ * framework routes). The auth plugin configures the guard; this middleware
+ * enforces it on every request.
+ *
+ * Without this, auth only runs for /_agent-native/* routes because the
+ * framework handler's middleware registry is scoped to that catch-all.
+ * Page routes (/, /settings) and API routes (/api/*) would bypass auth.
+ */
+import { defineEventHandler } from "h3";
+
+export default defineEventHandler(async (event) => {
+  return runAuthGuard(event);
+});

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

@@ -0,0 +1,58 @@
+import { getOrgContext } from "@agent-native/core/org";
+import {
+  createAgentChatPlugin,
+  loadActionsFromStaticRegistry,
+  type AgentChatPluginOptions,
+} from "@agent-native/core/server";
+
+import actionsRegistry from "../../.generated/actions-registry.js";
+
+const INITIAL_TOOL_NAMES = [
+  "view-screen",
+  "list-factories",
+  "get-factory-graph",
+  "save-factory-graph",
+  "list-factory-comments",
+  "add-factory-comment",
+  "list-triage-items",
+  "get-triage-item",
+  "poll-slack-channel",
+  "evaluate-triage-item",
+  "list-triage-rules",
+  "get-triage-config",
+  "navigate",
+];
+
+const options = {
+  appId: "factory",
+  actions: loadActionsFromStaticRegistry(actionsRegistry),
+  leanPrompt: true,
+  initialToolNames: INITIAL_TOOL_NAMES,
+  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
+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.
+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:
+SSL/TLS provider transport drop, Model reasoning_effort with tools, Provider
+overloaded_error, and Missing provider authentication. Always inspect interactive
+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.`,
+} satisfies AgentChatPluginOptions;
+
+export default createAgentChatPlugin(options);

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

@@ -0,0 +1,14 @@
+import { createAuthPlugin } from "@agent-native/core/server";
+
+export default createAuthPlugin({
+  marketing: {
+    appName: "Factory",
+    tagline:
+      "Build agent factories: work in one end, shipped changes out the other, with gates you control.",
+    features: [
+      "Inspect Slack and pull-request signals in one queue",
+      "Tune rules with prompts and reviewable feedback",
+      "Approve bounded agent work with a durable audit trail",
+    ],
+  },
+});

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

@@ -0,0 +1,247 @@
+import { runMigrations } from "@agent-native/core/db";
+import { defineNitroPlugin } from "@agent-native/core/server";
+
+const migrations = [
+  {
+    version: 1,
+    name: "factory-items-table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS factory_items (
+        id TEXT PRIMARY KEY,
+        source TEXT NOT NULL,
+        external_id TEXT NOT NULL,
+        source_url TEXT,
+        title TEXT NOT NULL,
+        summary TEXT,
+        status TEXT NOT NULL DEFAULT 'received',
+        risk TEXT NOT NULL DEFAULT 'unknown',
+        channel_id TEXT,
+        thread_ts TEXT,
+        repository TEXT,
+        pull_request_number INTEGER,
+        head_sha TEXT,
+        coverage TEXT NOT NULL DEFAULT 'unknown',
+        dedupe_key TEXT NOT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        last_seen_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        owner_email TEXT NOT NULL,
+        org_id TEXT
+      )
+    `,
+  },
+  {
+    version: 2,
+    name: "factory-rules-table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS factory_rules (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL,
+        prompt_text TEXT NOT NULL,
+        mode TEXT NOT NULL DEFAULT 'shadow',
+        enabled INTEGER NOT NULL DEFAULT 1,
+        guards_json TEXT NOT NULL DEFAULT '{}',
+        prompt_version INTEGER NOT NULL DEFAULT 1,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        owner_email TEXT NOT NULL,
+        org_id TEXT
+      )
+    `,
+  },
+  {
+    version: 3,
+    name: "factory-decisions-table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS factory_decisions (
+        id TEXT PRIMARY KEY,
+        item_id TEXT NOT NULL,
+        rule_id TEXT,
+        mode TEXT NOT NULL DEFAULT 'shadow',
+        outcome TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        guard_results_json TEXT NOT NULL DEFAULT '[]',
+        model TEXT,
+        prompt_version INTEGER,
+        created_at TEXT NOT NULL,
+        owner_email TEXT NOT NULL,
+        org_id TEXT
+      )
+    `,
+  },
+  {
+    version: 4,
+    name: "factory-runs-table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS factory_runs (
+        id TEXT PRIMARY KEY,
+        item_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'received',
+        progress_log_json TEXT NOT NULL DEFAULT '[]',
+        dispatch_attempts INTEGER NOT NULL DEFAULT 0,
+        needs_continuation INTEGER NOT NULL DEFAULT 0,
+        started_at TEXT NOT NULL,
+        heartbeat_at TEXT,
+        completed_at TEXT,
+        error TEXT,
+        owner_email TEXT NOT NULL,
+        org_id TEXT
+      )
+    `,
+  },
+  {
+    version: 5,
+    name: "factory-feedback-table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS factory_feedback (
+        id TEXT PRIMARY KEY,
+        decision_id TEXT NOT NULL,
+        verdict TEXT NOT NULL,
+        note TEXT,
+        created_at TEXT NOT NULL,
+        owner_email TEXT NOT NULL,
+        org_id TEXT
+      )
+    `,
+  },
+  {
+    version: 6,
+    name: "factory-config-table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS factory_config (
+        id TEXT PRIMARY KEY,
+        slack_workspace TEXT NOT NULL DEFAULT 'primary',
+        slack_channel_id TEXT,
+        slack_channel_name TEXT,
+        polling_enabled INTEGER NOT NULL DEFAULT 0,
+        last_slack_ts TEXT,
+        repository TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        owner_email TEXT NOT NULL,
+        org_id TEXT
+      )
+    `,
+  },
+  {
+    version: 7,
+    name: "factory-items-org-dedupe-index",
+    sql: `
+      CREATE UNIQUE INDEX IF NOT EXISTS factory_items_org_dedupe_idx
+        ON factory_items (org_id, dedupe_key)
+    `,
+  },
+  {
+    version: 8,
+    name: "factory-items-org-status-index",
+    sql: `
+      CREATE INDEX IF NOT EXISTS factory_items_org_status_idx
+        ON factory_items (org_id, status, updated_at)
+    `,
+  },
+  {
+    version: 9,
+    name: "factory-decisions-org-created-index",
+    sql: `
+      CREATE INDEX IF NOT EXISTS factory_decisions_org_created_idx
+        ON factory_decisions (org_id, created_at)
+    `,
+  },
+  {
+    version: 10,
+    name: "factory-runs-org-status-index",
+    sql: `
+      CREATE INDEX IF NOT EXISTS factory_runs_org_status_idx
+      ON factory_runs (org_id, status, heartbeat_at)
+    `,
+  },
+  {
+    version: 11,
+    name: "factory-config-slack-history-cursor",
+    sql: `
+      ALTER TABLE factory_config ADD COLUMN slack_history_cursor TEXT
+    `,
+  },
+  {
+    version: 12,
+    name: "factory-runs-executor-metadata",
+    sql: `
+      ALTER TABLE factory_runs ADD COLUMN provider TEXT;
+      ALTER TABLE factory_runs ADD COLUMN provider_task_id TEXT;
+      ALTER TABLE factory_runs ADD COLUMN dedupe_key TEXT;
+      ALTER TABLE factory_runs ADD COLUMN approval_email TEXT;
+    `,
+  },
+  {
+    version: 13,
+    name: "factory-definitions-table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS factory_definitions (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        prompt TEXT NOT NULL DEFAULT '',
+        graph_version INTEGER NOT NULL DEFAULT 1,
+        graph_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        owner_email TEXT NOT NULL,
+        org_id TEXT
+      );
+      CREATE INDEX IF NOT EXISTS factory_definitions_org_updated_idx
+        ON factory_definitions (org_id, updated_at);
+    `,
+  },
+  {
+    version: 14,
+    name: "factory-graph-versions-table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS factory_graph_versions (
+        id TEXT PRIMARY KEY,
+        factory_id TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        graph_json TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'manual',
+        change_summary TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL,
+        created_by TEXT NOT NULL,
+        owner_email TEXT NOT NULL,
+        org_id TEXT
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS factory_graph_versions_unique_idx
+        ON factory_graph_versions (org_id, factory_id, version);
+      CREATE INDEX IF NOT EXISTS factory_graph_versions_created_idx
+        ON factory_graph_versions (org_id, factory_id, created_at);
+    `,
+  },
+  {
+    version: 15,
+    name: "factory-comments-table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS factory_comments (
+        id TEXT PRIMARY KEY,
+        factory_id TEXT NOT NULL,
+        graph_version INTEGER NOT NULL,
+        target_type TEXT NOT NULL DEFAULT 'canvas',
+        target_id TEXT,
+        body TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        owner_email TEXT NOT NULL,
+        org_id TEXT
+      );
+      CREATE INDEX IF NOT EXISTS factory_comments_created_idx
+        ON factory_comments (org_id, factory_id, created_at);
+    `,
+  },
+];
+
+export const runFactoryMigrations = runMigrations(migrations, {
+  table: "factory_migrations",
+});
+
+export default defineNitroPlugin(async (nitroApp) => {
+  await runFactoryMigrations(nitroApp);
+});

package/corpus/templates/factory/server/plugins/factory-scheduler-job.ts

@@ -0,0 +1,116 @@
+import {
+  WORKSPACE_OWNER,
+  resourceGetByPath,
+  resourcePut,
+} from "@agent-native/core/resources";
+import { defineNitroPlugin } from "@agent-native/core/server";
+
+const JOB_PATH = "jobs/factory-observation-scheduler.md";
+
+const JOB_BODY = `
+# Factory observation scheduler
+
+Call get-triage-config. If pollingEnabled is true and a Slack channel is
+configured, call poll-slack-channel. Then call list-triage-items with status
+received and evaluate each returned item with evaluate-triage-item. Keep the
+work bounded to the returned page. This scheduled observer does not start work
+or send provider messages; interactive approvals happen through the Factory agent.
+If any action reports an error, preserve that error and continue to the next
+item; do not report a false success.
+`;
+
+function workspaceOwnerEmail() {
+  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;
+}
+
+function readFrontmatterField(content: string, key: string): string | null {
+  if (!content.startsWith("---\n")) return null;
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return null;
+  const match = content
+    .slice(4, end)
+    .match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
+  return match ? match[1].trim() : null;
+}
+
+function setFrontmatterField(content: string, key: string, value: string) {
+  if (!content.startsWith("---\n")) return content;
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return content;
+  const frontmatter = content.slice(4, end);
+  const pattern = new RegExp(`^${key}:.*$`, "m");
+  if (pattern.test(frontmatter)) {
+    return `---\n${frontmatter.replace(pattern, `${key}: ${value}`)}${content.slice(end)}`;
+  }
+  return `${content.slice(0, end)}\n${key}: ${value}${content.slice(end)}`;
+}
+
+function jobContent(createdBy: string) {
+  return `---
+schedule: "* * * * *"
+enabled: true
+createdBy: ${createdBy}
+runAs: creator
+---
+${JOB_BODY}`;
+}
+
+async function ensureSchedulerJob() {
+  const existing = await resourceGetByPath(WORKSPACE_OWNER, JOB_PATH);
+  const ownerEmail = workspaceOwnerEmail();
+
+  if (!existing) {
+    if (!ownerEmail) {
+      throw new Error(
+        "WORKSPACE_OWNER_EMAIL is required to seed the Factory scheduler",
+      );
+    }
+    await resourcePut(
+      WORKSPACE_OWNER,
+      JOB_PATH,
+      jobContent(ownerEmail),
+      "text/markdown",
+    );
+    return;
+  }
+
+  if (!ownerEmail) {
+    const runAs = readFrontmatterField(existing.content, "runAs");
+    const createdBy = readFrontmatterField(existing.content, "createdBy");
+    if (runAs === "creator" && createdBy) return;
+    throw new Error(
+      "WORKSPACE_OWNER_EMAIL is required to repair the Factory scheduler",
+    );
+  }
+
+  if (
+    !existing.content.startsWith("---\n") ||
+    !existing.content.includes("\n---", 4)
+  ) {
+    await resourcePut(
+      WORKSPACE_OWNER,
+      JOB_PATH,
+      jobContent(ownerEmail),
+      "text/markdown",
+    );
+    return;
+  }
+
+  const migrated = setFrontmatterField(
+    setFrontmatterField(existing.content, "createdBy", ownerEmail),
+    "runAs",
+    "creator",
+  );
+  if (migrated === existing.content) return;
+  await resourcePut(WORKSPACE_OWNER, JOB_PATH, migrated, "text/markdown");
+}
+
+export default defineNitroPlugin(async () => {
+  try {
+    await ensureSchedulerJob();
+  } catch (error) {
+    console.error("[factory-scheduler-job] failed to seed job:", error);
+  }
+});

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

@@ -0,0 +1,46 @@
+import crypto from "node:crypto";
+
+import {
+  createIntegrationsPlugin,
+  loadActionsFromStaticRegistry,
+  slackAdapter,
+  type IncomingMessage,
+} from "@agent-native/core/server";
+
+import actionsRegistry from "../../.generated/actions-registry.js";
+
+function fallbackOwner(incoming: IncomingMessage): string {
+  const tenant = String(
+    incoming.platformContext.teamId ??
+      incoming.platformContext.channelId ??
+      incoming.externalThreadId,
+  );
+  const digest = crypto
+    .createHash("sha256")
+    .update(`${incoming.platform}:${tenant}:${incoming.senderId ?? ""}`)
+    .digest("hex")
+    .slice(0, 16);
+  return `factory+${digest}@integration.local`;
+}
+
+export default createIntegrationsPlugin({
+  appId: "factory",
+  adapters: [slackAdapter()],
+  actions: loadActionsFromStaticRegistry(actionsRegistry),
+  resolveOwner: async (incoming) =>
+    incoming.senderVerified && incoming.senderEmail?.trim()
+      ? incoming.senderEmail.trim().toLowerCase()
+      : fallbackOwner(incoming),
+  systemPrompt: `You are the Factory agent responding through Slack.
+
+Use Factory actions to inspect Slack and pull-request evidence, explain decisions,
+record human feedback, and tune rules. If a user asks to start work, first
+inspect the item and its hard guard results. "Do it now" means explicit human
+approval of that one item, so call approve-factory-item with the item and decision
+identified in the thread. Never claim a coding agent, PR, merge, assignment, or
+provider message exists until the returned run state confirms it. If the item
+is protected, incomplete, unreadable, or missing a terminal callback, explain
+that a human must intervene and include the Factory item URL when available.
+
+Keep replies concise and operational.`,
+});

package/corpus/templates/factory/server/routes/[...page].get.ts

@@ -0,0 +1,5 @@
+import { createH3SSRHandler } from "@agent-native/core/server/ssr-handler";
+
+export default createH3SSRHandler(
+  () => import("virtual:react-router/server-build"),
+);

package/corpus/templates/factory/server/routes/_agent-native/factory/builder-callback.post.ts

@@ -0,0 +1,116 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+import { and, eq } from "drizzle-orm";
+import {
+  getRequestHeader,
+  getQuery,
+  readRawBody,
+  setResponseStatus,
+  type H3Event,
+} from "h3";
+import { defineEventHandler } from "h3";
+
+import { resolveConnectorSecret } from "../../../connectors/credentials.js";
+import { getDb } from "../../../db/index.js";
+import { triageItems, triageRuns } from "../../../db/schema.js";
+
+export default defineEventHandler(async (event: H3Event) => {
+  const runId = String(getQuery(event).runId ?? "").trim();
+  if (!runId) {
+    setResponseStatus(event, 400);
+    return { ok: false, error: "runId is required" };
+  }
+  const rawBody = (await readRawBody(event)) ?? "";
+  let payload: {
+    status?: string;
+    taskId?: string;
+    id?: string;
+    error?: string;
+  };
+  try {
+    payload = JSON.parse(rawBody) as typeof payload;
+  } catch {
+    setResponseStatus(event, 400);
+    return { ok: false, error: "Invalid JSON body" };
+  }
+
+  const db = getDb();
+  const run = (
+    await db
+      .select({
+        id: triageRuns.id,
+        ownerEmail: triageRuns.ownerEmail,
+        orgId: triageRuns.orgId,
+        itemId: triageRuns.itemId,
+      })
+      .from(triageRuns)
+      .where(eq(triageRuns.id, runId))
+      .limit(1)
+  )[0];
+  if (!run || !run.orgId) {
+    setResponseStatus(event, 404);
+    return { ok: false, error: "Factory run not found" };
+  }
+
+  const secret = await resolveConnectorSecret(
+    "FACTORY_BUILDER_WEBHOOK_SECRET",
+    run.ownerEmail,
+    {
+      orgId: run.orgId,
+    },
+  );
+  const signature = getRequestHeader(event, "x-builder-signature") ?? "";
+  if (!secret || !verifySignature(rawBody, signature, secret)) {
+    setResponseStatus(event, secret ? 401 : 503);
+    return {
+      ok: false,
+      error: secret
+        ? "Invalid Builder callback signature"
+        : "Callback secret is not configured",
+    };
+  }
+
+  const now = new Date().toISOString();
+  const terminal = payload.status === "success" ? "completed" : "failed";
+  const reason =
+    payload.status === "success"
+      ? "Builder reported a successful terminal callback."
+      : payload.error?.trim() || "Builder reported an error terminal callback.";
+  const progress = [{ at: now, state: terminal, reason }];
+  await db
+    .update(triageRuns)
+    .set({
+      status: terminal,
+      providerTaskId: payload.taskId ?? payload.id ?? undefined,
+      progressLogJson: JSON.stringify(progress),
+      heartbeatAt: now,
+      completedAt: now,
+      error: terminal === "failed" ? reason : null,
+    })
+    .where(and(eq(triageRuns.id, runId), eq(triageRuns.orgId, run.orgId)));
+  await db
+    .update(triageItems)
+    .set({
+      status: terminal === "completed" ? "evidence_ready" : "failed",
+      updatedAt: now,
+    })
+    .where(
+      and(eq(triageItems.id, run.itemId), eq(triageItems.orgId, run.orgId)),
+    );
+
+  return { ok: true, runId, status: terminal };
+});
+
+function verifySignature(
+  rawBody: string,
+  signature: string,
+  secret: string,
+): boolean {
+  const expected = `sha256=${createHmac("sha256", secret).update(rawBody).digest("hex")}`;
+  const actualBytes = Buffer.from(signature);
+  const expectedBytes = Buffer.from(expected);
+  return (
+    actualBytes.length === expectedBytes.length &&
+    timingSafeEqual(actualBytes, expectedBytes)
+  );
+}