@agent-native/core 0.168.7 → 0.168.9

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

@@ -0,0 +1,136 @@
+export const PR_AUTOMATIONS = [
+  "factory-pr-governance",
+  "factory-pr-babysit",
+] as const;
+
+export function resolveEnabledAutomations(input: {
+  observeSlack: boolean;
+  slackChannelId?: string;
+  observeGithub: boolean;
+  repository?: string;
+  observeSentry: boolean;
+  sentryOrgSlug?: string;
+  sentryProjectSlug?: string;
+}): {
+  enabledNames: Set<string>;
+  pollingEnabled: boolean;
+  githubPollingEnabled: boolean;
+  sentryPollingEnabled: boolean;
+  hasConfig: boolean;
+} {
+  const enabledNames = new Set<string>();
+  let pollingEnabled = false;
+  let githubPollingEnabled = false;
+  let sentryPollingEnabled = false;
+  let hasConfig = false;
+
+  if (input.observeSlack) {
+    if (!input.slackChannelId?.trim()) {
+      throw new Error(
+        "Configure a Slack channel before enabling Slack observation.",
+      );
+    }
+    enabledNames.add("factory-slack-feedback");
+    pollingEnabled = true;
+    hasConfig = true;
+  }
+
+  if (input.observeGithub) {
+    if (!input.repository?.trim()) {
+      throw new Error(
+        "Configure a GitHub repository before enabling GitHub observation.",
+      );
+    }
+    enabledNames.add("factory-github-issues");
+    githubPollingEnabled = true;
+    hasConfig = true;
+  }
+
+  if (input.repository?.trim()) {
+    for (const name of PR_AUTOMATIONS) enabledNames.add(name);
+    hasConfig = true;
+  }
+
+  if (input.observeSentry) {
+    if (!input.sentryOrgSlug?.trim() || !input.sentryProjectSlug?.trim()) {
+      throw new Error(
+        "Configure Sentry organization and project slugs before enabling Sentry observation.",
+      );
+    }
+    enabledNames.add("factory-sentry-errors");
+    sentryPollingEnabled = true;
+    hasConfig = true;
+  }
+
+  return {
+    enabledNames,
+    pollingEnabled,
+    githubPollingEnabled,
+    sentryPollingEnabled,
+    hasConfig,
+  };
+}
+
+export function resolveEnabledAutomationsFromSavedConfig(config: {
+  pollingEnabled: boolean | number;
+  githubPollingEnabled: boolean | number;
+  sentryPollingEnabled: boolean | number;
+  slackChannelId?: string | null;
+  repository?: string | null;
+  sentryOrgSlug?: string | null;
+  sentryProjectSlug?: string | null;
+}): Set<string> {
+  const enabledNames = new Set<string>();
+  const pollingEnabled =
+    config.pollingEnabled === true || config.pollingEnabled === 1;
+  const githubPollingEnabled =
+    config.githubPollingEnabled === true || config.githubPollingEnabled === 1;
+  const sentryPollingEnabled =
+    config.sentryPollingEnabled === true || config.sentryPollingEnabled === 1;
+
+  if (pollingEnabled && config.slackChannelId?.trim()) {
+    enabledNames.add("factory-slack-feedback");
+  }
+  if (githubPollingEnabled && config.repository?.trim()) {
+    enabledNames.add("factory-github-issues");
+  }
+  if (config.repository?.trim()) {
+    for (const name of PR_AUTOMATIONS) enabledNames.add(name);
+  }
+  if (
+    sentryPollingEnabled &&
+    config.sentryOrgSlug?.trim() &&
+    config.sentryProjectSlug?.trim()
+  ) {
+    enabledNames.add("factory-sentry-errors");
+  }
+  return enabledNames;
+}
+
+export function isFactoryIdConflict(error: unknown): boolean {
+  const message = String(
+    (error as { message?: unknown } | null)?.message ?? "",
+  ).toLowerCase();
+  const code = String((error as { code?: unknown } | null)?.code ?? "");
+  return (
+    code === "23505" ||
+    code === "SQLITE_CONSTRAINT_PRIMARYKEY" ||
+    code === "SQLITE_CONSTRAINT_UNIQUE" ||
+    message.includes("unique constraint") ||
+    message.includes("duplicate key") ||
+    message.includes("primary key")
+  );
+}
+
+export function isFactorySlackChannelConflict(error: unknown): boolean {
+  const message = String(
+    (error as { message?: unknown } | null)?.message ?? "",
+  ).toLowerCase();
+  const code = String((error as { code?: unknown } | null)?.code ?? "");
+  const unique =
+    code === "23505" ||
+    code === "SQLITE_CONSTRAINT_UNIQUE" ||
+    message.includes("unique constraint") ||
+    message.includes("duplicate key");
+  return unique && message.includes("slack_channel");
+}

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

@@ -0,0 +1,31 @@
+import { getDb } from "../db/index.js";
+import {
+  ensureFactoryAutomations,
+  syncFactoryAutomationEnabledStates,
+} from "../plugins/factory-scheduler-job.js";
+import { resolveEnabledAutomationsFromSavedConfig } from "./factory-automation-plan.js";
+import { readTriageConfigRow } from "./factory-scope.js";
+
+export async function repairFactoryAutomationsFromConfig(
+  ownerEmail: string,
+  orgId: string,
+  factoryId: string,
+): Promise<void> {
+  const config = await readTriageConfigRow(getDb(), orgId, factoryId);
+  if (!config) return;
+  const enabledNames = resolveEnabledAutomationsFromSavedConfig({
+    pollingEnabled: config.pollingEnabled,
+    githubPollingEnabled: config.githubPollingEnabled,
+    sentryPollingEnabled: config.sentryPollingEnabled,
+    slackChannelId: config.slackChannelId,
+    repository: config.repository,
+    sentryOrgSlug: config.sentryOrgSlug,
+    sentryProjectSlug: config.sentryProjectSlug,
+  });
+  await ensureFactoryAutomations(ownerEmail, orgId, factoryId, {
+    enabledNames,
+  });
+  await syncFactoryAutomationEnabledStates(ownerEmail, orgId, factoryId, [
+    ...enabledNames,
+  ]);
+}

package/corpus/templates/factory/server/lib/factory-scope.ts

@@ -0,0 +1,416 @@
+import { and, eq, type AnyColumn, type SQL } from "drizzle-orm";
+import { z } from "zod";
+
+import type { getDb } from "../db/index.js";
+import {
+  factoryDefinitions,
+  factoryGraphVersions,
+  triageConfig,
+  triageDecisions,
+  triageFeedback,
+  triageItems,
+  triageRules,
+  triageRuns,
+} from "../db/schema.js";
+import { DEFAULT_FACTORY_ID } from "../factory-graph/store.js";
+
+export { DEFAULT_FACTORY_ID };
+
+export const factoryIdSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(120)
+  .regex(/^[a-z0-9][a-z0-9-]*$/);
+
+export function factoryConfigRowId(orgId: string, factoryId: string): string {
+  return `${orgId}:${factoryId}`;
+}
+
+const MAX_FACTORY_ID_LENGTH = 120;
+
+export function slugifyFactoryId(name: string): string {
+  const normalized = name
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-+/g, "-")
+    .slice(0, 100);
+  const base =
+    normalized && /^[a-z0-9]/.test(normalized)
+      ? normalized
+      : `factory-${normalized || "untitled"}`;
+  return base.slice(0, MAX_FACTORY_ID_LENGTH);
+}
+
+export function factoryIdCandidateWithSuffix(
+  base: string,
+  suffix: number,
+): string {
+  const suffixText = `-${suffix}`;
+  const maxBaseLength = MAX_FACTORY_ID_LENGTH - suffixText.length;
+  return `${base.slice(0, maxBaseLength)}${suffixText}`;
+}
+
+export async function resolveUniqueFactoryId(
+  db: Db,
+  orgId: string,
+  name: string,
+): Promise<string> {
+  const base = slugifyFactoryId(name);
+  let candidate = base;
+  let suffix = 2;
+  while (await factoryIdTaken(db, orgId, candidate)) {
+    candidate = factoryIdCandidateWithSuffix(base, suffix);
+    suffix += 1;
+  }
+  return candidate;
+}
+
+async function factoryIdTaken(
+  db: Db,
+  orgId: string,
+  factoryId: string,
+): Promise<boolean> {
+  const definition = (
+    await db
+      .select({ id: factoryDefinitions.id })
+      .from(factoryDefinitions)
+      .where(eq(factoryDefinitions.id, factoryId))
+      .limit(1)
+  )[0];
+  if (definition) return true;
+
+  const config = (
+    await db
+      .select({ factoryId: triageConfig.factoryId })
+      .from(triageConfig)
+      .where(
+        and(
+          eq(triageConfig.orgId, orgId),
+          eq(triageConfig.factoryId, factoryId),
+        ),
+      )
+      .limit(1)
+  )[0];
+  if (config) return true;
+
+  const graphVersion = (
+    await db
+      .select({ factoryId: factoryGraphVersions.factoryId })
+      .from(factoryGraphVersions)
+      .where(
+        and(
+          eq(factoryGraphVersions.orgId, orgId),
+          eq(factoryGraphVersions.factoryId, factoryId),
+        ),
+      )
+      .limit(1)
+  )[0];
+  return Boolean(graphVersion);
+}
+
+export function legacyFactoryConfigRowId(orgId: string): string {
+  return orgId;
+}
+
+/** Row id to use when persisting poll cursors — follows the loaded config row. */
+export function triageConfigUpdateRowId(
+  config: { id: string } | null | undefined,
+  orgId: string,
+  factoryId: string,
+): string {
+  return config?.id ?? factoryConfigRowId(orgId, factoryId);
+}
+
+type Db = ReturnType<typeof getDb>;
+
+export async function readTriageConfigRow(
+  db: Db,
+  orgId: string,
+  factoryId: string,
+) {
+  const scopedId = factoryConfigRowId(orgId, factoryId);
+  const scoped = (
+    await db
+      .select()
+      .from(triageConfig)
+      .where(and(eq(triageConfig.id, scopedId), eq(triageConfig.orgId, orgId)))
+      .limit(1)
+  )[0];
+  if (scoped) return scoped;
+  if (factoryId !== DEFAULT_FACTORY_ID) return undefined;
+  return (
+    await db
+      .select()
+      .from(triageConfig)
+      .where(
+        and(
+          eq(triageConfig.id, legacyFactoryConfigRowId(orgId)),
+          eq(triageConfig.orgId, orgId),
+        ),
+      )
+      .limit(1)
+  )[0];
+}
+
+export function orgFactoryFilter(
+  table: { orgId: AnyColumn; factoryId: AnyColumn },
+  orgId: string,
+  factoryId: string,
+): SQL {
+  return and(eq(table.orgId, orgId), eq(table.factoryId, factoryId))!;
+}
+
+export function orgFactoryItemFilter(orgId: string, factoryId: string): SQL {
+  return orgFactoryFilter(triageItems, orgId, factoryId);
+}
+
+export function orgFactoryScopedItemWhere(
+  itemId: string,
+  orgId: string,
+  factoryId: string,
+): SQL {
+  return and(
+    eq(triageItems.id, itemId),
+    orgFactoryItemFilter(orgId, factoryId),
+  )!;
+}
+
+export function orgFactoryRuleFilter(orgId: string, factoryId: string): SQL {
+  return orgFactoryFilter(triageRules, orgId, factoryId);
+}
+
+export function orgFactoryDecisionFilter(
+  orgId: string,
+  factoryId: string,
+): SQL {
+  return orgFactoryFilter(triageDecisions, orgId, factoryId);
+}
+
+export function orgFactoryRunFilter(orgId: string, factoryId: string): SQL {
+  return orgFactoryFilter(triageRuns, orgId, factoryId);
+}
+
+export function orgFactoryFeedbackFilter(
+  orgId: string,
+  factoryId: string,
+): SQL {
+  return orgFactoryFilter(triageFeedback, orgId, factoryId);
+}
+
+export function resolveAutomationFactoryId(
+  meta: Record<string, unknown> | object | undefined,
+): string {
+  const raw =
+    meta && typeof meta === "object" && "factoryId" in meta
+      ? (meta as { factoryId?: unknown }).factoryId
+      : undefined;
+  return typeof raw === "string" && raw.trim()
+    ? raw.trim()
+    : DEFAULT_FACTORY_ID;
+}
+
+function readFrontmatterFactoryId(content: string): string | undefined {
+  if (!content.startsWith("---\n")) return undefined;
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return undefined;
+  const match = content.slice(4, end).match(/^factoryId:\s*(.*)$/m);
+  const value = match?.[1]?.trim();
+  if (!value) return undefined;
+  return value.replace(/^(\"|')|((\"|')$)/g, "");
+}
+
+export function readAutomationFactoryId(meta: object, content: string): string {
+  const fromContent = readFrontmatterFactoryId(content);
+  return resolveAutomationFactoryId(
+    fromContent ? { ...meta, factoryId: fromContent } : meta,
+  );
+}
+
+export function factoryAutomationJobPath(
+  factoryId: string,
+  automationName: string,
+): string {
+  if (factoryId === DEFAULT_FACTORY_ID) {
+    return `jobs/${automationName}.md`;
+  }
+  return `jobs/factories/${factoryId}/${automationName}.md`;
+}
+
+export function legacyFactoryAutomationJobPath(automationName: string): string {
+  return `jobs/${automationName}.md`;
+}
+
+export function isLegacyFactoryAutomationPath(path: string): boolean {
+  return /^jobs\/factory-[^/]+\.md$/.test(path);
+}
+
+export function readFactoryIdFromAutomationPath(path: string): string | null {
+  const match = path.match(/^jobs\/factories\/([^/]+)\/factory-[^/]+\.md$/);
+  return match?.[1] ?? null;
+}
+
+export async function findFactoryIdForSlackChannel(
+  db: Db,
+  orgId: string,
+  channelId: string,
+): Promise<string | null> {
+  const rows = await db
+    .select({
+      factoryId: triageConfig.factoryId,
+      slackChannelId: triageConfig.slackChannelId,
+    })
+    .from(triageConfig)
+    .where(
+      and(
+        eq(triageConfig.orgId, orgId),
+        eq(triageConfig.slackChannelId, channelId),
+      ),
+    );
+  const factoryIds = rows
+    .map((row) => row.factoryId)
+    .filter((value): value is string => Boolean(value?.trim()));
+  if (factoryIds.length === 1) return factoryIds[0]!;
+  return null;
+}
+
+export async function assertUniqueSlackChannelForFactory(
+  db: Db,
+  orgId: string,
+  factoryId: string,
+  channelId: string | null | undefined,
+): Promise<void> {
+  const normalized = channelId?.trim();
+  if (!normalized) return;
+  const conflict = (
+    await db
+      .select({ factoryId: triageConfig.factoryId })
+      .from(triageConfig)
+      .where(
+        and(
+          eq(triageConfig.orgId, orgId),
+          eq(triageConfig.slackChannelId, normalized),
+        ),
+      )
+  ).find((row) => row.factoryId && row.factoryId !== factoryId);
+  if (conflict) {
+    throw new Error(
+      "That Slack channel is already used by another Factory in this workspace.",
+    );
+  }
+}
+
+function readFrontmatterField(
+  content: string,
+  key: string,
+): string | undefined {
+  if (!content.startsWith("---\n")) return undefined;
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return undefined;
+  const match = content
+    .slice(4, end)
+    .match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
+  const value = match?.[1]?.trim();
+  if (!value) return undefined;
+  return value.replace(/^(\"|')|((\"|')$)/g, "");
+}
+
+export function readAutomationDisplayName(content: string): string | null {
+  const value = readFrontmatterField(content, "displayName")?.trim();
+  return value || null;
+}
+
+export function resolveAutomationDisplayName(
+  automationName: string,
+  content: string,
+): string {
+  return readAutomationDisplayName(content) ?? automationName;
+}
+
+export function setAutomationFrontmatterField(
+  content: string,
+  key: string,
+  value: string,
+): string {
+  if (!content.startsWith("---\n")) return content;
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return content;
+  const trimmed = value.trim();
+  const frontmatter = content.slice(4, end);
+  const pattern = new RegExp(`^${key}:.*\\n?`, "m");
+  if (!trimmed) {
+    if (!pattern.test(frontmatter)) return content;
+    const nextFrontmatter = frontmatter.replace(pattern, "").trimEnd();
+    return nextFrontmatter
+      ? `---\n${nextFrontmatter}${content.slice(end)}`
+      : content;
+  }
+  if (pattern.test(frontmatter)) {
+    return `---\n${frontmatter.replace(pattern, `${key}: ${trimmed}\n`)}${content.slice(end)}`;
+  }
+  return `${content.slice(0, end)}\n${key}: ${trimmed}${content.slice(end)}`;
+}
+
+export function replaceAutomationBody(content: string, body: string): string {
+  if (!content.startsWith("---\n")) return content;
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return content;
+  const trimmedBody = body.trim();
+  return `${content.slice(0, end + 4)}\n${trimmedBody ? `${trimmedBody}\n` : ""}`;
+}
+
+export function patchAutomationResource(
+  content: string,
+  patch: {
+    body?: string;
+    enabled?: boolean;
+    schedule?: string;
+    model?: string | null;
+    displayName?: string;
+  },
+): string {
+  let next =
+    patch.body === undefined
+      ? content
+      : replaceAutomationBody(content, patch.body);
+  if (patch.enabled !== undefined) {
+    next = setAutomationFrontmatterField(
+      next,
+      "enabled",
+      patch.enabled ? "true" : "false",
+    );
+  }
+  if (patch.schedule !== undefined) {
+    next = setAutomationFrontmatterField(next, "schedule", patch.schedule);
+  }
+  if (patch.model !== undefined) {
+    next = setAutomationFrontmatterField(
+      next,
+      "model",
+      patch.model?.trim() ?? "",
+    );
+  }
+  if (patch.displayName !== undefined) {
+    next = setAutomationFrontmatterField(
+      next,
+      "displayName",
+      patch.displayName,
+    );
+  }
+  return next;
+}
+
+export function readAutomationEnabled(content: string): boolean {
+  const value = readFrontmatterField(content, "enabled")?.trim().toLowerCase();
+  return value === "true" || value === "1" || value === "yes";
+}
+
+export function readAutomationSchedule(content: string): string | null {
+  return readFrontmatterField(content, "schedule")?.trim() || null;
+}
+
+export function readAutomationModel(content: string): string | null {
+  return readFrontmatterField(content, "model")?.trim() || null;
+}

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

@@ -1,6 +1,7 @@
 import type { ActionRunContext } from "@agent-native/core/action";
 import { listAutomationDefinitions } from "@agent-native/core/triggers";
 
+import { readAutomationFactoryId } from "./factory-scope.js";
 import type { WorkspaceMemberIdentity } from "./require-workspace-member.js";
 
 const FACTORY_AUTOMATION_NAMES = {
@@ -31,6 +32,7 @@ export async function requireFactoryAutomation(
   context: ActionRunContext | undefined,
   identity: Pick<WorkspaceMemberIdentity, "userEmail" | "orgId">,
   role: FactoryAutomationRole,
+  expectedFactoryId?: string,
 ): Promise<void> {
   if (context?.caller !== "automation") {
     throw new Error("This action is only available to Factory automations.");
@@ -67,4 +69,13 @@ export async function requireFactoryAutomation(
       "The action was not invoked by a governed Factory automation.",
     );
   }
+  if (
+    expectedFactoryId &&
+    readAutomationFactoryId(definition.meta, definition.resource.content) !==
+      expectedFactoryId
+  ) {
+    throw new Error(
+      "The action was not invoked by a governed Factory automation.",
+    );
+  }
 }

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

@@ -70,8 +70,10 @@ provider keys per factory. Start with provider-api-catalog to discover the
 workspace's connected provider APIs, use provider-api-docs when an endpoint is
 unclear, and use provider-api-request with the shared credentials. The normalized
 poll-slack-channel, poll-github-sources, and poll-sentry-errors actions are legacy
-observer adapters for the default triage queue, not a list of Factory integrations
-or a limit on what agents can use.
+observer adapters scoped by factoryId (pass the current factory from automation
+meta or navigation), not a list of Factory integrations or a limit on what agents
+can use. Triage config, inbox, rules, automations, and activity are per-factory;
+reusable agents and workspace integrations stay shared.
 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.