botschat 0.1.0

package/packages/api/src/routes/tasks.ts

@@ -0,0 +1,375 @@
+import { Hono } from "hono";
+import type { Env } from "../env.js";
+import { generateId } from "../utils/id.js";
+
+const tasks = new Hono<{ Bindings: Env; Variables: { userId: string } }>();
+
+// ---------------------------------------------------------------------------
+// Helper: push task schedule to OpenClaw via ConnectionDO
+// ---------------------------------------------------------------------------
+async function pushScheduleToOpenClaw(
+  env: Env,
+  userId: string,
+  task: { taskId: string; name?: string; openclawCronJobId: string; agentId: string; schedule: string; instructions: string; enabled: boolean; model?: string },
+): Promise<void> {
+  try {
+    const doId = env.CONNECTION_DO.idFromName(userId);
+    const stub = env.CONNECTION_DO.get(doId);
+    await stub.fetch(
+      new Request("https://internal/send", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          type: "task.schedule",
+          taskId: task.taskId,
+          name: task.name,
+          cronJobId: task.openclawCronJobId,
+          agentId: task.agentId,
+          schedule: task.schedule,
+          instructions: task.instructions,
+          enabled: task.enabled,
+          model: task.model,
+        }),
+      }),
+    );
+  } catch (err) {
+    console.error("Failed to push schedule to OpenClaw:", err);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helper: push task delete to OpenClaw via ConnectionDO
+// ---------------------------------------------------------------------------
+async function pushDeleteToOpenClaw(
+  env: Env,
+  userId: string,
+  cronJobId: string,
+): Promise<void> {
+  try {
+    const doId = env.CONNECTION_DO.idFromName(userId);
+    const stub = env.CONNECTION_DO.get(doId);
+    await stub.fetch(
+      new Request("https://internal/send", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          type: "task.delete",
+          cronJobId,
+        }),
+      }),
+    );
+  } catch (err) {
+    console.error("Failed to push task delete to OpenClaw:", err);
+  }
+}
+
+/** GET /api/channels/:channelId/tasks — list tasks for a channel */
+tasks.get("/", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+
+  // Verify channel ownership
+  const channel = await c.env.DB.prepare(
+    "SELECT id, openclaw_agent_id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first<{ id: string; openclaw_agent_id: string }>();
+
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  // Note: schedule, instructions, model are NOT stored in D1.
+  // They belong to OpenClaw and are delivered to the frontend via WebSocket task.scan.result.
+  const { results } = await c.env.DB.prepare(
+    "SELECT id, name, kind, openclaw_cron_job_id, session_key, enabled, created_at, updated_at FROM tasks WHERE channel_id = ? ORDER BY kind ASC, created_at ASC",
+  )
+    .bind(channelId)
+    .all<{
+      id: string;
+      name: string;
+      kind: string;
+      openclaw_cron_job_id: string | null;
+      session_key: string | null;
+      enabled: number;
+      created_at: number;
+      updated_at: number;
+    }>();
+
+  return c.json({
+    tasks: (results ?? []).map((r) => ({
+      id: r.id,
+      name: r.name,
+      kind: r.kind,
+      openclawCronJobId: r.openclaw_cron_job_id,
+      sessionKey: r.session_key,
+      enabled: !!r.enabled,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at,
+    })),
+  });
+});
+
+/** POST /api/channels/:channelId/tasks — create a new task */
+tasks.post("/", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+
+  // Verify channel ownership
+  const channel = await c.env.DB.prepare(
+    "SELECT id, openclaw_agent_id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first<{ id: string; openclaw_agent_id: string }>();
+
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  const { name, kind, schedule, instructions } = await c.req.json<{
+    name: string;
+    kind: "background" | "adhoc";
+    schedule?: string;
+    instructions?: string;
+  }>();
+
+  if (!name?.trim()) {
+    return c.json({ error: "Task name is required" }, 400);
+  }
+  if (!["background", "adhoc"].includes(kind)) {
+    return c.json({ error: "Task kind must be 'background' or 'adhoc'" }, 400);
+  }
+
+  const id = generateId("tsk_");
+  const agentId = channel.openclaw_agent_id;
+
+  // Build session key based on task kind
+  let sessionKey: string;
+  if (kind === "adhoc") {
+    const slug = name
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "");
+    sessionKey = `agent:${agentId}:botschat:${userId}:adhoc:${slug}`;
+  } else {
+    sessionKey = `agent:${agentId}:botschat:${userId}:task:${id}`;
+  }
+
+  // D1 only stores basic task metadata — schedule/instructions/model belong to OpenClaw.
+  // openclawCronJobId is initially null for new background tasks; it will be set
+  // when the plugin creates the cron job and sends back a task.schedule.ack.
+  await c.env.DB.prepare(
+    "INSERT INTO tasks (id, channel_id, name, kind, openclaw_cron_job_id, session_key) VALUES (?, ?, ?, ?, ?, ?)",
+  )
+    .bind(id, channelId, name.trim(), kind, null, sessionKey)
+    .run();
+
+  // Push schedule to OpenClaw for background tasks (plugin will create the cron job)
+  if (kind === "background" && schedule) {
+    await pushScheduleToOpenClaw(c.env, userId, {
+      taskId: id,
+      name: name.trim(),
+      openclawCronJobId: "",
+      agentId,
+      schedule: schedule.trim(),
+      instructions: instructions?.trim() ?? "",
+      enabled: true,
+    });
+  }
+
+  return c.json(
+    {
+      id,
+      name: name.trim(),
+      kind,
+      openclawCronJobId: null,
+      sessionKey,
+      enabled: true,
+    },
+    201,
+  );
+});
+
+/** PATCH /api/channels/:channelId/tasks/:taskId — update a task */
+tasks.patch("/:taskId", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+  const taskId = c.req.param("taskId");
+
+  // Verify ownership and get task+channel info
+  const channel = await c.env.DB.prepare(
+    "SELECT id, openclaw_agent_id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first<{ id: string; openclaw_agent_id: string }>();
+
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  const existingTask = await c.env.DB.prepare(
+    "SELECT id, kind, openclaw_cron_job_id, enabled FROM tasks WHERE id = ? AND channel_id = ?",
+  )
+    .bind(taskId, channelId)
+    .first<{
+      id: string;
+      kind: string;
+      openclaw_cron_job_id: string | null;
+      enabled: number;
+    }>();
+
+  if (!existingTask) return c.json({ error: "Task not found" }, 404);
+
+  const body = await c.req.json<{
+    name?: string;
+    schedule?: string;
+    instructions?: string;
+    model?: string;
+    enabled?: boolean;
+  }>();
+
+  // D1 only stores: name and enabled.
+  // Schedule, instructions, model belong to OpenClaw — pushed via WebSocket.
+  const sets: string[] = [];
+  const values: unknown[] = [];
+
+  if (body.name !== undefined) {
+    sets.push("name = ?");
+    values.push(body.name.trim());
+  }
+  if (body.enabled !== undefined) {
+    sets.push("enabled = ?");
+    values.push(body.enabled ? 1 : 0);
+  }
+
+  if (sets.length > 0) {
+    sets.push("updated_at = unixepoch()");
+    values.push(taskId, channelId);
+    await c.env.DB.prepare(
+      `UPDATE tasks SET ${sets.join(", ")} WHERE id = ? AND channel_id = ?`,
+    )
+      .bind(...values)
+      .run();
+  }
+
+  // Push OpenClaw-owned fields directly to OpenClaw for background tasks.
+  // The client must send ALL OpenClaw fields (schedule, instructions, enabled)
+  // together since they are not stored in D1.
+  if (existingTask.kind === "background" && existingTask.openclaw_cron_job_id) {
+    const needsPush = body.schedule !== undefined || body.instructions !== undefined || body.enabled !== undefined || body.model !== undefined;
+    if (needsPush) {
+      await pushScheduleToOpenClaw(c.env, userId, {
+        taskId: taskId,
+        openclawCronJobId: existingTask.openclaw_cron_job_id,
+        agentId: channel.openclaw_agent_id,
+        schedule: body.schedule ?? "",
+        instructions: body.instructions ?? "",
+        enabled: body.enabled ?? !!existingTask.enabled,
+        model: body.model,
+      });
+    }
+  }
+
+  return c.json({ ok: true });
+});
+
+/** POST /api/channels/:channelId/tasks/:taskId/run — trigger a one-time immediate execution */
+tasks.post("/:taskId/run", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+  const taskId = c.req.param("taskId");
+
+  // Verify ownership
+  const channel = await c.env.DB.prepare(
+    "SELECT id, openclaw_agent_id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first<{ id: string; openclaw_agent_id: string }>();
+
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  const task = await c.env.DB.prepare(
+    "SELECT id, kind, openclaw_cron_job_id FROM tasks WHERE id = ? AND channel_id = ?",
+  )
+    .bind(taskId, channelId)
+    .first<{
+      id: string;
+      kind: string;
+      openclaw_cron_job_id: string | null;
+    }>();
+
+  if (!task) return c.json({ error: "Task not found" }, 404);
+  if (task.kind !== "background") return c.json({ error: "Only background tasks can be triggered" }, 400);
+  if (!task.openclaw_cron_job_id) return c.json({ error: "Task has no associated cron job" }, 400);
+
+  // Send a task.run message to OpenClaw via ConnectionDO.
+  // Instructions and model are not included — the plugin reads them
+  // directly from OpenClaw's jobs.json (the single source of truth).
+  try {
+    const doId = c.env.CONNECTION_DO.idFromName(userId);
+    const stub = c.env.CONNECTION_DO.get(doId);
+    const resp = await stub.fetch(
+      new Request("https://internal/send", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          type: "task.run",
+          cronJobId: task.openclaw_cron_job_id,
+          agentId: channel.openclaw_agent_id,
+        }),
+      }),
+    );
+
+    if (!resp.ok) {
+      const err = await resp.json().catch(() => ({ error: "Unknown error" }));
+      return c.json({ error: (err as { error?: string }).error ?? "Failed to trigger task" }, 503);
+    }
+  } catch (err) {
+    console.error("Failed to trigger task run:", err);
+    return c.json({ error: "OpenClaw is not connected" }, 503);
+  }
+
+  return c.json({ ok: true, message: "Task triggered" });
+});
+
+/** DELETE /api/channels/:channelId/tasks/:taskId */
+tasks.delete("/:taskId", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+  const taskId = c.req.param("taskId");
+
+  const channel = await c.env.DB.prepare(
+    "SELECT id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first();
+
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  // Get task to check if it's background (need to delete CronJob)
+  const task = await c.env.DB.prepare(
+    "SELECT kind, openclaw_cron_job_id FROM tasks WHERE id = ? AND channel_id = ?",
+  )
+    .bind(taskId, channelId)
+    .first<{ kind: string; openclaw_cron_job_id: string | null }>();
+
+  await c.env.DB.prepare(
+    "DELETE FROM tasks WHERE id = ? AND channel_id = ?",
+  )
+    .bind(taskId, channelId)
+    .run();
+
+  // Delete associated jobs
+  await c.env.DB.prepare("DELETE FROM jobs WHERE task_id = ?").bind(taskId).run();
+
+  // Push delete to OpenClaw for background tasks
+  if (task?.kind === "background" && task.openclaw_cron_job_id) {
+    // Record the deletion so task.scan won't re-create the task
+    await c.env.DB.prepare(
+      "INSERT OR IGNORE INTO deleted_cron_jobs (cron_job_id, user_id) VALUES (?, ?)",
+    )
+      .bind(task.openclaw_cron_job_id, userId)
+      .run();
+
+    await pushDeleteToOpenClaw(c.env, userId, task.openclaw_cron_job_id);
+  }
+
+  return c.json({ ok: true });
+});
+
+export { tasks };

package/packages/api/src/routes/upload.ts

@@ -0,0 +1,52 @@
+import { Hono } from "hono";
+import type { Env } from "../env.js";
+
+export const upload = new Hono<{
+  Bindings: Env;
+  Variables: { userId: string };
+}>();
+
+/** POST / — Upload a file to R2 and return its public URL. */
+upload.post("/", async (c) => {
+  const userId = c.get("userId");
+  const contentType = c.req.header("Content-Type") ?? "";
+
+  if (!contentType.includes("multipart/form-data")) {
+    return c.json({ error: "Expected multipart/form-data" }, 400);
+  }
+
+  const formData = await c.req.formData();
+  const file = formData.get("file") as File | null;
+
+  if (!file) {
+    return c.json({ error: "No file provided" }, 400);
+  }
+
+  // Validate file type — only images allowed
+  if (!file.type.startsWith("image/")) {
+    return c.json({ error: "Only image files are allowed" }, 400);
+  }
+
+  // Limit file size to 10 MB
+  const MAX_SIZE = 10 * 1024 * 1024;
+  if (file.size > MAX_SIZE) {
+    return c.json({ error: "File too large (max 10 MB)" }, 413);
+  }
+
+  // Generate a unique key: media/{userId}/{timestamp}-{random}.{ext}
+  const ext = file.name.split(".").pop()?.toLowerCase() ?? "png";
+  const safeExt = ["jpg", "jpeg", "png", "gif", "webp", "svg", "bmp", "ico"].includes(ext) ? ext : "png";
+  const key = `media/${userId}/${Date.now()}-${crypto.randomUUID().slice(0, 8)}.${safeExt}`;
+
+  // Upload to R2
+  await c.env.MEDIA.put(key, file.stream(), {
+    httpMetadata: {
+      contentType: file.type,
+    },
+  });
+
+  // Return the URL for serving through the API
+  const url = `/api/media/${key.replace("media/", "")}`;
+
+  return c.json({ url, key });
+});

package/packages/api/src/utils/auth.ts

@@ -0,0 +1,101 @@
+import type { Context, MiddlewareHandler } from "hono";
+import type { Env } from "../env.js";
+
+// Simple JWT-like token using HMAC-SHA256.
+// In production, use a proper JWT library or Cloudflare Access.
+
+type TokenPayload = {
+  sub: string; // user ID
+  exp: number; // expiration timestamp (seconds)
+};
+
+const ENCODER = new TextEncoder();
+
+async function hmacSign(secret: string, data: string): Promise<string> {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    ENCODER.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"],
+  );
+  const sig = await crypto.subtle.sign("HMAC", key, ENCODER.encode(data));
+  return btoa(String.fromCharCode(...new Uint8Array(sig)))
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/, "");
+}
+
+function base64UrlEncode(obj: unknown): string {
+  return btoa(JSON.stringify(obj))
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/, "");
+}
+
+function base64UrlDecode(str: string): unknown {
+  const padded = str.replace(/-/g, "+").replace(/_/g, "/");
+  return JSON.parse(atob(padded));
+}
+
+export async function createToken(
+  userId: string,
+  secret: string,
+  expiresInSeconds = 86400 * 7, // 7 days
+): Promise<string> {
+  const payload: TokenPayload = {
+    sub: userId,
+    exp: Math.floor(Date.now() / 1000) + expiresInSeconds,
+  };
+  const header = base64UrlEncode({ alg: "HS256", typ: "JWT" });
+  const body = base64UrlEncode(payload);
+  const signature = await hmacSign(secret, `${header}.${body}`);
+  return `${header}.${body}.${signature}`;
+}
+
+export async function verifyToken(
+  token: string,
+  secret: string,
+): Promise<TokenPayload | null> {
+  const parts = token.split(".");
+  if (parts.length !== 3) return null;
+
+  const [header, body, signature] = parts;
+  const expected = await hmacSign(secret, `${header}.${body}`);
+  if (signature !== expected) return null;
+
+  const payload = base64UrlDecode(body) as TokenPayload;
+  if (payload.exp < Math.floor(Date.now() / 1000)) return null;
+
+  return payload;
+}
+
+/** Hash a password using SHA-256 (for simplicity; production should use bcrypt/scrypt). */
+export async function hashPassword(password: string): Promise<string> {
+  const data = ENCODER.encode(password);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hash))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+/** Auth middleware: extracts user ID from Bearer token and sets it on context. */
+export function authMiddleware(): MiddlewareHandler<{ Bindings: Env; Variables: { userId: string } }> {
+  return async (c, next) => {
+    const authHeader = c.req.header("Authorization");
+    if (!authHeader?.startsWith("Bearer ")) {
+      return c.json({ error: "Missing or invalid Authorization header" }, 401);
+    }
+
+    const token = authHeader.slice(7);
+    const secret = c.env.JWT_SECRET ?? "botschat-dev-secret";
+    const payload = await verifyToken(token, secret);
+
+    if (!payload) {
+      return c.json({ error: "Invalid or expired token" }, 401);
+    }
+
+    c.set("userId", payload.sub);
+    await next();
+  };
+}

package/packages/api/src/utils/id.ts

@@ -0,0 +1,19 @@
+/** Generate a short random ID (URL-safe). */
+export function generateId(prefix = ""): string {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = prefix;
+  for (let i = 0; i < 16; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return id;
+}
+
+/** Generate a pairing token with bc_pat_ prefix. */
+export function generatePairingToken(): string {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let token = "bc_pat_";
+  for (let i = 0; i < 32; i++) {
+    token += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return token;
+}

package/packages/api/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "lib": ["ES2022"],
+    "types": ["@cloudflare/workers-types"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/plugin/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { botschatPlugin } from "./src/channel.js";
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: {
+        safeParse: () => {
+            success: boolean;
+        };
+    };
+    register(api: {
+        runtime: unknown;
+        registerChannel: (reg: {
+            plugin: typeof botschatPlugin;
+        }) => void;
+    }): void;
+};
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/packages/plugin/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMlD,QAAA,MAAM,MAAM;;;;;;;;;kBAKI;QACZ,OAAO,EAAE,OAAO,CAAC;QACjB,eAAe,EAAE,CAAC,GAAG,EAAE;YAAE,MAAM,EAAE,OAAO,cAAc,CAAA;SAAE,KAAK,IAAI,CAAC;KACnE;CAIF,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/packages/plugin/dist/index.js

@@ -0,0 +1,17 @@
+import { botschatPlugin } from "./src/channel.js";
+import { setBotsChatRuntime } from "./src/runtime.js";
+// OpenClaw Plugin Definition
+// This is the entry point loaded by OpenClaw's plugin system.
+// It registers the BotsChat channel plugin.
+const plugin = {
+    id: "botschat",
+    name: "BotsChat",
+    description: "Connect to BotsChat cloud chat platform",
+    configSchema: { safeParse: () => ({ success: true }) },
+    register(api) {
+        setBotsChatRuntime(api.runtime);
+        api.registerChannel({ plugin: botschatPlugin });
+    },
+};
+export default plugin;
+//# sourceMappingURL=index.js.map

package/packages/plugin/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,6BAA6B;AAC7B,8DAA8D;AAC9D,4CAA4C;AAC5C,MAAM,MAAM,GAAG;IACb,EAAE,EAAE,UAAU;IACd,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,yCAAyC;IACtD,YAAY,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE;IACtD,QAAQ,CAAC,GAGR;QACC,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAChC,GAAG,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC;IAClD,CAAC;CACF,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/packages/plugin/dist/src/accounts.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedBotsChatAccount } from "./types.js";
+/** List all configured account IDs. */
+export declare function listBotsChatAccountIds(cfg: unknown): string[];
+/** Resolve default account ID. */
+export declare function resolveDefaultBotsChatAccountId(cfg: unknown): string;
+/** Resolve a single account by ID. */
+export declare function resolveBotsChatAccount(cfg: unknown, accountId?: string | null): ResolvedBotsChatAccount;
+/** Delete an account from config, returning the updated config. */
+export declare function deleteBotsChatAccount(cfg: unknown, accountId: string): unknown;
+/** Enable or disable an account, returning updated config. */
+export declare function setBotsChatAccountEnabled(cfg: unknown, accountId: string, enabled: boolean): unknown;
+//# sourceMappingURL=accounts.d.ts.map

package/packages/plugin/dist/src/accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/accounts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAUpB,uCAAuC;AACvC,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,CAgB7D;AAED,kCAAkC;AAClC,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAGpE;AAED,sCAAsC;AACtC,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,OAAO,EACZ,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GACxB,uBAAuB,CA6BzB;AAED,mEAAmE;AACnE,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,MAAM,GAChB,OAAO,CAsBT;AAED,8DAA8D;AAC9D,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,GACf,OAAO,CAoBT"}