apteva 0.4.4 → 0.4.5

package/src/integrations/agentdojo.ts

@@ -0,0 +1,350 @@
+// AgentDojo Integration Provider
+// Connects to our hosted MCP API
+
+import type {
+  IntegrationProvider,
+  IntegrationApp,
+  ConnectedAccount,
+  ConnectionRequest,
+  ConnectionCredentials,
+} from "./index";
+
+// AgentDojo MCP API base URL
+const AGENTDOJO_API_BASE = process.env.AGENTDOJO_API_BASE || "https://api.agentdojo.dev";
+
+export const AgentDojoProvider: IntegrationProvider = {
+  id: "agentdojo",
+  name: "AgentDojo",
+
+  // List available toolkits as "apps"
+  async listApps(apiKey: string): Promise<IntegrationApp[]> {
+    const res = await fetch(`${AGENTDOJO_API_BASE}/toolkits?include_tools=true`, {
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!res.ok) {
+      console.error("AgentDojo listApps error:", res.status, await res.text());
+      return [];
+    }
+
+    const data = await res.json();
+    const toolkits = data.toolkits || [];
+
+    return toolkits.map((toolkit: any) => ({
+      id: toolkit.id,
+      name: toolkit.display_name || toolkit.name,
+      slug: toolkit.name,
+      description: toolkit.description || null,
+      logo: toolkit.icon_url || null,
+      categories: [],
+      // If toolkit requires auth, it needs API_KEY connection
+      authSchemes: toolkit.requires_auth ? ["API_KEY"] : ["NONE"],
+      toolsCount: toolkit.tools_count || toolkit.tools?.length || 0,
+      tools: toolkit.tools || [],
+    }));
+  },
+
+  // List user's credentials (stored locally, validated against toolkits)
+  async listConnectedAccounts(apiKey: string, userId: string): Promise<ConnectedAccount[]> {
+    // Get list of credentials from our credentials API
+    const res = await fetch(`${AGENTDOJO_API_BASE}/credentials`, {
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!res.ok) {
+      console.error("AgentDojo listConnectedAccounts error:", res.status, await res.text());
+      return [];
+    }
+
+    const data = await res.json();
+    const credentials = data.data || data.credentials || [];
+
+    return credentials.map((cred: any) => ({
+      id: cred.id,
+      appId: cred.provider_id || cred.toolkit_id || cred.provider_name,
+      appName: cred.provider_name || cred.toolkit_name || cred.provider_id,
+      status: cred.is_valid !== false ? "active" : "failed",
+      createdAt: cred.created_at || new Date().toISOString(),
+      metadata: {
+        keyHint: cred.key_hint,
+      },
+    }));
+  },
+
+  // Store credentials for a toolkit
+  async initiateConnection(
+    apiKey: string,
+    userId: string,
+    appSlug: string,
+    redirectUrl: string,
+    credentials?: ConnectionCredentials
+  ): Promise<ConnectionRequest> {
+    if (!credentials?.apiKey) {
+      throw new Error("API key is required for AgentDojo connections");
+    }
+
+    // Store the credential
+    const res = await fetch(`${AGENTDOJO_API_BASE}/credentials`, {
+      method: "POST",
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        provider_id: appSlug,
+        provider_name: appSlug,
+        api_key: credentials.apiKey,
+      }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      console.error("AgentDojo initiateConnection error:", res.status, text);
+      throw new Error(`Failed to store credentials: ${text}`);
+    }
+
+    const data = await res.json();
+
+    return {
+      redirectUrl: null, // No OAuth redirect
+      connectionId: data.data?.id || data.id,
+      status: "active", // Credentials are immediately active
+    };
+  },
+
+  async getConnectionStatus(apiKey: string, connectionId: string): Promise<ConnectedAccount | null> {
+    const res = await fetch(`${AGENTDOJO_API_BASE}/credentials`, {
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!res.ok) return null;
+
+    const data = await res.json();
+    const credentials = data.data || data.credentials || [];
+    const cred = credentials.find((c: any) => c.id === connectionId);
+
+    if (!cred) return null;
+
+    return {
+      id: cred.id,
+      appId: cred.provider_id || cred.toolkit_id,
+      appName: cred.provider_name || cred.toolkit_name,
+      status: "active",
+      createdAt: cred.created_at || new Date().toISOString(),
+    };
+  },
+
+  async disconnect(apiKey: string, connectionId: string): Promise<boolean> {
+    const res = await fetch(`${AGENTDOJO_API_BASE}/credentials/${connectionId}`, {
+      method: "DELETE",
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json",
+      },
+    });
+
+    return res.ok;
+  },
+};
+
+// ============ AgentDojo MCP Server Management ============
+
+export interface AgentDojoServer {
+  id: string;
+  slug: string;
+  name: string;
+  description: string | null;
+  url: string;
+  tools: Array<{
+    id: string;
+    name: string;
+    description: string;
+  }>;
+  isActive: boolean;
+  createdAt: string;
+}
+
+export interface AgentDojoToolkit {
+  id: string;
+  name: string;
+  displayName: string;
+  description: string | null;
+  iconUrl: string | null;
+  toolsCount: number;
+  tools?: Array<{
+    id: string;
+    name: string;
+    displayName: string;
+    description: string;
+  }>;
+  status: string;
+  requiresAuth: boolean;
+}
+
+// List available toolkits
+export async function listToolkits(apiKey: string, includeTools = false): Promise<AgentDojoToolkit[]> {
+  const res = await fetch(
+    `${AGENTDOJO_API_BASE}/toolkits?include_tools=${includeTools}`,
+    {
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json",
+      },
+    }
+  );
+
+  if (!res.ok) {
+    console.error("Failed to list AgentDojo toolkits:", await res.text());
+    return [];
+  }
+
+  const data = await res.json();
+  const toolkits = data.toolkits || [];
+
+  return toolkits.map((t: any) => ({
+    id: t.id,
+    name: t.name,
+    displayName: t.display_name || t.name,
+    description: t.description,
+    iconUrl: t.icon_url,
+    toolsCount: t.tools_count || t.tools?.length || 0,
+    tools: t.tools?.map((tool: any) => ({
+      id: tool.id,
+      name: tool.name,
+      displayName: tool.display_name || tool.name,
+      description: tool.description,
+    })),
+    status: t.status || "active",
+    requiresAuth: t.requires_auth || false,
+  }));
+}
+
+// List user's MCP servers (configs)
+export async function listServers(apiKey: string, includeTools = false): Promise<AgentDojoServer[]> {
+  const res = await fetch(
+    `${AGENTDOJO_API_BASE}/servers?include_tools=${includeTools}`,
+    {
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json",
+      },
+    }
+  );
+
+  if (!res.ok) {
+    console.error("Failed to list AgentDojo servers:", await res.text());
+    return [];
+  }
+
+  const data = await res.json();
+  const servers = data.data || [];
+
+  return servers.map((s: any) => ({
+    id: s.id,
+    slug: s.slug,
+    name: s.name,
+    description: s.description,
+    url: s.url,
+    tools: s.tools || [],
+    isActive: s.is_active,
+    createdAt: s.created_at,
+  }));
+}
+
+// Create a new MCP server with selected toolkits
+export async function createServer(
+  apiKey: string,
+  name: string,
+  toolkits: string[],
+  description?: string
+): Promise<AgentDojoServer | null> {
+  const res = await fetch(`${AGENTDOJO_API_BASE}/servers`, {
+    method: "POST",
+    headers: {
+      "X-API-Key": apiKey,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      name,
+      toolkits,
+      description,
+    }),
+  });
+
+  if (!res.ok) {
+    const errText = await res.text();
+    console.error("Failed to create AgentDojo server:", errText);
+    throw new Error(`Failed to create server: ${errText}`);
+  }
+
+  const data = await res.json();
+  const server = data.data || data;
+
+  return {
+    id: server.id,
+    slug: server.slug,
+    name: server.name,
+    description: server.description,
+    url: server.url,
+    tools: server.tools || [],
+    isActive: server.is_active ?? true,
+    createdAt: server.created_at,
+  };
+}
+
+// Get a specific server
+export async function getServer(apiKey: string, serverId: string): Promise<AgentDojoServer | null> {
+  const res = await fetch(`${AGENTDOJO_API_BASE}/servers/${serverId}`, {
+    headers: {
+      "X-API-Key": apiKey,
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!res.ok) {
+    if (res.status === 404) return null;
+    console.error("Failed to get AgentDojo server:", await res.text());
+    return null;
+  }
+
+  const data = await res.json();
+  const server = data.data || data;
+
+  return {
+    id: server.id,
+    slug: server.slug,
+    name: server.name,
+    description: server.description,
+    url: server.url,
+    tools: server.tools || [],
+    isActive: server.is_active ?? true,
+    createdAt: server.created_at,
+  };
+}
+
+// Delete a server
+export async function deleteServer(apiKey: string, serverId: string): Promise<boolean> {
+  const res = await fetch(`${AGENTDOJO_API_BASE}/servers/${serverId}`, {
+    method: "DELETE",
+    headers: {
+      "X-API-Key": apiKey,
+      "Content-Type": "application/json",
+    },
+  });
+
+  return res.ok;
+}
+
+// Get the base URL for constructing MCP server URLs
+export function getBaseUrl(): string {
+  return AGENTDOJO_API_BASE;
+}

package/src/openapi.ts

@@ -69,6 +69,7 @@ The new access token will be returned and a new refresh token cookie will be set
     { name: "MCP", description: "Model Context Protocol servers" },
     { name: "Providers", description: "LLM providers and API keys" },
     { name: "Projects", description: "Agent grouping" },
+    { name: "Skills", description: "Agent skills management" },
     { name: "System", description: "Health and version info" },
   ],
   security: [{ BearerAuth: [] }],
@@ -1297,6 +1298,169 @@ eventSource.onmessage = (event) => {
         },
       },
     },
+    // Skills endpoints
+    "/skills": {
+      get: {
+        tags: ["Skills"],
+        summary: "List all skills",
+        description: "Returns all installed skills. Can filter by project.",
+        parameters: [
+          { name: "project", in: "query", schema: { type: "string" }, description: "Filter: 'all', 'global', or project ID" },
+          { name: "forAgent", in: "query", schema: { type: "string" }, description: "Agent's project ID (shows global + project)" },
+        ],
+        responses: {
+          "200": {
+            description: "List of skills",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    skills: { type: "array", items: { $ref: "#/components/schemas/Skill" } },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      post: {
+        tags: ["Skills"],
+        summary: "Create a new skill",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/SkillCreate" },
+            },
+          },
+        },
+        responses: {
+          "201": {
+            description: "Skill created",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Skill" },
+              },
+            },
+          },
+        },
+      },
+    },
+    "/skills/github/{owner}/{repo}": {
+      get: {
+        tags: ["Skills"],
+        summary: "List skills from GitHub repo",
+        description: "Fetches and lists all skills from a GitHub repository. Skills should be in subdirectories with SKILL.md files.",
+        parameters: [
+          { name: "owner", in: "path", required: true, schema: { type: "string" }, description: "GitHub repo owner" },
+          { name: "repo", in: "path", required: true, schema: { type: "string" }, description: "GitHub repo name" },
+        ],
+        responses: {
+          "200": {
+            description: "List of skills from repo",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    skills: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          name: { type: "string" },
+                          description: { type: "string" },
+                          path: { type: "string" },
+                          size: { type: "integer" },
+                          downloadUrl: { type: "string" },
+                        },
+                      },
+                    },
+                    repo: {
+                      type: "object",
+                      properties: {
+                        owner: { type: "string" },
+                        repo: { type: "string" },
+                        url: { type: "string" },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          "404": { description: "Repository not found" },
+        },
+      },
+    },
+    "/skills/github/install": {
+      post: {
+        tags: ["Skills"],
+        summary: "Install skill from GitHub",
+        description: "Downloads and installs a skill from a GitHub repository.",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                required: ["owner", "repo", "skillName", "downloadUrl"],
+                properties: {
+                  owner: { type: "string", description: "GitHub repo owner" },
+                  repo: { type: "string", description: "GitHub repo name" },
+                  skillName: { type: "string", description: "Name of the skill to install" },
+                  downloadUrl: { type: "string", description: "Raw URL to the SKILL.md file" },
+                  projectId: { type: "string", nullable: true, description: "Project ID (null for global)" },
+                },
+              },
+            },
+          },
+        },
+        responses: {
+          "201": {
+            description: "Skill installed",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Skill" },
+              },
+            },
+          },
+          "400": { description: "Skill already exists or invalid request" },
+        },
+      },
+    },
+    "/skills/{skillId}": {
+      get: {
+        tags: ["Skills"],
+        summary: "Get skill by ID",
+        parameters: [
+          { name: "skillId", in: "path", required: true, schema: { type: "string" } },
+        ],
+        responses: {
+          "200": {
+            description: "Skill details",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Skill" },
+              },
+            },
+          },
+          "404": { description: "Skill not found" },
+        },
+      },
+      delete: {
+        tags: ["Skills"],
+        summary: "Delete skill",
+        parameters: [
+          { name: "skillId", in: "path", required: true, schema: { type: "string" } },
+        ],
+        responses: {
+          "200": { description: "Skill deleted" },
+          "404": { description: "Skill not found" },
+        },
+      },
+    },
   },
   components: {
     securitySchemes: {
@@ -1493,6 +1657,37 @@ eventSource.onmessage = (event) => {
           agentName: { type: "string" },
         },
       },
+      Skill: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          name: { type: "string" },
+          description: { type: "string" },
+          content: { type: "string" },
+          version: { type: "string" },
+          license: { type: "string", nullable: true },
+          compatibility: { type: "string", nullable: true },
+          metadata: { type: "object" },
+          allowed_tools: { type: "array", items: { type: "string" } },
+          source: { type: "string", enum: ["local", "skillsmp", "github", "import"] },
+          source_url: { type: "string", nullable: true },
+          enabled: { type: "boolean" },
+          project_id: { type: "string", nullable: true },
+          created_at: { type: "string", format: "date-time" },
+          updated_at: { type: "string", format: "date-time" },
+        },
+      },
+      SkillCreate: {
+        type: "object",
+        required: ["name", "description", "content"],
+        properties: {
+          name: { type: "string", description: "Skill name (lowercase, hyphens allowed)" },
+          description: { type: "string", description: "What this skill does" },
+          content: { type: "string", description: "Skill instructions in markdown" },
+          source: { type: "string", enum: ["local", "skillsmp", "github", "import"] },
+          project_id: { type: "string", nullable: true, description: "Project ID (null for global)" },
+        },
+      },
       McpServer: {
         type: "object",
         properties: {

package/src/providers.ts

@@ -175,7 +175,13 @@ export type ProviderId = keyof typeof PROVIDERS;
 // Provider Keys Management
 export const ProviderKeys = {
   // Save an API key (encrypts before storing)
-  async save(providerId: string, apiKey: string): Promise<{ success: boolean; error?: string }> {
+  // projectId: null = global key, string = project-scoped key
+  async save(
+    providerId: string,
+    apiKey: string,
+    projectId: string | null = null,
+    name: string | null = null
+  ): Promise<{ success: boolean; error?: string; id?: string }> {
     // Validate format
     const validation = validateKeyFormat(providerId, apiKey);
     if (!validation.valid) {
@@ -185,14 +191,14 @@ export const ProviderKeys = {
     try {
       const encryptedKey = encrypt(apiKey.trim());
       const keyHint = createKeyHint(apiKey.trim());
-      ProviderKeysDB.save(providerId, encryptedKey, keyHint);
-      return { success: true };
+      const record = ProviderKeysDB.save(providerId, encryptedKey, keyHint, projectId, name);
+      return { success: true, id: record.id };
     } catch (err) {
       return { success: false, error: `Failed to save key: ${err}` };
     }
   },
 
-  // Get decrypted API key for a provider
+  // Get decrypted API key for a provider (global key)
   getDecrypted(providerId: string): string | null {
     const record = ProviderKeysDB.findByProvider(providerId);
     if (!record) return null;
@@ -205,33 +211,93 @@ export const ProviderKeys = {
     }
   },
 
-  // Check if a provider has a key configured
+  // Get decrypted API key for a provider and project
+  // Falls back to global key if no project-specific key exists
+  getDecryptedForProject(providerId: string, projectId: string | null): string | null {
+    // Try project-specific key first
+    if (projectId) {
+      const projectRecord = ProviderKeysDB.findByProviderAndProject(providerId, projectId);
+      if (projectRecord) {
+        try {
+          return decrypt(projectRecord.encrypted_key);
+        } catch (err) {
+          console.error(`Failed to decrypt project key for ${providerId}/${projectId}:`, err);
+        }
+      }
+    }
+    // Fall back to global key
+    return this.getDecrypted(providerId);
+  },
+
+  // Check if a provider has a key configured (global)
   hasKey(providerId: string): boolean {
     return ProviderKeysDB.findByProvider(providerId) !== null;
   },
 
+  // Check if a provider has a key for a specific project (or global)
+  hasKeyForProject(providerId: string, projectId: string | null): boolean {
+    if (projectId && ProviderKeysDB.findByProviderAndProject(providerId, projectId)) {
+      return true;
+    }
+    return ProviderKeysDB.findByProvider(providerId) !== null;
+  },
+
   // Get all configured providers with their status (without exposing keys)
   getAll(): Array<{
+    id: string;
     provider_id: string;
     key_hint: string;
     is_valid: boolean;
     last_tested_at: string | null;
     created_at: string;
+    project_id: string | null;
+    name: string | null;
   }> {
     return ProviderKeysDB.findAll().map(k => ({
+      id: k.id,
       provider_id: k.provider_id,
       key_hint: k.key_hint,
       is_valid: k.is_valid,
       last_tested_at: k.last_tested_at,
       created_at: k.created_at,
+      project_id: k.project_id,
+      name: k.name,
     }));
   },
 
-  // Delete a provider key
+  // Get all keys for a specific provider
+  getAllByProvider(providerId: string): Array<{
+    id: string;
+    provider_id: string;
+    key_hint: string;
+    is_valid: boolean;
+    last_tested_at: string | null;
+    created_at: string;
+    project_id: string | null;
+    name: string | null;
+  }> {
+    return ProviderKeysDB.findAllByProvider(providerId).map(k => ({
+      id: k.id,
+      provider_id: k.provider_id,
+      key_hint: k.key_hint,
+      is_valid: k.is_valid,
+      last_tested_at: k.last_tested_at,
+      created_at: k.created_at,
+      project_id: k.project_id,
+      name: k.name,
+    }));
+  },
+
+  // Delete a provider key (global)
   delete(providerId: string): boolean {
     return ProviderKeysDB.delete(providerId);
   },
 
+  // Delete a provider key by ID
+  deleteById(id: string): boolean {
+    return ProviderKeysDB.deleteById(id);
+  },
+
   // Test if an API key is valid by making a test request
   // TODO: Implement actual API testing per provider (Anthropic needs POST, others GET)
   async test(providerId: string, apiKey?: string): Promise<{ valid: boolean; error?: string }> {
@@ -254,10 +320,15 @@ export const ProviderKeys = {
     return { valid: true };
   },
 
-  // Get list of provider IDs that have valid keys
+  // Get list of provider IDs that have valid keys (global only)
   getConfiguredProviders(): string[] {
     return ProviderKeysDB.getConfiguredProviders();
   },
+
+  // Get list of all provider IDs that have keys (including project-scoped)
+  getAllConfiguredProviders(): string[] {
+    return ProviderKeysDB.getAllConfiguredProviders();
+  },
 };
 
 // Onboarding status management