@okrlinkhub/agent-factory 0.2.0 → 0.2.2

package/src/component/identity.ts

@@ -1,5 +1,6 @@
 import { v } from "convex/values";
-import { mutation, query } from "./_generated/server.js";
+import { internal } from "./_generated/api.js";
+import { action, mutation, query } from "./_generated/server.js";
 import type { MutationCtx } from "./_generated/server.js";
 
 const bindingStatusValidator = v.union(v.literal("active"), v.literal("revoked"));
@@ -38,6 +39,17 @@ const pairingCodeViewValidator = v.object({
   telegramChatId: v.union(v.null(), v.string()),
 });
 
+const telegramWebhookStatusValidator = v.object({
+  ok: v.boolean(),
+  webhookUrl: v.string(),
+  currentUrl: v.union(v.null(), v.string()),
+  isReady: v.boolean(),
+  pendingUpdateCount: v.number(),
+  lastErrorMessage: v.union(v.null(), v.string()),
+  lastErrorDate: v.union(v.null(), v.number()),
+  description: v.string(),
+});
+
 type BindingSource = "manual" | "telegram_pairing" | "api";
 
 type UpsertBindingArgs = {
@@ -50,6 +62,106 @@ type UpsertBindingArgs = {
   nowMs?: number;
 };
 
+export const configureTelegramWebhook = action({
+  args: {
+    convexSiteUrl: v.string(),
+    secretRef: v.optional(v.string()),
+  },
+  returns: telegramWebhookStatusValidator,
+  handler: async (ctx, args) => {
+    const secretRef = args.secretRef?.trim() || "telegram.botToken.default";
+    const token = await ctx.runQuery(internal.queue.getActiveSecretPlaintext, {
+      secretRef,
+    });
+    if (!token) {
+      throw new Error(
+        `Missing Telegram token. Import an active '${secretRef}' secret before pairing.`,
+      );
+    }
+
+    const rawSiteUrl = args.convexSiteUrl.trim();
+    if (!rawSiteUrl) {
+      throw new Error("convexSiteUrl is required.");
+    }
+
+    const normalizedSiteUrl = rawSiteUrl
+      .replace(/\/+$/, "")
+      .replace(/\.cloud$/i, ".site");
+    if (!normalizedSiteUrl.startsWith("https://")) {
+      throw new Error("convexSiteUrl must start with https://");
+    }
+
+    const webhookUrl = `${normalizedSiteUrl}/agent-factory/telegram/webhook`;
+    const telegramApiBaseUrl = `https://api.telegram.org/bot${encodeURIComponent(token)}`;
+
+    const setWebhookResponse = await fetch(`${telegramApiBaseUrl}/setWebhook`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        url: webhookUrl,
+      }),
+    });
+
+    const setWebhookPayload = (await setWebhookResponse.json().catch(() => ({}))) as {
+      ok?: boolean;
+      description?: string;
+    };
+
+    if (!setWebhookResponse.ok || setWebhookPayload.ok !== true) {
+      const description =
+        typeof setWebhookPayload.description === "string"
+          ? setWebhookPayload.description
+          : "setWebhook failed";
+      throw new Error(`Telegram setWebhook failed: ${description}`);
+    }
+
+    const webhookInfoResponse = await fetch(`${telegramApiBaseUrl}/getWebhookInfo`);
+    const webhookInfoPayload = (await webhookInfoResponse.json().catch(() => ({}))) as {
+      ok?: boolean;
+      description?: string;
+      result?: {
+        url?: string;
+        pending_update_count?: number;
+        last_error_message?: string;
+        last_error_date?: number;
+      };
+    };
+
+    if (!webhookInfoResponse.ok || webhookInfoPayload.ok !== true) {
+      const description =
+        typeof webhookInfoPayload.description === "string"
+          ? webhookInfoPayload.description
+          : "getWebhookInfo failed";
+      throw new Error(`Telegram getWebhookInfo failed: ${description}`);
+    }
+
+    const currentUrl = typeof webhookInfoPayload.result?.url === "string"
+      ? webhookInfoPayload.result.url
+      : null;
+    const pendingUpdateCount = Number(webhookInfoPayload.result?.pending_update_count ?? 0);
+    const lastErrorMessage = typeof webhookInfoPayload.result?.last_error_message === "string"
+      ? webhookInfoPayload.result.last_error_message
+      : null;
+    const lastErrorDate = typeof webhookInfoPayload.result?.last_error_date === "number"
+      ? webhookInfoPayload.result.last_error_date
+      : null;
+    const isReady = currentUrl === webhookUrl;
+
+    return {
+      ok: true,
+      webhookUrl,
+      currentUrl,
+      isReady,
+      pendingUpdateCount,
+      lastErrorMessage,
+      lastErrorDate,
+      description: "Telegram webhook configured and verified.",
+    };
+  },
+});
+
 export const createPairingCode = mutation({
   args: {
     consumerUserId: v.string(),

package/src/component/lib.test.ts

@@ -4,6 +4,17 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { api, internal } from "./_generated/api.js";
 import { initConvexTest } from "./setup.test.js";
 
+const TEST_PROVIDER_CONFIG = {
+  kind: "fly" as const,
+  appName: "agent-factory-workers-test",
+  organizationSlug: "personal",
+  image: "registry.fly.io/agent-factory-workers-test:test-image",
+  region: "iad",
+  volumeName: "openclaw_data_test",
+  volumePath: "/data",
+  volumeSizeGb: 10,
+};
+
 describe("component lib", () => {
   beforeEach(async () => {
     vi.useFakeTimers();
@@ -361,6 +372,7 @@ describe("component lib", () => {
         idleTimeoutMs: 300_000,
         reconcileIntervalMs: 15_000,
       },
+      providerConfig: TEST_PROVIDER_CONFIG,
     });
     expect(reconcile.activeWorkers).toBe(3);
     expect(reconcile.spawned).toBe(0);
@@ -433,16 +445,7 @@ describe("component lib", () => {
         idleTimeoutMs: 300_000,
         reconcileIntervalMs: 15_000,
       },
-      providerConfig: {
-        kind: "fly",
-        appName: "agent-factory-workers",
-        organizationSlug: "personal",
-        image: "registry.fly.io/agent-factory-workers:test-image",
-        region: "iad",
-        volumeName: "",
-        volumePath: "",
-        volumeSizeGb: 10,
-      },
+      providerConfig: TEST_PROVIDER_CONFIG,
     });
     expect(reconcile.activeWorkers).toBe(3);
     expect(reconcile.spawned).toBe(0);

package/src/component/lib.ts

@@ -29,6 +29,7 @@ export {
   resolveAgentForUser,
   resolveAgentForTelegram,
   getUserAgentBinding,
+  configureTelegramWebhook,
   createPairingCode,
   consumePairingCode,
   getPairingCodeStatus,

package/src/component/queue.ts

@@ -6,7 +6,7 @@ import {
   mutation,
   query,
 } from "./_generated/server.js";
-import { computeRetryDelayMs, DEFAULT_CONFIG } from "./config.js";
+import { computeRetryDelayMs, DEFAULT_CONFIG, providerConfigValidator } from "./config.js";
 
 const queueStatusValidator = v.union(
   v.literal("queued"),
@@ -79,6 +79,7 @@ export const enqueueMessage = mutation({
     scheduledFor: v.optional(v.number()),
     maxAttempts: v.optional(v.number()),
     nowMs: v.optional(v.number()),
+    providerConfig: v.optional(providerConfigValidator),
   },
   returns: v.id("messageQueue"),
   handler: async (ctx, args) => {
@@ -125,6 +126,7 @@ export const enqueueMessage = mutation({
     try {
       await ctx.scheduler.runAfter(0, (internal.scheduler as any).reconcileWorkerPoolFromEnqueue, {
         workspaceId: "default",
+        providerConfig: args.providerConfig,
       });
     } catch (error) {
       console.warn(

package/src/component/scheduler.ts

@@ -99,7 +99,7 @@ async function runReconcileWorkerPool(
 ) {
   const nowMs = args.nowMs ?? Date.now();
   const scaling = args.scalingPolicy ?? DEFAULT_CONFIG.scaling;
-  const providerConfig = args.providerConfig ?? DEFAULT_CONFIG.provider;
+  const providerConfig = ensureProviderConfig(args.providerConfig ?? DEFAULT_CONFIG.provider);
   const flyApiToken =
     args.flyApiToken ??
     (await ctx.runQuery(internal.queue.getActiveSecretPlaintext, {
@@ -304,7 +304,7 @@ async function runEnforceIdleShutdowns(
   },
 ) {
   const nowMs = args.nowMs ?? Date.now();
-  const providerConfig = args.providerConfig ?? DEFAULT_CONFIG.provider;
+  const providerConfig = ensureProviderConfig(args.providerConfig ?? DEFAULT_CONFIG.provider);
   const flyApiToken =
     args.flyApiToken ??
     (await ctx.runQuery(internal.queue.getActiveSecretPlaintext, {
@@ -431,6 +431,27 @@ function resolveProvider(kind: string, flyApiToken: string): WorkerProvider {
   }
 }
 
+function ensureProviderConfig(providerConfig: typeof DEFAULT_CONFIG.provider) {
+  const requiredFields: Array<
+    "appName" | "organizationSlug" | "image" | "region" | "volumeName" | "volumePath"
+  > = [
+    "appName",
+    "organizationSlug",
+    "image",
+    "region",
+    "volumeName",
+    "volumePath",
+  ];
+  for (const field of requiredFields) {
+    if (!providerConfig[field]?.trim()) {
+      throw new Error(
+        `Missing providerConfig.${field}. Pass providerConfig explicitly when starting/reconciling workers.`,
+      );
+    }
+  }
+  return providerConfig;
+}
+
 function clamp(value: number, min: number, max: number): number {
   return Math.max(min, Math.min(max, value));
 }