@meistrari/chat-nuxt 1.0.0

package/dist/runtime/composables/useFilePreviewPanel.js

@@ -0,0 +1,42 @@
+const isOpen = ref(false);
+const isLoading = ref(false);
+const currentFile = ref(null);
+const panelWidth = ref(400);
+const MIN_PANEL_WIDTH = 320;
+const MAX_PANEL_WIDTH = 800;
+export function useFilePreviewPanel() {
+  function openPreview(data) {
+    currentFile.value = data;
+    isLoading.value = !data.resolvedUrl && !data.cachedBase64;
+    isOpen.value = true;
+  }
+  function updatePreview(data) {
+    if (currentFile.value) {
+      currentFile.value = { ...currentFile.value, ...data };
+    }
+    isLoading.value = false;
+  }
+  function setError() {
+    isLoading.value = false;
+  }
+  function closePreview() {
+    isOpen.value = false;
+    isLoading.value = false;
+  }
+  function setPanelWidth(width) {
+    panelWidth.value = Math.min(Math.max(width, MIN_PANEL_WIDTH), MAX_PANEL_WIDTH);
+  }
+  return {
+    isOpen: readonly(isOpen),
+    isLoading: readonly(isLoading),
+    currentFile: readonly(currentFile),
+    panelWidth: readonly(panelWidth),
+    minPanelWidth: MIN_PANEL_WIDTH,
+    maxPanelWidth: MAX_PANEL_WIDTH,
+    openPreview,
+    updatePreview,
+    setError,
+    closePreview,
+    setPanelWidth
+  };
+}

package/dist/runtime/composables/useFileUpload.d.ts

@@ -0,0 +1,7 @@
+import type { FileUploadInput } from '../types/chat.js';
+export declare function useFileUpload(): {
+    uploading: any;
+    uploadError: any;
+    uploadFile: (file: File) => Promise<FileUploadInput>;
+    uploadFiles: (files: File[]) => Promise<FileUploadInput[]>;
+};

package/dist/runtime/composables/useFileUpload.js

@@ -0,0 +1,39 @@
+export function useFileUpload() {
+  const uploading = ref(false);
+  const uploadError = ref(null);
+  async function uploadFile(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const { vaultReference, url, mimeType, size } = await $fetch("/api/vault/upload", {
+      method: "POST",
+      body: formData
+    });
+    return {
+      url,
+      name: file.name,
+      mimeType,
+      vaultReference,
+      size
+    };
+  }
+  async function uploadFiles(files) {
+    if (files.length === 0)
+      return [];
+    uploading.value = true;
+    uploadError.value = null;
+    try {
+      return await Promise.all(files.map((file) => uploadFile(file)));
+    } catch (err) {
+      uploadError.value = err instanceof Error ? err.message : "Erro ao fazer upload dos arquivos";
+      throw err;
+    } finally {
+      uploading.value = false;
+    }
+  }
+  return {
+    uploading: readonly(uploading),
+    uploadError: readonly(uploadError),
+    uploadFile,
+    uploadFiles
+  };
+}

package/dist/runtime/composables/useGitHubSkills.d.ts

@@ -0,0 +1,6 @@
+export declare function useGitHubSkills(): {
+    connection: any;
+    fetchConnection: () => Promise<void>;
+    connect: () => void;
+    disconnect: () => Promise<void>;
+};

package/dist/runtime/composables/useGitHubSkills.js

@@ -0,0 +1,68 @@
+import * as Sentry from "@sentry/nuxt";
+export function useGitHubSkills() {
+  const config = useRuntimeConfig();
+  const { activeOrganization } = useTelaApplicationAuth();
+  const { settings, updateSettings } = useWorkspaceSettings();
+  const connection = useState("github-skills-connection", () => ({
+    connected: false,
+    loading: true
+  }));
+  async function fetchConnection() {
+    connection.value.loading = true;
+    try {
+      const response = await $fetch("/api/github/status");
+      connection.value = {
+        ...response,
+        loading: false
+      };
+      if (!response.connected) {
+        await removePrivateSkills();
+      }
+    } catch (e) {
+      Sentry.captureException(e);
+      connection.value = {
+        connected: false,
+        loading: false
+      };
+    }
+  }
+  function connect() {
+    if (!activeOrganization.value?.id)
+      return;
+    const returnUrl = `${window.location.origin}${window.location.pathname}`;
+    window.location.href = `${config.public.agentApiUrl}/v3/public/connections/github?workspaceId=${activeOrganization.value.id}&returnUrl=${encodeURIComponent(returnUrl)}`;
+  }
+  async function disconnect() {
+    connection.value.loading = true;
+    try {
+      await $fetch("/api/github/disconnect", { method: "POST" });
+      await removePrivateSkills();
+      connection.value = { connected: false, loading: false };
+    } catch (e) {
+      Sentry.captureException(e);
+      connection.value.loading = false;
+    }
+  }
+  async function removePrivateSkills() {
+    const currentSkills = settings.value?.externalSkills ?? [];
+    const publicSkills = currentSkills.filter((s) => s.isPublic).map((s) => ({
+      ref: s.ref,
+      name: s.name,
+      description: s.description,
+      runtime: s.runtime,
+      allowedTools: [...s.allowedTools],
+      isPublic: s.isPublic,
+      addedBy: { userId: s.addedBy.userId, username: s.addedBy.username },
+      addedAt: s.addedAt
+    }));
+    if (publicSkills.length !== currentSkills.length) {
+      await updateSettings({ externalSkills: publicSkills.length > 0 ? publicSkills : null });
+    }
+  }
+  return {
+    connection: readonly(connection),
+    fetchConnection,
+    connect,
+    disconnect
+  };
+}

package/dist/runtime/composables/useGitHubSkillsCallback.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handles query params from GitHub OAuth callback via Agent API.
+ * Shows appropriate toast messages and cleans up URL.
+ */
+export declare function useGitHubSkillsCallback(): void;

package/dist/runtime/composables/useGitHubSkillsCallback.js

@@ -0,0 +1,42 @@
+export function useGitHubSkillsCallback() {
+  const route = useRoute();
+  const router = useRouter();
+  const statusToast = useStatusToast();
+  const { openModal } = useWorkspaceSettings();
+  function handleCallback() {
+    const provider = route.query.provider;
+    if (provider !== "github")
+      return;
+    const status = route.query.status;
+    const account = route.query.account;
+    if (status === "success") {
+      statusToast.update({
+        text: `GitHub conectado: ${account}`,
+        icon: "i-ph-check-circle"
+      });
+      openModal("external-skills");
+    } else if (status === "cancelled") {
+      statusToast.update({
+        text: "Conex\xE3o cancelada",
+        icon: "i-ph-x-circle"
+      });
+    } else if (status === "pending") {
+      statusToast.update({
+        text: "Solicita\xE7\xE3o enviada, aguardando aprova\xE7\xE3o da organiza\xE7\xE3o",
+        icon: "i-ph-clock"
+      });
+    } else if (status === "error") {
+      statusToast.update({
+        text: "Erro ao conectar com GitHub",
+        icon: "i-ph-warning"
+      });
+    }
+    if (status) {
+      const { status: _, account: __, provider: ___, ...rest } = route.query;
+      router.replace({ query: rest });
+    }
+  }
+  onMounted(() => {
+    handleCallback();
+  });
+}

package/dist/runtime/composables/useIDB.d.ts

@@ -0,0 +1,11 @@
+interface IDBOptions {
+    dbName?: string;
+    storeName: string;
+    version?: number;
+}
+export declare function useIDB(options: IDBOptions): {
+    get: (key: string) => Promise<any>;
+    set: (key: string, value: any) => Promise<void>;
+    remove: (key: string) => Promise<void>;
+};
+export {};

package/dist/runtime/composables/useIDB.js

@@ -0,0 +1,57 @@
+export function useIDB(options) {
+  const { dbName = "tela", storeName, version } = options;
+  let dbInstance = null;
+  async function setup() {
+    if (dbInstance)
+      return dbInstance;
+    return new Promise((resolve, reject) => {
+      const request = version ? indexedDB.open(dbName, version) : indexedDB.open(dbName);
+      request.onerror = reject;
+      request.onsuccess = () => {
+        dbInstance = request.result;
+        if (!dbInstance.objectStoreNames.contains(storeName)) {
+          dbInstance.close();
+          const newVersion = dbInstance.version + 1;
+          const newRequest = indexedDB.open(dbName, newVersion);
+          newRequest.onupgradeneeded = (event) => {
+            const db = event.target.result;
+            db.createObjectStore(storeName);
+          };
+          newRequest.onsuccess = () => {
+            dbInstance = newRequest.result;
+            resolve(dbInstance);
+          };
+          newRequest.onerror = reject;
+        } else {
+          resolve(dbInstance);
+        }
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(storeName)) {
+          db.createObjectStore(storeName);
+        }
+      };
+    });
+  }
+  async function withStore(mode, callback) {
+    const db = await setup();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(storeName, mode);
+      const store = transaction.objectStore(storeName);
+      const request = callback(store);
+      request.onerror = reject;
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  async function get(key) {
+    return withStore("readonly", (store) => store.get(key));
+  }
+  async function set(key, value) {
+    await withStore("readwrite", (store) => store.put(value, key));
+  }
+  async function remove(key) {
+    await withStore("readwrite", (store) => store.delete(key));
+  }
+  return { get, set, remove };
+}

package/dist/runtime/composables/useInputHistory.d.ts

@@ -0,0 +1,7 @@
+import type { Message } from '../types/chat.js';
+export declare function useInputHistory(messages: Ref<Message[]>): {
+    navigateUp: (currentContent: string) => string | null;
+    navigateDown: () => string | null;
+    resetNavigation: () => void;
+    isNavigating: any;
+};

package/dist/runtime/composables/useInputHistory.js

@@ -0,0 +1,36 @@
+export function useInputHistory(messages) {
+  const historyIndex = ref(-1);
+  const savedDraft = ref("");
+  const userMessages = computed(
+    () => messages.value.filter((m) => m.role === "user" && m.content.trim()).map((m) => m.content)
+  );
+  function navigateUp(currentContent) {
+    if (userMessages.value.length === 0)
+      return null;
+    if (historyIndex.value === -1) {
+      savedDraft.value = currentContent;
+      historyIndex.value = userMessages.value.length - 1;
+    } else if (historyIndex.value > 0) {
+      historyIndex.value--;
+    } else {
+      return null;
+    }
+    return userMessages.value[historyIndex.value] ?? null;
+  }
+  function navigateDown() {
+    if (historyIndex.value === -1)
+      return null;
+    if (historyIndex.value < userMessages.value.length - 1) {
+      historyIndex.value++;
+      return userMessages.value[historyIndex.value] ?? null;
+    }
+    historyIndex.value = -1;
+    return savedDraft.value ?? "";
+  }
+  function resetNavigation() {
+    historyIndex.value = -1;
+    savedDraft.value = "";
+  }
+  const isNavigating = computed(() => historyIndex.value !== -1);
+  return { navigateUp, navigateDown, resetNavigation, isNavigating };
+}

package/dist/runtime/composables/useKnowledgeSources.d.ts

@@ -0,0 +1,6 @@
+import type { KnowledgeSource } from '../types/chat.js';
+export declare function useKnowledgeSources(): {
+    knowledgeSources: any;
+    setKnowledgeSources: (sources: KnowledgeSource[] | null) => void;
+    getWorkstationName: (workstationId: string) => string | undefined;
+};

package/dist/runtime/composables/useKnowledgeSources.js

@@ -0,0 +1,15 @@
+const knowledgeSources = useState("knowledgeSources", () => []);
+export function useKnowledgeSources() {
+  function setKnowledgeSources(sources) {
+    knowledgeSources.value = sources ?? [];
+  }
+  function getWorkstationName(workstationId) {
+    const source = knowledgeSources.value.find((s) => s.id === workstationId);
+    return source?.name;
+  }
+  return {
+    knowledgeSources: readonly(knowledgeSources),
+    setKnowledgeSources,
+    getWorkstationName
+  };
+}

package/dist/runtime/composables/useMediaCache.d.ts

@@ -0,0 +1,13 @@
+export declare function useMediaCache(): {
+    getCached: (cacheKey: string) => Promise<string | null>;
+    setCache: (cacheKey: string, base64: string) => Promise<void>;
+    removeFromCache: (cacheKey: string) => Promise<void>;
+    fetchWithCache: (cacheKey: string, fetchFn: () => Promise<string>) => Promise<string | null>;
+    fetchUrlAsBase64: (url: string) => Promise<string>;
+    fetchUrlWithMetadata: (url: string) => Promise<{
+        base64: string;
+        mimeType: string | null;
+    }>;
+    getOrFetchBase64: (vaultReference: string, resolvedUrl: string) => Promise<string | null>;
+    base64ToDataUrl: (base64: string, mimeType: string) => string;
+};

package/dist/runtime/composables/useMediaCache.js

@@ -0,0 +1,92 @@
+const mediaCache = useIDB({
+  storeName: "vault-media-cache",
+  version: 2
+});
+export function useMediaCache() {
+  async function getCached(cacheKey) {
+    try {
+      const cachedData = await mediaCache.get(cacheKey);
+      if (cachedData)
+        return cachedData;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async function setCache(cacheKey, base64) {
+    try {
+      await mediaCache.set(cacheKey, base64);
+    } catch {
+    }
+  }
+  async function removeFromCache(cacheKey) {
+    try {
+      await mediaCache.remove(cacheKey);
+    } catch {
+    }
+  }
+  async function fetchWithCache(cacheKey, fetchFn) {
+    const cached = await getCached(cacheKey);
+    if (cached)
+      return cached;
+    try {
+      const base64 = await fetchFn();
+      if (base64)
+        setCache(cacheKey, base64);
+      return base64;
+    } catch {
+      return null;
+    }
+  }
+  async function fetchUrlAsBase64(url) {
+    const response = await fetch(url);
+    const blob = await response.blob();
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        const result = reader.result;
+        const base64 = result.split(",")[1];
+        if (base64)
+          resolve(base64);
+        else
+          reject(new Error("Falha ao extrair base64 da URL de dados"));
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+  async function fetchUrlWithMetadata(url) {
+    const response = await fetch(url);
+    const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() ?? null;
+    const blob = await response.blob();
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        const result = reader.result;
+        const base64 = result.split(",")[1];
+        if (base64)
+          resolve({ base64, mimeType: mimeType || blob.type || null });
+        else
+          reject(new Error("Falha ao extrair base64 da URL de dados"));
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+  async function getOrFetchBase64(vaultReference, resolvedUrl) {
+    return fetchWithCache(vaultReference, () => fetchUrlAsBase64(resolvedUrl));
+  }
+  function base64ToDataUrl(base64, mimeType) {
+    return `data:${mimeType};base64,${base64}`;
+  }
+  return {
+    getCached,
+    setCache,
+    removeFromCache,
+    fetchWithCache,
+    fetchUrlAsBase64,
+    fetchUrlWithMetadata,
+    getOrFetchBase64,
+    base64ToDataUrl
+  };
+}

package/dist/runtime/composables/useMentionAutocomplete.d.ts

@@ -0,0 +1,10 @@
+import type { MentionItem } from '../types/chat.js';
+type UseMentionAutocompleteOptions = {
+    editorRef: Ref<HTMLElement | null>;
+    fileItems: ComputedRef<MentionItem[]>;
+    skillItems: ComputedRef<MentionItem[]>;
+    disabled?: Ref<boolean | undefined>;
+    onInsert?: () => void;
+};
+export declare function useMentionAutocomplete(options: UseMentionAutocompleteOptions): any;
+export {};