Clawdbot Hub

Copy codenpm install convex-clawdbot-hub

Copy code// convex/convex.config.ts
import { defineApp } from "convex/server";
import clawdbotHub from "convex-clawdbot-hub/convex.config";

const app = defineApp();
app.use(clawdbotHub);

export default app;

Copy code// convex/hub.ts
import { ClawdBotHub } from "convex-clawdbot-hub";
import { components } from "./_generated/api.js";
import { httpAction, mutation, query } from "./_generated/server.js";
import { v } from "convex/values";

const hub = new ClawdBotHub(components.clawdbotHub);

// Process inbound webhook from any ClawdBot gateway
export const webhook = httpAction(async (ctx, request) => {
  const body = await request.json();

  const result = await hub.processInbound(ctx, {
    gateway: body.gateway,
    gatewayMessageId: body.messageId,
    channelId: body.channelId,
    userId: body.userId,
    content: body.content,
    sessionScope: "peer",
  });

  if (!result) {
    return new Response("duplicate", { status: 200 });
  }

  return new Response(JSON.stringify(result), {
    status: 200,
    headers: { "Content-Type": "application/json" },
  });
});

// Send bot response
export const sendReply = mutation({
  args: {
    sessionId: v.string(),
    gateway: v.string(),
    channelId: v.string(),
    userId: v.string(),
    content: v.string(),
  },
  handler: async (ctx, args) => {
    return await hub.sendOutbound(ctx, args);
  },
});

// Get conversation history
export const getHistory = query({
  args: { sessionId: v.string(), limit: v.optional(v.number()) },
  handler: async (ctx, args) => {
    return await hub.getMessages(ctx, args);
  },
});

// Real-time latest messages (subscribe for live updates)
export const liveMessages = query({
  args: { sessionId: v.string() },
  handler: async (ctx, args) => {
    return await hub.getLatestMessages(ctx, { sessionId: args.sessionId, limit: 20 });
  },
});

Copy codeexport const setupGateway = mutation({
  args: { gatewayId: v.string(), name: v.string(), type: v.string() },
  handler: async (ctx, args) => {
    return await hub.registerGateway(ctx, args);
  },
});

Copy code// convex/crons.ts
import { cronJobs } from "convex/server";
const crons = cronJobs();

// Prune inactive sessions older than 7 days
crons.daily("prune sessions", { hourUTC: 3, minuteUTC: 0 },
  internal.hub.pruneSessions);

// Clean up dedup records older than 24 hours
crons.hourly("prune dedup", { minuteUTC: 30 },
  internal.hub.pruneDedup);

export default crons;

Copy codeimport { Id } from "./_generated/dataModel.js";

// Type-safe with your app's ID types:
const hub = new ClawdBotHub<Id<"users">, Id<"channels">>(
  components.clawdbotHub
);

// Or with string IDs:
const hub = new ClawdBotHub<string, string>(components.clawdbotHub);