@vellumai/assistant 0.4.10 → 0.4.12

package/src/config/vellum-skills/chatgpt-import/tools/chatgpt-import.ts

@@ -1,295 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-
-import { eq } from 'drizzle-orm';
-import { v4 as uuid } from 'uuid';
-
-import { addMessage, createConversation, setConversationOriginInterfaceIfUnset } from '../../../../memory/conversation-store.js';
-import { getDb } from '../../../../memory/db.js';
-import { conversationKeys,conversations, messages as messagesTable } from '../../../../memory/schema.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-
-// -- ChatGPT export format types --
-
-interface ChatGPTContent {
-  content_type: string;
-  parts?: (string | null | Record<string, unknown>)[];
-}
-
-interface ChatGPTNode {
-  message: {
-    author: { role: string };
-    content: ChatGPTContent;
-    create_time?: number | null;
-  } | null;
-  parent: string | null;
-  children: string[];
-}
-
-interface ChatGPTConversation {
-  id?: string;
-  title: string;
-  create_time: number;
-  update_time: number;
-  current_node: string;
-  mapping: Record<string, ChatGPTNode>;
-}
-
-interface ImportedMessage {
-  role: string;
-  content: Array<{ type: string; text: string }>;
-  createdAt: number;
-}
-
-interface ImportedConversation {
-  sourceId: string;
-  title: string;
-  createdAt: number;
-  updatedAt: number;
-  messages: ImportedMessage[];
-}
-
-// -- Tool entry point --
-
-export async function run(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const filePath = input.file_path as string;
-
-  if (!filePath) {
-    return { content: 'Error: file_path is required', isError: true };
-  }
-
-  if (!filePath.endsWith('.zip')) {
-    return { content: 'Error: Only ZIP files are accepted. Please provide the ChatGPT export ZIP file.', isError: true };
-  }
-
-  if (!existsSync(filePath)) {
-    return { content: `Error: File not found: ${filePath}`, isError: true };
-  }
-
-  let imported: ImportedConversation[];
-  try {
-    imported = parseChatGPTExport(filePath);
-  } catch (err) {
-    return {
-      content: `Error parsing export file: ${err instanceof Error ? err.message : String(err)}`,
-      isError: true,
-    };
-  }
-
-  if (imported.length === 0) {
-    return { content: 'No conversations found in the export file.', isError: false };
-  }
-
-  const db = getDb();
-  let importedCount = 0;
-  let skippedCount = 0;
-  let messageCount = 0;
-
-  for (const conv of imported) {
-    const convKey = `chatgpt:${conv.sourceId}`;
-
-    const existing = db
-      .select()
-      .from(conversationKeys)
-      .where(eq(conversationKeys.conversationKey, convKey))
-      .get();
-
-    if (existing) {
-      skippedCount++;
-      continue;
-    }
-
-    const conversation = createConversation(conv.title);
-    const importChannelMetadata = {
-      userMessageChannel: 'vellum',
-      assistantMessageChannel: 'vellum',
-      userMessageInterface: 'vellum',
-      assistantMessageInterface: 'vellum',
-    } as const;
-
-    for (const msg of conv.messages) {
-      await addMessage(conversation.id, msg.role, JSON.stringify(msg.content), importChannelMetadata);
-    }
-
-    // addMessage auto-fills originChannel but not originInterface, so set it explicitly
-    setConversationOriginInterfaceIfUnset(conversation.id, 'vellum');
-
-    // Override timestamps to match ChatGPT originals
-    db.update(conversations)
-      .set({ createdAt: conv.createdAt, updatedAt: conv.updatedAt })
-      .where(eq(conversations.id, conversation.id))
-      .run();
-
-    // Update message timestamps to match ChatGPT originals
-    const dbMessages = db
-      .select({ id: messagesTable.id })
-      .from(messagesTable)
-      .where(eq(messagesTable.conversationId, conversation.id))
-      .orderBy(messagesTable.createdAt)
-      .all();
-
-    for (let i = 0; i < dbMessages.length && i < conv.messages.length; i++) {
-      db.update(messagesTable)
-        .set({ createdAt: conv.messages[i].createdAt })
-        .where(eq(messagesTable.id, dbMessages[i].id))
-        .run();
-    }
-
-    db.insert(conversationKeys)
-      .values({
-        id: uuid(),
-        conversationKey: convKey,
-        conversationId: conversation.id,
-        createdAt: Date.now(),
-      })
-      .run();
-
-    importedCount++;
-    messageCount += conv.messages.length;
-  }
-
-  const lines = [`Imported ${importedCount} conversation(s) with ${messageCount} message(s).`];
-  if (skippedCount > 0) {
-    lines.push(`Skipped ${skippedCount} already-imported conversation(s).`);
-  }
-  return { content: lines.join('\n'), isError: false };
-}
-
-// -- Parser --
-
-function parseChatGPTExport(zipPath: string): ImportedConversation[] {
-  const jsonContent = extractConversationsJsonFromZip(zipPath);
-
-  const raw = JSON.parse(jsonContent);
-  if (!Array.isArray(raw)) {
-    throw new Error('Expected conversations.json to contain a JSON array');
-  }
-
-  const results: ImportedConversation[] = [];
-  for (const conv of raw as ChatGPTConversation[]) {
-    const imported = parseConversation(conv);
-    if (imported) {
-      results.push(imported);
-    }
-  }
-  return results;
-}
-
-function parseConversation(conv: ChatGPTConversation): ImportedConversation | null {
-  const { mapping, current_node } = conv;
-  if (!mapping || !current_node || !mapping[current_node]) return null;
-
-  // Walk from current_node to root via parent pointers, then reverse for chronological order
-  const nodeIds: string[] = [];
-  let nodeId: string | null = current_node;
-  while (nodeId) {
-    nodeIds.push(nodeId);
-    nodeId = mapping[nodeId]?.parent ?? null;
-  }
-  nodeIds.reverse();
-
-  const messages: ImportedMessage[] = [];
-  for (const id of nodeIds) {
-    const node = mapping[id];
-    if (!node?.message) continue;
-
-    const { author, content, create_time } = node.message;
-    const role = author?.role;
-    if (role !== 'user' && role !== 'assistant') continue;
-
-    const text = extractText(content);
-    if (!text) continue;
-
-    messages.push({
-      role,
-      content: [{ type: 'text', text }],
-      createdAt: create_time ? Math.round(create_time * 1000) : Math.round(conv.create_time * 1000),
-    });
-  }
-
-  if (messages.length === 0) return null;
-
-  return {
-    sourceId: conv.id ?? `${conv.title}-${conv.create_time}`,
-    title: conv.title || 'Untitled',
-    createdAt: Math.round(conv.create_time * 1000),
-    updatedAt: Math.round(conv.update_time * 1000),
-    messages,
-  };
-}
-
-function extractText(content: ChatGPTContent): string {
-  if (!content?.parts) return '';
-  return content.parts.filter((p): p is string => typeof p === 'string').join('');
-}
-
-// -- ZIP extraction --
-
-function extractConversationsJsonFromZip(zipPath: string): string {
-  const buffer = readFileSync(zipPath);
-
-  // Find end of central directory record (EOCD signature: 0x06054b50)
-  let eocdOffset = -1;
-  for (let i = buffer.length - 22; i >= 0; i--) {
-    if (buffer[i] === 0x50 && buffer[i + 1] === 0x4b && buffer[i + 2] === 0x05 && buffer[i + 3] === 0x06) {
-      eocdOffset = i;
-      break;
-    }
-  }
-  if (eocdOffset === -1) {
-    throw new Error('Invalid ZIP file: could not find end of central directory');
-  }
-
-  const centralDirOffset = buffer.readUInt32LE(eocdOffset + 16);
-  const centralDirEntries = buffer.readUInt16LE(eocdOffset + 10);
-
-  // Walk central directory to find conversations.json
-  let offset = centralDirOffset;
-  for (let i = 0; i < centralDirEntries; i++) {
-    if (buffer[offset] !== 0x50 || buffer[offset + 1] !== 0x4b || buffer[offset + 2] !== 0x01 || buffer[offset + 3] !== 0x02) {
-      throw new Error('Invalid ZIP central directory entry');
-    }
-
-    const cdCompressedSize = buffer.readUInt32LE(offset + 20);
-    const fileNameLength = buffer.readUInt16LE(offset + 28);
-    const extraLength = buffer.readUInt16LE(offset + 30);
-    const commentLength = buffer.readUInt16LE(offset + 32);
-    const localHeaderOffset = buffer.readUInt32LE(offset + 42);
-    const fileName = buffer.subarray(offset + 46, offset + 46 + fileNameLength).toString('utf-8');
-
-    if (fileName === 'conversations.json' || fileName.endsWith('/conversations.json')) {
-      return extractLocalFile(buffer, localHeaderOffset, cdCompressedSize);
-    }
-
-    offset += 46 + fileNameLength + extraLength + commentLength;
-  }
-
-  throw new Error('conversations.json not found in ZIP file');
-}
-
-function extractLocalFile(buffer: Buffer, offset: number, cdCompressedSize: number): string {
-  if (buffer[offset] !== 0x50 || buffer[offset + 1] !== 0x4b || buffer[offset + 2] !== 0x03 || buffer[offset + 3] !== 0x04) {
-    throw new Error('Invalid ZIP local file header');
-  }
-
-  const compressionMethod = buffer.readUInt16LE(offset + 8);
-  const localCompressedSize = buffer.readUInt32LE(offset + 18);
-  const compressedSize = cdCompressedSize > 0 ? cdCompressedSize : localCompressedSize;
-  const fileNameLength = buffer.readUInt16LE(offset + 26);
-  const extraLength = buffer.readUInt16LE(offset + 28);
-
-  const dataOffset = offset + 30 + fileNameLength + extraLength;
-  const fileData = buffer.subarray(dataOffset, dataOffset + compressedSize);
-
-  if (compressionMethod === 0) {
-    return fileData.toString('utf-8');
-  } else if (compressionMethod === 8) {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { inflateRawSync } = require('node:zlib') as typeof import('node:zlib');
-    return inflateRawSync(fileData).toString('utf-8');
-  } else {
-    throw new Error(`Unsupported ZIP compression method: ${compressionMethod}`);
-  }
-}

package/src/skills/vellum-catalog-remote.ts

@@ -1,166 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { gunzipSync } from 'node:zlib';
-
-import type { CatalogEntry } from '../tools/skills/vellum-catalog.js';
-import { getLogger } from '../util/logger.js';
-import { readPlatformToken } from '../util/platform.js';
-
-const log = getLogger('vellum-catalog-remote');
-
-const PLATFORM_URL = process.env.VELLUM_ASSISTANT_PLATFORM_URL ?? 'https://assistant.vellum.ai';
-
-const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
-
-interface CatalogManifest {
-  version: number;
-  skills: CatalogEntry[];
-}
-
-let cachedEntries: CatalogEntry[] | null = null;
-let cacheTimestamp = 0;
-
-function getBundledCatalogPath(): string {
-  return join(import.meta.dir, '..', 'config', 'vellum-skills', 'catalog.json');
-}
-
-function loadBundledCatalog(): CatalogEntry[] {
-  try {
-    const raw = readFileSync(getBundledCatalogPath(), 'utf-8');
-    const manifest: CatalogManifest = JSON.parse(raw);
-    return manifest.skills ?? [];
-  } catch (err) {
-    log.warn({ err }, 'Failed to read bundled catalog.json');
-    return [];
-  }
-}
-
-function getBundledSkillContent(skillId: string): string | null {
-  try {
-    const skillPath = join(import.meta.dir, '..', 'config', 'vellum-skills', skillId, 'SKILL.md');
-    return readFileSync(skillPath, 'utf-8');
-  } catch {
-    return null;
-  }
-}
-
-/** Build request headers, including platform token when available. */
-function buildPlatformHeaders(): Record<string, string> {
-  const headers: Record<string, string> = {};
-  const token = readPlatformToken();
-  if (token) {
-    headers['X-Session-Token'] = token;
-  }
-  return headers;
-}
-
-/**
- * Fetch catalog entries from the platform API. Falls back to bundled copy.
- * Reads the platform token from ~/.vellum/platform-token automatically.
- */
-export async function fetchCatalogEntries(): Promise<CatalogEntry[]> {
-  const now = Date.now();
-  if (cachedEntries && now - cacheTimestamp < CACHE_TTL_MS) {
-    return cachedEntries;
-  }
-
-  try {
-    const url = `${PLATFORM_URL}/v1/skills/`;
-    const response = await fetch(url, {
-      headers: buildPlatformHeaders(),
-      signal: AbortSignal.timeout(5000),
-    });
-
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-
-    const manifest: CatalogManifest = await response.json();
-    const skills = manifest.skills;
-    if (!Array.isArray(skills) || skills.length === 0) {
-      throw new Error('Platform catalog has invalid or empty skills array');
-    }
-    cachedEntries = skills;
-    cacheTimestamp = now;
-    log.info({ count: cachedEntries.length }, 'Fetched vellum-skills catalog from platform API');
-    return cachedEntries;
-  } catch (err) {
-    log.warn({ err }, 'Failed to fetch catalog from platform API, falling back to bundled copy');
-    const bundled = loadBundledCatalog();
-    // Cache the bundled result too so we don't re-fetch on every call during outage
-    cachedEntries = bundled;
-    cacheTimestamp = now;
-    return bundled;
-  }
-}
-
-/**
- * Extract SKILL.md content from a tar archive (uncompressed).
- * Tar format: 512-byte header blocks followed by file data blocks.
- */
-function extractSkillMdFromTar(tarBuffer: Buffer): string | null {
-  let offset = 0;
-  while (offset + 512 <= tarBuffer.length) {
-    const header = tarBuffer.subarray(offset, offset + 512);
-
-    // Check for end-of-archive (two consecutive zero blocks)
-    if (header.every((b) => b === 0)) break;
-
-    // Extract filename (bytes 0-99, null-terminated)
-    const nameEnd = header.indexOf(0, 0);
-    const name = header.subarray(0, Math.min(nameEnd >= 0 ? nameEnd : 100, 100)).toString('utf-8');
-
-    // Extract file size (bytes 124-135, octal string)
-    const sizeStr = header.subarray(124, 136).toString('utf-8').trim();
-    const size = parseInt(sizeStr, 8) || 0;
-
-    offset += 512; // move past header
-
-    if (name.endsWith('SKILL.md') || name === 'SKILL.md') {
-      return tarBuffer.subarray(offset, offset + size).toString('utf-8');
-    }
-
-    // Skip to next header (data blocks are padded to 512 bytes)
-    offset += Math.ceil(size / 512) * 512;
-  }
-  return null;
-}
-
-/**
- * Fetch a skill's SKILL.md content from the platform tar API.
- * GET /v1/skills/{skill_id}/ returns a tar.gz archive containing all skill files.
- * Falls back to bundled copy on failure.
- */
-export async function fetchSkillContent(skillId: string): Promise<string | null> {
-  try {
-    const url = `${PLATFORM_URL}/v1/skills/${encodeURIComponent(skillId)}/`;
-    const response = await fetch(url, {
-      headers: buildPlatformHeaders(),
-      signal: AbortSignal.timeout(15000),
-    });
-
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-
-    const gzipBuffer = Buffer.from(await response.arrayBuffer());
-    const tarBuffer = gunzipSync(gzipBuffer);
-    const skillMd = extractSkillMdFromTar(tarBuffer);
-
-    if (skillMd) {
-      return skillMd;
-    }
-
-    log.warn({ skillId }, 'SKILL.md not found in platform tar archive, falling back to bundled');
-  } catch (err) {
-    log.warn({ err, skillId }, 'Failed to fetch skill content from platform API, falling back to bundled');
-  }
-
-  return getBundledSkillContent(skillId);
-}
-
-/** Check if a skill ID exists in the catalog. */
-export async function checkVellumSkill(skillId: string): Promise<boolean> {
-  const entries = await fetchCatalogEntries();
-  return entries.some((e) => e.id === skillId);
-}

package/src/tools/skills/vellum-catalog.ts

@@ -1,168 +0,0 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { parseFrontmatterFields } from '../../skills/frontmatter.js';
-import { createManagedSkill } from '../../skills/managed-store.js';
-import { checkVellumSkill,fetchCatalogEntries, fetchSkillContent } from '../../skills/vellum-catalog-remote.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-
-export interface CatalogEntry {
-  id: string;
-  name: string;
-  description: string;
-  emoji?: string;
-  includes?: string[];
-  version?: string;
-}
-
-export { checkVellumSkill,fetchCatalogEntries as listCatalogEntries };
-
-/**
- * Install a skill from the vellum-skills catalog by ID.
- * Fetches SKILL.md from GitHub (with bundled fallback) and creates a managed skill.
- * Returns { success, skillName, error }.
- */
-export async function installFromVellumCatalog(skillId: string, options?: { overwrite?: boolean }): Promise<{ success: boolean; skillName?: string; error?: string }> {
-  const trimmedId = skillId.trim();
-
-  // Verify skill exists in catalog and get its metadata
-  const catalogEntries = await fetchCatalogEntries();
-  const catalogEntry = catalogEntries.find((e) => e.id === trimmedId);
-  if (!catalogEntry) {
-    return { success: false, error: `Skill "${trimmedId}" not found in the Vellum catalog` };
-  }
-
-  // Fetch SKILL.md content (remote with bundled fallback)
-  const content = await fetchSkillContent(trimmedId);
-  if (!content) {
-    return { success: false, error: `Skill "${trimmedId}" SKILL.md not found` };
-  }
-
-  const parsed = parseFrontmatterFields(content);
-  if (!parsed) {
-    return { success: false, error: `Skill "${trimmedId}" has invalid SKILL.md` };
-  }
-
-  const { fields, body: bodyMarkdown } = parsed;
-
-  const name = fields.name?.trim();
-  const description = fields.description?.trim();
-  if (!name || !description) {
-    return { success: false, error: `Skill "${trimmedId}" has invalid SKILL.md (missing name or description)` };
-  }
-
-  let emoji: string | undefined;
-  const metadataRaw = fields.metadata?.trim();
-  if (metadataRaw) {
-    try {
-      const metaObj = JSON.parse(metadataRaw);
-      if (metaObj?.vellum?.emoji) {
-        emoji = metaObj.vellum.emoji as string;
-      }
-    } catch {
-      // ignore malformed metadata
-    }
-  }
-
-  let includes: string[] | undefined;
-  const includesRaw = fields.includes?.trim();
-  if (includesRaw) {
-    try {
-      const includesObj = JSON.parse(includesRaw);
-      if (Array.isArray(includesObj) && includesObj.every((item: unknown) => typeof item === 'string')) {
-        const filtered = (includesObj as string[]).map((s) => s.trim()).filter((s) => s.length > 0);
-        if (filtered.length > 0) includes = filtered;
-      }
-    } catch {
-      // ignore malformed includes
-    }
-  }
-  const result = createManagedSkill({
-    id: trimmedId,
-    name,
-    description,
-    bodyMarkdown,
-    emoji,
-    includes,
-    overwrite: options?.overwrite ?? true,
-    addToIndex: true,
-    version: catalogEntry.version,
-  });
-
-  if (!result.created) {
-    return { success: false, error: result.error };
-  }
-
-  return { success: true, skillName: trimmedId };
-}
-
-class VellumSkillsCatalogTool implements Tool {
-  name = 'vellum_skills_catalog';
-  description = 'List and install Vellum-provided skills from the first-party catalog';
-  category = 'skills';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          action: {
-            type: 'string',
-            enum: ['list', 'install'],
-            description: 'The operation to perform. "list" shows available skills; "install" copies a skill to managed skills.',
-          },
-          skill_id: {
-            type: 'string',
-            description: 'The skill ID to install (required for install action).',
-          },
-          overwrite: {
-            type: 'boolean',
-            description: 'Whether to overwrite if the skill is already installed (default: false).',
-          },
-        },
-        required: ['action'],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const action = input.action as string;
-
-    switch (action) {
-      case 'list': {
-        const entries = await fetchCatalogEntries();
-        if (entries.length === 0) {
-          return { content: 'No Vellum-provided skills available in the catalog.', isError: false };
-        }
-        return { content: JSON.stringify(entries, null, 2), isError: false };
-      }
-
-      case 'install': {
-        const skillId = input.skill_id;
-        if (typeof skillId !== 'string' || !skillId.trim()) {
-          return { content: 'Error: skill_id is required for install action', isError: true };
-        }
-
-        const result = await installFromVellumCatalog(skillId, { overwrite: input.overwrite === true });
-        if (!result.success) {
-          return { content: `Error: ${result.error}`, isError: true };
-        }
-
-        return {
-          content: JSON.stringify({
-            installed: true,
-            skill_id: result.skillName,
-          }),
-          isError: false,
-        };
-      }
-
-      default:
-        return { content: `Error: unknown action "${action}". Use "list" or "install".`, isError: true };
-    }
-  }
-}
-
-export const vellumSkillsCatalogTool: Tool = new VellumSkillsCatalogTool();