@meistrari/chat-nuxt 1.0.0

package/dist/runtime/server/api/vault/permalink-metadata.post.js

@@ -0,0 +1,77 @@
+import { logger } from "#chat-runtime/server/utils/logger";
+import { isAllowedPermalinkUrl, isAllowedRedirectUrl } from "#chat-runtime/server/utils/vault";
+export default defineEventHandler(async (event) => {
+  const { url } = await readBody(event);
+  const { vaultUrl, vaultS3Bucket } = useRuntimeConfig();
+  if (!url || !isAllowedPermalinkUrl(url, vaultUrl)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid permalink URL"
+    });
+  }
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      redirect: "manual"
+    });
+    if (response.status === 404) {
+      throw createError({ statusCode: 404, statusMessage: "Permalink not found" });
+    }
+    if (response.status === 401 || response.status === 403) {
+      throw createError({ statusCode: response.status, statusMessage: "Vault authorization failed" });
+    }
+    if (response.status !== 302) {
+      throw new Error(`Expected redirect, got: ${response.status}`);
+    }
+    const s3Url = response.headers.get("location");
+    if (!s3Url || !isAllowedRedirectUrl(s3Url, vaultS3Bucket || void 0)) {
+      throw new Error("Invalid or missing redirect location");
+    }
+    const s3UrlParams = new URL(s3Url).searchParams;
+    const disposition = s3UrlParams.get("response-content-disposition");
+    let originalFileName;
+    if (disposition) {
+      const match = disposition.match(/filename=["']?([^"']+)["']?/);
+      if (match?.[1])
+        originalFileName = decodeURIComponent(match[1]);
+    }
+    const s3Response = await fetch(s3Url, {
+      method: "GET",
+      headers: { Range: "bytes=0-0" }
+    });
+    const contentType = s3Response.headers.get("content-type")?.split(";")[0]?.trim();
+    const contentRange = s3Response.headers.get("content-range");
+    let fileSize;
+    if (contentRange) {
+      const sizeMatch = contentRange.match(/\/(\d+)$/);
+      if (sizeMatch?.[1])
+        fileSize = Number.parseInt(sizeMatch[1]);
+    }
+    return {
+      mimeType: contentType ?? void 0,
+      fileSize,
+      originalFileName
+    };
+  } catch (error) {
+    const status = error?.statusCode ?? error?.status ?? error?.response?.status;
+    if (status === 404) {
+      logger.warn({ error }, "Permalink not found");
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Permalink not found"
+      });
+    }
+    if (status === 401 || status === 403) {
+      logger.warn({ error }, "Vault authorization failed");
+      throw createError({
+        statusCode: status,
+        statusMessage: "Vault authorization failed"
+      });
+    }
+    logger.error({ error }, "Failed to fetch permalink metadata");
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to fetch permalink metadata"
+    });
+  }
+});

package/dist/runtime/server/api/vault/resolve.post.d.ts

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

package/dist/runtime/server/api/vault/resolve.post.js

@@ -0,0 +1,82 @@
+import { APIKeyAuthStrategy, VaultFile } from "@meistrari/vault-sdk";
+import { logger } from "#chat-runtime/server/utils/logger";
+import { getAgentDataToken } from "#chat-runtime/server/utils/agent-api";
+export default defineEventHandler(async (event) => {
+  const { reference } = await readBody(event);
+  if (!reference) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Reference is required"
+    });
+  }
+  if (reference.startsWith("https://")) {
+    logger.debug("Vault resolve passthrough for HTTPS reference");
+    return { url: reference };
+  }
+  const { vaultUrl } = useRuntimeConfig();
+  const authToken = getAgentDataToken(event);
+  if (!vaultUrl) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Vault URL not configured"
+    });
+  }
+  try {
+    const vaultFile = await VaultFile.fromVaultReference({
+      reference,
+      config: {
+        authStrategy: new APIKeyAuthStrategy(authToken),
+        vaultUrl
+      }
+    });
+    await vaultFile.populateMetadata();
+    const permalinks = await vaultFile.getPermalinks();
+    let permalink = permalinks.find((p) => !p.expiresAt);
+    if (!permalink) {
+      permalink = await vaultFile.createPermalink();
+    }
+    let finalUrl = permalink.url.toString();
+    if (finalUrl.includes("/_services/vault/permalinks/")) {
+      try {
+        const redirectResponse = await fetch(finalUrl, {
+          method: "GET",
+          redirect: "manual"
+        });
+        if (redirectResponse.status === 302) {
+          const s3Url = redirectResponse.headers.get("location");
+          if (s3Url)
+            finalUrl = s3Url;
+        }
+      } catch {
+        logger.debug("Vault permalink redirect resolution failed, using original URL");
+      }
+    }
+    logger.debug({ hasOriginalFileName: !!vaultFile.metadata?.originalFileName }, "Vault reference resolved");
+    return {
+      url: finalUrl,
+      originalFileName: vaultFile.metadata?.originalFileName ?? void 0,
+      mimeType: vaultFile.metadata?.mimeType ?? void 0
+    };
+  } catch (error) {
+    const status = error?.statusCode ?? error?.status ?? error?.response?.status;
+    if (status === 401 || status === 403) {
+      logger.warn({ error }, "Vault authorization failed");
+      throw createError({
+        statusCode: status,
+        statusMessage: "Vault authorization failed"
+      });
+    }
+    if (status === 404) {
+      logger.warn({ error }, "Vault file not found");
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Vault file not found"
+      });
+    }
+    logger.error({ error }, "Failed to resolve vault reference");
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to resolve vault reference"
+    });
+  }
+});

package/dist/runtime/server/api/vault/upload.post.d.ts

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

package/dist/runtime/server/api/vault/upload.post.js

@@ -0,0 +1,55 @@
+import { APIKeyAuthStrategy, VaultFile } from "@meistrari/vault-sdk";
+import { logger } from "#chat-runtime/server/utils/logger";
+import { getAgentDataToken } from "#chat-runtime/server/utils/agent-api";
+export default defineEventHandler(async (event) => {
+  const formData = await readFormData(event);
+  const file = formData.get("file");
+  if (!file) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "File is required"
+    });
+  }
+  const { vaultUrl } = useRuntimeConfig();
+  const authToken = getAgentDataToken(event);
+  if (!vaultUrl) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Vault not configured"
+    });
+  }
+  try {
+    const vaultFile = await VaultFile.fromContent({
+      name: file.name,
+      content: file,
+      upload: true,
+      config: {
+        authStrategy: new APIKeyAuthStrategy(authToken),
+        vaultUrl
+      }
+    });
+    await vaultFile.populateMetadata();
+    const permalink = await vaultFile.createPermalink();
+    logger.info({ fileName: file.name, mimeType: file.type, size: file.size }, "File uploaded to vault");
+    return {
+      vaultReference: vaultFile.getVaultReference(),
+      url: permalink.url.toString(),
+      mimeType: vaultFile.metadata?.mimeType ?? file.type,
+      size: file.size
+    };
+  } catch (error) {
+    const status = error?.statusCode ?? error?.status ?? error?.response?.status;
+    if (status === 401 || status === 403) {
+      logger.warn({ error }, "Vault authorization failed during upload");
+      throw createError({
+        statusCode: status,
+        statusMessage: "Vault authorization failed"
+      });
+    }
+    logger.error({ error }, "Failed to upload file to vault");
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to upload file"
+    });
+  }
+});

package/dist/runtime/server/api/workspace/credentials/[id].delete.d.ts

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

package/dist/runtime/server/api/workspace/credentials/[id].delete.js

@@ -0,0 +1,18 @@
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { telaFetch } from "#chat-runtime/server/utils/tela-api";
+export default defineEventHandler(async (event) => {
+  requireUser(event);
+  const credentialId = getRouterParam(event, "id");
+  if (!credentialId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "ID da credencial \xE9 obrigat\xF3rio"
+    });
+  }
+  await telaFetch(
+    event,
+    `/credentials/${credentialId}`,
+    { method: "DELETE" }
+  );
+  return { success: true };
+});

package/dist/runtime/server/api/workspace/credentials/[id].put.d.ts

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

package/dist/runtime/server/api/workspace/credentials/[id].put.js

@@ -0,0 +1,28 @@
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { telaFetch } from "#chat-runtime/server/utils/tela-api";
+export default defineEventHandler(async (event) => {
+  requireUser(event);
+  const credentialId = getRouterParam(event, "id");
+  const body = await readBody(event);
+  if (!credentialId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "ID da credencial \xE9 obrigat\xF3rio"
+    });
+  }
+  if (!body.value?.trim()) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "O valor \xE9 obrigat\xF3rio"
+    });
+  }
+  const updated = await telaFetch(
+    event,
+    `/credentials/${credentialId}`,
+    {
+      method: "PUT",
+      body: JSON.stringify({ value: body.value.trim() })
+    }
+  );
+  return updated;
+});

package/dist/runtime/server/api/workspace/credentials/index.get.d.ts

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

package/dist/runtime/server/api/workspace/credentials/index.get.js

@@ -0,0 +1,10 @@
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { telaFetch } from "#chat-runtime/server/utils/tela-api";
+export default defineEventHandler(async (event) => {
+  const session = requireUser(event);
+  const credentials = await telaFetch(
+    event,
+    `/workspaces/${session.workspace.id}/credentials?scopeType=workspace`
+  );
+  return credentials ?? [];
+});

package/dist/runtime/server/api/workspace/credentials/index.post.d.ts

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

package/dist/runtime/server/api/workspace/credentials/index.post.js

@@ -0,0 +1,33 @@
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { telaFetch } from "#chat-runtime/server/utils/tela-api";
+export default defineEventHandler(async (event) => {
+  const session = requireUser(event);
+  const body = await readBody(event);
+  if (!body.key?.trim()) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "O nome \xE9 obrigat\xF3rio"
+    });
+  }
+  if (!/^[A-Z][A-Z0-9_]*$/.test(body.key.trim())) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "O nome deve conter apenas letras mai\xFAsculas, n\xFAmeros e underscore, come\xE7ando com uma letra"
+    });
+  }
+  if (!body.value?.trim()) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "O valor \xE9 obrigat\xF3rio"
+    });
+  }
+  const created = await telaFetch(
+    event,
+    `/workspaces/${session.workspace.id}/credentials`,
+    {
+      method: "POST",
+      body: JSON.stringify({ key: body.key.trim(), value: body.value.trim() })
+    }
+  );
+  return created;
+});

package/dist/runtime/server/api/workspace/settings.get.d.ts

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

package/dist/runtime/server/api/workspace/settings.get.js

@@ -0,0 +1,27 @@
+import { eq } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { rowToExternalSkill } from "#chat-runtime/server/utils/external-skills";
+export default defineEventHandler(async (event) => {
+  const session = requireUser(event);
+  const db = useDb();
+  const [settings] = await db.select().from(schema.workspaceSettings).where(eq(schema.workspaceSettings.workspaceId, session.workspace.id));
+  const skillRows = await db.select().from(schema.externalSkills).where(eq(schema.externalSkills.workspaceId, session.workspace.id));
+  const externalSkills = skillRows.map(rowToExternalSkill);
+  if (!settings) {
+    return {
+      workspaceId: session.workspace.id,
+      systemMessage: null,
+      contextFiles: null,
+      canvasTools: null,
+      knowledgeSources: null,
+      externalSkills: externalSkills.length > 0 ? externalSkills : null,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  return {
+    ...settings,
+    externalSkills: externalSkills.length > 0 ? externalSkills : null
+  };
+});

package/dist/runtime/server/api/workspace/settings.patch.d.ts

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

package/dist/runtime/server/api/workspace/settings.patch.js

@@ -0,0 +1,86 @@
+import { eq, and, inArray } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { rowToExternalSkill } from "#chat-runtime/server/utils/external-skills";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const session = requireUser(event);
+  const db = useDb();
+  const body = await readBody(event);
+  const hasSystemMessage = body.systemMessage !== void 0;
+  const hasContextFiles = body.contextFiles !== void 0;
+  const hasCanvasTools = body.canvasTools !== void 0;
+  const hasKnowledgeSources = body.knowledgeSources !== void 0;
+  const hasExternalSkills = body.externalSkills !== void 0;
+  if (!hasSystemMessage && !hasContextFiles && !hasCanvasTools && !hasKnowledgeSources && !hasExternalSkills) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "At least one field is required to update"
+    });
+  }
+  const updateData = {
+    updatedAt: /* @__PURE__ */ new Date()
+  };
+  if (hasSystemMessage) {
+    updateData.systemMessage = body.systemMessage?.trim() || null;
+  }
+  if (hasContextFiles) {
+    updateData.contextFiles = body.contextFiles && body.contextFiles.length > 0 ? body.contextFiles : null;
+  }
+  if (hasCanvasTools) {
+    updateData.canvasTools = body.canvasTools && body.canvasTools.length > 0 ? body.canvasTools : null;
+  }
+  if (hasKnowledgeSources) {
+    updateData.knowledgeSources = body.knowledgeSources && body.knowledgeSources.length > 0 ? body.knowledgeSources : null;
+  }
+  const [existing] = await db.select().from(schema.workspaceSettings).where(eq(schema.workspaceSettings.workspaceId, session.workspace.id));
+  if (hasExternalSkills) {
+    const existingSkillRows = await db.select().from(schema.externalSkills).where(eq(schema.externalSkills.workspaceId, session.workspace.id));
+    const existingRefs = new Set(existingSkillRows.map((s) => s.ref));
+    const newSkills = body.externalSkills ?? [];
+    const newRefs = new Set(newSkills.map((s) => s.ref));
+    const refsToDelete = existingSkillRows.filter((s) => !newRefs.has(s.ref)).map((s) => s.ref);
+    if (refsToDelete.length > 0) {
+      await db.delete(schema.externalSkills).where(
+        and(
+          eq(schema.externalSkills.workspaceId, session.workspace.id),
+          inArray(schema.externalSkills.ref, refsToDelete)
+        )
+      );
+    }
+    const skillsToInsert = newSkills.filter((s) => !existingRefs.has(s.ref)).map((skill) => ({
+      workspaceId: session.workspace.id,
+      ref: skill.ref,
+      name: skill.name,
+      description: skill.description,
+      runtime: skill.runtime,
+      allowedTools: skill.allowedTools,
+      isPublic: skill.isPublic,
+      addedByUserId: skill.addedBy?.userId || session.user.id,
+      addedByUsername: skill.addedBy?.username || session.user.name || "",
+      addedAt: skill.addedAt ? new Date(skill.addedAt) : /* @__PURE__ */ new Date()
+    }));
+    if (skillsToInsert.length > 0) {
+      await db.insert(schema.externalSkills).values(skillsToInsert);
+    }
+  }
+  logger.info({ workspaceId: session.workspace.id, fields: Object.keys(updateData) }, "Workspace settings updating");
+  let settings;
+  if (existing) {
+    const [updated] = await db.update(schema.workspaceSettings).set(updateData).where(eq(schema.workspaceSettings.workspaceId, session.workspace.id)).returning();
+    settings = updated;
+  } else {
+    const [created] = await db.insert(schema.workspaceSettings).values({
+      workspaceId: session.workspace.id,
+      ...updateData
+    }).returning();
+    settings = created;
+  }
+  const skillRows = await db.select().from(schema.externalSkills).where(eq(schema.externalSkills.workspaceId, session.workspace.id));
+  const externalSkills = skillRows.map(rowToExternalSkill);
+  logger.info({ workspaceId: session.workspace.id, externalSkillsCount: externalSkills.length }, "Workspace settings updated");
+  return {
+    ...settings,
+    externalSkills: externalSkills.length > 0 ? externalSkills : null
+  };
+});

package/dist/runtime/server/api/workspace/usage.get.d.ts

@@ -0,0 +1,48 @@
+import { type BillingConfig } from '#chat-runtime/server/utils/billing';
+interface UsageRecord {
+    id: string;
+    conversationId: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    promptCost: number;
+    completionCost: number;
+    totalCost: number;
+    durationMs: number | null;
+    turns: number | null;
+    userId: string;
+    userEmail: string | null;
+    model: string | null;
+    createdAt: Date;
+}
+interface UsageSummary {
+    totalTokens: number;
+    totalCost: number;
+    breakdown: {
+        promptTokens: number;
+        completionTokens: number;
+        promptCost: number;
+        completionCost: number;
+    };
+}
+interface GroupedUsage {
+    key: string;
+    label: string;
+    totalTokens: number;
+    totalCost: number;
+    promptTokens: number;
+    completionTokens: number;
+    promptCost: number;
+    completionCost: number;
+    count: number;
+}
+export interface WorkspaceUsageResponse {
+    usage: UsageSummary;
+    records: UsageRecord[];
+    grouped?: GroupedUsage[];
+    cursor?: string;
+    hasMore: boolean;
+    billing: BillingConfig;
+}
+declare const _default: any;
+export default _default;