@meistrari/chat-nuxt 1.0.0

package/dist/runtime/server/utils/chat-context.d.ts

@@ -0,0 +1,9 @@
+import type { H3Event } from 'h3';
+import { type AppSession } from '#chat-runtime/server/utils/auth';
+export type ChatContext = {
+    user: AppSession['user'];
+    workspaceId: string;
+};
+export declare function resolveRequestedWorkspaceId(requestedWorkspaceId: string | null | undefined): string | null;
+export declare function resolveChatContextFromSession(session: AppSession, requestedWorkspaceId?: string | null): ChatContext;
+export declare function resolveChatContext(event: H3Event): ChatContext;

package/dist/runtime/server/utils/chat-context.js

@@ -0,0 +1,24 @@
+import { createError, getHeader } from "h3";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+export function resolveRequestedWorkspaceId(requestedWorkspaceId) {
+  const normalized = requestedWorkspaceId?.trim();
+  return normalized || null;
+}
+export function resolveChatContextFromSession(session, requestedWorkspaceId) {
+  const normalizedRequestedWorkspaceId = resolveRequestedWorkspaceId(requestedWorkspaceId);
+  if (normalizedRequestedWorkspaceId && normalizedRequestedWorkspaceId !== session.workspace.id) {
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Forbidden"
+    });
+  }
+  return {
+    user: session.user,
+    workspaceId: normalizedRequestedWorkspaceId ?? session.workspace.id
+  };
+}
+export function resolveChatContext(event) {
+  const session = requireUser(event);
+  const requestedWorkspaceId = getHeader(event, "x-chat-workspace-id");
+  return resolveChatContextFromSession(session, requestedWorkspaceId);
+}

package/dist/runtime/server/utils/chat-message-builder.d.ts

@@ -0,0 +1,4 @@
+import type { KnowledgeSource } from '#chat-runtime/types/chat';
+export declare function renderSystemPrompt(vaultUrl: string): string;
+export declare function truncateTitle(content: string, maxLength?: number): string;
+export declare function buildMessageWithContext(content: string, systemMessage: string | null, knowledgeSources: KnowledgeSource[] | null, isFirstMessage: boolean, renderedSystemPrompt: string): string;

package/dist/runtime/server/utils/chat-message-builder.js

@@ -0,0 +1,39 @@
+import { readChatPromptTemplate } from "#chat-runtime/server/utils/chat-prompts";
+import { getVaultHost } from "#chat-runtime/server/utils/vault";
+const BASE_SYSTEM_PROMPT_TEMPLATE = readChatPromptTemplate("base-system.md");
+const KNOWLEDGE_SOURCES_TEMPLATE = readChatPromptTemplate("knowledge-sources.md");
+export function renderSystemPrompt(vaultUrl) {
+  return BASE_SYSTEM_PROMPT_TEMPLATE.replaceAll("{{VAULT_HOST}}", getVaultHost(vaultUrl));
+}
+export function truncateTitle(content, maxLength = 50) {
+  const firstLine = content.split("\n")[0]?.trim() ?? "";
+  if (firstLine.length <= maxLength)
+    return firstLine;
+  return `${firstLine.slice(0, maxLength)}...`;
+}
+function buildKnowledgeSourcesContext(knowledgeSources) {
+  if (!knowledgeSources || knowledgeSources.length === 0)
+    return "";
+  const sources = knowledgeSources.map((source) => {
+    return `- **${source.name}** (ID: \`${source.id}\`)${source.description ? ` - ${source.description}` : ""}${source.taskCount ? ` [${source.taskCount} documentos processados]` : ""}`;
+  }).join("\n");
+  return KNOWLEDGE_SOURCES_TEMPLATE.replace("{{SOURCES}}", sources);
+}
+export function buildMessageWithContext(content, systemMessage, knowledgeSources, isFirstMessage, renderedSystemPrompt) {
+  if (!isFirstMessage)
+    return content;
+  const knowledgeContext = buildKnowledgeSourcesContext(knowledgeSources);
+  const parts = [renderedSystemPrompt];
+  if (systemMessage) {
+    parts.push(`# Instru\xE7\xF5es do Usu\xE1rio
+${systemMessage}`);
+  }
+  if (knowledgeContext) {
+    parts.push(knowledgeContext);
+  }
+  return `<system_context>
+${parts.join("\n\n")}
+</system_context>
+
+${content}`;
+}

package/dist/runtime/server/utils/chat-prompts.d.ts

@@ -0,0 +1,7 @@
+declare const chatPromptTemplates: {
+    readonly 'base-system.md': any;
+    readonly 'knowledge-sources.md': any;
+};
+export type ChatPromptTemplateName = keyof typeof chatPromptTemplates;
+export declare function readChatPromptTemplate(fileName: ChatPromptTemplateName): string;
+export {};

package/dist/runtime/server/utils/chat-prompts.js

@@ -0,0 +1,9 @@
+import baseSystemPromptTemplate from "#chat-runtime/server/prompts/base-system";
+import knowledgeSourcesPromptTemplate from "#chat-runtime/server/prompts/knowledge-sources";
+const chatPromptTemplates = {
+  "base-system.md": baseSystemPromptTemplate,
+  "knowledge-sources.md": knowledgeSourcesPromptTemplate
+};
+export function readChatPromptTemplate(fileName) {
+  return chatPromptTemplates[fileName];
+}

package/dist/runtime/server/utils/chat-workspace-settings.d.ts

@@ -0,0 +1,16 @@
+import type { H3Event } from 'h3';
+import { type useDb } from '#chat-runtime/server/db';
+import type { ResolvedWorkspaceSettings } from '#chat-runtime/server/db/schema';
+import type { ChatContext } from './chat-context.js';
+export type ResolvedWorkspaceSettingsInput = Partial<ResolvedWorkspaceSettings>;
+type DbInstance = ReturnType<typeof useDb>;
+export declare function normalizeResolvedWorkspaceSettings(settings: ResolvedWorkspaceSettingsInput | null | undefined, fallbackUpdatedAt?: Date | string): ResolvedWorkspaceSettings;
+export declare function serializeResolvedWorkspaceSettings(settings: ResolvedWorkspaceSettings): ResolvedWorkspaceSettings;
+export declare function getConversationAppliedSettings(conversation: {
+    appliedSettingsSnapshot?: ResolvedWorkspaceSettingsInput | null;
+}, trustedSettings?: ResolvedWorkspaceSettingsInput | null): ResolvedWorkspaceSettings;
+export declare function hasMaterialWorkspaceSettingsMismatch(currentSettings: ResolvedWorkspaceSettingsInput | null | undefined, trustedSettings: ResolvedWorkspaceSettingsInput | null | undefined): boolean;
+export declare function resolveDefaultWorkspaceSettings(db: DbInstance, workspaceId: string): Promise<ResolvedWorkspaceSettings>;
+export declare function resolveWorkspaceSettings(event: H3Event, context: ChatContext, db: DbInstance): Promise<ResolvedWorkspaceSettings>;
+export declare function getWorkspaceSettingsUpdatedAt(settings: ResolvedWorkspaceSettings): Date;
+export {};

package/dist/runtime/server/utils/chat-workspace-settings.js

@@ -0,0 +1,115 @@
+import { isDeepStrictEqual } from "node:util";
+import { createError } from "h3";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { schema } from "#chat-runtime/server/db";
+import registeredWorkspaceSettingsResolver from "#chat-workspace-settings-resolver";
+import { rowToExternalSkill } from "#chat-runtime/server/utils/external-skills";
+import { logger } from "#chat-runtime/server/utils/logger";
+const contextFileSchema = z.object({
+  url: z.string(),
+  name: z.string(),
+  mimeType: z.string().optional(),
+  vaultReference: z.string().optional()
+});
+const resolvedWorkspaceSettingsSchema = z.object({
+  systemMessage: z.string().nullable().optional(),
+  contextFiles: z.array(contextFileSchema).nullable().optional(),
+  canvasTools: z.array(z.object({ id: z.string() }).passthrough()).nullable().optional(),
+  knowledgeSources: z.array(z.object({ id: z.string() }).passthrough()).nullable().optional(),
+  externalSkills: z.array(z.object({ ref: z.string(), name: z.string() }).passthrough()).nullable().optional(),
+  updatedAt: z.union([z.string(), z.date()]).optional()
+});
+function getRegisteredWorkspaceSettingsResolver() {
+  const resolver = registeredWorkspaceSettingsResolver;
+  return typeof resolver === "function" ? resolver : null;
+}
+export function normalizeResolvedWorkspaceSettings(settings, fallbackUpdatedAt = /* @__PURE__ */ new Date()) {
+  return {
+    systemMessage: settings?.systemMessage ?? null,
+    contextFiles: settings?.contextFiles ?? null,
+    canvasTools: settings?.canvasTools ?? null,
+    knowledgeSources: settings?.knowledgeSources ?? null,
+    externalSkills: settings?.externalSkills ?? null,
+    updatedAt: settings?.updatedAt ?? fallbackUpdatedAt
+  };
+}
+export function serializeResolvedWorkspaceSettings(settings) {
+  return {
+    ...settings,
+    updatedAt: settings.updatedAt instanceof Date ? settings.updatedAt.toISOString() : settings.updatedAt
+  };
+}
+export function getConversationAppliedSettings(conversation, trustedSettings) {
+  if (conversation.appliedSettingsSnapshot) {
+    return normalizeResolvedWorkspaceSettings(conversation.appliedSettingsSnapshot);
+  }
+  return normalizeResolvedWorkspaceSettings(trustedSettings);
+}
+export function hasMaterialWorkspaceSettingsMismatch(currentSettings, trustedSettings) {
+  const normalizeForCompare = (settings) => ({
+    systemMessage: settings?.systemMessage ?? null,
+    contextFiles: settings?.contextFiles ?? null,
+    canvasTools: settings?.canvasTools ?? null,
+    knowledgeSources: settings?.knowledgeSources ?? null,
+    externalSkills: settings?.externalSkills ?? null
+  });
+  return !isDeepStrictEqual(normalizeForCompare(currentSettings), normalizeForCompare(trustedSettings));
+}
+function parseResolverResult(settings) {
+  const parsedSettings = resolvedWorkspaceSettingsSchema.safeParse(settings);
+  if (!parsedSettings.success) {
+    logger.error({
+      issues: parsedSettings.error.issues
+    }, "Workspace settings resolver returned an invalid payload");
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to resolve chat workspace settings"
+    });
+  }
+  return normalizeResolvedWorkspaceSettings(parsedSettings.data);
+}
+export async function resolveDefaultWorkspaceSettings(db, workspaceId) {
+  const [settings, skillRows] = await Promise.all([
+    db.select().from(schema.workspaceSettings).where(eq(schema.workspaceSettings.workspaceId, workspaceId)),
+    db.select().from(schema.externalSkills).where(eq(schema.externalSkills.workspaceId, workspaceId))
+  ]);
+  const baseSettings = settings[0];
+  const externalSkills = skillRows.map(rowToExternalSkill);
+  if (!baseSettings) {
+    return normalizeResolvedWorkspaceSettings({
+      externalSkills: externalSkills.length > 0 ? externalSkills : null
+    }, /* @__PURE__ */ new Date(0));
+  }
+  return normalizeResolvedWorkspaceSettings({
+    systemMessage: baseSettings.systemMessage,
+    contextFiles: baseSettings.contextFiles,
+    canvasTools: baseSettings.canvasTools,
+    knowledgeSources: baseSettings.knowledgeSources,
+    externalSkills: externalSkills.length > 0 ? externalSkills : null,
+    updatedAt: baseSettings.updatedAt
+  }, baseSettings.updatedAt);
+}
+export async function resolveWorkspaceSettings(event, context, db) {
+  const resolver = getRegisteredWorkspaceSettingsResolver();
+  try {
+    const result = resolver ? await resolver(event, context) : await resolveDefaultWorkspaceSettings(db, context.workspaceId);
+    return parseResolverResult(result);
+  } catch (error) {
+    if (error && typeof error === "object" && "statusCode" in error) {
+      throw error;
+    }
+    logger.error({
+      error,
+      workspaceId: context.workspaceId,
+      userId: context.user.id
+    }, "Workspace settings resolution failed");
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to resolve chat workspace settings"
+    });
+  }
+}
+export function getWorkspaceSettingsUpdatedAt(settings) {
+  return settings.updatedAt instanceof Date ? settings.updatedAt : new Date(settings.updatedAt);
+}

package/dist/runtime/server/utils/external-skills.d.ts

@@ -0,0 +1,2 @@
+import type { ExternalSkill, ExternalSkillRow } from '#chat-runtime/server/db/schema';
+export declare function rowToExternalSkill(row: ExternalSkillRow): ExternalSkill;

package/dist/runtime/server/utils/external-skills.js

@@ -0,0 +1,15 @@
+export function rowToExternalSkill(row) {
+  return {
+    ref: row.ref,
+    name: row.name,
+    description: row.description,
+    runtime: row.runtime,
+    allowedTools: row.allowedTools,
+    isPublic: row.isPublic,
+    addedBy: {
+      userId: row.addedByUserId,
+      username: row.addedByUsername
+    },
+    addedAt: row.addedAt.toISOString()
+  };
+}

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

@@ -0,0 +1,2 @@
+import type { Logger } from 'pino';
+export declare const logger: Logger;

package/dist/runtime/server/utils/logger.js

@@ -0,0 +1,12 @@
+import pino from "@meistrari/logger";
+const isDevelopment = process.env.ENVIRONMENT === "development";
+export const logger = pino({
+  level: process.env.LOG_LEVEL || "info",
+  transport: isDevelopment ? {
+    target: "pino-pretty",
+    options: {
+      messageKey: "message",
+      singleLine: true
+    }
+  } : void 0
+});

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

@@ -0,0 +1,32 @@
+interface SlackBlock {
+    type: string;
+    text?: {
+        type: string;
+        text: string;
+        emoji?: boolean;
+    };
+    elements?: Array<{
+        type: string;
+        text: string;
+        emoji?: boolean;
+    }>;
+}
+interface SlackMessage {
+    text?: string;
+    blocks?: SlackBlock[];
+}
+export interface WorkspaceUsageData {
+    workspaceId: string;
+    workspaceName: string;
+    totalTokens: number;
+    totalCost: number;
+    rawCost: number;
+    promptTokens: number;
+    completionTokens: number;
+    conversationCount: number;
+    userCount: number;
+    billingMode: 'plan' | 'credits';
+}
+export declare function sendSlackMessage(webhookUrl: string, message: SlackMessage): Promise<boolean>;
+export declare function formatUsageReport(workspaceUsage: WorkspaceUsageData[], reportDate: Date): SlackMessage;
+export {};

package/dist/runtime/server/utils/slack.js

@@ -0,0 +1,102 @@
+import { logger } from "#chat-runtime/server/utils/logger";
+export async function sendSlackMessage(webhookUrl, message) {
+  try {
+    const response = await fetch(webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(message)
+    });
+    if (!response.ok) {
+      logger.error({ status: response.status, text: await response.text() }, "Slack webhook error");
+      return false;
+    }
+    return true;
+  } catch (error) {
+    logger.error(error, "Failed to send Slack message");
+    return false;
+  }
+}
+function formatNumber(num) {
+  return num.toLocaleString("en-US");
+}
+function formatCost(cost, billingMode) {
+  if (billingMode === "credits") {
+    return `${Math.round(cost)} credits`;
+  }
+  return `$${cost.toFixed(2)}`;
+}
+function formatDate(date) {
+  return date.toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+export function formatUsageReport(workspaceUsage, reportDate) {
+  const blocks = [];
+  blocks.push({
+    type: "header",
+    text: {
+      type: "plain_text",
+      text: `\u{1F4CA} Chat Usage Report - ${formatDate(reportDate)}`,
+      emoji: true
+    }
+  });
+  blocks.push({
+    type: "divider"
+  });
+  let totalTokens = 0;
+  let totalRawCost = 0;
+  let totalConversations = 0;
+  for (const usage of workspaceUsage) {
+    totalTokens += usage.totalTokens;
+    totalRawCost += usage.rawCost;
+    totalConversations += usage.conversationCount;
+    const costText = `${formatCost(usage.totalCost, usage.billingMode)} ($${usage.rawCost.toFixed(2)})`;
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: [
+          `*${usage.workspaceName}*`,
+          `\u251C Tokens: ${formatNumber(usage.totalTokens)} (prompt: ${formatNumber(usage.promptTokens)} / completion: ${formatNumber(usage.completionTokens)})`,
+          `\u251C Cost: ${costText}`,
+          `\u251C Conversations: ${formatNumber(usage.conversationCount)}`,
+          `\u2514 Users: ${formatNumber(usage.userCount)}`
+        ].join("\n")
+      }
+    });
+  }
+  blocks.push({
+    type: "divider"
+  });
+  blocks.push({
+    type: "section",
+    text: {
+      type: "mrkdwn",
+      text: [
+        "*Totals*",
+        `\u251C Total Tokens: ${formatNumber(totalTokens)}`,
+        `\u251C Total Raw Cost: $${totalRawCost.toFixed(2)}`,
+        `\u251C Total Conversations: ${formatNumber(totalConversations)}`,
+        `\u2514 Workspaces: ${workspaceUsage.length}`
+      ].join("\n")
+    }
+  });
+  blocks.push({
+    type: "context",
+    elements: [
+      {
+        type: "mrkdwn",
+        text: `Report generated at ${(/* @__PURE__ */ new Date()).toISOString()}`
+      }
+    ]
+  });
+  return {
+    text: `Daily Usage Report - ${formatDate(reportDate)}`,
+    blocks
+  };
+}

package/dist/runtime/server/utils/tela-api.d.ts

@@ -0,0 +1,2 @@
+import type { H3Event } from 'h3';
+export declare function telaFetch<T>(event: H3Event, path: string, options?: RequestInit): Promise<T>;

package/dist/runtime/server/utils/tela-api.js

@@ -0,0 +1,29 @@
+import { logger } from "#chat-runtime/server/utils/logger";
+export async function telaFetch(event, path, options) {
+  const config = useRuntimeConfig();
+  const token = event.context.auth?.token;
+  if (!token) {
+    throw createError({ statusCode: 401, statusMessage: "No auth token" });
+  }
+  const start = performance.now();
+  const response = await fetch(`${config.telaApiUrl}${path}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+  if (!response.ok) {
+    logger.error({ status: response.status, statusText: response.statusText, path }, "Tela API request failed");
+    throw createError({
+      statusCode: response.status,
+      statusMessage: `Tela API error: ${response.statusText}`
+    });
+  }
+  logger.debug({ path, durationMs: Math.round(performance.now() - start), status: response.status }, "Tela API request succeeded");
+  if (response.status === 204 || response.headers.get("content-length") === "0") {
+    return void 0;
+  }
+  return response.json();
+}

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

@@ -0,0 +1,3 @@
+export declare function getVaultHost(vaultUrl: string): string;
+export declare function isAllowedPermalinkUrl(url: string, vaultUrl: string): boolean;
+export declare function isAllowedRedirectUrl(url: string, vaultS3Bucket?: string): boolean;

package/dist/runtime/server/utils/vault.js

@@ -0,0 +1,52 @@
+const KNOWN_VAULT_HOSTS = /* @__PURE__ */ new Set(["vault.tela.com", "api.tela.com", "api.telastaging.com"]);
+const PERMALINK_PATH_RE = /^(?:\/.*)?\/permalinks\/[a-zA-Z0-9_-]+$/;
+export function getVaultHost(vaultUrl) {
+  if (!vaultUrl)
+    return "vault.tela.com";
+  try {
+    const url = new URL(vaultUrl);
+    const path = url.pathname.replace(/\/+$/, "");
+    return path && path !== "/" ? `${url.host}${path}` : url.host;
+  } catch {
+    return "vault.tela.com";
+  }
+}
+function parseVaultHost(vaultUrl) {
+  if (!vaultUrl)
+    return null;
+  try {
+    return new URL(vaultUrl).host;
+  } catch {
+    return null;
+  }
+}
+export function isAllowedPermalinkUrl(url, vaultUrl) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:")
+      return false;
+    if (!PERMALINK_PATH_RE.test(parsed.pathname))
+      return false;
+    const allowedHosts = new Set(KNOWN_VAULT_HOSTS);
+    const envHost = parseVaultHost(vaultUrl);
+    if (envHost)
+      allowedHosts.add(envHost);
+    return allowedHosts.has(parsed.host);
+  } catch {
+    return false;
+  }
+}
+export function isAllowedRedirectUrl(url, vaultS3Bucket) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:")
+      return false;
+    if (vaultS3Bucket) {
+      const escaped = vaultS3Bucket.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(`^${escaped}\\.s3(\\.[a-z0-9-]+)?\\.amazonaws\\.com$`).test(parsed.host);
+    }
+    return /\.s3(\.[a-z0-9-]+)?\.amazonaws\.com$/.test(parsed.host);
+  } catch {
+    return false;
+  }
+}

package/dist/runtime/server/utils/workspace-settings-resolver.stub.d.ts

@@ -0,0 +1,2 @@
+declare const _default: null;
+export default _default;

package/dist/runtime/server/utils/workspace-settings-resolver.stub.js

@@ -0,0 +1 @@
+export default null;

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

@@ -0,0 +1,4 @@
+import type { H3Event } from 'h3';
+import { type useDb } from '#chat-runtime/server/db';
+export declare function getWorkspaceSettings(db: ReturnType<typeof useDb>, workspaceId: string): Promise<any>;
+export declare function resolveWorkspaceCredentials(event: H3Event, workspaceId: string): Promise<Record<string, string>>;

package/dist/runtime/server/utils/workspace.js

@@ -0,0 +1,21 @@
+import { eq } from "drizzle-orm";
+import { schema } from "#chat-runtime/server/db";
+import { telaFetch } from "#chat-runtime/server/utils/tela-api";
+export async function getWorkspaceSettings(db, workspaceId) {
+  const [settings] = await db.select().from(schema.workspaceSettings).where(eq(schema.workspaceSettings.workspaceId, workspaceId));
+  return settings ?? null;
+}
+export async function resolveWorkspaceCredentials(event, workspaceId) {
+  const config = useRuntimeConfig();
+  return await telaFetch(
+    event,
+    `/workspaces/${workspaceId}/credentials/resolve`,
+    {
+      headers: {
+        "X-Service-Name": "chat-app",
+        "X-Service-Key": config.chatAppServiceKey,
+        "x-data-token": event.context.auth?.token ?? ""
+      }
+    }
+  ) ?? {};
+}