qarpeo 0.0.0-alpha.10

package/dist/runtime/server/routes/storage/upload.post.mjs

@@ -0,0 +1,96 @@
+import { defineEventHandler, getQuery, createError } from "nuxt/server";
+import { uploadStorageFile, verifyPresignedUploadTicket } from "../../utils/storage.mjs";
+async function readEventRawBody(event) {
+  const req = event.req || event.request;
+  if (req?.arrayBuffer) {
+    const ab = await req.arrayBuffer();
+    return new Uint8Array(ab);
+  }
+  if (event.node?.req) {
+    const chunks = [];
+    for await (const chunk of event.node.req) {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return new Uint8Array(Buffer.concat(chunks));
+  }
+  return null;
+}
+async function readEventMultipartFormData(event) {
+  const req = event.req || event.request;
+  if (req?.formData) {
+    try {
+      const fd = await req.formData();
+      const parts = [];
+      for (const [_, val] of fd.entries()) {
+        if (val && typeof val === "object" && "arrayBuffer" in val) {
+          const file = val;
+          parts.push({
+            filename: file.name,
+            type: file.type,
+            data: new Uint8Array(await file.arrayBuffer())
+          });
+        }
+      }
+      if (parts.length > 0) return parts;
+    } catch {
+    }
+  }
+  return [];
+}
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const ticket = query.ticket;
+  const ticketKey = query.key;
+  const ticketType = query.type;
+  const queryAccess = query.access || void 0;
+  if (ticket && ticketKey && ticketType) {
+    const ticketAccess = queryAccess || "public";
+    await verifyPresignedUploadTicket(event, ticketKey, ticketType, ticket, ticketAccess);
+    const rawData = await readEventRawBody(event);
+    if (!rawData) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Bad Request",
+        message: "Empty file body"
+      });
+    }
+    const uploaded = await uploadStorageFile(
+      event,
+      { data: rawData, type: ticketType, size: rawData.byteLength },
+      { key: ticketKey, access: ticketAccess }
+    );
+    return uploaded;
+  }
+  const formData = await readEventMultipartFormData(event);
+  if (!formData || formData.length === 0) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Bad Request",
+      message: "No files provided in multipart/form-data request"
+    });
+  }
+  const results = [];
+  for (const part of formData) {
+    if (part.filename && part.data) {
+      const uploaded = await uploadStorageFile(
+        event,
+        {
+          data: part.data,
+          filename: part.filename,
+          type: part.type,
+          size: part.data.byteLength
+        },
+        { access: queryAccess }
+      );
+      results.push(uploaded);
+    }
+  }
+  if (results.length === 0) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Bad Request",
+      message: "No valid file parts found in multipart request"
+    });
+  }
+  return results.length === 1 ? results[0] : { files: results };
+});

package/dist/runtime/server/routes/tenants/[tenant]/domains/[domain]/index.delete.d.ts

@@ -0,0 +1,8 @@
+/**
+ * DELETE /api/tenants/:tenant/domains/:domain Removes a custom domain from Cloudflare and edge
+ * lookup cache.
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    success: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/routes/tenants/[tenant]/domains/[domain]/index.delete.mjs

@@ -0,0 +1,39 @@
+import { defineEventHandler, getRouterParam, createError } from "nuxt/server";
+import { getAuthSession } from "../../../../../utils/session.mjs";
+import { getD1Binding } from "../../../../../../db.mjs";
+import { deleteCustomDomain, getCustomDomain } from "../../../../../utils/domains.mjs";
+import { getTenantById } from "../../../../../utils/tenant.mjs";
+export default defineEventHandler(async (event) => {
+  const session = await getAuthSession(event).catch(() => null);
+  const userId = session?.user?.id;
+  if (!userId) {
+    throw createError({ statusCode: 401, message: "Authentication required." });
+  }
+  const domain = getRouterParam(event, "domain");
+  if (!domain) {
+    throw createError({ statusCode: 400, message: "Missing domain parameter." });
+  }
+  const domainRecord = await getCustomDomain(domain, event);
+  if (domainRecord) {
+    const tenant = await getTenantById(domainRecord.tenantId, event);
+    if (tenant?.organizationId) {
+      try {
+        const bindingName = globalThis.process?.env?.QARPEO_DEFAULT_DB_BINDING || "DB";
+        const d1 = getD1Binding(bindingName, event);
+        const membership = await d1.prepare(
+          "SELECT role FROM _qarpeo_members WHERE organization_id = ? AND user_id = ? LIMIT 1"
+        ).bind(tenant.organizationId, userId).first();
+        if (!membership || !["owner", "admin"].includes(membership.role)) {
+          throw createError({
+            statusCode: 403,
+            message: "Forbidden: insufficient permissions for this tenant."
+          });
+        }
+      } catch (err) {
+        if (err.statusCode === 403) throw err;
+      }
+    }
+  }
+  const result = await deleteCustomDomain(domain, event);
+  return result;
+});

package/dist/runtime/server/routes/tenants/[tenant]/domains/[domain]/verify.post.d.ts

@@ -0,0 +1,8 @@
+/**
+ * POST /api/tenants/:tenant/domains/:domain/verify Triggers re-verification of the custom domain
+ * DNS / SSL status with Cloudflare.
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    domain: import("../../../../../../../types").CustomDomainRecord;
+}>>;
+export default _default;

package/dist/runtime/server/routes/tenants/[tenant]/domains/[domain]/verify.post.mjs

@@ -0,0 +1,39 @@
+import { defineEventHandler, getRouterParam, createError } from "nuxt/server";
+import { getAuthSession } from "../../../../../utils/session.mjs";
+import { getD1Binding } from "../../../../../../db.mjs";
+import { getCustomDomain, verifyCustomDomain } from "../../../../../utils/domains.mjs";
+import { getTenantById } from "../../../../../utils/tenant.mjs";
+export default defineEventHandler(async (event) => {
+  const session = await getAuthSession(event).catch(() => null);
+  const userId = session?.user?.id;
+  if (!userId) {
+    throw createError({ statusCode: 401, message: "Authentication required." });
+  }
+  const domain = getRouterParam(event, "domain");
+  if (!domain) {
+    throw createError({ statusCode: 400, message: "Missing domain parameter." });
+  }
+  const domainRecord = await getCustomDomain(domain, event);
+  if (domainRecord) {
+    const tenant = await getTenantById(domainRecord.tenantId, event);
+    if (tenant?.organizationId) {
+      try {
+        const bindingName = globalThis.process?.env?.QARPEO_DEFAULT_DB_BINDING || "DB";
+        const d1 = getD1Binding(bindingName, event);
+        const membership = await d1.prepare(
+          "SELECT role FROM _qarpeo_members WHERE organization_id = ? AND user_id = ? LIMIT 1"
+        ).bind(tenant.organizationId, userId).first();
+        if (!membership || !["owner", "admin"].includes(membership.role)) {
+          throw createError({
+            statusCode: 403,
+            message: "Forbidden: insufficient permissions for this tenant."
+          });
+        }
+      } catch (err) {
+        if (err.statusCode === 403) throw err;
+      }
+    }
+  }
+  const record = await verifyCustomDomain(domain, event);
+  return { domain: record };
+});

package/dist/runtime/server/routes/tenants/[tenant]/domains/index.get.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GET /api/tenants/:tenant/domains Lists all custom domains registered for the specified tenant
+ * slug or ID.
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    domains: import("../../../../../../types").CustomDomainRecord[];
+}>>;
+export default _default;

package/dist/runtime/server/routes/tenants/[tenant]/domains/index.get.mjs

@@ -0,0 +1,20 @@
+import { defineEventHandler, getRouterParam, createError } from "nuxt/server";
+import { getAuthSession } from "../../../../utils/session.mjs";
+import { listTenantDomains } from "../../../../utils/domains.mjs";
+import { getTenantById, getTenantBySlug } from "../../../../utils/tenant.mjs";
+export default defineEventHandler(async (event) => {
+  const session = await getAuthSession(event).catch(() => null);
+  if (!session?.user?.id) {
+    throw createError({ statusCode: 401, message: "Authentication required." });
+  }
+  const tenantParam = getRouterParam(event, "tenant");
+  if (!tenantParam) {
+    throw createError({ statusCode: 400, message: "Missing tenant identifier." });
+  }
+  const tenant = await getTenantById(tenantParam, event) || await getTenantBySlug(tenantParam, event);
+  if (!tenant) {
+    throw createError({ statusCode: 404, message: `Tenant "${tenantParam}" not found.` });
+  }
+  const domains = await listTenantDomains(tenant.id, event);
+  return { domains };
+});

package/dist/runtime/server/routes/tenants/[tenant]/domains/index.post.d.ts

@@ -0,0 +1,8 @@
+/**
+ * POST /api/tenants/:tenant/domains Registers a new custom domain for the tenant via Cloudflare for
+ * SaaS.
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    domain: import("../../../../../../types").CustomDomainRecord;
+}>>;
+export default _default;

package/dist/runtime/server/routes/tenants/[tenant]/domains/index.post.mjs

@@ -0,0 +1,44 @@
+import { defineEventHandler, getRouterParam, readBody, createError } from "nuxt/server";
+import { getAuthSession } from "../../../../utils/session.mjs";
+import { getD1Binding } from "../../../../../db.mjs";
+import { registerCustomDomain } from "../../../../utils/domains.mjs";
+import { getTenantById, getTenantBySlug } from "../../../../utils/tenant.mjs";
+export default defineEventHandler(async (event) => {
+  const session = await getAuthSession(event).catch(() => null);
+  const userId = session?.user?.id;
+  if (!userId) {
+    throw createError({ statusCode: 401, message: "Authentication required." });
+  }
+  const tenantParam = getRouterParam(event, "tenant");
+  if (!tenantParam) {
+    throw createError({ statusCode: 400, message: "Missing tenant identifier." });
+  }
+  const tenant = await getTenantById(tenantParam, event) || await getTenantBySlug(tenantParam, event);
+  if (!tenant) {
+    throw createError({ statusCode: 404, message: `Tenant "${tenantParam}" not found.` });
+  }
+  if (tenant.organizationId) {
+    try {
+      const bindingName = globalThis.process?.env?.QARPEO_DEFAULT_DB_BINDING || "DB";
+      const d1 = getD1Binding(bindingName, event);
+      const membership = await d1.prepare(
+        "SELECT role FROM _qarpeo_members WHERE organization_id = ? AND user_id = ? LIMIT 1"
+      ).bind(tenant.organizationId, userId).first();
+      if (!membership || !["owner", "admin"].includes(membership.role)) {
+        throw createError({
+          statusCode: 403,
+          message: "Forbidden: insufficient permissions for this tenant."
+        });
+      }
+    } catch (err) {
+      if (err.statusCode === 403) throw err;
+    }
+  }
+  const body = await readBody(event).catch(() => ({}));
+  const domain = body?.domain;
+  if (!domain || typeof domain !== "string") {
+    throw createError({ statusCode: 400, message: "A valid 'domain' string is required." });
+  }
+  const record = await registerCustomDomain(tenant.id, domain, void 0, event);
+  return { domain: record };
+});

package/dist/runtime/server/routes/tenants/current.get.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GET /api/tenants/current Returns the currently active tenant resolved from the incoming host or
+ * header.
+ */
+declare const _default: import("nuxt/server").EventHandler<{
+    tenant: import("../../../../types").TenantRecord | null;
+}>;
+export default _default;

package/dist/runtime/server/routes/tenants/current.get.mjs

@@ -0,0 +1,6 @@
+import { defineEventHandler } from "nuxt/server";
+import { getTenant } from "../../utils/tenant.mjs";
+export default defineEventHandler((event) => {
+  const tenant = getTenant(event);
+  return { tenant };
+});

package/dist/runtime/server/tasks/cms/publish.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("nitro/types").Task<{
+    publishedCount: number;
+}>;
+export default _default;

package/dist/runtime/server/tasks/cms/publish.mjs

@@ -0,0 +1,18 @@
+import { defineTask } from "nitro/task";
+import { publishDueScheduledEntries } from "../../utils/cms.mjs";
+export default defineTask({
+  meta: {
+    name: "cms:publish",
+    description: "Publish due scheduled CMS entries"
+  },
+  async run({ payload, context }) {
+    try {
+      const event = context?.event;
+      const published = await publishDueScheduledEntries(event);
+      return { result: { publishedCount: published.length } };
+    } catch (err) {
+      console.error("[qarpeo:cms] Scheduled publish task failed:", err);
+      return { error: err?.message || String(err) };
+    }
+  }
+});

package/dist/runtime/server/utils/agent-store.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared in-memory store for Agent definitions and conversation histories. Persists across dev
+ * reloads via globalThis.
+ */
+export interface AgentMessageRecord {
+    id: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp: string;
+    model?: string;
+    latencyMs?: number;
+}
+export interface AgentSessionRecord {
+    id: string;
+    name: string;
+    description: string;
+    status: "idle" | "busy";
+    model: string;
+    systemPrompt: string;
+    tools: string[];
+    createdAt: number;
+    messages: AgentMessageRecord[];
+}
+export declare function getDevMockAgentsStore(): Map<string, AgentSessionRecord>;

package/dist/runtime/server/utils/agent-store.mjs

@@ -0,0 +1,53 @@
+const GLOBAL_AGENTS_KEY = "__qarpeo_dev_mock_agents__";
+export function getDevMockAgentsStore() {
+  const g = globalThis;
+  if (!g[GLOBAL_AGENTS_KEY]) {
+    g[GLOBAL_AGENTS_KEY] = /* @__PURE__ */ new Map([
+      [
+        "agent_chat",
+        {
+          id: "agent_chat",
+          name: "Chat Assistant",
+          description: "General-purpose chat agent with persistent edge state and memory.",
+          status: "idle",
+          model: "@cf/meta/llama-3.3-70b-instruct",
+          systemPrompt: "You are a helpful, knowledgeable AI assistant running on Cloudflare Workers edge runtime.",
+          tools: ["searchDocs", "fetchContext"],
+          createdAt: Date.now() - 864e5,
+          messages: [
+            {
+              id: "msg_1",
+              role: "assistant",
+              content: "Hello! I am your Edge Chat Assistant running on Cloudflare Durable Objects. How can I help you today?",
+              timestamp: new Date(Date.now() - 36e5).toISOString(),
+              model: "@cf/meta/llama-3.3-70b-instruct"
+            }
+          ]
+        }
+      ],
+      [
+        "agent_support",
+        {
+          id: "agent_support",
+          name: "Support Bot",
+          description: "Customer support agent with automatic tier escalation and knowledge base access.",
+          status: "idle",
+          model: "@cf/meta/llama-3.1-8b-instruct",
+          systemPrompt: "You are a friendly customer support agent. Answer questions concisely and escalate unresolved inquiries.",
+          tools: ["lookupTicket", "escalateToHuman"],
+          createdAt: Date.now() - 864e5 * 2,
+          messages: [
+            {
+              id: "msg_2",
+              role: "assistant",
+              content: "Welcome to Customer Support! Please provide your order or ticket ID to get started.",
+              timestamp: new Date(Date.now() - 72e5).toISOString(),
+              model: "@cf/meta/llama-3.1-8b-instruct"
+            }
+          ]
+        }
+      ]
+    ]);
+  }
+  return g[GLOBAL_AGENTS_KEY];
+}

package/dist/runtime/server/utils/agents-registry-fallback.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/server/utils/agents-registry-fallback.mjs

@@ -0,0 +1 @@
+export {};

package/dist/runtime/server/utils/ai.d.ts

@@ -0,0 +1,119 @@
+import "#qarpeo/agents-registry";
+import type { AgentDefinition, AgentMessage, AgentTool, StreamTextOptions, DurableObjectStub, GenerateImageOptions, GenerateImageResult, GenerateSpeechOptions, GenerateSpeechResult, TranscribeAudioInput, TranscribeAudioOptions, TranscribeAudioResult } from "../../../types";
+/** Registers an agent definition in the shared server runtime registry. */
+export declare function registerAgentDefinition(definition: AgentDefinition): void;
+/** Retrieves a registered agent definition by its unique name. */
+export declare function getAgentDefinition(name: string): AgentDefinition | undefined;
+/** Retrieves all currently registered agent definitions. */
+export declare function getAllAgentDefinitions(): AgentDefinition[];
+/**
+ * Define a typed tool for an edge agent or LLM function call.
+ *
+ * @example
+ *   export const searchDocs = defineTool({
+ *     description: "Search documentation articles",
+ *     parameters: {
+ *       type: "object",
+ *       properties: { query: { type: "string" } },
+ *       required: ["query"],
+ *     },
+ *     async execute({ query }) {
+ *       return await performSearch(query)
+ *     },
+ *   })
+ */
+export declare function defineTool<TParams = any, TResult = any>(tool: AgentTool<TParams, TResult>): AgentTool<TParams, TResult>;
+/**
+ * Define a stateful edge agent and register it in the runtime registry.
+ *
+ * @example
+ *   // server/agents/support.ts
+ *   export default defineAgent({
+ *     name: "support",
+ *     model: "@cf/meta/llama-3.3-70b-instruct",
+ *     system: "You are a customer support agent.",
+ *     tools: { searchDocs },
+ *   })
+ */
+export declare function defineAgent(definition: AgentDefinition): AgentDefinition;
+/** Retrieves the Durable Object stub for a specific agent instance. */
+export declare function getAgentDurableObject(agentName: string, id?: string, bindingName?: string, event?: any): DurableObjectStub;
+export declare function useAgent(agentName: string, id?: string, event?: any): {
+    chat(message: string, options?: {
+        stream?: boolean;
+        model?: string;
+        system?: string;
+        maxSteps?: number;
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<Response>;
+    history(): Promise<AgentMessage[]>;
+    clear(): Promise<void>;
+    getState(): Promise<Record<string, any>>;
+    setState(state: Record<string, any>): Promise<void>;
+};
+/**
+ * Generate vector embeddings for text using Cloudflare Workers AI.
+ *
+ * @default model: "@cf/baai/bge-base-en-v1.5"
+ */
+export declare function embedText(text: string | string[], options?: {
+    model?: string;
+    binding?: string;
+    event?: any;
+}): Promise<number[][]>;
+export interface SimilaritySearchOptions {
+    topK?: number;
+    binding?: string;
+    namespace?: string;
+    filter?: Record<string, any>;
+    returnValues?: boolean;
+    returnMetadata?: boolean | "all" | "indexed";
+    model?: string;
+    event?: any;
+}
+/** Performs vector similarity search using Cloudflare Vectorize. */
+export declare function similaritySearch(indexName: string, query: string, options?: SimilaritySearchOptions): Promise<any[]>;
+/** Generate a complete text response using Cloudflare Workers AI. */
+export declare function generateText(options: StreamTextOptions): Promise<string>;
+/** Stream text directly via Server-Sent Events using Cloudflare Workers AI. */
+export declare function streamText(options: StreamTextOptions): Promise<Response>;
+/**
+ * Generate an image using Cloudflare Workers AI.
+ *
+ * @param options Text prompt string or configuration options
+ * @default model "@cf/black-forest-labs/flux-1-schnell"
+ *
+ * @example
+ *   const img = await generateImage("A futuristic city at sunset, synthwave style")
+ *   return img.toResponse()
+ */
+export declare function generateImage(options: string | GenerateImageOptions): Promise<GenerateImageResult>;
+/** Alias for `generateImage`. */
+export declare const textToImage: typeof generateImage;
+/**
+ * Generate spoken audio from text using Cloudflare Workers AI Text-to-Speech (TTS).
+ *
+ * @param options Text script or configuration options
+ * @default model "@cf/meta/mms-tts-eng"
+ *
+ * @example
+ *   const audio = await generateSpeech("Welcome to our platform!")
+ *   return audio.toResponse()
+ */
+export declare function generateSpeech(options: string | GenerateSpeechOptions): Promise<GenerateSpeechResult>;
+/** Alias for `generateSpeech`. */
+export declare const textToSpeech: typeof generateSpeech;
+/**
+ * Transcribe spoken audio to text using Cloudflare Workers AI Whisper (STT).
+ *
+ * @param options Audio data (Uint8Array, ArrayBuffer, Blob, number array) or configuration options
+ * @default model "@cf/openai/whisper"
+ *
+ * @example
+ *   const result = await transcribeAudio(audioBytes)
+ *   console.log(result.text)
+ */
+export declare function transcribeAudio(options: TranscribeAudioInput | TranscribeAudioOptions): Promise<TranscribeAudioResult>;
+/** Alias for `transcribeAudio`. */
+export declare const speechToText: typeof transcribeAudio;