qarpeo 0.0.0-alpha.10

package/dist/runtime/app/composables/analytics.mjs

@@ -0,0 +1,81 @@
+import { ref, readonly } from "vue";
+export function useAnalyticsDashboard(basePath = "/api/analytics") {
+  const loading = ref(false);
+  const error = ref(null);
+  const summary = ref(null);
+  const pageviews = ref(null);
+  const events = ref([]);
+  const fetchJson = async (url, query) => {
+    const qs = query ? "?" + Object.entries(query).filter(([_, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&") : "";
+    const fullUrl = `${url}${qs}`;
+    if (typeof globalThis.$fetch === "function") {
+      return globalThis.$fetch(fullUrl);
+    }
+    const res = await fetch(fullUrl);
+    if (!res.ok) {
+      throw new Error(`Analytics request failed: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  };
+  async function fetchSummary(range = "7d") {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(`${basePath}/summary`, { range });
+      summary.value = data ?? null;
+    } catch (e) {
+      error.value = e;
+    } finally {
+      loading.value = false;
+    }
+    return summary.value;
+  }
+  async function fetchPageviews(range = "7d") {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(`${basePath}/pageviews`, { range });
+      pageviews.value = data ?? null;
+    } catch (e) {
+      error.value = e;
+    } finally {
+      loading.value = false;
+    }
+    return pageviews.value;
+  }
+  async function fetchEvents(range = "7d", name, limit = 20) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(`${basePath}/events`, {
+        range,
+        ...name ? { name } : {},
+        limit
+      });
+      events.value = data ?? [];
+    } catch (e) {
+      error.value = e;
+    } finally {
+      loading.value = false;
+    }
+    return events.value;
+  }
+  return {
+    /** Whether a fetch is in flight. */
+    loading: readonly(loading),
+    /** Last error, if any. */
+    error: readonly(error),
+    /** KPI summary data. */
+    summary: readonly(summary),
+    /** Pageview time-series data. */
+    pageviews: readonly(pageviews),
+    /** Custom event records. */
+    events: readonly(events),
+    /** Fetch the KPI summary. */
+    fetchSummary,
+    /** Fetch pageview time-series. */
+    fetchPageviews,
+    /** Fetch custom events. */
+    fetchEvents
+  };
+}

package/dist/runtime/app/composables/api-tokens.d.ts

@@ -0,0 +1,49 @@
+export interface ApiToken {
+    id: string;
+    name: string;
+    scopes: string[];
+    lastUsedAt: number | null;
+    expiresAt: number | null;
+    createdAt: number;
+}
+export declare function useApiTokens(): {
+    tokens: import("vue").Ref<{
+        id: string;
+        name: string;
+        scopes: string[];
+        lastUsedAt: number | null;
+        expiresAt: number | null;
+        createdAt: number;
+    }[], ApiToken[] | {
+        id: string;
+        name: string;
+        scopes: string[];
+        lastUsedAt: number | null;
+        expiresAt: number | null;
+        createdAt: number;
+    }[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    fetchTokens: () => Promise<{
+        id: string;
+        name: string;
+        scopes: string[];
+        lastUsedAt: number | null;
+        expiresAt: number | null;
+        createdAt: number;
+    }[]>;
+    createToken: (input: {
+        name: string;
+        scopes?: string[];
+        expiresInDays?: number;
+    }) => Promise<{
+        id: string;
+        token: string;
+        name: string;
+        scopes: string[];
+        expiresAt: number | null;
+        createdAt: number;
+    }>;
+    revokeToken: (tokenId: string) => Promise<{
+        success: boolean;
+    }>;
+};

package/dist/runtime/app/composables/api-tokens.mjs

@@ -0,0 +1,61 @@
+import { ref } from "vue";
+export function useApiTokens() {
+  const runtimeConfig = useRuntimeConfig();
+  const authConfig = runtimeConfig.public?.qarpeo?.auth || {};
+  const authPrefix = authConfig.prefix || "/api/auth";
+  const tokens = ref([]);
+  const loading = ref(false);
+  const fetchTokens = async () => {
+    loading.value = true;
+    try {
+      const data = await $fetch(`${authPrefix}/tokens`, {
+        credentials: "include"
+      }).catch(() => []);
+      tokens.value = data || [];
+      return tokens.value;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const createToken = async (input) => {
+    loading.value = true;
+    try {
+      const res = await $fetch(`${authPrefix}/tokens/create`, {
+        method: "POST",
+        body: input,
+        credentials: "include"
+      });
+      tokens.value.unshift({
+        id: res.id,
+        name: res.name,
+        scopes: res.scopes,
+        lastUsedAt: null,
+        expiresAt: res.expiresAt,
+        createdAt: res.createdAt
+      });
+      return res;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const revokeToken = async (tokenId) => {
+    loading.value = true;
+    try {
+      const res = await $fetch(`${authPrefix}/tokens/${tokenId}`, {
+        method: "DELETE",
+        credentials: "include"
+      });
+      tokens.value = tokens.value.filter((t) => t.id !== tokenId);
+      return res;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    tokens,
+    loading,
+    fetchTokens,
+    createToken,
+    revokeToken
+  };
+}

package/dist/runtime/app/composables/auth.d.ts

@@ -0,0 +1,50 @@
+import type { QarpeoUser, QarpeoSession, DeleteAccountOptions } from "../../types/auth";
+export interface QarpeoDeviceSession {
+    id: string;
+    clientType: string;
+    userAgent: string | null;
+    ipAddress: string | null;
+    lastActive: number;
+    expiresAt: number;
+    isCurrent: boolean;
+}
+export declare function useAuth(): {
+    loggedIn: any;
+    user: import("vue").ComputedRef<QarpeoUser | null>;
+    session: import("vue").ComputedRef<QarpeoSession | null>;
+    ready: any;
+    fetch: any;
+    clear: any;
+    logout: (redirect?: string) => Promise<void>;
+    logoutAll: (redirect?: string) => Promise<void>;
+    mfaRequired: import("vue").ComputedRef<boolean>;
+    mfaVerified: import("vue").ComputedRef<boolean>;
+    deleteAccount: (options?: DeleteAccountOptions, redirect?: string) => Promise<void>;
+    loginWithSSO: (params: {
+        domain?: string;
+        org?: string;
+        connectionId?: string;
+        redirect?: string;
+    }) => void;
+    sessions: import("vue").Ref<{
+        id: string;
+        clientType: string;
+        userAgent: string | null;
+        ipAddress: string | null;
+        lastActive: number;
+        expiresAt: number;
+        isCurrent: boolean;
+    }[], QarpeoDeviceSession[] | {
+        id: string;
+        clientType: string;
+        userAgent: string | null;
+        ipAddress: string | null;
+        lastActive: number;
+        expiresAt: number;
+        isCurrent: boolean;
+    }[]>;
+    sessionsLoading: import("vue").Ref<boolean, boolean>;
+    fetchSessions: () => Promise<void>;
+    revokeSession: (sessionId: string) => Promise<void>;
+    revokeAllOthers: () => Promise<void>;
+};

package/dist/runtime/app/composables/auth.mjs

@@ -0,0 +1,101 @@
+import { ref, computed } from "vue";
+export function useAuth() {
+  const { loggedIn, user, session, clear, fetch, ready } = useUserSession();
+  const runtimeConfig = useRuntimeConfig();
+  const typedUser = computed(() => user.value || null);
+  const typedSession = computed(
+    () => session.value || null
+  );
+  const authConfig = runtimeConfig.public?.qarpeo?.auth || {};
+  const authPrefix = authConfig.prefix || "/api/auth";
+  const mfaRequired = computed(() => Boolean(typedSession.value?.mfaRequired));
+  const mfaVerified = computed(() => Boolean(typedSession.value?.mfaVerified));
+  const sessions = ref([]);
+  const sessionsLoading = ref(false);
+  const fetchSessions = async () => {
+    if (!loggedIn.value) return;
+    sessionsLoading.value = true;
+    try {
+      const data = await $fetch(`${authPrefix}/sessions`, {
+        credentials: "include"
+      }).catch(() => []);
+      sessions.value = data || [];
+    } finally {
+      sessionsLoading.value = false;
+    }
+  };
+  const revokeSession = async (sessionId) => {
+    await $fetch(`${authPrefix}/sessions/${sessionId}`, {
+      method: "DELETE",
+      credentials: "include"
+    });
+    sessions.value = sessions.value.filter((s) => s.id !== sessionId);
+  };
+  const revokeAllOthers = async () => {
+    await $fetch(`${authPrefix}/logout-others`, {
+      method: "POST",
+      credentials: "include"
+    });
+    sessions.value = sessions.value.filter((s) => s.isCurrent);
+  };
+  const logout = async (redirect) => {
+    await clear();
+    const target = redirect || authConfig.redirect?.logout || "/login";
+    if (target) {
+      await navigateTo(target);
+    }
+  };
+  const logoutAll = async (redirect) => {
+    await $fetch(`${authPrefix}/logout-all`, {
+      method: "POST",
+      credentials: "include"
+    });
+    sessions.value = [];
+    const target = redirect || authConfig.redirect?.logout || "/login";
+    if (target) {
+      await navigateTo(target);
+    }
+  };
+  const deleteAccount = async (options = {}, redirect) => {
+    await $fetch(`${authPrefix}/account`, {
+      method: "DELETE",
+      body: options,
+      credentials: "include"
+    });
+    await clear();
+    const target = redirect || "/";
+    await navigateTo(target);
+  };
+  const loginWithSSO = (params) => {
+    const qs = new URLSearchParams();
+    if (params.domain) qs.set("domain", params.domain);
+    if (params.org) qs.set("org", params.org);
+    if (params.connectionId) qs.set("connectionId", params.connectionId);
+    if (params.redirect) qs.set("redirect", params.redirect);
+    const url = `${authPrefix}/sso/login?${qs.toString()}`;
+    if (typeof window !== "undefined") {
+      window.location.href = url;
+    }
+  };
+  return {
+    loggedIn,
+    user: typedUser,
+    session: typedSession,
+    ready,
+    fetch,
+    clear,
+    logout,
+    logoutAll,
+    // Enterprise Auth additions
+    mfaRequired,
+    mfaVerified,
+    deleteAccount,
+    loginWithSSO,
+    // Phase 3: Multi-device session management
+    sessions,
+    sessionsLoading,
+    fetchSessions,
+    revokeSession,
+    revokeAllOthers
+  };
+}

package/dist/runtime/app/composables/chat.d.ts

@@ -0,0 +1,69 @@
+import type { AgentMessage } from "../../../types";
+export interface UseChatOptions {
+    /** Target agent name. @default "default" */
+    agent?: string;
+    /** Conversation or session instance ID. @default "default" */
+    id?: string;
+    /** Unique session identifier alias for `id`. @default "default" */
+    sessionId?: string;
+    /** Enable Server-Sent Events token streaming. @default true */
+    stream?: boolean;
+    /** Custom chat API endpoint override. Defaults to `/api/agents/${agent}/chat` */
+    api?: string;
+    /** Initial messages list */
+    initialMessages?: AgentMessage[];
+    /** Automatically fetch conversation history on mount */
+    loadHistory?: boolean;
+    /** Callback fired when a tool execution is initiated */
+    onToolCall?: (toolCall: {
+        id: string;
+        name: string;
+        arguments: any;
+    }) => void;
+    /** Callback fired when a full message is completed */
+    onFinish?: (message: AgentMessage) => void;
+    /** Callback fired on streaming error */
+    onError?: (error: Error) => void;
+}
+export declare function useChat(options?: UseChatOptions): {
+    messages: import("vue").Ref<{
+        id?: string | undefined;
+        role: import("../../../types").AgentRole;
+        content: string;
+        name?: string | undefined;
+        toolCalls?: {
+            id: string;
+            name: string;
+            arguments: any;
+        }[] | undefined;
+        toolCallId?: string | undefined;
+        createdAt?: number | undefined;
+    }[], AgentMessage[] | {
+        id?: string | undefined;
+        role: import("../../../types").AgentRole;
+        content: string;
+        name?: string | undefined;
+        toolCalls?: {
+            id: string;
+            name: string;
+            arguments: any;
+        }[] | undefined;
+        toolCallId?: string | undefined;
+        createdAt?: number | undefined;
+    }[]>;
+    input: import("vue").Ref<string, string>;
+    isStreaming: import("vue").Ref<boolean, boolean>;
+    sending: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<Error | null, Error | null>;
+    sendMessage: (contentOverride?: string) => Promise<void>;
+    send: (contentOverride?: string) => Promise<void>;
+    handleSubmit: (e?: Event) => Promise<void>;
+    clear: () => Promise<void>;
+    reload: () => Promise<void>;
+};
+/**
+ * Universal Vue 3 / Nuxt 5 composable for edge agent conversations with real-time SSE streaming.
+ * Alias for `useChat`.
+ */
+export declare const useAgentChat: typeof useChat;
+export type UseAgentChatOptions = UseChatOptions;

package/dist/runtime/app/composables/chat.mjs

@@ -0,0 +1,159 @@
+import { ref, onMounted } from "vue";
+export function useChat(options = {}) {
+  const agentName = options.agent || "default";
+  const instanceId = options.sessionId || options.id || "default";
+  const streamEnabled = options.stream !== false;
+  const apiEndpoint = options.api || `/api/agents/${agentName}/chat`;
+  const historyEndpoint = `/api/agents/${agentName}/history?id=${encodeURIComponent(instanceId)}`;
+  const clearEndpoint = `/api/agents/${agentName}/clear`;
+  const messages = ref(options.initialMessages || []);
+  const input = ref("");
+  const isStreaming = ref(false);
+  const error = ref(null);
+  const loadConversationHistory = async () => {
+    try {
+      const res = await fetch(historyEndpoint);
+      if (res.ok) {
+        const data = await res.json();
+        if (Array.isArray(data.messages) && data.messages.length > 0) {
+          messages.value = data.messages;
+        }
+      }
+    } catch {
+    }
+  };
+  if (options.loadHistory !== false) {
+    onMounted(() => {
+      loadConversationHistory();
+    });
+  }
+  const sendMessage = async (contentOverride) => {
+    const text = (contentOverride !== void 0 ? contentOverride : input.value).trim();
+    if (!text || isStreaming.value) return;
+    input.value = "";
+    error.value = null;
+    const userMsg = {
+      id: `msg_${Date.now()}_u`,
+      role: "user",
+      content: text,
+      createdAt: Date.now()
+    };
+    messages.value.push(userMsg);
+    const assistantMsg = {
+      id: `msg_${Date.now()}_a`,
+      role: "assistant",
+      content: "",
+      createdAt: Date.now()
+    };
+    messages.value.push(assistantMsg);
+    isStreaming.value = true;
+    try {
+      const res = await fetch(apiEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          id: instanceId,
+          message: text,
+          stream: streamEnabled
+        })
+      });
+      if (!res.ok) {
+        throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+      }
+      if (!res.body) {
+        throw new Error("No response body received from agent");
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const events = buffer.split("\n\n");
+        buffer = events.pop() || "";
+        for (const rawEvent of events) {
+          if (!rawEvent.trim()) continue;
+          const lines = rawEvent.split("\n");
+          let eventType = "message";
+          let dataStr = "";
+          for (const line of lines) {
+            if (line.startsWith("event: ")) {
+              eventType = line.slice(7).trim();
+            } else if (line.startsWith("data: ")) {
+              dataStr = line.slice(6).trim();
+            }
+          }
+          if (eventType === "text-delta" && dataStr) {
+            try {
+              const data = JSON.parse(dataStr);
+              if (data.delta) {
+                assistantMsg.content += data.delta;
+              }
+            } catch {
+            }
+          } else if (eventType === "tool-call" && dataStr) {
+            try {
+              const data = JSON.parse(dataStr);
+              if (!assistantMsg.toolCalls) assistantMsg.toolCalls = [];
+              assistantMsg.toolCalls.push(data);
+              options.onToolCall?.(data);
+            } catch {
+            }
+          } else if (eventType === "done") {
+            try {
+              const data = JSON.parse(dataStr);
+              if (data.content) {
+                assistantMsg.content = data.content;
+              }
+            } catch {
+            }
+          } else if (eventType === "error" && dataStr) {
+            try {
+              const data = JSON.parse(dataStr);
+              throw new Error(data.message || "Agent streaming failed");
+            } catch (err) {
+              throw err;
+            }
+          }
+        }
+      }
+      options.onFinish?.(assistantMsg);
+    } catch (err) {
+      error.value = err;
+      assistantMsg.content = assistantMsg.content || `[Error: ${err?.message || "Failed to communicate with agent"}]`;
+      options.onError?.(err);
+    } finally {
+      isStreaming.value = false;
+    }
+  };
+  const handleSubmit = async (e) => {
+    e?.preventDefault();
+    await sendMessage();
+  };
+  const clear = async () => {
+    messages.value = [];
+    error.value = null;
+    try {
+      await fetch(clearEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ id: instanceId })
+      });
+    } catch {
+    }
+  };
+  return {
+    messages,
+    input,
+    isStreaming,
+    sending: isStreaming,
+    error,
+    sendMessage,
+    send: sendMessage,
+    handleSubmit,
+    clear,
+    reload: loadConversationHistory
+  };
+}
+export const useAgentChat = useChat;

package/dist/runtime/app/composables/cms-preview.d.ts

@@ -0,0 +1,33 @@
+import type { CMSPreviewState } from "../../../types";
+/**
+ * Reactive client composable for CMS Draft / Preview mode.
+ * Automatically inspects the current route query (?preview=true, ?preview_token=...)
+ * and the `qarpeo_preview` cookie to expose reactive preview status, token, and exit helpers.
+ */
+export declare function useCMSPreview(): {
+    isPreview: {
+        value: boolean;
+    };
+    token: {
+        value: string | null;
+    };
+    expires: {
+        value: string | null;
+    };
+    collection: {
+        value: string | null;
+    };
+    slug: {
+        value: string | null;
+    };
+    state: {
+        value: CMSPreviewState;
+    };
+    enable: (options?: {
+        token?: string;
+        expires?: number | string;
+        collection?: string;
+        slug?: string;
+    }) => void;
+    disable: () => Promise<any> | void;
+};

package/dist/runtime/app/composables/cms-preview.mjs

@@ -0,0 +1,83 @@
+import { computed } from "vue";
+export function useCMSPreview() {
+  let route;
+  let cookie;
+  try {
+    route = useRoute();
+  } catch {
+  }
+  try {
+    cookie = useCookie("qarpeo_preview");
+  } catch {
+  }
+  const cookieData = computed(() => {
+    if (!cookie?.value) return null;
+    try {
+      return typeof cookie.value === "string" ? JSON.parse(cookie.value) : cookie.value;
+    } catch {
+      return null;
+    }
+  });
+  const token = computed(() => {
+    return route?.query?.preview_token || cookieData.value?.token || null;
+  });
+  const expires = computed(() => {
+    if (route?.query?.expires) return String(route.query.expires);
+    if (cookieData.value?.expires) return String(cookieData.value.expires);
+    return null;
+  });
+  const collection = computed(() => {
+    return route?.query?.collection || cookieData.value?.collection || null;
+  });
+  const slug = computed(() => {
+    return route?.query?.slug || cookieData.value?.slug || null;
+  });
+  const isPreview = computed(() => {
+    if (route?.query?.preview === "true") return true;
+    if (cookieData.value?.token) {
+      const exp = Number(cookieData.value?.expires);
+      return !exp || exp > Date.now();
+    }
+    return false;
+  });
+  const state = computed(() => ({
+    isPreview: isPreview.value,
+    token: token.value,
+    expires: expires.value,
+    collection: collection.value,
+    slug: slug.value
+  }));
+  const enable = (options = {}) => {
+    if (cookie) {
+      const targetExp = options.expires ? Number(options.expires) : Date.now() + 24 * 60 * 60 * 1e3;
+      cookie.value = JSON.stringify({
+        token: options.token || token.value,
+        expires: targetExp,
+        collection: options.collection || collection.value,
+        slug: options.slug || slug.value
+      });
+    }
+  };
+  const disable = () => {
+    if (cookie) {
+      cookie.value = null;
+    }
+    if (route && (route.query?.preview || route.query?.preview_token || route.query?.expires)) {
+      const newQuery = { ...route.query };
+      delete newQuery.preview;
+      delete newQuery.preview_token;
+      delete newQuery.expires;
+      return navigateTo({ path: route.path, query: newQuery });
+    }
+  };
+  return {
+    isPreview,
+    token,
+    expires,
+    collection,
+    slug,
+    state,
+    enable,
+    disable
+  };
+}