octocode-cli 1.2.8 → 1.2.9

package/skills/octocode-research/src/__tests__/integration/promptsRoutes.test.ts

@@ -0,0 +1,180 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { errorHandler } from '../../middleware/errorHandler.js';
+
+vi.mock('../../mcpCache.js', () => ({
+  getMcpContent: vi.fn().mockReturnValue({
+    tools: {},
+    prompts: {
+      research: {
+        name: 'Research',
+        description: 'Start a code research session',
+        args: [
+          { name: 'goal', description: 'The research goal', required: true },
+          { name: 'context', description: 'Additional context', required: false },
+        ],
+        content: 'You are a code research agent...',
+      },
+      research_local: {
+        name: 'Research Local',
+        description: 'Research local codebase',
+        args: [{ name: 'goal', description: 'What to investigate', required: true }],
+        content: 'Investigate the local codebase...',
+      },
+      plan: {
+        name: 'Plan',
+        description: 'Plan an implementation',
+        args: [],
+        content: 'Plan the implementation steps...',
+      },
+    },
+    instructions: 'Test',
+    baseHints: [],
+    genericErrorHints: [],
+  }),
+  initializeMcpContent: vi.fn().mockResolvedValue({}),
+  isMcpInitialized: vi.fn().mockReturnValue(true),
+}));
+
+vi.mock('../../index.js', () => ({
+  logPromptCall: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../../utils/asyncTimeout.js', () => ({
+  fireAndForgetWithTimeout: vi.fn(),
+}));
+
+import { promptsRoutes } from '../../routes/prompts.js';
+
+function createApp(): any {
+  const app = express();
+  app.use(express.json());
+  app.use('/prompts', promptsRoutes);
+  app.use(errorHandler);
+  return app;
+}
+
+describe('Prompts Routes', () => {
+  let app: any;
+
+  beforeEach(() => {
+    app = createApp();
+    vi.clearAllMocks();
+  });
+
+  describe('GET /prompts/list', () => {
+    it('returns 200 with all prompts', async () => {
+      const res = await request(app).get('/prompts/list');
+      expect(res.status).toBe(200);
+      expect(res.body.success).toBe(true);
+    });
+
+    it('returns correct number of prompts', async () => {
+      const res = await request(app).get('/prompts/list');
+      expect(res.body.data.prompts).toHaveLength(3);
+      expect(res.body.data.totalCount).toBe(3);
+    });
+
+    it('includes version', async () => {
+      const res = await request(app).get('/prompts/list');
+      expect(res.body.data).toHaveProperty('version');
+    });
+
+    it('each prompt has name and description', async () => {
+      const res = await request(app).get('/prompts/list');
+      for (const prompt of res.body.data.prompts) {
+        expect(prompt).toHaveProperty('name');
+        expect(prompt).toHaveProperty('description');
+      }
+    });
+
+    it('uses key name not display name', async () => {
+      const res = await request(app).get('/prompts/list');
+      const names = res.body.data.prompts.map((p: any) => p.name);
+      expect(names).toContain('research');
+      expect(names).toContain('research_local');
+      expect(names).toContain('plan');
+    });
+
+    it('includes arguments when present', async () => {
+      const res = await request(app).get('/prompts/list');
+      const research = res.body.data.prompts.find((p: any) => p.name === 'research');
+      expect(research.arguments).toHaveLength(2);
+      expect(research.arguments[0]).toEqual({
+        name: 'goal',
+        description: 'The research goal',
+        required: true,
+      });
+    });
+
+    it('includes hints', async () => {
+      const res = await request(app).get('/prompts/list');
+      expect(res.body.hints).toBeDefined();
+      expect(res.body.hints[0]).toContain('/prompts/info/');
+    });
+  });
+
+  describe('GET /prompts/info/:promptName', () => {
+    it('returns prompt details for valid prompt', async () => {
+      const res = await request(app).get('/prompts/info/research');
+      expect(res.status).toBe(200);
+      expect(res.body.success).toBe(true);
+      expect(res.body.data.name).toBe('Research');
+      expect(res.body.data.description).toBe('Start a code research session');
+    });
+
+    it('includes prompt content', async () => {
+      const res = await request(app).get('/prompts/info/research');
+      expect(res.body.data.content).toBe('You are a code research agent...');
+    });
+
+    it('includes arguments with required field', async () => {
+      const res = await request(app).get('/prompts/info/research');
+      expect(res.body.data.arguments).toHaveLength(2);
+      expect(res.body.data.arguments[0].required).toBe(true);
+      expect(res.body.data.arguments[1].required).toBe(false);
+    });
+
+    it('returns prompt with no arguments', async () => {
+      const res = await request(app).get('/prompts/info/plan');
+      expect(res.status).toBe(200);
+      expect(res.body.data.name).toBe('Plan');
+    });
+
+    it('returns 404 for unknown prompt', async () => {
+      const res = await request(app).get('/prompts/info/nonExistent');
+      expect(res.status).toBe(404);
+      expect(res.body.success).toBe(false);
+    });
+
+    it('provides helpful hints for unknown prompt', async () => {
+      const res = await request(app).get('/prompts/info/badPrompt');
+      expect(res.body.hints).toBeDefined();
+      expect(res.body.hints.some((h: string) => h.includes('badPrompt'))).toBe(true);
+      expect(res.body.hints.some((h: string) => h.includes('Available prompts'))).toBe(true);
+      expect(res.body.hints.some((h: string) => h.includes('/prompts/list'))).toBe(true);
+    });
+
+    it('logs prompt call for telemetry', async () => {
+      await request(app).get('/prompts/info/research');
+      const { fireAndForgetWithTimeout } = await import('../../utils/asyncTimeout.js');
+      expect(fireAndForgetWithTimeout).toHaveBeenCalled();
+    });
+  });
+
+  describe('Readiness gate', () => {
+    it('returns 503 when not initialized', async () => {
+      const { isMcpInitialized } = await import('../../mcpCache.js');
+      vi.mocked(isMcpInitialized).mockReturnValue(false);
+
+      const res = await request(app).get('/prompts/list');
+      expect(res.status).toBe(503);
+      expect(res.body.error.code).toBe('SERVER_INITIALIZING');
+
+      vi.mocked(isMcpInitialized).mockReturnValue(true);
+    });
+  });
+});

package/skills/octocode-research/src/__tests__/integration/serverHttp.test.ts

@@ -0,0 +1,221 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import request from 'supertest';
+
+vi.mock('../../mcpCache.js', () => ({
+  getMcpContent: vi.fn().mockReturnValue({
+    tools: { localSearchCode: { name: 'localSearchCode', description: 'Search', schema: {}, hints: { hasResults: [], empty: [] } } },
+    prompts: { research: { name: 'research', description: 'Research', args: [], content: 'test' } },
+    instructions: 'Test instructions',
+    baseHints: [],
+    genericErrorHints: [],
+    baseSchema: {},
+  }),
+  initializeMcpContent: vi.fn().mockResolvedValue({}),
+  isMcpInitialized: vi.fn().mockReturnValue(true),
+}));
+
+vi.mock('../../index.js', () => {
+  const r = { content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      files: []\n      totalMatches: 0' }] };
+  return {
+    initializeProviders: vi.fn().mockResolvedValue(undefined),
+    initializeSession: vi.fn(),
+    logSessionInit: vi.fn().mockResolvedValue(undefined),
+    logToolCall: vi.fn().mockResolvedValue(undefined),
+    logPromptCall: vi.fn().mockResolvedValue(undefined),
+    localSearchCode: vi.fn().mockResolvedValue(r),
+    localGetFileContent: vi.fn().mockResolvedValue(r),
+    localFindFiles: vi.fn().mockResolvedValue(r),
+    localViewStructure: vi.fn().mockResolvedValue(r),
+    githubSearchCode: vi.fn().mockResolvedValue(r),
+    githubGetFileContent: vi.fn().mockResolvedValue(r),
+    githubViewRepoStructure: vi.fn().mockResolvedValue(r),
+    githubSearchRepositories: vi.fn().mockResolvedValue(r),
+    githubSearchPullRequests: vi.fn().mockResolvedValue(r),
+    lspGotoDefinition: vi.fn().mockResolvedValue(r),
+    lspFindReferences: vi.fn().mockResolvedValue(r),
+    lspCallHierarchy: vi.fn().mockResolvedValue(r),
+    packageSearch: vi.fn().mockResolvedValue(r),
+  };
+});
+
+vi.mock('../../utils/logger.js', () => ({
+  initializeLogger: vi.fn(),
+  getLogsPath: vi.fn().mockReturnValue('/tmp/logs'),
+  logToolCall: vi.fn(),
+  logError: vi.fn(),
+  logWarn: vi.fn(),
+  sanitizeQueryParams: vi.fn().mockReturnValue({}),
+}));
+
+vi.mock('../../utils/circuitBreaker.js', () => ({
+  getAllCircuitStates: vi.fn().mockReturnValue({}),
+  clearAllCircuits: vi.fn(),
+  stopCircuitCleanup: vi.fn(),
+  configureCircuit: vi.fn(),
+  withCircuitBreaker: vi.fn((_name: string, fn: () => any) => fn()),
+}));
+
+vi.mock('../../utils/resilience.js', () => ({
+  withGitHubResilience: vi.fn(async (fn: () => any) => fn()),
+  withLocalResilience: vi.fn(async (fn: () => any) => fn()),
+  withLspResilience: vi.fn(async (fn: () => any) => fn()),
+  withPackageResilience: vi.fn(async (fn: () => any) => fn()),
+}));
+
+vi.mock('../../utils/asyncTimeout.js', () => ({
+  fireAndForgetWithTimeout: vi.fn(),
+  withTimeout: vi.fn(async (fn: () => any) => fn()),
+}));
+
+vi.mock('../../utils/errorQueue.js', () => ({
+  errorQueue: {
+    getRecent: vi.fn().mockReturnValue([]),
+    push: vi.fn(),
+    size: 0,
+  },
+}));
+
+import { createServer } from '../../server.js';
+
+describe('Server HTTP Flows', () => {
+  let app: any;
+
+  beforeEach(async () => {
+    app = await createServer();
+  });
+
+  describe('GET /health', () => {
+    it('returns 200 with health data when initialized', async () => {
+      const res = await request(app).get('/health');
+      expect(res.status).toBe(200);
+      expect(res.body.status).toBe('ok');
+    });
+
+    it('includes all required health fields', async () => {
+      const res = await request(app).get('/health');
+      const body = res.body;
+      expect(body).toHaveProperty('host');
+      expect(body).toHaveProperty('port');
+      expect(body).toHaveProperty('uptime');
+      expect(body).toHaveProperty('processManager');
+      expect(body).toHaveProperty('pid');
+      expect(body).toHaveProperty('idle');
+      expect(body).toHaveProperty('memory');
+      expect(body).toHaveProperty('circuits');
+      expect(body).toHaveProperty('errors');
+    });
+
+    it('reports detached daemon as process manager', async () => {
+      const res = await request(app).get('/health');
+      expect(res.body.processManager).toContain('detached');
+    });
+
+    it('returns numeric pid', async () => {
+      const res = await request(app).get('/health');
+      expect(typeof res.body.pid).toBe('number');
+      expect(res.body.pid).toBeGreaterThan(0);
+    });
+
+    it('includes idle tracking info', async () => {
+      const res = await request(app).get('/health');
+      const { idle } = res.body;
+      expect(idle).toHaveProperty('currentMs');
+      expect(idle).toHaveProperty('thresholdMs');
+      expect(idle).toHaveProperty('checkIntervalMs');
+      expect(idle).toHaveProperty('percentToRestart');
+      expect(typeof idle.currentMs).toBe('number');
+    });
+
+    it('includes memory stats in MB', async () => {
+      const res = await request(app).get('/health');
+      const { memory } = res.body;
+      expect(memory).toHaveProperty('heapUsed');
+      expect(memory).toHaveProperty('heapTotal');
+      expect(memory).toHaveProperty('rss');
+      expect(memory.heapUsed).toBeGreaterThan(0);
+    });
+
+    it('returns initializing when MCP not ready', async () => {
+      const { isMcpInitialized } = await import('../../mcpCache.js');
+      vi.mocked(isMcpInitialized).mockReturnValueOnce(false);
+      const res = await request(app).get('/health');
+      expect(res.body.status).toBe('initializing');
+    });
+
+    it('includes version string', async () => {
+      const res = await request(app).get('/health');
+      expect(res.body).toHaveProperty('version');
+      expect(typeof res.body.version).toBe('string');
+    });
+  });
+
+  describe('404 handler', () => {
+    it('returns 404 for unknown routes', async () => {
+      const res = await request(app).get('/nonexistent');
+      expect(res.status).toBe(404);
+      expect(res.body.success).toBe(false);
+    });
+
+    it('includes error code NOT_FOUND', async () => {
+      const res = await request(app).get('/does-not-exist');
+      expect(res.body.error.code).toBe('NOT_FOUND');
+    });
+
+    it('lists available routes in response', async () => {
+      const res = await request(app).get('/unknown');
+      expect(res.body.error.availableRoutes).toBeDefined();
+      expect(Array.isArray(res.body.error.availableRoutes)).toBe(true);
+      expect(res.body.error.availableRoutes.length).toBeGreaterThan(5);
+    });
+
+    it('includes hint about POST tool calls', async () => {
+      const res = await request(app).get('/wrong-path');
+      expect(res.body.error.hint).toContain('POST');
+    });
+
+    it('returns 404 for POST to unknown routes', async () => {
+      const res = await request(app).post('/unknown').send({});
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe('Middleware', () => {
+    it('parses JSON request bodies', async () => {
+      const res = await request(app)
+        .post('/tools/call/localSearchCode')
+        .send({
+          queries: [{
+            id: 'test-1',
+            researchGoal: 'test',
+            reasoning: 'test',
+            pattern: 'foo',
+            path: '/test',
+          }],
+        });
+      expect(res.status).not.toBe(415);
+    });
+
+    it('updates idle timer on requests', async () => {
+      const res1 = await request(app).get('/health');
+      const idle1 = res1.body.idle.currentMs;
+      await new Promise((r) => setTimeout(r, 50));
+      const res2 = await request(app).get('/health');
+      const idle2 = res2.body.idle.currentMs;
+      expect(idle2).toBeLessThanOrEqual(idle1 + 200);
+    });
+  });
+
+  describe('Route mounting', () => {
+    it('tools routes are mounted at /tools', async () => {
+      const res = await request(app).get('/tools/list');
+      expect(res.status).toBe(200);
+    });
+
+    it('prompts routes are mounted at /prompts', async () => {
+      const res = await request(app).get('/prompts/list');
+      expect(res.status).toBe(200);
+    });
+  });
+});

package/skills/octocode-research/src/__tests__/integration/serverLifecycle.test.ts

@@ -0,0 +1,194 @@
+/**
+ * Integration test: detached daemon lifecycle.
+ *
+ * Spawns server-init.js on a random test port, verifies that:
+ * 1. init exits after server is healthy (detached daemon behavior)
+ * 2. server survives init exit
+ * 3. second init detects running server and exits immediately
+ * 4. PID file is created on startup and removed on shutdown
+ */
+
+import { describe, it, expect, afterEach } from 'vitest';
+import { spawn, type ChildProcess } from 'child_process';
+import { join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+
+const SCRIPTS_DIR = join(import.meta.dirname, '..', '..', '..', 'scripts');
+const SERVER_INIT_SCRIPT = join(SCRIPTS_DIR, 'server-init.js');
+
+const TEST_PORT = 19871;
+const HEALTH_URL = `http://localhost:${TEST_PORT}/health`;
+const OCTOCODE_DIR = process.env.OCTOCODE_HOME || join(homedir(), '.octocode');
+const PID_FILE = join(OCTOCODE_DIR, `research-server-${TEST_PORT}.pid`);
+
+async function pollHealth(timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(HEALTH_URL, { signal: AbortSignal.timeout(2000) });
+      if (res.ok) {
+        const body = (await res.json()) as { status: string };
+        if (body.status === 'ok') return true;
+      }
+    } catch {
+      // not ready yet
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+
+async function isServerDown(timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      await fetch(HEALTH_URL, { signal: AbortSignal.timeout(1000) });
+    } catch {
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  return false;
+}
+
+function spawnInitScript(): ChildProcess {
+  return spawn('node', [SERVER_INIT_SCRIPT], {
+    env: {
+      ...process.env,
+      OCTOCODE_PORT: String(TEST_PORT),
+      OCTOCODE_RESEARCH_PORT: String(TEST_PORT),
+    },
+    stdio: 'pipe',
+  });
+}
+
+function killListenersOnPort(port: number): Promise<void> {
+  return new Promise((resolve) => {
+    const proc = spawn('sh', ['-c', `lsof -sTCP:LISTEN -ti :${port} | xargs kill -9 2>/dev/null`], {
+      stdio: 'ignore',
+    });
+    proc.on('close', () => resolve());
+    setTimeout(() => resolve(), 2000);
+  });
+}
+
+function waitForExit(proc: ChildProcess, timeoutMs: number): Promise<number | null> {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      proc.kill('SIGKILL');
+      resolve(null);
+    }, timeoutMs);
+    proc.on('exit', (code) => {
+      clearTimeout(timeout);
+      resolve(code);
+    });
+  });
+}
+
+describe('Server Lifecycle (Detached Daemon)', () => {
+  let initProc: ChildProcess | null = null;
+
+  afterEach(async () => {
+    if (initProc && !initProc.killed) {
+      initProc.kill('SIGTERM');
+      await new Promise<void>((resolve) => {
+        const timeout = setTimeout(() => {
+          try { initProc?.kill('SIGKILL'); } catch { /* already dead */ }
+          resolve();
+        }, 5000);
+        initProc!.on('exit', () => { clearTimeout(timeout); resolve(); });
+      });
+    }
+    initProc = null;
+    await killListenersOnPort(TEST_PORT);
+    await new Promise((r) => setTimeout(r, 500));
+  });
+
+  it('init exits after server is healthy and server survives', async () => {
+    initProc = spawnInitScript();
+
+    let initOutput = '';
+    initProc.stdout?.on('data', (chunk: Buffer) => { initOutput += chunk.toString(); });
+    initProc.stderr?.on('data', (chunk: Buffer) => { initOutput += chunk.toString(); });
+
+    // Init should exit on its own after server is ready
+    const exitCode = await waitForExit(initProc, 45_000);
+    expect(exitCode, `Init should exit 0. Output:\n${initOutput}`).toBe(0);
+    expect(initOutput).toContain('ok');
+
+    // Server should still be running after init exits
+    const serverAlive = await pollHealth(5_000);
+    expect(serverAlive, 'Server should survive init exit (detached daemon)').toBe(true);
+
+    // Verify health response reflects detached mode
+    const healthRes = await fetch(HEALTH_URL, { signal: AbortSignal.timeout(3000) });
+    const healthBody = (await healthRes.json()) as { status: string; port: number; processManager: string; pid: number };
+    expect(healthBody.status).toBe('ok');
+    expect(healthBody.port).toBe(TEST_PORT);
+    expect(healthBody.processManager).toContain('detached');
+    expect(healthBody.pid).toBeGreaterThan(0);
+  }, 60_000);
+
+  it('init exits immediately when server is already running', async () => {
+    // Start first init → starts server
+    initProc = spawnInitScript();
+
+    let output1 = '';
+    initProc.stdout?.on('data', (chunk: Buffer) => { output1 += chunk.toString(); });
+
+    const exitCode1 = await waitForExit(initProc, 45_000);
+    expect(exitCode1, `First init should exit 0. Output:\n${output1}`).toBe(0);
+
+    // Server should be alive
+    const ready = await pollHealth(5_000);
+    expect(ready, 'Server should be running').toBe(true);
+
+    // Start a SECOND init — should detect running server and exit fast
+    const secondInit = spawnInitScript();
+
+    let output2 = '';
+    secondInit.stdout?.on('data', (chunk: Buffer) => { output2 += chunk.toString(); });
+
+    const exitCode2 = await waitForExit(secondInit, 15_000);
+    expect(exitCode2, `Second init should exit 0 (fast path). Output:\n${output2}`).toBe(0);
+    expect(output2).toContain('ok');
+
+    // Server should still be alive
+    const stillAlive = await pollHealth(3_000);
+    expect(stillAlive).toBe(true);
+  }, 60_000);
+
+  it('PID file is created on startup and cleaned up on shutdown', async () => {
+    initProc = spawnInitScript();
+
+    let initOutput = '';
+    initProc.stdout?.on('data', (chunk: Buffer) => { initOutput += chunk.toString(); });
+
+    const exitCode = await waitForExit(initProc, 45_000);
+    expect(exitCode, `Init should exit 0. Output:\n${initOutput}`).toBe(0);
+
+    // PID file should exist
+    expect(existsSync(PID_FILE), 'PID file should exist after server starts').toBe(true);
+
+    const pidContent = readFileSync(PID_FILE, 'utf-8').trim();
+    const pid = parseInt(pidContent, 10);
+    expect(pid).toBeGreaterThan(0);
+
+    // Verify the PID matches the running server
+    const healthRes = await fetch(HEALTH_URL, { signal: AbortSignal.timeout(3000) });
+    const healthBody = (await healthRes.json()) as { pid: number };
+    expect(pid).toBe(healthBody.pid);
+
+    // Kill the server via its PID
+    process.kill(pid, 'SIGTERM');
+
+    // Server should stop
+    const serverDead = await isServerDown(10_000);
+    expect(serverDead, 'Server should stop after SIGTERM').toBe(true);
+
+    // PID file should be cleaned up
+    await new Promise((r) => setTimeout(r, 1000));
+    expect(existsSync(PID_FILE), 'PID file should be removed on shutdown').toBe(false);
+  }, 60_000);
+});