@okrlinkhub/agent-factory 2.0.3 → 3.0.1

package/src/component/messageTemplates.ts

@@ -0,0 +1,205 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+import type { MutationCtx } from "./_generated/server.js";
+
+const messageTemplateViewValidator = v.object({
+  _id: v.id("messageTemplates"),
+  templateKey: v.string(),
+  title: v.string(),
+  text: v.string(),
+  tags: v.array(v.string()),
+  usageCount: v.number(),
+  enabled: v.boolean(),
+  createdBy: v.string(),
+  updatedBy: v.string(),
+  createdAt: v.number(),
+  updatedAt: v.number(),
+});
+
+function normalizeTemplateKey(value: string) {
+  return value.trim().toLowerCase();
+}
+
+function buildTemplateKeyBase(title: string) {
+  const normalized = title
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return normalized || "message-template";
+}
+
+function normalizeTitle(value: string) {
+  return value.trim();
+}
+
+function normalizeText(value: string) {
+  return value.trim();
+}
+
+function normalizeTags(tags: Array<string>) {
+  return Array.from(
+    new Set(
+      tags
+        .map((tag) => tag.trim().toLowerCase())
+        .filter((tag) => tag.length > 0),
+    ),
+  ).sort((left, right) => left.localeCompare(right));
+}
+
+function validateMessageTemplateFields(input: {
+  title?: string;
+  text?: string;
+}) {
+  if (input.title !== undefined && input.title.length === 0) {
+    throw new Error("Template title is required");
+  }
+  if (input.text !== undefined && input.text.length === 0) {
+    throw new Error("Template text is required");
+  }
+}
+
+async function resolveUniqueTemplateKey(
+  ctx: MutationCtx,
+  title: string,
+  currentTemplateId?: string,
+) {
+  const baseKey = buildTemplateKeyBase(title);
+  let candidate = baseKey;
+  let suffix = 2;
+
+  while (true) {
+    const existing = await ctx.db
+      .query("messageTemplates")
+      .withIndex("by_templateKey", (q) => q.eq("templateKey", candidate))
+      .unique();
+    if (!existing || String(existing._id) === currentTemplateId) {
+      return candidate;
+    }
+    candidate = `${baseKey}-${suffix}`;
+    suffix += 1;
+  }
+}
+
+export const createMessageTemplate = mutation({
+  args: {
+    title: v.string(),
+    text: v.string(),
+    tags: v.array(v.string()),
+    enabled: v.optional(v.boolean()),
+    actorUserId: v.string(),
+    nowMs: v.optional(v.number()),
+  },
+  returns: v.id("messageTemplates"),
+  handler: async (ctx, args) => {
+    const title = normalizeTitle(args.title);
+    const text = normalizeText(args.text);
+    const tags = normalizeTags(args.tags);
+    validateMessageTemplateFields({ title, text });
+    const templateKey = normalizeTemplateKey(await resolveUniqueTemplateKey(ctx, title));
+
+    const nowMs = args.nowMs ?? Date.now();
+    return await ctx.db.insert("messageTemplates", {
+      templateKey,
+      title,
+      text,
+      tags,
+      usageCount: 0,
+      enabled: args.enabled ?? true,
+      createdBy: args.actorUserId,
+      updatedBy: args.actorUserId,
+      createdAt: nowMs,
+      updatedAt: nowMs,
+    });
+  },
+});
+
+export const updateMessageTemplate = mutation({
+  args: {
+    templateId: v.id("messageTemplates"),
+    title: v.optional(v.string()),
+    text: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+    enabled: v.optional(v.boolean()),
+    actorUserId: v.string(),
+    nowMs: v.optional(v.number()),
+  },
+  returns: v.boolean(),
+  handler: async (ctx, args) => {
+    const template = await ctx.db.get(args.templateId);
+    if (!template) return false;
+
+    const title = args.title !== undefined ? normalizeTitle(args.title) : template.title;
+    const text = args.text !== undefined ? normalizeText(args.text) : template.text;
+    const tags = args.tags !== undefined ? normalizeTags(args.tags) : template.tags;
+    validateMessageTemplateFields({ title, text });
+    const templateKey =
+      title !== template.title
+        ? normalizeTemplateKey(await resolveUniqueTemplateKey(ctx, title, String(template._id)))
+        : template.templateKey;
+
+    const nowMs = args.nowMs ?? Date.now();
+    await ctx.db.patch(template._id, {
+      templateKey,
+      title,
+      text,
+      tags,
+      enabled: args.enabled ?? template.enabled,
+      updatedBy: args.actorUserId,
+      updatedAt: nowMs,
+    });
+    return true;
+  },
+});
+
+export const deleteMessageTemplate = mutation({
+  args: {
+    templateId: v.id("messageTemplates"),
+  },
+  returns: v.boolean(),
+  handler: async (ctx, args) => {
+    const template = await ctx.db.get(args.templateId);
+    if (!template) return false;
+    await ctx.db.delete(template._id);
+    return true;
+  },
+});
+
+export const listMessageTemplatesByCompany = query({
+  args: {
+    includeDisabled: v.optional(v.boolean()),
+    limit: v.optional(v.number()),
+  },
+  returns: v.array(messageTemplateViewValidator),
+  handler: async (ctx, args) => {
+    const includeDisabled = args.includeDisabled ?? false;
+    const limit = Math.max(1, Math.min(args.limit ?? 100, 200));
+
+    const rows = includeDisabled
+      ? await ctx.db.query("messageTemplates").take(limit)
+      : await ctx.db
+          .query("messageTemplates")
+          .withIndex("by_enabled", (q) => q.eq("enabled", true))
+          .take(limit);
+
+    rows.sort((left, right) => {
+      if (right.usageCount !== left.usageCount) {
+        return right.usageCount - left.usageCount;
+      }
+      return right.updatedAt - left.updatedAt;
+    });
+    return rows.map((row) => ({
+      _id: row._id,
+      templateKey: row.templateKey,
+      title: row.title,
+      text: row.text,
+      tags: row.tags,
+      usageCount: row.usageCount,
+      enabled: row.enabled,
+      createdBy: row.createdBy,
+      updatedBy: row.updatedBy,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    }));
+  },
+});

package/src/component/queue.ts

@@ -208,7 +208,6 @@ const globalSkillManifestItemValidator = v.object({
   version: v.string(),
   moduleFormat: globalSkillModuleFormatValidator,
   entryPoint: v.string(),
-  sourceJs: v.string(),
   sha256: v.string(),
   skillDirName: v.string(),
   files: v.array(globalSkillManifestFileValidator),
@@ -742,7 +741,7 @@ export const deployGlobalSkill = mutation({
     displayName: v.optional(v.string()),
     description: v.optional(v.string()),
     version: v.string(),
-    sourceJs: v.string(),
+    files: v.array(globalSkillManifestFileValidator),
     entryPoint: v.optional(v.string()),
     moduleFormat: v.optional(globalSkillModuleFormatValidator),
     releaseChannel: v.optional(globalSkillReleaseChannelValidator),
@@ -766,7 +765,7 @@ export const deployGlobalSkill = mutation({
     const releaseChannel = args.releaseChannel ?? "stable";
     const moduleFormat = args.moduleFormat ?? "esm";
     const actor = args.actor?.trim() || "system";
-    const sourceJs = args.sourceJs.trim();
+    const files = await normalizeGlobalSkillBundleFiles(args.files, moduleFormat);
 
     if (!/^[a-z0-9][a-z0-9-_]{1,127}$/.test(slug)) {
       throw new Error("Invalid skill slug. Use lowercase letters, numbers, '-' and '_'.");
@@ -774,17 +773,11 @@ export const deployGlobalSkill = mutation({
     if (!/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/.test(version)) {
       throw new Error("Invalid skill version. Use semantic versioning format.");
     }
-    if (sourceJs.length < 16) {
-      throw new Error("Skill source is too short.");
-    }
-    if (sourceJs.length > 200_000) {
-      throw new Error("Skill source too large (max 200KB).");
-    }
     if (!entryPoint) {
       throw new Error("entryPoint is required.");
     }
 
-    const sha256 = await computeSha256Hex(sourceJs);
+    const sha256 = await computeGlobalSkillBundleSha256(files);
 
     const existingSkill = await ctx.db
       .query("globalSkills")
@@ -826,13 +819,17 @@ export const deployGlobalSkill = mutation({
         version,
         moduleFormat,
         entryPoint,
-        sourceJs,
+        files,
         sha256,
         createdBy: actor,
         createdAt: nowMs,
       });
-    } else if (existingVersion.sha256 !== sha256) {
-      throw new Error(`Skill ${slug}@${version} already exists with a different source.`);
+    } else if (
+      existingVersion.sha256 !== sha256 ||
+      existingVersion.moduleFormat !== moduleFormat ||
+      existingVersion.entryPoint !== entryPoint
+    ) {
+      throw new Error(`Skill ${slug}@${version} already exists with a different bundle.`);
     }
 
     const activeReleases = await ctx.db
@@ -993,7 +990,6 @@ export const getWorkerGlobalSkillsManifest = query({
       version: string;
       moduleFormat: "esm" | "cjs";
       entryPoint: string;
-      sourceJs: string;
       sha256: string;
       skillDirName: string;
       files: Array<{
@@ -1019,7 +1015,7 @@ export const getWorkerGlobalSkillsManifest = query({
         version: version.version,
         moduleFormat: version.moduleFormat,
         entryPoint: version.entryPoint,
-        sourceJs: version.sourceJs,
+        files: version.files,
         sha256: version.sha256,
       });
       manifestSkills.push({
@@ -1027,7 +1023,6 @@ export const getWorkerGlobalSkillsManifest = query({
         version: version.version,
         moduleFormat: version.moduleFormat,
         entryPoint: version.entryPoint,
-        sourceJs: version.sourceJs,
         sha256: version.sha256,
         skillDirName: materializedSkill.skillDirName,
         files: materializedSkill.files,
@@ -1040,7 +1035,14 @@ export const getWorkerGlobalSkillsManifest = query({
     });
 
     const fingerprintSeed = manifestSkills
-      .map((row) => `${row.slug}@${row.version}:${row.sha256}`)
+      .map(
+        (row) =>
+          `${row.slug}@${row.version}:${row.sha256}:${row.files
+            .filter((file) => file.path !== ".af-global-skill.json")
+            .map((file) => `${file.path}:${file.sha256}`)
+            .sort()
+            .join(",")}`,
+      )
       .join("|");
     const manifestVersion = await computeSha256Hex(fingerprintSeed || "empty");
 
@@ -2011,6 +2013,67 @@ export const sendMessageToUserAgent = mutation({
   },
 });
 
+export const sendMessageTemplateToUserAgent = mutation({
+  args: {
+    consumerUserId: v.string(),
+    agentKey: v.string(),
+    templateId: v.id("messageTemplates"),
+    metadata: v.optional(v.record(v.string(), v.string())),
+    nowMs: v.optional(v.number()),
+    providerConfig: v.optional(providerConfigValidator),
+  },
+  returns: v.object({
+    messageId: v.id("messageQueue"),
+    usageCount: v.number(),
+  }),
+  handler: async (ctx, args) => {
+    const template = await ctx.db.get(args.templateId);
+    if (!template || !template.enabled) {
+      throw new Error("Message template not found");
+    }
+
+    const nowMs = args.nowMs ?? Date.now();
+    const target = await resolveConversationTargetForUserAgent(
+      ctx,
+      args.consumerUserId,
+      args.agentKey,
+      true,
+    );
+    const providerUserId =
+      target.telegramUserId ?? target.telegramChatId ?? args.consumerUserId;
+    const usageCount = template.usageCount + 1;
+    const messageId = await enqueueMessageRecord(ctx, {
+      conversationId: target.conversationId,
+      agentKey: args.agentKey,
+      payload: {
+        provider: target.provider,
+        providerUserId,
+        messageText: template.text,
+        metadata: {
+          ...(args.metadata ?? {}),
+          consumerUserId: args.consumerUserId,
+          source: "message_template",
+          templateId: String(template._id),
+          templateKey: template.templateKey,
+          ...(target.telegramChatId ? { telegramChatId: target.telegramChatId } : {}),
+          ...(target.telegramUserId ? { telegramUserId: target.telegramUserId } : {}),
+        },
+      },
+      scheduledFor: nowMs,
+      providerConfig: args.providerConfig,
+    });
+
+    await ctx.db.patch(template._id, {
+      usageCount,
+    });
+
+    return {
+      messageId,
+      usageCount,
+    };
+  },
+});
+
 export const listSnapshotsForConversation = query({
   args: {
     conversationId: v.string(),
@@ -3414,7 +3477,11 @@ async function buildGlobalSkillMaterialization(skill: {
   version: string;
   moduleFormat: "esm" | "cjs";
   entryPoint: string;
-  sourceJs: string;
+  files: Array<{
+    path: string;
+    content: string;
+    sha256: string;
+  }>;
   sha256: string;
 }): Promise<{
   skillDirName: string;
@@ -3425,26 +3492,11 @@ async function buildGlobalSkillMaterialization(skill: {
   }>;
 }> {
   const skillDirName = normalizeGlobalSkillDirName(skill.slug);
-  const scriptExt = skill.moduleFormat === "cjs" ? "cjs" : "mjs";
-  const scriptRelativePath = `scripts/index.${scriptExt}`;
-  const skillMd = [
-    "---",
-    `name: ${skill.slug}`,
-    `description: Global skill ${skill.slug}@${skill.version} provisioned by agent-factory.`,
-    "---",
-    "",
-    "# Global Skill",
-    "",
-    "This skill is generated automatically from agent-factory globalSkills.",
-    "",
-    `- slug: ${skill.slug}`,
-    `- version: ${skill.version}`,
-    `- entryPoint: ${skill.entryPoint}`,
-    `- moduleFormat: ${skill.moduleFormat}`,
-    "",
-    "Do not edit manually.",
-    "",
-  ].join("\n");
+  const bundleFiles = await normalizeGlobalSkillBundleFiles(skill.files, skill.moduleFormat);
+  const bundleSha256 = await computeGlobalSkillBundleSha256(bundleFiles);
+  if (bundleSha256 !== skill.sha256) {
+    throw new Error(`Global skill bundle checksum mismatch for ${skill.slug}@${skill.version}.`);
+  }
   const markerJson = `${JSON.stringify(
     {
       slug: skill.slug,
@@ -3453,22 +3505,12 @@ async function buildGlobalSkillMaterialization(skill: {
       managedBy: "agent-factory",
       entryPoint: skill.entryPoint,
       moduleFormat: skill.moduleFormat,
-      generatedAt: Date.now(),
     },
     null,
     2,
   )}\n`;
   const files = [
-    {
-      path: "SKILL.md",
-      content: `${skillMd}\n`,
-      sha256: await computeSha256Hex(`${skillMd}\n`),
-    },
-    {
-      path: scriptRelativePath,
-      content: `${skill.sourceJs.trimEnd()}\n`,
-      sha256: await computeSha256Hex(`${skill.sourceJs.trimEnd()}\n`),
-    },
+    ...bundleFiles,
     {
       path: ".af-global-skill.json",
       content: markerJson,
@@ -3478,11 +3520,85 @@ async function buildGlobalSkillMaterialization(skill: {
   return { skillDirName, files };
 }
 
+async function normalizeGlobalSkillBundleFiles(
+  rawFiles: Array<{
+    path: string;
+    content: string;
+    sha256: string;
+  }>,
+  moduleFormat: "esm" | "cjs",
+): Promise<Array<{
+  path: string;
+  content: string;
+  sha256: string;
+}>> {
+  if (!Array.isArray(rawFiles) || rawFiles.length === 0) {
+    throw new Error("Global skill bundle must contain at least one file.");
+  }
+
+  const byPath = new Map<string, { path: string; content: string; sha256: string }>();
+  let totalBytes = 0;
+  for (const rawFile of rawFiles) {
+    const path = normalizeRelativePath(rawFile.path);
+    if (path === ".af-global-skill.json") {
+      throw new Error("Bundle files must not include .af-global-skill.json.");
+    }
+    if (byPath.has(path)) {
+      throw new Error(`Duplicate bundle file path: ${path}`);
+    }
+    const content = typeof rawFile.content === "string" ? rawFile.content : "";
+    totalBytes += new TextEncoder().encode(content).length;
+    if (totalBytes > 200_000) {
+      throw new Error("Global skill bundle too large (max 200KB).");
+    }
+    const sha256 = typeof rawFile.sha256 === "string" ? rawFile.sha256.trim() : "";
+    if (!sha256) {
+      throw new Error(`Missing bundle checksum for ${path}.`);
+    }
+    const computedSha = await computeSha256Hex(content);
+    if (computedSha !== sha256) {
+      throw new Error(`Global skill checksum mismatch for ${path}.`);
+    }
+    byPath.set(path, { path, content, sha256 });
+  }
+
+  const entryScriptPath = `scripts/index.${moduleFormat === "cjs" ? "cjs" : "mjs"}`;
+  if (!byPath.has("SKILL.md")) {
+    throw new Error("Global skill bundle must include SKILL.md.");
+  }
+  if (!byPath.has(entryScriptPath)) {
+    throw new Error(`Global skill bundle must include ${entryScriptPath}.`);
+  }
+
+  return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+
+async function computeGlobalSkillBundleSha256(
+  files: Array<{
+    path: string;
+    content: string;
+    sha256: string;
+  }>,
+): Promise<string> {
+  const fingerprint = files
+    .map((file) => `${file.path}\n${file.sha256}\n${file.content}`)
+    .join("\n---\n");
+  return await computeSha256Hex(fingerprint);
+}
+
 function normalizeGlobalSkillDirName(slug: string): string {
   const normalized = slug.trim().toLowerCase().replace(/[^a-z0-9-_]/g, "-");
   return normalized.length > 0 ? normalized : "unnamed-skill";
 }
 
+function normalizeRelativePath(value: string): string {
+  const normalized = String(value || "").replaceAll("\\", "/").replace(/^\/+/, "");
+  if (!normalized || normalized === "." || normalized.includes("../")) {
+    throw new Error(`invalid_relative_path:${value}`);
+  }
+  return normalized;
+}
+
 function getBridgeSecretRefsForProfile(
   agentKey: string,
   bridgeConfig:

package/src/component/schema.ts

@@ -315,7 +315,13 @@ export default defineSchema({
     version: v.string(),
     moduleFormat: v.union(v.literal("esm"), v.literal("cjs")),
     entryPoint: v.string(),
-    sourceJs: v.string(),
+    files: v.array(
+      v.object({
+        path: v.string(),
+        content: v.string(),
+        sha256: v.string(),
+      }),
+    ),
     sha256: v.string(),
     createdBy: v.string(),
     createdAt: v.number(),
@@ -404,6 +410,21 @@ export default defineSchema({
     .index("by_companyId_and_templateKey", ["companyId", "templateKey"])
     .index("by_companyId_and_enabled", ["companyId", "enabled"]),
 
+  messageTemplates: defineTable({
+    templateKey: v.string(),
+    title: v.string(),
+    text: v.string(),
+    tags: v.array(v.string()),
+    usageCount: v.number(),
+    enabled: v.boolean(),
+    createdBy: v.string(),
+    updatedBy: v.string(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_templateKey", ["templateKey"])
+    .index("by_enabled", ["enabled"]),
+
   messagePushJobs: defineTable({
     companyId: v.string(),
     consumerUserId: v.string(),