@framers/agentos-ext-cloud-vercel 0.1.0 → 0.1.1

package/src/tools/deploy.ts

@@ -1,59 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview VercelDeployTool — deploy a project to Vercel from a Git repository.
- */
-
-import type { VercelService, DeployResult } from '../VercelService.js';
-
-export interface VercelDeployInput {
-  gitUrl: string;
-  projectName?: string;
-  framework?: string;
-  buildCommand?: string;
-  outputDirectory?: string;
-  envVars?: Record<string, string>;
-  target?: 'production' | 'preview';
-}
-
-export class VercelDeployTool {
-  readonly id = 'vercelDeploy';
-  readonly name = 'vercelDeploy';
-  readonly displayName = 'Deploy to Vercel';
-  readonly description = 'Deploy a project to Vercel from a Git repository URL. Creates the project if it does not exist. Supports Next.js, React, Vue, Svelte, static sites, and serverless functions with automatic framework detection.';
-  readonly category = 'cloud';
-  readonly version = '0.1.0';
-  readonly hasSideEffects = true;
-
-  readonly inputSchema = {
-    type: 'object' as const,
-    properties: {
-      gitUrl: { type: 'string', description: 'Git repository URL (e.g. "https://github.com/user/repo")' },
-      projectName: { type: 'string', description: 'Project name on Vercel (auto-generated from repo name if omitted)' },
-      framework: { type: 'string', description: 'Framework preset (e.g. "nextjs", "vite", "gatsby"). Auto-detected if omitted.' },
-      buildCommand: { type: 'string', description: 'Build command override (e.g. "npm run build")' },
-      outputDirectory: { type: 'string', description: 'Output directory override (e.g. "dist", ".next", "build")' },
-      envVars: { type: 'object', description: 'Environment variables to set on the project (key-value pairs)' },
-      target: { type: 'string', enum: ['production', 'preview'], description: 'Deployment target (default: production)' },
-    },
-    required: ['gitUrl'],
-  };
-
-  constructor(private service: VercelService) {}
-
-  async execute(args: VercelDeployInput): Promise<{ success: boolean; data?: DeployResult; error?: string }> {
-    try {
-      const result = await this.service.deployFromGit({
-        gitUrl: args.gitUrl,
-        projectName: args.projectName,
-        framework: args.framework,
-        buildCommand: args.buildCommand,
-        outputDirectory: args.outputDirectory,
-        envVars: args.envVars,
-      });
-
-      return { success: true, data: result };
-    } catch (err: any) {
-      return { success: false, error: err.message };
-    }
-  }
-}

package/src/tools/getDeployment.ts

@@ -1,35 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview VercelGetDeploymentTool — check the status of a Vercel deployment.
- */
-
-import type { VercelService, VercelDeployment } from '../VercelService.js';
-
-export class VercelGetDeploymentTool {
-  readonly id = 'vercelGetDeployment';
-  readonly name = 'vercelGetDeployment';
-  readonly displayName = 'Get Deployment Status';
-  readonly description = 'Check the current status of a Vercel deployment by its ID. Returns state (BUILDING, READY, ERROR), URL, and inspector link.';
-  readonly category = 'cloud';
-  readonly version = '0.1.0';
-  readonly hasSideEffects = false;
-
-  readonly inputSchema = {
-    type: 'object' as const,
-    properties: {
-      deploymentId: { type: 'string', description: 'The deployment ID or URL to check' },
-    },
-    required: ['deploymentId'],
-  };
-
-  constructor(private service: VercelService) {}
-
-  async execute(args: { deploymentId: string }): Promise<{ success: boolean; data?: VercelDeployment; error?: string }> {
-    try {
-      const deployment = await this.service.getDeployment(args.deploymentId);
-      return { success: true, data: deployment };
-    } catch (err: any) {
-      return { success: false, error: err.message };
-    }
-  }
-}

package/src/tools/listProjects.ts

@@ -1,35 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview VercelListProjectsTool — list all projects on a Vercel account.
- */
-
-import type { VercelService, VercelProject } from '../VercelService.js';
-
-export class VercelListProjectsTool {
-  readonly id = 'vercelListProjects';
-  readonly name = 'vercelListProjects';
-  readonly displayName = 'List Vercel Projects';
-  readonly description = 'List all projects in the connected Vercel account. Shows project name, framework, linked Git repo, and latest deployment status.';
-  readonly category = 'cloud';
-  readonly version = '0.1.0';
-  readonly hasSideEffects = false;
-
-  readonly inputSchema = {
-    type: 'object' as const,
-    properties: {
-      limit: { type: 'number', description: 'Maximum number of projects to return (default: 20, max: 100)' },
-    },
-    required: [] as string[],
-  };
-
-  constructor(private service: VercelService) {}
-
-  async execute(args: { limit?: number }): Promise<{ success: boolean; data?: VercelProject[]; error?: string }> {
-    try {
-      const projects = await this.service.listProjects(args.limit ?? 20);
-      return { success: true, data: projects };
-    } catch (err: any) {
-      return { success: false, error: err.message };
-    }
-  }
-}

package/src/tools/setEnvVars.ts

@@ -1,65 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview VercelSetEnvVarsTool — set environment variables on a Vercel project.
- */
-
-import type { VercelService, VercelEnvVar } from '../VercelService.js';
-
-export interface SetEnvVarsInput {
-  projectId: string;
-  vars?: Record<string, string>;
-  action?: 'set' | 'list';
-  target?: ('production' | 'preview' | 'development')[];
-}
-
-export class VercelSetEnvVarsTool {
-  readonly id = 'vercelSetEnvVars';
-  readonly name = 'vercelSetEnvVars';
-  readonly displayName = 'Set Environment Variables';
-  readonly description = 'Set or list environment variables on a Vercel project. Variables are encrypted at rest. Targets production, preview, and development environments by default.';
-  readonly category = 'cloud';
-  readonly version = '0.1.0';
-  readonly hasSideEffects = true;
-
-  readonly inputSchema = {
-    type: 'object' as const,
-    properties: {
-      projectId: { type: 'string', description: 'Vercel project ID or name' },
-      vars: { type: 'object', description: 'Key-value pairs of environment variables to set' },
-      action: { type: 'string', enum: ['set', 'list'], description: 'Action to perform (default: set)' },
-      target: {
-        type: 'array',
-        items: { type: 'string', enum: ['production', 'preview', 'development'] },
-        description: 'Deployment targets for the variables (default: all three)',
-      },
-    },
-    required: ['projectId'],
-  };
-
-  constructor(private service: VercelService) {}
-
-  async execute(args: SetEnvVarsInput): Promise<{
-    success: boolean;
-    data?: { set: number } | VercelEnvVar[];
-    error?: string;
-  }> {
-    try {
-      const action = args.action ?? 'set';
-
-      if (action === 'list') {
-        const envVars = await this.service.listEnvVars(args.projectId);
-        return { success: true, data: envVars };
-      }
-
-      if (!args.vars || Object.keys(args.vars).length === 0) {
-        return { success: false, error: 'No environment variables provided. Pass vars as a key-value object.' };
-      }
-
-      const target = args.target ?? ['production', 'preview', 'development'];
-      await this.service.setEnvVars(args.projectId, args.vars, target);
-      return { success: true, data: { set: Object.keys(args.vars).length } };
-    } catch (err: any) {
-      return { success: false, error: err.message };
-    }
-  }
-}

package/test/VercelService.test.ts

@@ -1,464 +0,0 @@
-// @ts-nocheck
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { VercelService } from '../src/VercelService.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function mockResponse(data: unknown, status = 200): Response {
-  return {
-    ok: status >= 200 && status < 300,
-    status,
-    text: () => Promise.resolve(typeof data === 'string' ? data : JSON.stringify(data)),
-    json: () => Promise.resolve(data),
-    headers: new Headers(),
-  } as unknown as Response;
-}
-
-const TOKEN = 'test-vercel-token';
-const TEAM_ID = 'team_abc123';
-
-function createService(teamId?: string) {
-  return new VercelService({
-    token: TOKEN,
-    teamId,
-    baseUrl: 'https://api.vercel.com',
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('VercelService', () => {
-  let mockFetch: ReturnType<typeof vi.fn>;
-  let service: VercelService;
-
-  beforeEach(() => {
-    mockFetch = vi.fn();
-    vi.stubGlobal('fetch', mockFetch);
-    service = createService();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  // ── initialize / shutdown ─────────────────────────────────────────────
-
-  describe('initialize', () => {
-    it('should set isRunning to true on successful auth', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({ user: { id: 'u1' } }));
-
-      await service.initialize();
-
-      expect(service.isRunning).toBe(true);
-      expect(mockFetch).toHaveBeenCalledWith(
-        'https://api.vercel.com/v2/user',
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: `Bearer ${TOKEN}`,
-          }),
-        }),
-      );
-    });
-
-    it('should throw on auth failure', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse('Unauthorized', 401));
-
-      await expect(service.initialize()).rejects.toThrow('Vercel auth failed: 401');
-      expect(service.isRunning).toBe(false);
-    });
-  });
-
-  describe('shutdown', () => {
-    it('should set isRunning to false', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({ user: {} }));
-      await service.initialize();
-      expect(service.isRunning).toBe(true);
-
-      await service.shutdown();
-      expect(service.isRunning).toBe(false);
-    });
-  });
-
-  // ── Team query parameter ──────────────────────────────────────────────
-
-  describe('team scoping', () => {
-    it('should append teamId as query param when configured', async () => {
-      const teamService = createService(TEAM_ID);
-      mockFetch.mockResolvedValueOnce(mockResponse({ projects: [] }));
-
-      await teamService.listProjects();
-
-      const url = mockFetch.mock.calls[0][0] as string;
-      expect(url).toContain(`teamId=${TEAM_ID}`);
-    });
-
-    it('should use & separator when path already has query params', async () => {
-      const teamService = createService(TEAM_ID);
-      mockFetch.mockResolvedValueOnce(mockResponse({ projects: [] }));
-
-      await teamService.listProjects(5);
-
-      const url = mockFetch.mock.calls[0][0] as string;
-      expect(url).toContain('?limit=5&teamId=');
-    });
-  });
-
-  // ── Projects ──────────────────────────────────────────────────────────
-
-  describe('listProjects', () => {
-    it('should return mapped projects', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        projects: [
-          { id: 'p1', name: 'my-app', framework: 'nextjs', createdAt: 1000, updatedAt: 2000 },
-          { id: 'p2', name: 'api', framework: null, createdAt: 1500, updatedAt: 2500 },
-        ],
-      }));
-
-      const projects = await service.listProjects();
-
-      expect(projects).toHaveLength(2);
-      expect(projects[0]).toEqual({
-        id: 'p1',
-        name: 'my-app',
-        framework: 'nextjs',
-        createdAt: 1000,
-        updatedAt: 2000,
-        latestDeployments: undefined,
-        link: undefined,
-      });
-    });
-
-    it('should pass limit as query parameter', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({ projects: [] }));
-
-      await service.listProjects(5);
-
-      const url = mockFetch.mock.calls[0][0] as string;
-      expect(url).toContain('limit=5');
-    });
-
-    it('should return empty array when no projects', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({ projects: undefined }));
-
-      const projects = await service.listProjects();
-      expect(projects).toEqual([]);
-    });
-  });
-
-  describe('getProject', () => {
-    it('should return a single mapped project', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        id: 'p1',
-        name: 'my-app',
-        framework: 'nextjs',
-        createdAt: 1000,
-        updatedAt: 2000,
-        link: { type: 'github', repo: 'my-app', org: 'acme' },
-      }));
-
-      const project = await service.getProject('my-app');
-
-      expect(project.id).toBe('p1');
-      expect(project.link).toEqual({ type: 'github', repo: 'my-app', org: 'acme' });
-    });
-
-    it('should throw on non-OK response', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse('Not Found', 404));
-
-      await expect(service.getProject('nonexistent')).rejects.toThrow('Vercel API 404');
-    });
-  });
-
-  describe('createProject', () => {
-    it('should create a project linked to a GitHub repo', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        id: 'p-new',
-        name: 'my-app',
-        framework: 'nextjs',
-        createdAt: 3000,
-        updatedAt: 3000,
-      }));
-
-      const project = await service.createProject('my-app', 'https://github.com/acme/my-app', {
-        framework: 'nextjs',
-      });
-
-      expect(project.id).toBe('p-new');
-
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.gitRepository).toEqual({ type: 'github', repo: 'acme/my-app' });
-      expect(body.framework).toBe('nextjs');
-    });
-
-    it('should detect GitLab provider', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        id: 'p-gl', name: 'gl-app', framework: null, createdAt: 0, updatedAt: 0,
-      }));
-
-      await service.createProject('gl-app', 'https://gitlab.com/org/gl-app');
-
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.gitRepository.type).toBe('gitlab');
-    });
-
-    it('should throw for unparseable git URL', async () => {
-      await expect(
-        service.createProject('bad', 'https://example.com/repo'),
-      ).rejects.toThrow('Cannot parse git URL');
-    });
-  });
-
-  // ── Deployments ───────────────────────────────────────────────────────
-
-  describe('createDeployment', () => {
-    it('should trigger a production deployment by default', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        id: 'dpl_1',
-        url: 'my-app-abc.vercel.app',
-        readyState: 'BUILDING',
-        inspectorUrl: 'https://vercel.com/inspect/dpl_1',
-        projectId: 'p1',
-      }));
-
-      const result = await service.createDeployment('my-app');
-
-      expect(result.id).toBe('dpl_1');
-      expect(result.url).toBe('https://my-app-abc.vercel.app');
-      expect(result.readyState).toBe('BUILDING');
-
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.target).toBe('production');
-    });
-
-    it('should include gitRef when provided', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        id: 'dpl_2', url: 'x.vercel.app', readyState: 'QUEUED', projectId: 'p1',
-      }));
-
-      await service.createDeployment('my-app', { target: 'preview', gitRef: 'feature/xyz' });
-
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.target).toBe('preview');
-      expect(body.gitSource).toEqual({ ref: 'feature/xyz' });
-    });
-  });
-
-  describe('deployFromGit', () => {
-    it('should create project if it does not exist, set env vars, then deploy', async () => {
-      // getProject -> 404
-      mockFetch.mockResolvedValueOnce(mockResponse('Not Found', 404));
-      // createProject -> success
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        id: 'p-new', name: 'my-repo', framework: null, createdAt: 0, updatedAt: 0,
-      }));
-      // setEnvVars -> POST env
-      mockFetch.mockResolvedValueOnce(mockResponse({}, 200));
-      // createDeployment
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        id: 'dpl_3', url: 'my-repo.vercel.app', readyState: 'BUILDING', projectId: 'p-new',
-      }));
-
-      const result = await service.deployFromGit({
-        gitUrl: 'https://github.com/acme/my-repo',
-        envVars: { NODE_ENV: 'production' },
-      });
-
-      expect(result.id).toBe('dpl_3');
-      expect(mockFetch).toHaveBeenCalledTimes(4);
-    });
-
-    it('should reuse existing project when it exists', async () => {
-      // getProject -> success
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        id: 'p-existing', name: 'my-repo', framework: null, createdAt: 0, updatedAt: 0,
-      }));
-      // createDeployment
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        id: 'dpl_4', url: 'my-repo.vercel.app', readyState: 'BUILDING', projectId: 'p-existing',
-      }));
-
-      const result = await service.deployFromGit({
-        gitUrl: 'https://github.com/acme/my-repo',
-      });
-
-      expect(result.id).toBe('dpl_4');
-      // No createProject call, no setEnvVars call
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('getDeployment', () => {
-    it('should return mapped deployment', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        uid: 'dpl_1', name: 'my-app', url: 'https://my-app.vercel.app',
-        state: 'READY', created: 5000, inspectorUrl: 'https://inspect/1',
-      }));
-
-      const deployment = await service.getDeployment('dpl_1');
-
-      expect(deployment.uid).toBe('dpl_1');
-      expect(deployment.state).toBe('READY');
-      expect(deployment.url).toBe('https://my-app.vercel.app');
-    });
-
-    it('should prefix url with https if missing', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        uid: 'dpl_2', name: 'app', url: 'app-xyz.vercel.app', state: 'BUILDING', created: 0,
-      }));
-
-      const deployment = await service.getDeployment('dpl_2');
-      expect(deployment.url).toBe('https://app-xyz.vercel.app');
-    });
-  });
-
-  describe('listDeployments', () => {
-    it('should return mapped deployments with projectId filter', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        deployments: [
-          { uid: 'd1', name: 'a', url: 'a.vercel.app', state: 'READY', created: 100 },
-          { uid: 'd2', name: 'b', url: 'b.vercel.app', state: 'BUILDING', created: 200 },
-        ],
-      }));
-
-      const deps = await service.listDeployments('p1', 5);
-
-      expect(deps).toHaveLength(2);
-      const url = mockFetch.mock.calls[0][0] as string;
-      expect(url).toContain('projectId=p1');
-      expect(url).toContain('limit=5');
-    });
-  });
-
-  // ── Domains ───────────────────────────────────────────────────────────
-
-  describe('addDomain', () => {
-    it('should add a domain to a project', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        name: 'example.com', verified: true, configured: false,
-      }));
-
-      const domain = await service.addDomain('p1', 'example.com');
-
-      expect(domain.name).toBe('example.com');
-      expect(domain.verified).toBe(true);
-      expect(domain.configured).toBe(false);
-    });
-
-    it('should forward optional domain settings', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        name: 'old.example.com', verified: true, configured: true,
-        redirect: 'new.example.com', redirectStatusCode: 301,
-      }));
-
-      const domain = await service.addDomain('p1', 'old.example.com', {
-        redirect: 'new.example.com',
-        redirectStatusCode: 301,
-      });
-
-      expect(domain.redirect).toBe('new.example.com');
-      expect(domain.redirectStatusCode).toBe(301);
-
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.redirect).toBe('new.example.com');
-    });
-  });
-
-  describe('removeDomain', () => {
-    it('should send DELETE request', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({}, 200));
-
-      await service.removeDomain('p1', 'example.com');
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.stringContaining('/v9/projects/p1/domains/example.com'),
-        expect.objectContaining({ method: 'DELETE' }),
-      );
-    });
-  });
-
-  describe('listDomains', () => {
-    it('should return mapped domain list', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        domains: [
-          { name: 'a.com', verified: true, configured: true },
-          { name: 'b.com', verified: false, configured: false },
-        ],
-      }));
-
-      const domains = await service.listDomains('p1');
-      expect(domains).toHaveLength(2);
-      expect(domains[0].name).toBe('a.com');
-    });
-  });
-
-  describe('getDomainConfig', () => {
-    it('should return domain DNS configuration', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        configuredBy: 'CNAME',
-        nameservers: ['ns1.vercel-dns.com'],
-        misconfigured: false,
-        cnames: ['cname.vercel-dns.com'],
-        aValues: ['76.76.21.21'],
-      }));
-
-      const config = await service.getDomainConfig('example.com');
-
-      expect(config.configuredBy).toBe('CNAME');
-      expect(config.misconfigured).toBe(false);
-      expect(config.aValues).toContain('76.76.21.21');
-    });
-  });
-
-  // ── Environment Variables ─────────────────────────────────────────────
-
-  describe('setEnvVars', () => {
-    it('should create env vars via POST', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({}, 200));
-      mockFetch.mockResolvedValueOnce(mockResponse({}, 200));
-
-      await service.setEnvVars('p1', { API_KEY: 'abc', SECRET: 'xyz' });
-
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.key).toBe('API_KEY');
-      expect(body.type).toBe('encrypted');
-    });
-
-    it('should patch env var when it already exists', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse(
-        { error: { code: 'ENV_ALREADY_EXISTS', envId: 'env_123' } },
-        409,
-      ));
-      // PATCH call
-      mockFetch.mockResolvedValueOnce(mockResponse({}, 200));
-
-      await service.setEnvVars('p1', { EXISTING_KEY: 'new-value' });
-
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-      const patchUrl = mockFetch.mock.calls[1][0] as string;
-      expect(patchUrl).toContain('/env/env_123');
-    });
-  });
-
-  describe('listEnvVars', () => {
-    it('should return mapped env vars', async () => {
-      mockFetch.mockResolvedValueOnce(mockResponse({
-        envs: [
-          { key: 'NODE_ENV', value: 'production', target: ['production'], type: 'plain' },
-          { key: 'SECRET', target: ['production', 'preview'], type: 'encrypted' },
-        ],
-      }));
-
-      const vars = await service.listEnvVars('p1');
-
-      expect(vars).toHaveLength(2);
-      expect(vars[0].key).toBe('NODE_ENV');
-      expect(vars[0].value).toBe('production');
-      expect(vars[1].value).toBe('(encrypted)');
-    });
-  });
-});