acp-vscode 0.3.8 → 0.3.9

package/__tests__/fetcher-verbose-integration.test.js

@@ -0,0 +1,274 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const axios = require('axios');
+jest.mock('axios');
+
+let fetcher;
+let fetchIndex;
+let diskPaths;
+const cache = require('../src/cache');
+
+describe('fetcher verbose logging integration tests', () => {
+  const tmp = path.join(os.tmpdir(), `acp-fetcher-integration-${Date.now()}`);
+  const origCwd = process.cwd();
+  let origNodeEnv;
+
+  beforeAll(async () => {
+    await fs.ensureDir(tmp);
+    process.chdir(tmp);
+    origNodeEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'test';
+    // require after chdir so diskPaths uses tmp cwd
+    fetcher = require('../src/fetcher');
+    fetchIndex = fetcher.fetchIndex;
+    diskPaths = fetcher.diskPaths;
+  });
+
+  afterAll(async () => {
+    process.chdir(origCwd);
+    if (origNodeEnv === undefined) {
+      delete process.env.NODE_ENV;
+    } else {
+      process.env.NODE_ENV = origNodeEnv;
+    }
+    await fs.remove(tmp);
+  });
+
+  beforeEach(async () => {
+    cache.del('index');
+    const { DISK_CACHE_DIR } = diskPaths();
+    await fs.remove(DISK_CACHE_DIR).catch(() => {});
+    axios.get.mockReset();
+    // Clear env vars
+    delete process.env.ACP_INDEX_JSON;
+    delete process.env.ACP_REPOS_JSON;
+  });
+
+  test('verbose logging works through complete flow: env var -> parse -> fetch -> cache', async () => {
+    const testRepoConfig = [
+      {
+        id: 'test-acp-cli',
+        treeUrl: 'https://api.github.com/repos/AndyG-0/test-acp-cli/git/trees/main?recursive=1',
+        rawBase: 'https://raw.githubusercontent.com/AndyG-0/test-acp-cli/main'
+      }
+    ];
+    process.env.ACP_REPOS_JSON = JSON.stringify(testRepoConfig);
+    
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      // Mock the GitHub API responses
+      axios.get.mockImplementation((url) => {
+        if (url === 'https://api.github.com/repos/AndyG-0/test-acp-cli/git/trees/main?recursive=1') {
+          return Promise.resolve({
+            status: 200,
+            data: {
+              tree: [
+                { type: 'blob', path: 'prompts/sample-prompt.prompt.md' },
+                { type: 'blob', path: 'agents/sample-agent.agent.md' },
+                { type: 'blob', path: 'instructions/sample-instructions.instructions.md' },
+                { type: 'blob', path: 'skills/sample-skill/skill.md' },
+                { type: 'tree', path: 'skills/sample-skill' }
+              ]
+            }
+          });
+        }
+        // Mock content fetches
+        if (url.includes('raw.githubusercontent.com')) {
+          return Promise.resolve({
+            status: 200,
+            data: '---\ntitle: "Test Sample"\nversion: 1.0.0\n---\nContent here'
+          });
+        }
+        return Promise.reject(new Error('Unexpected URL: ' + url));
+      });
+      
+      const result = await fetchIndex({ verbose: true });
+      
+      // Verify the verbose logs captured key events
+      expect(logs.some(l => l.includes('fetchIndex called'))).toBe(true);
+      expect(logs.some(l => l.includes('ACP_REPOS_JSON environment variable detected'))).toBe(true);
+      expect(logs.some(l => l.includes('successfully parsed ACP_REPOS_JSON'))).toBe(true);
+      expect(logs.some(l => l.includes('using repos from ACP_REPOS_JSON: test-acp-cli'))).toBe(true);
+      expect(logs.some(l => l.includes('fetching tree for repo: test-acp-cli'))).toBe(true);
+      expect(logs.some(l => l.includes('successfully fetched tree for repo: test-acp-cli'))).toBe(true);
+      expect(logs.some(l => l.includes('blob items'))).toBe(true);
+      expect(logs.some(l => l.includes('prompts'))).toBe(true);
+      expect(logs.some(l => l.includes('agents'))).toBe(true);
+      expect(logs.some(l => l.includes('combined index contains:'))).toBe(true);
+      expect(logs.some(l => l.includes('disk cache written'))).toBe(true);
+      expect(logs.some(l => l.includes('index successfully built and cached'))).toBe(true);
+      
+      // Verify the index was built correctly
+      expect(result).toHaveProperty('prompts');
+      expect(result).toHaveProperty('agents');
+      expect(result).toHaveProperty('instructions');
+      expect(result).toHaveProperty('skills');
+      expect(result).toHaveProperty('_repos');
+      // Now includes both the default awesome-copilot repo and test-acp-cli
+      expect(result._repos.length).toBeGreaterThanOrEqual(2);
+      expect(result._repos.some(r => r.id === 'test-acp-cli')).toBe(true);
+      expect(result._repos.some(r => r.id === 'awesome-copilot')).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('verbose logging shows configuration source priority', async () => {
+    // Test 1: With ACP_REPOS_JSON env var (highest priority)
+    const testRepoConfig = [
+      { id: 'from-env', treeUrl: 'https://api.test/env', rawBase: 'https://raw.test/env' }
+    ];
+    process.env.ACP_REPOS_JSON = JSON.stringify(testRepoConfig);
+    
+    const logs1 = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs1.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { tree: [{ type: 'blob', path: 'prompts/p.prompt.md' }] } });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs1.some(l => l.includes('ACP_REPOS_JSON environment variable detected'))).toBe(true);
+      expect(logs1.some(l => l.includes('from-env'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+    
+    // Clear env var and test file-based config
+    delete process.env.ACP_REPOS_JSON;
+    cache.del('index');
+    const { DISK_CACHE_DIR } = diskPaths();
+    await fs.remove(DISK_CACHE_DIR);
+    
+    // Test 2: With acp-repos.json file (second priority)
+    const baseDir = process.cwd();
+    const repoFile = path.join(baseDir, 'acp-repos.json');
+    const fileRepoConfig = [
+      { id: 'from-file', treeUrl: 'https://api.test/file', rawBase: 'https://raw.test/file' }
+    ];
+    await fs.writeJson(repoFile, fileRepoConfig);
+    
+    const logs2 = [];
+    console.log = jest.fn(msg => logs2.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { tree: [{ type: 'blob', path: 'prompts/p.prompt.md' }] } });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs2.some(l => l.includes('acp-repos.json found'))).toBe(true);
+      expect(logs2.some(l => l.includes('from-file'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+    
+    // Clear file and test default config
+    await fs.remove(repoFile);
+    cache.del('index');
+    await fs.remove(DISK_CACHE_DIR);
+    
+    // Test 3: With defaults (lowest priority)
+    const logs3 = [];
+    console.log = jest.fn(msg => logs3.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { tree: [{ type: 'blob', path: 'prompts/p.prompt.md' }] } });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs3.some(l => l.includes('awesome-copilot'))).toBe(true);
+      // Now the final repos list should include awesome-copilot plus any configured repos
+      expect(logs3.some(l => l.includes('final repos list:'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('verbose logging captures and reports specific repo fetch errors', async () => {
+    const testRepoConfig = [
+      {
+        id: 'good-repo',
+        treeUrl: 'https://api.test/good',
+        rawBase: 'https://raw.test/good'
+      },
+      {
+        id: 'bad-repo-invalid-json',
+        treeUrl: 'https://api.test/badjson',
+        rawBase: 'https://raw.test/badjson'
+      },
+      {
+        id: 'bad-repo-network',
+        treeUrl: 'https://api.test/badnetwork',
+        rawBase: 'https://raw.test/badnetwork'
+      }
+    ];
+    process.env.ACP_REPOS_JSON = JSON.stringify(testRepoConfig);
+    
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockImplementation((url) => {
+        if (url === 'https://api.test/good') {
+          return Promise.resolve({ status: 200, data: { tree: [{ type: 'blob', path: 'prompts/p.prompt.md' }] } });
+        }
+        if (url === 'https://api.test/badjson') {
+          return Promise.resolve({ status: 500, data: 'Server error' });
+        }
+        if (url === 'https://api.test/badnetwork') {
+          return Promise.reject(new Error('Network timeout'));
+        }
+        return Promise.reject(new Error('Unexpected URL'));
+      });
+      
+      await fetchIndex({ verbose: true });
+      
+      // Verify we see success for good repo
+      expect(logs.some(l => l.includes('fetching tree for repo: good-repo'))).toBe(true);
+      expect(logs.some(l => l.includes('successfully fetched tree for repo: good-repo'))).toBe(true);
+      
+      // Verify we see error for bad repos
+      expect(logs.some(l => l.includes('fetching tree for repo: bad-repo-invalid-json'))).toBe(true);
+      expect(logs.some(l => l.includes('fetching tree for repo: bad-repo-network'))).toBe(true);
+      expect(logs.some(l => l.includes('failed to fetch tree'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('verbose logs show transition from disk cache to fresh fetch', async () => {
+    const logs1 = [];
+    const originalLog = console.log;
+    
+    try {
+      // First fetch - write fresh cache
+      axios.get.mockResolvedValue({ status: 200, data: { prompts: [{ id: 'p1' }] } });
+      
+      console.log = jest.fn(msg => logs1.push(msg));
+      const result1 = await fetchIndex({ verbose: true });
+      
+      expect(logs1.some(l => l.includes('disk cache written'))).toBe(true);
+      expect(result1.prompts).toHaveLength(1);
+      
+      // Second fetch - use in-memory cache
+      cache.del('index'); // Clear in-memory but disk cache still valid
+      logs1.length = 0;
+      
+      console.log = jest.fn(msg => logs1.push(msg));
+      const result2 = await fetchIndex({ verbose: true });
+      
+      expect(logs1.some(l => l.includes('reading disk cache from'))).toBe(true);
+      expect(logs1.some(l => l.includes('disk cache read successfully'))).toBe(true);
+      expect(logs1.some(l => l.includes('using fresh disk cache'))).toBe(true);
+      expect(result2.prompts).toHaveLength(1);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+});

package/__tests__/fetcher-verbose.test.js

@@ -0,0 +1,316 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const axios = require('axios');
+jest.mock('axios');
+
+let fetcher;
+let fetchIndex;
+let diskPaths;
+const cache = require('../src/cache');
+
+describe('fetcher verbose logging', () => {
+  const tmp = path.join(os.tmpdir(), `acp-fetcher-verbose-${Date.now()}`);
+  const origCwd = process.cwd();
+
+  beforeAll(async () => {
+    await fs.ensureDir(tmp);
+    process.chdir(tmp);
+    // require after chdir so diskPaths uses tmp cwd
+    fetcher = require('../src/fetcher');
+    fetchIndex = fetcher.fetchIndex;
+    diskPaths = fetcher.diskPaths;
+  });
+
+  afterAll(async () => {
+    process.chdir(origCwd);
+    await fs.remove(tmp);
+  });
+
+  beforeEach(async () => {
+    cache.del('index');
+    const { DISK_CACHE_DIR } = diskPaths();
+    await fs.remove(DISK_CACHE_DIR).catch(() => {});
+    axios.get.mockReset();
+    // Clear env vars
+    delete process.env.ACP_INDEX_JSON;
+    delete process.env.ACP_REPOS_JSON;
+  });
+
+  test('logs when using ACP_INDEX_JSON environment variable', async () => {
+    const indexData = { prompts: [{ id: 'p1', name: 'Prompt One' }] };
+    process.env.ACP_INDEX_JSON = JSON.stringify(indexData);
+    
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('ACP_INDEX_JSON environment variable detected'))).toBe(true);
+      expect(logs.some(l => l.includes('successfully parsed ACP_INDEX_JSON'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('logs error when ACP_INDEX_JSON is malformed', async () => {
+    process.env.ACP_INDEX_JSON = 'not valid json {';
+    
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      // Mock the default repo call
+      axios.get.mockResolvedValue({ status: 200, data: { prompts: [{ id: 'p1' }] } });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('ACP_INDEX_JSON environment variable detected'))).toBe(true);
+      expect(logs.some(l => l.includes('failed to parse ACP_INDEX_JSON'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('logs when using ACP_REPOS_JSON environment variable', async () => {
+    const reposData = [
+      { id: 'test-repo', treeUrl: 'https://api.github.test/repo1', rawBase: 'https://raw.test/repo1' }
+    ];
+    process.env.ACP_REPOS_JSON = JSON.stringify(reposData);
+    
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { tree: [{ type: 'blob', path: 'prompts/p1.prompt.md' }] } });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('ACP_REPOS_JSON environment variable detected'))).toBe(true);
+      expect(logs.some(l => l.includes('successfully parsed ACP_REPOS_JSON with 1 repo(s)'))).toBe(true);
+      expect(logs.some(l => l.includes('using repos from ACP_REPOS_JSON: test-repo'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('logs error when ACP_REPOS_JSON is malformed', async () => {
+    process.env.ACP_REPOS_JSON = 'not valid json {';
+    
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { prompts: [{ id: 'p1' }] } });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('ACP_REPOS_JSON environment variable detected'))).toBe(true);
+      expect(logs.some(l => l.includes('failed to parse ACP_REPOS_JSON'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('logs when loading acp-repos.json file', async () => {
+    const reposData = [
+      { id: 'file-repo', treeUrl: 'https://api.github.test/repo2', rawBase: 'https://raw.test/repo2' }
+    ];
+    
+    const baseDir = process.cwd();
+    const repoFile = path.join(baseDir, 'acp-repos.json');
+    await fs.writeJson(repoFile, reposData);
+    
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { tree: [{ type: 'blob', path: 'prompts/p1.prompt.md' }] } });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('checking for acp-repos.json at'))).toBe(true);
+      expect(logs.some(l => l.includes('acp-repos.json found, reading...'))).toBe(true);
+      expect(logs.some(l => l.includes('successfully loaded 1 repo(s) from acp-repos.json'))).toBe(true);
+      expect(logs.some(l => l.includes('using repos from acp-repos.json: file-repo'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('logs error when acp-repos.json is malformed', async () => {
+    const baseDir = process.cwd();
+    const repoFile = path.join(baseDir, 'acp-repos.json');
+    await fs.writeFile(repoFile, 'not valid json {');
+    
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { prompts: [{ id: 'p1' }] } });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('checking for acp-repos.json at'))).toBe(true);
+      expect(logs.some(l => l.includes('failed to read acp-repos.json'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('logs when using default repos', async () => {
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { tree: [{ type: 'blob', path: 'prompts/p1.prompt.md' }] } });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('checking for acp-repos.json at'))).toBe(true);
+      // The key assertion is that we either see "found" or "not found"
+      expect(logs.some(l => l.includes('acp-repos.json') && (l.includes('not found') || l.includes('found')))).toBe(true);
+      expect(logs.some(l => l.includes('final repos list:'))).toBe(true);
+      expect(logs.some(l => l.includes('awesome-copilot'))).toBe(true);
+      expect(logs.some(l => l.includes('fetching repos'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('logs repo fetching successes and failures', async () => {
+    const reposData = [
+      { id: 'success-repo', treeUrl: 'https://api.github.test/success', rawBase: 'https://raw.test/success' },
+      { id: 'fail-repo', treeUrl: 'https://api.github.test/fail', rawBase: 'https://raw.test/fail' }
+    ];
+    process.env.ACP_REPOS_JSON = JSON.stringify(reposData);
+    
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockImplementation((url) => {
+        if (url === 'https://api.github.test/success') {
+          return Promise.resolve({ status: 200, data: { tree: [{ type: 'blob', path: 'prompts/p1.prompt.md' }] } });
+        }
+        if (url === 'https://api.github.test/fail') {
+          return Promise.reject(new Error('Network error'));
+        }
+        return Promise.reject(new Error('Unexpected URL'));
+      });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('fetching tree for repo: success-repo'))).toBe(true);
+      expect(logs.some(l => l.includes('successfully fetched tree for repo: success-repo'))).toBe(true);
+      expect(logs.some(l => l.includes('fetching tree for repo: fail-repo'))).toBe(true);
+      expect(logs.some(l => l.includes('failed to fetch tree for repo fail-repo'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('logs item count summary', async () => {
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockImplementation((url) => {
+        if (url.includes('tree')) {
+          return Promise.resolve({ 
+            status: 200, 
+            data: { 
+              tree: [
+                { type: 'blob', path: 'prompts/p1.prompt.md' },
+                { type: 'blob', path: 'agents/a1.agent.md' }
+              ] 
+            } 
+          });
+        }
+        return Promise.reject(new Error('Unexpected URL'));
+      });
+      
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('combined index contains:'))).toBe(true);
+      expect(logs.some(l => l.includes('prompts:'))).toBe(true);
+      expect(logs.some(l => l.includes('agents:'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('does not log when verbose is false', async () => {
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { prompts: [{ id: 'p1' }] } });
+      
+      await fetchIndex({ verbose: false });
+      
+      // Should not have verbose logs (only warnings about baseline-browser-mapping)
+      const verboseLogs = logs.filter(l => l.includes('verbose:'));
+      expect(verboseLogs.length).toBe(0);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('does not log when options is not provided', async () => {
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { prompts: [{ id: 'p1' }] } });
+      
+      await fetchIndex();
+      
+      // Should not have verbose logs
+      const verboseLogs = logs.filter(l => l.includes('verbose:'));
+      expect(verboseLogs.length).toBe(0);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test('logs disk cache operations', async () => {
+    const logs = [];
+    const originalLog = console.log;
+    console.log = jest.fn(msg => logs.push(msg));
+    
+    try {
+      axios.get.mockResolvedValue({ status: 200, data: { prompts: [{ id: 'p1' }] } });
+      
+      // First call should write cache
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('disk cache written to'))).toBe(true);
+      
+      // Clear in-memory cache to force disk read on second call
+      cache.del('index');
+      logs.length = 0;
+      
+      // Second call should read from disk
+      await fetchIndex({ verbose: true });
+      
+      expect(logs.some(l => l.includes('reading disk cache from'))).toBe(true);
+      expect(logs.some(l => l.includes('disk cache read successfully'))).toBe(true);
+      expect(logs.some(l => l.includes('using fresh disk cache'))).toBe(true);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+});

package/__tests__/fetcher.test.js

@@ -99,11 +99,11 @@ describe('fetcher', () => {
 
     const idx = await fetchIndex();
 
-    // repos metadata should be present
-    expect(idx._repos).toEqual([
-      { id: 'r1', treeUrl: 'https://api/repo1', rawBase: 'https://raw1' },
-      { id: 'r2', treeUrl: 'https://api/repo2', rawBase: 'https://raw2' }
-    ]);
+    // repos metadata should be present - now includes the default awesome-copilot repo
+    expect(idx._repos).toHaveLength(3);
+    expect(idx._repos.map(r => r.id)).toEqual(expect.arrayContaining(['awesome-copilot', 'r1', 'r2']));
+    expect(idx._repos.some(r => r.id === 'r1' && r.treeUrl === 'https://api/repo1')).toBe(true);
+    expect(idx._repos.some(r => r.id === 'r2' && r.treeUrl === 'https://api/repo2')).toBe(true);
 
     // prompts should include items from both repos
     const pids = idx.prompts.map(p => `${p.repo}:${p.id}`).sort();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acp-vscode",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "CLI to install GitHub Awesome Copilot agents, prompts, instructions, and skills into VS Code workspace or user profile",
   "bin": {
     "acp-vscode": "./bin/acp-vscode.js"