veryfront 0.0.48 → 0.0.50

package/dist/integrations/anthropic/files/ai/tools/list-api-keys.ts

@@ -0,0 +1,64 @@
+import { tool } from 'veryfront/ai';
+import { z } from 'zod';
+import { getAnthropicAdminClient } from '../../lib/anthropic-admin-client';
+
+/**
+ * Tool for listing API keys in the Anthropic organization
+ */
+export const listAPIKeys = tool({
+  name: 'list_api_keys',
+  description:
+    'List all API keys for the organization or a specific workspace. Returns key metadata including name, status, type, and usage information. The actual key values are not returned for security reasons.',
+  parameters: z.object({
+    workspaceId: z
+      .string()
+      .optional()
+      .describe(
+        'Optional workspace ID to filter API keys by workspace. If not provided, lists all organization API keys'
+      ),
+  }),
+  execute: async ({ workspaceId }) => {
+    try {
+      const client = getAnthropicAdminClient();
+      const result = await client.listAPIKeys(workspaceId);
+
+      // Group keys by status and type for summary
+      const activeKeys = result.api_keys.filter(key => key.status === 'active');
+      const revokedKeys = result.api_keys.filter(
+        key => key.status === 'revoked'
+      );
+
+      const keysByType = result.api_keys.reduce(
+        (acc, key) => {
+          acc[key.key_type] = (acc[key.key_type] || 0) + 1;
+          return acc;
+        },
+        {} as Record<string, number>
+      );
+
+      return {
+        success: true,
+        api_keys: result.api_keys,
+        summary: {
+          total: result.api_keys.length,
+          active: activeKeys.length,
+          revoked: revokedKeys.length,
+          by_type: keysByType,
+          workspace_id: workspaceId,
+        },
+        message: workspaceId
+          ? `Found ${result.api_keys.length} API key(s) for workspace ${workspaceId}`
+          : `Found ${result.api_keys.length} API key(s) in the organization`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error ? error.message : 'Failed to list API keys',
+        api_keys: [],
+      };
+    }
+  },
+});
+
+export default listAPIKeys;

package/dist/integrations/anthropic/files/ai/tools/list-members.ts

@@ -0,0 +1,65 @@
+import { tool } from 'veryfront/ai';
+import { z } from 'zod';
+import { getAnthropicAdminClient } from '../../lib/anthropic-admin-client';
+
+/**
+ * Tool for listing members in the Anthropic organization
+ */
+export const listMembers = tool({
+  name: 'list_members',
+  description:
+    'List all members in the Anthropic organization. Returns member details including email, role, status, and activity information.',
+  parameters: z.object({}),
+  execute: async () => {
+    try {
+      const client = getAnthropicAdminClient();
+      const result = await client.listMembers();
+
+      // Group members by role and status for summary
+      const membersByRole = result.members.reduce(
+        (acc, member) => {
+          acc[member.role] = (acc[member.role] || 0) + 1;
+          return acc;
+        },
+        {} as Record<string, number>
+      );
+
+      const membersByStatus = result.members.reduce(
+        (acc, member) => {
+          acc[member.status] = (acc[member.status] || 0) + 1;
+          return acc;
+        },
+        {} as Record<string, number>
+      );
+
+      const activeMembers = result.members.filter(
+        member => member.status === 'active'
+      );
+      const pendingMembers = result.members.filter(
+        member => member.status === 'pending'
+      );
+
+      return {
+        success: true,
+        members: result.members,
+        summary: {
+          total: result.members.length,
+          active: activeMembers.length,
+          pending: pendingMembers.length,
+          by_role: membersByRole,
+          by_status: membersByStatus,
+        },
+        message: `Found ${result.members.length} member(s) in the organization`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error ? error.message : 'Failed to list members',
+        members: [],
+      };
+    }
+  },
+});
+
+export default listMembers;

package/dist/integrations/anthropic/files/ai/tools/list-workspaces.ts

@@ -0,0 +1,35 @@
+import { tool } from 'veryfront/ai';
+import { z } from 'zod';
+import { getAnthropicAdminClient } from '../../lib/anthropic-admin-client';
+
+/**
+ * Tool for listing all workspaces in the Anthropic organization
+ */
+export const listWorkspaces = tool({
+  name: 'list_workspaces',
+  description:
+    'List all workspaces in the Anthropic organization. Workspaces allow you to organize API keys, usage, and permissions for different teams or projects.',
+  parameters: z.object({}),
+  execute: async () => {
+    try {
+      const client = getAnthropicAdminClient();
+      const result = await client.listWorkspaces();
+
+      return {
+        success: true,
+        workspaces: result.workspaces,
+        count: result.workspaces.length,
+        message: `Found ${result.workspaces.length} workspace(s)`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error ? error.message : 'Failed to list workspaces',
+        workspaces: [],
+      };
+    }
+  },
+});
+
+export default listWorkspaces;

package/dist/integrations/anthropic/files/lib/anthropic-admin-client.ts

@@ -0,0 +1,264 @@
+/**
+ * Anthropic Admin API Client
+ *
+ * Provides methods to interact with the Anthropic Admin API for organization management.
+ * Requires an admin API key with appropriate permissions.
+ *
+ * @see https://docs.anthropic.com/en/api/admin-api
+ */
+
+const ANTHROPIC_ADMIN_API_BASE_URL = 'https://api.anthropic.com/v1/admin';
+
+export interface AnthropicWorkspace {
+  id: string;
+  name: string;
+  display_name: string;
+  created_at: string;
+}
+
+export interface AnthropicUsageRecord {
+  workspace_id: string;
+  date: string;
+  model: string;
+  input_tokens: number;
+  output_tokens: number;
+  cache_creation_tokens?: number;
+  cache_read_tokens?: number;
+  total_cost_usd: number;
+}
+
+export interface AnthropicAPIKey {
+  id: string;
+  name: string;
+  workspace_id?: string;
+  created_at: string;
+  last_used_at?: string;
+  status: 'active' | 'revoked';
+  key_type: 'admin' | 'workspace' | 'service';
+}
+
+export interface AnthropicMember {
+  id: string;
+  email: string;
+  role: 'owner' | 'admin' | 'member' | 'developer';
+  status: 'active' | 'pending' | 'inactive';
+  created_at: string;
+  last_active_at?: string;
+}
+
+export interface AnthropicOrganization {
+  id: string;
+  name: string;
+  display_name: string;
+  created_at: string;
+  settings: {
+    default_model?: string;
+    rate_limit_tier?: string;
+    billing_email?: string;
+  };
+}
+
+export interface AnthropicUsageOptions {
+  startDate: string;
+  endDate: string;
+  workspaceId?: string;
+  model?: string;
+  granularity?: 'day' | 'hour';
+}
+
+export class AnthropicAdminError extends Error {
+  constructor(
+    message: string,
+    public statusCode?: number,
+    public response?: unknown
+  ) {
+    super(message);
+    this.name = 'AnthropicAdminError';
+  }
+}
+
+/**
+ * Client for interacting with the Anthropic Admin API
+ */
+export class AnthropicAdminClient {
+  private apiKey: string;
+  private baseUrl: string;
+
+  constructor(apiKey?: string, baseUrl?: string) {
+    this.apiKey = apiKey || process.env.ANTHROPIC_ADMIN_API_KEY || '';
+    this.baseUrl = baseUrl || ANTHROPIC_ADMIN_API_BASE_URL;
+
+    if (!this.apiKey) {
+      throw new AnthropicAdminError(
+        'ANTHROPIC_ADMIN_API_KEY is required. Please set it in your environment variables.'
+      );
+    }
+
+    if (!this.apiKey.startsWith('sk-ant-')) {
+      throw new AnthropicAdminError(
+        'Invalid Anthropic API key format. Admin keys should start with "sk-ant-"'
+      );
+    }
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit = {}
+  ): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`;
+
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        'x-api-key': this.apiKey,
+        'anthropic-version': '2023-06-01',
+        'Content-Type': 'application/json',
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new AnthropicAdminError(
+        errorData.error?.message || `API request failed: ${response.statusText}`,
+        response.status,
+        errorData
+      );
+    }
+
+    return response.json();
+  }
+
+  /**
+   * List all workspaces in the organization
+   */
+  async listWorkspaces(): Promise<{ workspaces: AnthropicWorkspace[] }> {
+    return this.request<{ workspaces: AnthropicWorkspace[] }>('/workspaces');
+  }
+
+  /**
+   * Get details for a specific workspace
+   */
+  async getWorkspace(workspaceId: string): Promise<AnthropicWorkspace> {
+    if (!workspaceId) {
+      throw new AnthropicAdminError('workspaceId is required');
+    }
+    return this.request<AnthropicWorkspace>(`/workspaces/${workspaceId}`);
+  }
+
+  /**
+   * Get API usage statistics for a date range
+   *
+   * @param options - Usage query options
+   * @returns Usage records grouped by date, workspace, and model
+   */
+  async getUsage(options: AnthropicUsageOptions): Promise<{
+    usage: AnthropicUsageRecord[];
+    total_cost_usd: number;
+  }> {
+    const { startDate, endDate, workspaceId, model, granularity = 'day' } = options;
+
+    if (!startDate || !endDate) {
+      throw new AnthropicAdminError('startDate and endDate are required');
+    }
+
+    // Validate date format (YYYY-MM-DD)
+    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+    if (!dateRegex.test(startDate) || !dateRegex.test(endDate)) {
+      throw new AnthropicAdminError(
+        'Dates must be in YYYY-MM-DD format'
+      );
+    }
+
+    const params = new URLSearchParams({
+      start_date: startDate,
+      end_date: endDate,
+      granularity,
+    });
+
+    if (workspaceId) {
+      params.append('workspace_id', workspaceId);
+    }
+
+    if (model) {
+      params.append('model', model);
+    }
+
+    return this.request<{
+      usage: AnthropicUsageRecord[];
+      total_cost_usd: number;
+    }>(`/usage?${params.toString()}`);
+  }
+
+  /**
+   * List API keys for the organization or a specific workspace
+   */
+  async listAPIKeys(workspaceId?: string): Promise<{ api_keys: AnthropicAPIKey[] }> {
+    const endpoint = workspaceId
+      ? `/workspaces/${workspaceId}/api-keys`
+      : '/api-keys';
+
+    return this.request<{ api_keys: AnthropicAPIKey[] }>(endpoint);
+  }
+
+  /**
+   * List all members in the organization
+   */
+  async listMembers(): Promise<{ members: AnthropicMember[] }> {
+    return this.request<{ members: AnthropicMember[] }>('/members');
+  }
+
+  /**
+   * Get organization details and settings
+   */
+  async getOrganization(): Promise<AnthropicOrganization> {
+    return this.request<AnthropicOrganization>('/organization');
+  }
+
+  /**
+   * Create a new API key (admin functionality)
+   */
+  async createAPIKey(data: {
+    name: string;
+    workspace_id?: string;
+    key_type?: 'workspace' | 'service';
+  }): Promise<{ api_key: AnthropicAPIKey & { key: string } }> {
+    return this.request<{ api_key: AnthropicAPIKey & { key: string } }>(
+      '/api-keys',
+      {
+        method: 'POST',
+        body: JSON.stringify(data),
+      }
+    );
+  }
+
+  /**
+   * Revoke an API key
+   */
+  async revokeAPIKey(keyId: string): Promise<{ success: boolean }> {
+    if (!keyId) {
+      throw new AnthropicAdminError('keyId is required');
+    }
+
+    return this.request<{ success: boolean }>(
+      `/api-keys/${keyId}/revoke`,
+      {
+        method: 'POST',
+      }
+    );
+  }
+}
+
+/**
+ * Get a singleton instance of the Anthropic Admin client
+ */
+let client: AnthropicAdminClient | null = null;
+
+export function getAnthropicAdminClient(): AnthropicAdminClient {
+  if (!client) {
+    client = new AnthropicAdminClient();
+  }
+  return client;
+}
+
+export default AnthropicAdminClient;

package/dist/integrations/asana/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "asana",
+  "displayName": "Asana",
+  "icon": "asana.svg",
+  "description": "Manage tasks, projects, and teams in Asana",
+  "auth": {
+    "type": "oauth2",
+    "provider": "asana",
+    "authorizationUrl": "https://app.asana.com/-/oauth_authorize",
+    "tokenUrl": "https://app.asana.com/-/oauth_token",
+    "scopes": ["default"],
+    "callbackPath": "/api/auth/asana/callback",
+    "requiredApis": [
+      {
+        "name": "Asana Developer Console",
+        "enableUrl": "https://app.asana.com/0/developer-console"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "ASANA_CLIENT_ID",
+      "description": "Asana OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developers.asana.com/docs/oauth"
+    },
+    {
+      "name": "ASANA_CLIENT_SECRET",
+      "description": "Asana OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developers.asana.com/docs/oauth"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-tasks",
+      "name": "List Tasks",
+      "description": "List tasks in a project or assigned to a user",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-task",
+      "name": "Get Task",
+      "description": "Get details of a specific task",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-task",
+      "name": "Create Task",
+      "description": "Create a new task in a project",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-task",
+      "name": "Update Task",
+      "description": "Update an existing task",
+      "requiresWrite": true
+    },
+    {
+      "id": "list-projects",
+      "name": "List Projects",
+      "description": "List all projects in the workspace",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "my-tasks",
+      "title": "Show my tasks",
+      "prompt": "List all tasks assigned to me in Asana with their due dates and priorities.",
+      "category": "productivity",
+      "icon": "list"
+    },
+    {
+      "id": "create-task",
+      "title": "Create a task",
+      "prompt": "Create a new task with a title, description, due date, and assignee.",
+      "category": "productivity",
+      "icon": "plus"
+    }
+  ],
+  "suggestedWith": ["slack", "notion", "calendar"]
+}

package/dist/integrations/asana/files/_env.example

@@ -0,0 +1,4 @@
+# Asana OAuth Configuration
+# Get your credentials from https://app.asana.com/0/developer-console
+ASANA_CLIENT_ID=your-client-id
+ASANA_CLIENT_SECRET=your-client-secret

package/dist/integrations/asana/files/ai/tools/create-task.ts

@@ -0,0 +1,34 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createTask } from "../../lib/asana-client.ts";
+
+export default tool({
+  id: "create-task",
+  description: "Create a new task in an Asana project.",
+  inputSchema: z.object({
+    projectGid: z.string().describe("The GID of the project to create the task in"),
+    name: z.string().describe("The name/title of the task"),
+    notes: z.string().optional().describe("Description or notes for the task"),
+    dueOn: z.string().optional().describe("Due date in YYYY-MM-DD format"),
+    assigneeGid: z.string().optional().describe("GID of the user to assign the task to"),
+  }),
+  async execute({ projectGid, name, notes, dueOn, assigneeGid }) {
+    const task = await createTask({
+      projectGid,
+      name,
+      notes,
+      dueOn,
+      assigneeGid,
+    });
+
+    return {
+      success: true,
+      task: {
+        gid: task.gid,
+        name: task.name,
+        dueOn: task.due_on,
+        assignee: task.assignee?.name,
+      },
+    };
+  },
+});

package/dist/integrations/asana/files/ai/tools/get-task.ts

@@ -0,0 +1,26 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getTask } from "../../lib/asana-client.ts";
+
+export default tool({
+  id: "get-task",
+  description: "Get details of a specific Asana task by its GID.",
+  inputSchema: z.object({
+    taskGid: z.string().describe("The GID of the task to retrieve"),
+  }),
+  async execute({ taskGid }) {
+    const task = await getTask(taskGid);
+
+    return {
+      gid: task.gid,
+      name: task.name,
+      notes: task.notes,
+      completed: task.completed,
+      dueOn: task.due_on,
+      assignee: task.assignee?.name,
+      projects: task.projects.map((p) => ({ gid: p.gid, name: p.name })),
+      createdAt: task.created_at,
+      modifiedAt: task.modified_at,
+    };
+  },
+});

package/dist/integrations/asana/files/ai/tools/list-projects.ts

@@ -0,0 +1,26 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listProjects, listWorkspaces } from "../../lib/asana-client.ts";
+
+export default tool({
+  id: "list-projects",
+  description: "List all projects in the Asana workspace.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(50).default(20).describe("Maximum number of projects to return"),
+  }),
+  async execute({ limit }) {
+    const workspaces = await listWorkspaces();
+    if (workspaces.length === 0) {
+      return { projects: [], message: "No workspaces found" };
+    }
+
+    const projects = await listProjects(workspaces[0].gid);
+
+    return projects.slice(0, limit).map((project) => ({
+      gid: project.gid,
+      name: project.name,
+      notes: project.notes,
+      createdAt: project.created_at,
+    }));
+  },
+});

package/dist/integrations/asana/files/ai/tools/list-tasks.ts

@@ -0,0 +1,50 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getMe, listTasks, listWorkspaces } from "../../lib/asana-client.ts";
+
+export default tool({
+  id: "list-tasks",
+  description:
+    "List tasks from Asana. Can filter by project or get tasks assigned to the current user.",
+  inputSchema: z.object({
+    projectGid: z.string().optional().describe("Project GID to list tasks from"),
+    assignedToMe: z.boolean().default(false).describe("List tasks assigned to the current user"),
+    includeCompleted: z.boolean().default(false).describe("Include completed tasks"),
+    limit: z.number().min(1).max(50).default(20).describe("Maximum number of tasks to return"),
+  }),
+  async execute({ projectGid, assignedToMe, includeCompleted, limit }) {
+    let tasks;
+
+    if (assignedToMe) {
+      const me = await getMe();
+      const workspaces = await listWorkspaces();
+      if (workspaces.length === 0) {
+        return { tasks: [], message: "No workspaces found" };
+      }
+      tasks = await listTasks({
+        assigneeGid: me.gid,
+        workspaceGid: workspaces[0].gid,
+        completedSince: includeCompleted ? undefined : "now",
+      });
+    } else if (projectGid) {
+      tasks = await listTasks({
+        projectGid,
+        completedSince: includeCompleted ? undefined : "now",
+      });
+    } else {
+      return {
+        tasks: [],
+        message: "Please specify either a projectGid or set assignedToMe to true",
+      };
+    }
+
+    return tasks.slice(0, limit).map((task) => ({
+      gid: task.gid,
+      name: task.name,
+      completed: task.completed,
+      dueOn: task.due_on,
+      assignee: task.assignee?.name,
+      projects: task.projects.map((p) => p.name),
+    }));
+  },
+});

package/dist/integrations/asana/files/ai/tools/update-task.ts

@@ -0,0 +1,36 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateTask } from "../../lib/asana-client.ts";
+
+export default tool({
+  id: "update-task",
+  description: "Update an existing Asana task.",
+  inputSchema: z.object({
+    taskGid: z.string().describe("The GID of the task to update"),
+    name: z.string().optional().describe("New name/title for the task"),
+    notes: z.string().optional().describe("New description or notes"),
+    completed: z.boolean().optional().describe("Mark the task as completed or not"),
+    dueOn: z.string().optional().describe("New due date in YYYY-MM-DD format"),
+    assigneeGid: z.string().optional().describe("GID of the user to reassign the task to"),
+  }),
+  async execute({ taskGid, name, notes, completed, dueOn, assigneeGid }) {
+    const task = await updateTask(taskGid, {
+      name,
+      notes,
+      completed,
+      dueOn,
+      assigneeGid,
+    });
+
+    return {
+      success: true,
+      task: {
+        gid: task.gid,
+        name: task.name,
+        completed: task.completed,
+        dueOn: task.due_on,
+        assignee: task.assignee?.name,
+      },
+    };
+  },
+});