catlog22/Claude-Code-Workflow
1
0
Fork 0
mirror of https://github.com/catlog22/Claude-Code-Workflow.git synced 2026-02-10 02:24:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

Issue Queue: issue-exec-20260106-160325 (#52)

Browse Source 
* feat(security): Secure dashboard server by default

## Solution Summary
- Solution-ID: SOL-DSC-002-1
- Issue-ID: DSC-002

## Tasks Completed
- [T1] JWT token manager (24h expiry, persisted secret/token)
- [T2] API auth middleware + localhost token endpoint
- [T3] Default bind 127.0.0.1, add --host with warning
- [T4] Localhost-only CORS with credentials + Vary
- [T5] SECURITY.md documentation + README link

## Verification
- npm run build
- npm test -- ccw/tests/token-manager.test.ts ccw/tests/middleware.test.ts ccw/tests/server-auth.integration.test.ts ccw/tests/server.test.ts ccw/tests/cors.test.ts

* fix(security): Prevent command injection in Windows spawn()

## Solution Summary
- **Solution-ID**: SOL-DSC-001-1
- **Issue-ID**: DSC-001
- **Risk/Impact/Complexity**: high/high/medium

## Tasks Completed
- [T1] Create Windows shell escape utility
- [T2] Escape cli-executor spawn() args on Windows
- [T3] Add command injection regression tests

## Files Modified
- ccw/src/utils/shell-escape.ts
- ccw/src/tools/cli-executor.ts
- ccw/tests/shell-escape.test.ts
- ccw/tests/security/command-injection.test.ts

## Verification
- npm run build
- npm test -- ccw/tests/shell-escape.test.ts ccw/tests/security/command-injection.test.ts

* fix(security): Harden path validation (DSC-005)

## Solution Summary
- Solution-ID: SOL-DSC-005-1
- Issue-ID: DSC-005

## Tasks Completed
- T1: Refactor path validation to pre-resolution checking
- T2: Implement allowlist-based path validation
- T3: Add path validation to API routes
- T4: Add path security regression tests

## Files Modified
- ccw/src/utils/path-resolver.ts
- ccw/src/utils/path-validator.ts
- ccw/src/core/routes/graph-routes.ts
- ccw/src/core/routes/files-routes.ts
- ccw/src/core/routes/skills-routes.ts
- ccw/tests/path-resolver.test.ts
- ccw/tests/graph-routes.test.ts
- ccw/tests/files-routes.test.ts
- ccw/tests/skills-routes.test.ts
- ccw/tests/security/path-traversal.test.ts

## Verification
- npm run build
- npm test -- path-resolver.test.ts
- npm test -- path-validator.test.ts
- npm test -- graph-routes.test.ts
- npm test -- files-routes.test.ts
- npm test -- skills-routes.test.ts
- npm test -- ccw/tests/security/path-traversal.test.ts

* fix(security): Prevent credential leakage (DSC-004)

## Solution Summary
- Solution-ID: SOL-DSC-004-1
- Issue-ID: DSC-004

## Tasks Completed
- T1: Create credential handling security tests
- T2: Add log sanitization tests
- T3: Add env var leakage prevention tests
- T4: Add secure storage tests

## Files Modified
- ccw/src/config/litellm-api-config-manager.ts
- ccw/src/core/routes/litellm-api-routes.ts
- ccw/tests/security/credential-handling.test.ts

## Verification
- npm run build
- node --experimental-strip-types --test ccw/tests/security/credential-handling.test.ts

* test(ranking): expand normalize_weights edge case coverage (ISS-1766920108814-0)

## Solution Summary
- Solution-ID: SOL-20251228113607
- Issue-ID: ISS-1766920108814-0

## Tasks Completed
- T1: Fix NaN and invalid total handling in normalize_weights
- T2: Add unit tests for NaN edge cases in normalize_weights

## Files Modified
- codex-lens/tests/test_rrf_fusion.py

## Verification
- python -m pytest codex-lens/tests/test_rrf_fusion.py::TestNormalizeBM25Score -v
- python -m pytest codex-lens/tests/test_rrf_fusion.py -v -k normalize
- python -m pytest codex-lens/tests/test_rrf_fusion.py::TestReciprocalRankFusion::test_weight_normalization codex-lens/tests/test_cli_hybrid_search.py::TestCLIHybridSearch::test_weights_normalization -v

* feat(security): Add CSRF protection and tighten CORS (DSC-006)

## Solution Summary
- Solution-ID: SOL-DSC-006-1
- Issue-ID: DSC-006
- Risk/Impact/Complexity: high/high/medium

## Tasks Completed
- T1: Create CSRF token generation system
- T2: Add CSRF token endpoints
- T3: Implement CSRF validation middleware
- T4: Restrict CORS to trusted origins
- T5: Add CSRF security tests

## Files Modified
- ccw/src/core/auth/csrf-manager.ts
- ccw/src/core/auth/csrf-middleware.ts
- ccw/src/core/routes/auth-routes.ts
- ccw/src/core/server.ts
- ccw/tests/csrf-manager.test.ts
- ccw/tests/auth-routes.test.ts
- ccw/tests/csrf-middleware.test.ts
- ccw/tests/security/csrf.test.ts

## Verification
- npm run build
- node --experimental-strip-types --test ccw/tests/csrf-manager.test.ts
- node --experimental-strip-types --test ccw/tests/auth-routes.test.ts
- node --experimental-strip-types --test ccw/tests/csrf-middleware.test.ts
- node --experimental-strip-types --test ccw/tests/cors.test.ts
- node --experimental-strip-types --test ccw/tests/security/csrf.test.ts

* fix(cli-executor): prevent stale SIGKILL timeouts

## Solution Summary

- Solution-ID: SOL-DSC-007-1

- Issue-ID: DSC-007

- Risk/Impact/Complexity: low/low/low

## Tasks Completed

- [T1] Store timeout handle in killCurrentCliProcess

## Files Modified

- ccw/src/tools/cli-executor.ts

- ccw/tests/cli-executor-kill.test.ts

## Verification

- node --experimental-strip-types --test ccw/tests/cli-executor-kill.test.ts

* fix(cli-executor): enhance merge validation guards

## Solution Summary

- Solution-ID: SOL-DSC-008-1

- Issue-ID: DSC-008

- Risk/Impact/Complexity: low/low/low

## Tasks Completed

- [T1] Enhance sourceConversations array validation

## Files Modified

- ccw/src/tools/cli-executor.ts

- ccw/tests/cli-executor-merge-validation.test.ts

## Verification

- node --experimental-strip-types --test ccw/tests/cli-executor-merge-validation.test.ts

* refactor(core): remove @ts-nocheck from core routes

## Solution Summary
- Solution-ID: SOL-DSC-003-1
- Issue-ID: DSC-003
- Queue-ID: QUE-20260106-164500
- Item-ID: S-9

## Tasks Completed
- T1: Create shared RouteContext type definition
- T2: Remove @ts-nocheck from small route files
- T3: Remove @ts-nocheck from medium route files
- T4: Remove @ts-nocheck from large route files
- T5: Remove @ts-nocheck from remaining core files

## Files Modified
- ccw/src/core/dashboard-generator-patch.ts
- ccw/src/core/dashboard-generator.ts
- ccw/src/core/routes/ccw-routes.ts
- ccw/src/core/routes/claude-routes.ts
- ccw/src/core/routes/cli-routes.ts
- ccw/src/core/routes/codexlens-routes.ts
- ccw/src/core/routes/discovery-routes.ts
- ccw/src/core/routes/files-routes.ts
- ccw/src/core/routes/graph-routes.ts
- ccw/src/core/routes/help-routes.ts
- ccw/src/core/routes/hooks-routes.ts
- ccw/src/core/routes/issue-routes.ts
- ccw/src/core/routes/litellm-api-routes.ts
- ccw/src/core/routes/litellm-routes.ts
- ccw/src/core/routes/mcp-routes.ts
- ccw/src/core/routes/mcp-routes.ts.backup
- ccw/src/core/routes/mcp-templates-db.ts
- ccw/src/core/routes/nav-status-routes.ts
- ccw/src/core/routes/rules-routes.ts
- ccw/src/core/routes/session-routes.ts
- ccw/src/core/routes/skills-routes.ts
- ccw/src/core/routes/status-routes.ts
- ccw/src/core/routes/system-routes.ts
- ccw/src/core/routes/types.ts
- ccw/src/core/server.ts
- ccw/src/core/websocket.ts

## Verification
- npm run build
- npm test

* refactor: split cli-executor and codexlens routes into modules

## Solution Summary
- Solution-ID: SOL-DSC-012-1
- Issue-ID: DSC-012
- Risk/Impact/Complexity: medium/medium/high

## Tasks Completed
- [T1] Extract execution orchestration from cli-executor.ts (Refactor ccw/src/tools)
- [T2] Extract route handlers from codexlens-routes.ts (Refactor ccw/src/core/routes)
- [T3] Extract prompt concatenation logic from cli-executor (Refactor ccw/src/tools)
- [T4] Document refactored module architecture (Docs)

## Files Modified
- ccw/src/tools/cli-executor.ts
- ccw/src/tools/cli-executor-core.ts
- ccw/src/tools/cli-executor-utils.ts
- ccw/src/tools/cli-executor-state.ts
- ccw/src/tools/cli-prompt-builder.ts
- ccw/src/tools/README.md
- ccw/src/core/routes/codexlens-routes.ts
- ccw/src/core/routes/codexlens/config-handlers.ts
- ccw/src/core/routes/codexlens/index-handlers.ts
- ccw/src/core/routes/codexlens/semantic-handlers.ts
- ccw/src/core/routes/codexlens/watcher-handlers.ts
- ccw/src/core/routes/codexlens/utils.ts
- ccw/src/core/routes/codexlens/README.md

## Verification
- npm run build
- npm test

* test(issue): Add comprehensive issue command tests

## Solution Summary
- **Solution-ID**: SOL-DSC-009-1
- **Issue-ID**: DSC-009
- **Risk/Impact/Complexity**: low/high/medium

## Tasks Completed
- [T1] Create issue command test file structure: Create isolated test harness
- [T2] Add JSONL read/write operation tests: Verify JSONL correctness and errors
- [T3] Add issue lifecycle tests: Verify status transitions and timestamps
- [T4] Add solution binding tests: Verify binding flows and error cases
- [T5] Add queue formation tests: Verify queue creation, IDs, and DAG behavior
- [T6] Add queue execution tests: Verify next/done/retry and status sync

## Files Modified
- ccw/src/commands/issue.ts
- ccw/tests/issue-command.test.ts

## Verification
- node --experimental-strip-types --test ccw/tests/issue-command.test.ts

* test(routes): Add integration tests for route modules

## Solution Summary
- Solution-ID: SOL-DSC-010-1
- Issue-ID: DSC-010
- Queue-ID: QUE-20260106-164500

## Tasks Completed
- [T1] Add tests for ccw-routes.ts
- [T2] Add tests for files-routes.ts
- [T3] Add tests for claude-routes.ts (includes Windows path fix for create)
- [T4] Add tests for issue-routes.ts
- [T5] Add tests for help-routes.ts (avoid hanging watchers)
- [T6] Add tests for nav-status-routes.ts
- [T7] Add tests for hooks/graph/rules/skills/litellm-api routes

## Files Modified
- ccw/src/core/routes/claude-routes.ts
- ccw/src/core/routes/help-routes.ts
- ccw/tests/integration/ccw-routes.test.ts
- ccw/tests/integration/claude-routes.test.ts
- ccw/tests/integration/files-routes.test.ts
- ccw/tests/integration/issue-routes.test.ts
- ccw/tests/integration/help-routes.test.ts
- ccw/tests/integration/nav-status-routes.test.ts
- ccw/tests/integration/hooks-routes.test.ts
- ccw/tests/integration/graph-routes.test.ts
- ccw/tests/integration/rules-routes.test.ts
- ccw/tests/integration/skills-routes.test.ts
- ccw/tests/integration/litellm-api-routes.test.ts

## Verification
- node --experimental-strip-types --test ccw/tests/integration/ccw-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/files-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/claude-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/issue-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/help-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/nav-status-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/hooks-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/graph-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/rules-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/skills-routes.test.ts
- node --experimental-strip-types --test ccw/tests/integration/litellm-api-routes.test.ts

* refactor(core): Switch cache and lite scanning to async fs

## Solution Summary
- Solution-ID: SOL-DSC-013-1
- Issue-ID: DSC-013
- Queue-ID: QUE-20260106-164500

## Tasks Completed
- [T1] Convert cache-manager.ts to async file operations
- [T2] Convert lite-scanner.ts to async file operations
- [T3] Update cache-manager call sites to await async API
- [T4] Update lite-scanner call sites to await async API

## Files Modified
- ccw/src/core/cache-manager.ts
- ccw/src/core/lite-scanner.ts
- ccw/src/core/data-aggregator.ts

## Verification
- npm run build
- npm test

* fix(exec): Add timeout protection for execSync

## Solution Summary
- Solution-ID: SOL-DSC-014-1
- Issue-ID: DSC-014
- Queue-ID: QUE-20260106-164500

## Tasks Completed
- [T1] Add timeout to execSync calls in python-utils.ts
- [T2] Add timeout to execSync calls in detect-changed-modules.ts
- [T3] Add timeout to execSync calls in claude-freshness.ts
- [T4] Add timeout to execSync calls in issue.ts
- [T5] Consolidate execSync timeout constants and audit coverage

## Files Modified
- ccw/src/utils/exec-constants.ts
- ccw/src/utils/python-utils.ts
- ccw/src/tools/detect-changed-modules.ts
- ccw/src/core/claude-freshness.ts
- ccw/src/commands/issue.ts
- ccw/src/tools/smart-search.ts
- ccw/src/tools/codex-lens.ts
- ccw/src/core/routes/codexlens/config-handlers.ts

## Verification
- npm run build
- npm test
- node --experimental-strip-types --test ccw/tests/issue-command.test.ts

* feat(cli): Add progress spinner with elapsed time for long-running operations

## Solution Summary
- Solution-ID: SOL-DSC-015-1
- Issue-ID: DSC-015
- Queue-Item: S-15
- Risk/Impact/Complexity: low/medium/low

## Tasks Completed
- [T1] Add progress spinner to CLI execution: Update ccw/src/commands/cli.ts

## Files Modified
- ccw/src/commands/cli.ts
- ccw/tests/cli-command.test.ts

## Verification
- node --experimental-strip-types --test ccw/tests/cli-command.test.ts
- node --experimental-strip-types --test ccw/tests/cli-executor-kill.test.ts
- node --experimental-strip-types --test ccw/tests/cli-executor-merge-validation.test.ts

* fix(cli): Move full output hint immediately after truncation notice

## Solution Summary
- Solution-ID: SOL-DSC-016-1
- Issue-ID: DSC-016
- Queue-Item: S-16
- Risk/Impact/Complexity: low/high/low

## Tasks Completed
- [T1] Relocate output hint after truncation: Update ccw/src/commands/cli.ts

## Files Modified
- ccw/src/commands/cli.ts
- ccw/tests/cli-command.test.ts

## Verification
- npm run build
- node --experimental-strip-types --test ccw/tests/cli-command.test.ts

* feat(cli): Add confirmation prompts for destructive operations

## Solution Summary
- Solution-ID: SOL-DSC-017-1
- Issue-ID: DSC-017
- Queue-Item: S-17
- Risk/Impact/Complexity: low/high/low

## Tasks Completed
- [T1] Add confirmation to storage clean operations: Update ccw/src/commands/cli.ts
- [T2] Add confirmation to issue queue delete: Update ccw/src/commands/issue.ts

## Files Modified
- ccw/src/commands/cli.ts
- ccw/src/commands/issue.ts
- ccw/tests/cli-command.test.ts
- ccw/tests/issue-command.test.ts

## Verification
- npm run build
- node --experimental-strip-types --test ccw/tests/cli-command.test.ts
- node --experimental-strip-types --test ccw/tests/issue-command.test.ts

* feat(cli): Improve multi-line prompt guidance

## Solution Summary
- Solution-ID: SOL-DSC-018-1
- Issue-ID: DSC-018
- Queue-Item: S-18
- Risk/Impact/Complexity: low/medium/low

## Tasks Completed
- [T1] Update CLI help to emphasize --file option: Update ccw/src/commands/cli.ts
- [T2] Add inline hint for multi-line detection: Update ccw/src/commands/cli.ts

## Files Modified
- ccw/src/commands/cli.ts
- ccw/tests/cli-command.test.ts

## Verification
- npm run build
- node --experimental-strip-types --test ccw/tests/cli-command.test.ts

---------

Co-authored-by: catlog22 <catlog22@github.com>
This commit is contained in:
catlog22
2026-01-07 22:35:46 +08:00
committed by GitHub
parent fae2f7e279
commit 09d99abee6
100 changed files with 14300 additions and 6456 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
ccw/tests/integration/ccw-routes.test.ts Normal file
View File

@@ -0,0 +1,146 @@
/**
* Integration tests for CCW routes (installations/tools).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Exercises real HTTP request/response flow via a minimal test server.
*/
import { after, before, describe, it } from 'node:test';
import assert from 'node:assert/strict';
import http from 'node:http';
const ccwRoutesUrl = new URL('../../dist/core/routes/ccw-routes.js', import.meta.url);
ccwRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
type JsonResponse = { status: number; json: any; text: string };
async function requestJson(baseUrl: string, method: string, path: string): Promise<JsonResponse> {
const url = new URL(path, baseUrl);
return new Promise((resolve, reject) => {
const req = http.request(
url,
{ method, headers: { Accept: 'application/json' } },
(res) => {
let body = '';
res.on('data', (chunk) => {
body += chunk.toString();
});
res.on('end', () => {
let json: any = null;
try {
json = body ? JSON.parse(body) : null;
} catch {
json = null;
}
resolve({ status: res.statusCode || 0, json, text: body });
});
},
);
req.on('error', reject);
req.end();
});
}
function handlePostRequest(req: http.IncomingMessage, res: http.ServerResponse, handler: (body: unknown) => Promise<any>): void {
let body = '';
req.on('data', (chunk) => {
body += chunk.toString();
});
req.on('end', async () => {
try {
const parsed = body ? JSON.parse(body) : {};
const result = await handler(parsed);
if (result?.error) {
res.writeHead(result.status || 500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: result.error }));
} else {
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify(result));
}
} catch (err: any) {
res.writeHead(500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: err?.message || String(err) }));
}
});
}
describe('ccw routes integration', async () => {
let server: http.Server | null = null;
let baseUrl = '';
before(async () => {
mod = await import(ccwRoutesUrl.href);
server = http.createServer(async (req, res) => {
const url = new URL(req.url || '/', 'http://localhost');
const pathname = url.pathname;
const ctx = {
pathname,
url,
req,
res,
initialPath: process.cwd(),
handlePostRequest,
broadcastToClients() {},
};
try {
const handled = await mod.handleCcwRoutes(ctx);
if (!handled) {
res.writeHead(404, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: 'Not Found' }));
}
} catch (err: any) {
res.writeHead(500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: err?.message || String(err) }));
}
});
await new Promise<void>((resolve) => {
server!.listen(0, () => resolve());
});
const addr = server.address();
const port = typeof addr === 'object' && addr ? addr.port : 0;
baseUrl = `http://127.0.0.1:${port}`;
});
after(async () => {
if (!server) return;
await new Promise<void>((resolve) => server!.close(() => resolve()));
});
it('GET /api/ccw/installations returns installation manifests', async () => {
const res = await requestJson(baseUrl, 'GET', '/api/ccw/installations');
assert.equal(res.status, 200);
assert.ok(res.json);
assert.equal(Array.isArray(res.json.installations), true);
});
it('GET /api/ccw/tools returns available tools', async () => {
const res = await requestJson(baseUrl, 'GET', '/api/ccw/tools');
assert.equal(res.status, 200);
assert.ok(res.json);
assert.equal(Array.isArray(res.json.tools), true);
});
it('GET /api/ccw/upgrade returns 404 (POST-only endpoint)', async () => {
const res = await requestJson(baseUrl, 'GET', '/api/ccw/upgrade');
assert.equal(res.status, 404);
assert.ok(res.json?.error);
});
it('returns 404 for unknown /api/ccw/* routes', async () => {
const res = await requestJson(baseUrl, 'GET', '/api/ccw/nope');
assert.equal(res.status, 404);
assert.ok(res.json?.error);
});
});

272
ccw/tests/integration/claude-routes.test.ts Normal file
View File

@@ -0,0 +1,272 @@
/**
* Integration tests for CLAUDE.md routes (scan + CRUD).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Uses temporary HOME/USERPROFILE to isolate user-level files.
* - Uses a temporary project root as initialPath for project/module operations.
*/
import { after, before, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import http from 'node:http';
import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const claudeRoutesUrl = new URL('../../dist/core/routes/claude-routes.js', import.meta.url);
claudeRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
const originalEnv = {
HOME: process.env.HOME,
USERPROFILE: process.env.USERPROFILE,
HOMEDRIVE: process.env.HOMEDRIVE,
HOMEPATH: process.env.HOMEPATH,
};
type JsonResponse = { status: number; json: any; text: string };
async function requestJson(
baseUrl: string,
method: string,
path: string,
body?: unknown,
): Promise<JsonResponse> {
const url = new URL(path, baseUrl);
const payload = body === undefined ? null : Buffer.from(JSON.stringify(body), 'utf8');
return new Promise((resolve, reject) => {
const req = http.request(
url,
{
method,
headers: {
Accept: 'application/json',
...(payload
? { 'Content-Type': 'application/json', 'Content-Length': String(payload.length) }
: {}),
},
},
(res) => {
let responseBody = '';
res.on('data', (chunk) => {
responseBody += chunk.toString();
});
res.on('end', () => {
let json: any = null;
try {
json = responseBody ? JSON.parse(responseBody) : null;
} catch {
json = null;
}
resolve({ status: res.statusCode || 0, json, text: responseBody });
});
},
);
req.on('error', reject);
if (payload) req.write(payload);
req.end();
});
}
function handlePostRequest(req: http.IncomingMessage, res: http.ServerResponse, handler: (body: unknown) => Promise<any>): void {
let body = '';
req.on('data', (chunk) => {
body += chunk.toString();
});
req.on('end', async () => {
try {
const parsed = body ? JSON.parse(body) : {};
const result = await handler(parsed);
if (result?.error) {
res.writeHead(result.status || 500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: result.error }));
} else {
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify(result));
}
} catch (err: any) {
res.writeHead(500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: err?.message || String(err) }));
}
});
}
describe('claude routes integration', async () => {
let server: http.Server | null = null;
let baseUrl = '';
let homeDir = '';
let projectRoot = '';
before(async () => {
homeDir = mkdtempSync(join(tmpdir(), 'ccw-claude-home-'));
projectRoot = mkdtempSync(join(tmpdir(), 'ccw-claude-project-'));
process.env.HOME = homeDir;
process.env.USERPROFILE = homeDir;
process.env.HOMEDRIVE = undefined;
process.env.HOMEPATH = undefined;
mock.method(console, 'log', () => {});
mock.method(console, 'error', () => {});
mod = await import(claudeRoutesUrl.href);
server = http.createServer(async (req, res) => {
const url = new URL(req.url || '/', 'http://localhost');
const pathname = url.pathname;
const ctx = {
pathname,
url,
req,
res,
initialPath: projectRoot,
handlePostRequest,
broadcastToClients() {},
};
try {
const handled = await mod.handleClaudeRoutes(ctx);
if (!handled) {
res.writeHead(404, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: 'Not Found' }));
}
} catch (err: any) {
res.writeHead(500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: err?.message || String(err) }));
}
});
await new Promise<void>((resolve) => server!.listen(0, () => resolve()));
const addr = server.address();
const port = typeof addr === 'object' && addr ? addr.port : 0;
baseUrl = `http://127.0.0.1:${port}`;
});
after(async () => {
mock.restoreAll();
process.env.HOME = originalEnv.HOME;
process.env.USERPROFILE = originalEnv.USERPROFILE;
process.env.HOMEDRIVE = originalEnv.HOMEDRIVE;
process.env.HOMEPATH = originalEnv.HOMEPATH;
if (server) {
await new Promise<void>((resolve) => server!.close(() => resolve()));
server = null;
}
if (projectRoot) {
rmSync(projectRoot, { recursive: true, force: true });
projectRoot = '';
}
if (homeDir) {
rmSync(homeDir, { recursive: true, force: true });
homeDir = '';
}
});
it('POST /api/memory/claude/create creates a project-level CLAUDE.md', async () => {
const res = await requestJson(baseUrl, 'POST', '/api/memory/claude/create', { level: 'project', template: 'minimal' });
assert.equal(res.status, 200);
assert.equal(res.json?.success, true);
assert.ok(typeof res.json.path === 'string' && res.json.path.endsWith('CLAUDE.md'));
assert.equal(existsSync(res.json.path), true);
});
it('GET /api/memory/claude/file parses frontmatter for project CLAUDE.md', async () => {
const claudePath = join(projectRoot, '.claude', 'CLAUDE.md');
mkdirSync(join(projectRoot, '.claude'), { recursive: true });
writeFileSync(
claudePath,
['---', 'paths: [src, docs]', '---', '', '# Project Rules', '', 'ok'].join('\n'),
'utf8',
);
const res = await requestJson(baseUrl, 'GET', `/api/memory/claude/file?path=${encodeURIComponent(claudePath)}`);
assert.equal(res.status, 200);
assert.equal(res.json.level, 'project');
assert.deepEqual(res.json.frontmatter?.paths, ['src', 'docs']);
assert.match(res.json.content, /# Project Rules/);
assert.equal(String(res.json.content).includes('paths:'), false);
});
it('POST /api/memory/claude/file saves updated content', async () => {
const claudePath = join(projectRoot, '.claude', 'CLAUDE.md');
mkdirSync(join(projectRoot, '.claude'), { recursive: true });
writeFileSync(claudePath, 'before\n', 'utf8');
const res = await requestJson(baseUrl, 'POST', '/api/memory/claude/file', { path: claudePath, content: 'after\n' });
assert.equal(res.status, 200);
assert.equal(res.json?.success, true);
assert.equal(readFileSync(claudePath, 'utf8'), 'after\n');
});
it('GET /api/memory/claude/scan separates user/project/module levels', async () => {
const userClaudePath = join(homeDir, '.claude', 'CLAUDE.md');
mkdirSync(join(homeDir, '.claude'), { recursive: true });
writeFileSync(userClaudePath, '# User CLAUDE\n', 'utf8');
const projectClaudePath = join(projectRoot, '.claude', 'CLAUDE.md');
mkdirSync(join(projectRoot, '.claude'), { recursive: true });
writeFileSync(projectClaudePath, ['---', 'paths: [src]', '---', '', '# Project CLAUDE'].join('\n'), 'utf8');
const moduleDir = join(projectRoot, 'module-a');
mkdirSync(moduleDir, { recursive: true });
writeFileSync(join(moduleDir, 'CLAUDE.md'), '# Module CLAUDE\n', 'utf8');
const res = await requestJson(baseUrl, 'GET', `/api/memory/claude/scan?path=${encodeURIComponent(projectRoot)}`);
assert.equal(res.status, 200);
assert.equal(res.json.user?.main?.level, 'user');
assert.ok(String(res.json.user.main.path).includes(homeDir));
assert.equal(res.json.project?.main?.level, 'project');
assert.ok(String(res.json.project.main.path).includes(projectRoot));
assert.deepEqual(res.json.project.main.frontmatter?.paths, ['src']);
assert.equal(String(res.json.project.main.content).includes('paths:'), false);
assert.equal(Array.isArray(res.json.modules), true);
assert.ok(res.json.modules.length >= 1);
const moduleFile = res.json.modules.find((m: any) => String(m.path).includes('module-a'));
assert.ok(moduleFile);
assert.equal(moduleFile.level, 'module');
assert.equal(moduleFile.parentDirectory, 'module-a');
});
it('DELETE /api/memory/claude/file requires confirm=true', async () => {
const moduleDir = join(projectRoot, 'module-del');
const moduleFilePath = join(moduleDir, 'CLAUDE.md');
mkdirSync(moduleDir, { recursive: true });
writeFileSync(moduleFilePath, '# To delete\n', 'utf8');
const res = await requestJson(baseUrl, 'DELETE', `/api/memory/claude/file?path=${encodeURIComponent(moduleFilePath)}`);
assert.equal(res.status, 400);
assert.equal(res.json?.error, 'Confirmation required');
assert.equal(existsSync(moduleFilePath), true);
});
it('DELETE /api/memory/claude/file deletes the file and creates a backup', async () => {
const moduleDir = join(projectRoot, 'module-del-ok');
const moduleFilePath = join(moduleDir, 'CLAUDE.md');
mkdirSync(moduleDir, { recursive: true });
writeFileSync(moduleFilePath, '# Bye\n', 'utf8');
const res = await requestJson(
baseUrl,
'DELETE',
`/api/memory/claude/file?path=${encodeURIComponent(moduleFilePath)}&confirm=true`,
);
assert.equal(res.status, 200);
assert.equal(res.json?.success, true);
assert.equal(existsSync(moduleFilePath), false);
const backups = readdirSync(moduleDir).filter((name) => name.startsWith('CLAUDE.md.deleted-'));
assert.equal(backups.length, 1);
});
});

206
ccw/tests/integration/files-routes.test.ts Normal file
View File

@@ -0,0 +1,206 @@
/**
* Integration tests for files routes (directory listing + file preview).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Uses a temporary project directory as the allowed root (initialPath).
*/
import { after, before, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import http from 'node:http';
import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const filesRoutesUrl = new URL('../../dist/core/routes/files-routes.js', import.meta.url);
filesRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
type JsonResponse = { status: number; json: any; text: string };
async function requestJson(baseUrl: string, method: string, path: string): Promise<JsonResponse> {
const url = new URL(path, baseUrl);
return new Promise((resolve, reject) => {
const req = http.request(
url,
{ method, headers: { Accept: 'application/json' } },
(res) => {
let body = '';
res.on('data', (chunk) => {
body += chunk.toString();
});
res.on('end', () => {
let json: any = null;
try {
json = body ? JSON.parse(body) : null;
} catch {
json = null;
}
resolve({ status: res.statusCode || 0, json, text: body });
});
},
);
req.on('error', reject);
req.end();
});
}
function handlePostRequest(req: http.IncomingMessage, res: http.ServerResponse, handler: (body: unknown) => Promise<any>): void {
let body = '';
req.on('data', (chunk) => {
body += chunk.toString();
});
req.on('end', async () => {
try {
const parsed = body ? JSON.parse(body) : {};
const result = await handler(parsed);
if (result?.error) {
res.writeHead(result.status || 500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: result.error }));
} else {
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify(result));
}
} catch (err: any) {
res.writeHead(500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: err?.message || String(err) }));
}
});
}
describe('files routes integration', async () => {
let server: http.Server | null = null;
let baseUrl = '';
let projectRoot = '';
before(async () => {
projectRoot = mkdtempSync(join(tmpdir(), 'ccw-files-routes-project-'));
mkdirSync(join(projectRoot, 'subdir'), { recursive: true });
mkdirSync(join(projectRoot, '.claude'), { recursive: true });
mkdirSync(join(projectRoot, '.workflow'), { recursive: true });
mkdirSync(join(projectRoot, 'node_modules'), { recursive: true });
mkdirSync(join(projectRoot, 'ignored-dir'), { recursive: true });
writeFileSync(join(projectRoot, 'visible.txt'), 'ok\n', 'utf8');
writeFileSync(join(projectRoot, 'ignored.txt'), 'nope\n', 'utf8');
writeFileSync(join(projectRoot, '.secret'), 'hidden\n', 'utf8');
writeFileSync(join(projectRoot, 'readme.md'), '# Hello\n', 'utf8');
writeFileSync(join(projectRoot, '.gitignore'), ['ignored.txt', 'ignored-dir/'].join('\n') + '\n', 'utf8');
mock.method(console, 'error', () => {});
mod = await import(filesRoutesUrl.href);
server = http.createServer(async (req, res) => {
const url = new URL(req.url || '/', 'http://localhost');
const pathname = url.pathname;
const ctx = {
pathname,
url,
req,
res,
initialPath: projectRoot,
handlePostRequest,
};
try {
const handled = await mod.handleFilesRoutes(ctx);
if (!handled) {
res.writeHead(404, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: 'Not Found' }));
}
} catch (err: any) {
res.writeHead(500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: err?.message || String(err) }));
}
});
await new Promise<void>((resolve) => {
server!.listen(0, () => resolve());
});
const addr = server.address();
const port = typeof addr === 'object' && addr ? addr.port : 0;
baseUrl = `http://127.0.0.1:${port}`;
});
after(async () => {
mock.restoreAll();
if (server) {
await new Promise<void>((resolve) => server!.close(() => resolve()));
server = null;
}
if (projectRoot) {
rmSync(projectRoot, { recursive: true, force: true });
projectRoot = '';
}
});
it('GET /api/files lists entries and respects gitignore/exclude rules', async () => {
const res = await requestJson(baseUrl, 'GET', `/api/files?path=${encodeURIComponent(projectRoot)}`);
assert.equal(res.status, 200);
assert.ok(res.json);
assert.equal(Array.isArray(res.json.files), true);
const names = res.json.files.map((f: any) => f.name);
assert.ok(names.includes('subdir'));
assert.ok(names.includes('visible.txt'));
assert.ok(names.includes('.claude'));
assert.ok(names.includes('.workflow'));
// Hidden dotfiles (except .claude/.workflow) are excluded.
assert.equal(names.includes('.secret'), false);
// Common excluded dirs are always removed.
assert.equal(names.includes('node_modules'), false);
// .gitignore patterns should be enforced.
assert.equal(names.includes('ignored.txt'), false);
assert.equal(names.includes('ignored-dir'), false);
assert.equal(Array.isArray(res.json.gitignorePatterns), true);
assert.ok(res.json.gitignorePatterns.includes('ignored.txt'));
});
it('GET /api/files returns 400 for non-existent path', async () => {
const missing = join(projectRoot, 'missing-dir');
const res = await requestJson(baseUrl, 'GET', `/api/files?path=${encodeURIComponent(missing)}`);
assert.equal(res.status, 400);
assert.equal(res.json?.error, 'Invalid path');
assert.equal(Array.isArray(res.json?.files), true);
assert.equal(res.json.files.length, 0);
});
it('GET /api/files blocks traversal outside initialPath', async () => {
const outside = join(projectRoot, '..');
const res = await requestJson(baseUrl, 'GET', `/api/files?path=${encodeURIComponent(outside)}`);
assert.equal(res.status, 403);
assert.equal(res.json?.error, 'Access denied');
});
it('GET /api/file-content returns preview content for files', async () => {
const target = join(projectRoot, 'readme.md');
const res = await requestJson(baseUrl, 'GET', `/api/file-content?path=${encodeURIComponent(target)}`);
assert.equal(res.status, 200);
assert.ok(res.json);
assert.equal(res.json.fileName, 'readme.md');
assert.equal(res.json.language, 'markdown');
assert.equal(res.json.isMarkdown, true);
assert.ok(String(res.json.content).includes('# Hello'));
});
it('GET /api/file-content returns 400 when path is missing', async () => {
const res = await requestJson(baseUrl, 'GET', '/api/file-content');
assert.equal(res.status, 400);
assert.ok(res.json?.error);
});
it('GET /api/file-content returns 404 when path is a directory', async () => {
const res = await requestJson(baseUrl, 'GET', `/api/file-content?path=${encodeURIComponent(projectRoot)}`);
assert.equal(res.status, 404);
assert.equal(res.json?.error, 'Cannot read directory');
});
});

93
ccw/tests/integration/graph-routes.test.ts Normal file
View File

@@ -0,0 +1,93 @@
/**
* Integration tests for graph routes (CodexLens graph API helpers).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Calls route handler directly (no HTTP server required).
*/
import { after, before, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const graphRoutesUrl = new URL('../../dist/core/routes/graph-routes.js', import.meta.url);
graphRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
async function callGraph(
projectRoot: string,
path: string,
): Promise<{ handled: boolean; status: number; json: any }> {
const url = new URL(path, 'http://localhost');
let status = 0;
let body = '';
const res = {
writeHead(code: number) {
status = code;
},
end(chunk?: any) {
body = chunk === undefined ? '' : String(chunk);
},
};
const handled = await mod.handleGraphRoutes({
pathname: url.pathname,
url,
req: { method: 'GET' },
res,
initialPath: projectRoot,
});
return { handled, status, json: body ? JSON.parse(body) : null };
}
describe('graph routes integration', async () => {
let projectRoot = '';
before(async () => {
projectRoot = mkdtempSync(join(tmpdir(), 'ccw-graph-project-'));
mock.method(console, 'error', () => {});
mod = await import(graphRoutesUrl.href);
});
after(() => {
mock.restoreAll();
if (projectRoot) {
rmSync(projectRoot, { recursive: true, force: true });
projectRoot = '';
}
});
it('GET /api/graph/search-process returns placeholder pipeline data', async () => {
const res = await callGraph(projectRoot, '/api/graph/search-process');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(Array.isArray(res.json.stages), true);
assert.equal(res.json.stages.length, 5);
assert.equal(typeof res.json.message, 'string');
});
it('GET /api/graph/files returns empty lists when no index exists', async () => {
const res = await callGraph(projectRoot, `/api/graph/files?path=${encodeURIComponent(projectRoot)}`);
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(Array.isArray(res.json.files), true);
assert.equal(Array.isArray(res.json.modules), true);
assert.equal(res.json.files.length, 0);
assert.equal(res.json.modules.length, 0);
});
it('GET /api/graph/impact validates required symbol parameter', async () => {
const res = await callGraph(projectRoot, `/api/graph/impact?path=${encodeURIComponent(projectRoot)}`);
assert.equal(res.handled, true);
assert.equal(res.status, 400);
assert.ok(String(res.json.error).includes('symbol'));
assert.equal(Array.isArray(res.json.directDependents), true);
assert.equal(Array.isArray(res.json.affectedFiles), true);
});
});

174
ccw/tests/integration/help-routes.test.ts Normal file
View File

@@ -0,0 +1,174 @@
/**
* Integration tests for help routes (command guide + CodexLens docs).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Avoids spinning up a real HTTP server; calls route handler directly.
* - Uses a temporary HOME/USERPROFILE to isolate ~/.claude/skills/command-guide/index data.
*/
import { after, before, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const helpRoutesUrl = new URL('../../dist/core/routes/help-routes.js', import.meta.url);
helpRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
const originalEnv = {
HOME: process.env.HOME,
USERPROFILE: process.env.USERPROFILE,
HOMEDRIVE: process.env.HOMEDRIVE,
HOMEPATH: process.env.HOMEPATH,
};
async function callRoute(path: string): Promise<{ handled: boolean; status: number; json: any; text: string }> {
const url = new URL(path, 'http://localhost');
let status = 0;
let text = '';
const res = {
writeHead(code: number) {
status = code;
},
end(chunk?: any) {
text = chunk === undefined ? '' : String(chunk);
},
};
const ctx = {
pathname: url.pathname,
url,
req: { method: 'GET' },
res,
};
const handled = await mod.handleHelpRoutes(ctx);
let json: any = null;
try {
json = text ? JSON.parse(text) : null;
} catch {
json = null;
}
return { handled, status, json, text };
}
describe('help routes integration', async () => {
let homeDir = '';
before(async () => {
homeDir = mkdtempSync(join(tmpdir(), 'ccw-help-home-'));
process.env.HOME = homeDir;
process.env.USERPROFILE = homeDir;
process.env.HOMEDRIVE = undefined;
process.env.HOMEPATH = undefined;
mock.method(console, 'log', () => {});
mock.method(console, 'warn', () => {});
mock.method(console, 'error', () => {});
const indexDir = join(homeDir, '.claude', 'skills', 'command-guide', 'index');
mkdirSync(indexDir, { recursive: true });
writeFileSync(
join(indexDir, 'all-commands.json'),
JSON.stringify(
[
{ name: 'Issue Next', command: 'ccw issue next', description: 'Fetch next item', category: 'issue', subcategory: 'queue' },
{ name: 'Serve', command: 'ccw serve', description: 'Start dashboard server', category: 'core' },
],
null,
2,
),
'utf8',
);
writeFileSync(
join(indexDir, 'command-relationships.json'),
JSON.stringify({ workflows: [{ name: 'Issue Queue', commands: ['ccw issue next', 'ccw issue done'] }] }, null, 2),
'utf8',
);
writeFileSync(
join(indexDir, 'by-category.json'),
JSON.stringify({ issue: ['ccw issue next'], core: ['ccw serve'] }, null, 2),
'utf8',
);
mod = await import(helpRoutesUrl.href);
});
after(() => {
mock.restoreAll();
process.env.HOME = originalEnv.HOME;
process.env.USERPROFILE = originalEnv.USERPROFILE;
process.env.HOMEDRIVE = originalEnv.HOMEDRIVE;
process.env.HOMEPATH = originalEnv.HOMEPATH;
const activeHandles: any[] = (process as any)._getActiveHandles?.() || [];
for (const handle of activeHandles) {
if (handle?.constructor?.name === 'FSWatcher' && typeof handle.close === 'function') {
try {
handle.close();
} catch {
// ignore
}
}
}
if (homeDir) {
rmSync(homeDir, { recursive: true, force: true });
homeDir = '';
}
});
it('GET /api/help/commands returns commands and grouped categories', async () => {
const res = await callRoute('/api/help/commands');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(Array.isArray(res.json.commands), true);
assert.equal(res.json.total, 2);
assert.equal(typeof res.json.grouped, 'object');
assert.ok(res.json.grouped.issue);
});
it('GET /api/help/commands?q filters commands by search query', async () => {
const res = await callRoute('/api/help/commands?q=issue');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(res.json.total, 1);
assert.equal(res.json.commands[0].command, 'ccw issue next');
});
it('GET /api/help/workflows returns workflow relationships data', async () => {
const res = await callRoute('/api/help/workflows');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(Array.isArray(res.json.workflows), true);
assert.equal(res.json.workflows[0].name, 'Issue Queue');
});
it('GET /api/help/commands/by-category returns category index data', async () => {
const res = await callRoute('/api/help/commands/by-category');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(Array.isArray(res.json.issue), true);
assert.equal(res.json.issue[0], 'ccw issue next');
});
it('GET /api/help/codexlens returns CodexLens quick start content', async () => {
const res = await callRoute('/api/help/codexlens');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(res.json.title, 'CodexLens Quick Start');
assert.equal(Array.isArray(res.json.sections), true);
assert.ok(res.json.sections.length > 0);
});
});

159
ccw/tests/integration/hooks-routes.test.ts Normal file
View File

@@ -0,0 +1,159 @@
/**
* Integration tests for hooks routes (hooks configuration CRUD).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Uses temporary HOME/USERPROFILE for global settings isolation.
* - Calls route handler directly (no HTTP server required).
*/
import { after, before, beforeEach, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const hooksRoutesUrl = new URL('../../dist/core/routes/hooks-routes.js', import.meta.url);
hooksRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
const originalEnv = {
HOME: process.env.HOME,
USERPROFILE: process.env.USERPROFILE,
HOMEDRIVE: process.env.HOMEDRIVE,
HOMEPATH: process.env.HOMEPATH,
};
async function callHooks(
initialPath: string,
method: string,
pathname: string,
body?: any,
): Promise<{ handled: boolean; status: number; json: any }> {
const url = new URL(pathname, 'http://localhost');
let status = 0;
let text = '';
const res = {
writeHead(code: number) {
status = code;
},
end(chunk?: any) {
text = chunk === undefined ? '' : String(chunk);
},
};
const handlePostRequest = async (_req: any, _res: any, handler: (parsed: any) => Promise<any>) => {
const result = await handler(body ?? {});
if (result && typeof result === 'object' && typeof result.error === 'string' && result.error.length > 0) {
res.writeHead(typeof result.status === 'number' ? result.status : 500);
res.end(JSON.stringify({ error: result.error }));
return;
}
res.writeHead(200);
res.end(JSON.stringify(result));
};
const handled = await mod.handleHooksRoutes({
pathname: url.pathname,
url,
req: { method },
res,
initialPath,
handlePostRequest,
broadcastToClients() {},
extractSessionIdFromPath() {
return null;
},
});
return { handled, status, json: text ? JSON.parse(text) : null };
}
describe('hooks routes integration', async () => {
let homeDir = '';
let projectRoot = '';
before(async () => {
homeDir = mkdtempSync(join(tmpdir(), 'ccw-hooks-home-'));
projectRoot = mkdtempSync(join(tmpdir(), 'ccw-hooks-project-'));
process.env.HOME = homeDir;
process.env.USERPROFILE = homeDir;
process.env.HOMEDRIVE = undefined;
process.env.HOMEPATH = undefined;
mock.method(console, 'log', () => {});
mock.method(console, 'warn', () => {});
mock.method(console, 'error', () => {});
mod = await import(hooksRoutesUrl.href);
});
beforeEach(() => {
rmSync(join(homeDir, '.claude'), { recursive: true, force: true });
rmSync(join(projectRoot, '.claude'), { recursive: true, force: true });
});
after(() => {
mock.restoreAll();
process.env.HOME = originalEnv.HOME;
process.env.USERPROFILE = originalEnv.USERPROFILE;
process.env.HOMEDRIVE = originalEnv.HOMEDRIVE;
process.env.HOMEPATH = originalEnv.HOMEPATH;
rmSync(projectRoot, { recursive: true, force: true });
rmSync(homeDir, { recursive: true, force: true });
});
it('GET /api/hooks returns global and project hook configs', async () => {
const res = await callHooks(projectRoot, 'GET', '/api/hooks');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.ok(res.json);
assert.ok(res.json.global);
assert.ok(res.json.project);
assert.deepEqual(res.json.global.hooks, {});
assert.deepEqual(res.json.project.hooks, {});
});
it('POST /api/hooks saves a global hook and GET reflects it', async () => {
const save = await callHooks(projectRoot, 'POST', '/api/hooks', {
scope: 'global',
event: 'PreToolUse',
hookData: { command: 'echo hi' },
});
assert.equal(save.handled, true);
assert.equal(save.status, 200);
assert.equal(save.json.success, true);
const read = await callHooks(projectRoot, 'GET', '/api/hooks');
assert.equal(read.status, 200);
assert.equal(Array.isArray(read.json.global.hooks.PreToolUse), true);
assert.equal(read.json.global.hooks.PreToolUse.length, 1);
assert.equal(read.json.global.hooks.PreToolUse[0].command, 'echo hi');
});
it('DELETE /api/hooks removes a hook by index', async () => {
await callHooks(projectRoot, 'POST', '/api/hooks', {
scope: 'global',
event: 'PreToolUse',
hookData: { command: 'echo hi' },
});
const del = await callHooks(projectRoot, 'DELETE', '/api/hooks', {
scope: 'global',
event: 'PreToolUse',
hookIndex: 0,
});
assert.equal(del.status, 200);
assert.equal(del.json.success, true);
const read = await callHooks(projectRoot, 'GET', '/api/hooks');
assert.equal(read.status, 200);
assert.deepEqual(read.json.global.hooks, {});
});
});

296
ccw/tests/integration/issue-routes.test.ts Normal file
View File

@@ -0,0 +1,296 @@
/**
* Integration tests for issue routes (issues + solutions + queue).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Uses a temporary project root to isolate `.workflow/issues` JSONL storage.
*/
import { after, before, beforeEach, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import http from 'node:http';
import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const issueRoutesUrl = new URL('../../dist/core/routes/issue-routes.js', import.meta.url);
issueRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
type JsonResponse = { status: number; json: any; text: string };
async function requestJson(
baseUrl: string,
method: string,
path: string,
body?: unknown,
): Promise<JsonResponse> {
const url = new URL(path, baseUrl);
const payload = body === undefined ? null : Buffer.from(JSON.stringify(body), 'utf8');
return new Promise((resolve, reject) => {
const req = http.request(
url,
{
method,
headers: {
Accept: 'application/json',
...(payload
? { 'Content-Type': 'application/json', 'Content-Length': String(payload.length) }
: {}),
},
},
(res) => {
let responseBody = '';
res.on('data', (chunk) => {
responseBody += chunk.toString();
});
res.on('end', () => {
let json: any = null;
try {
json = responseBody ? JSON.parse(responseBody) : null;
} catch {
json = null;
}
resolve({ status: res.statusCode || 0, json, text: responseBody });
});
},
);
req.on('error', reject);
if (payload) req.write(payload);
req.end();
});
}
function handlePostRequest(req: http.IncomingMessage, res: http.ServerResponse, handler: (body: any) => Promise<any>): void {
let body = '';
req.on('data', (chunk) => {
body += chunk.toString();
});
req.on('end', async () => {
try {
const parsed = body ? JSON.parse(body) : {};
const result = await handler(parsed);
if (result?.error) {
res.writeHead(result.status || 500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: result.error }));
} else {
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify(result));
}
} catch (err: any) {
res.writeHead(500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: err?.message || String(err) }));
}
});
}
function readJsonl(path: string): any[] {
if (!existsSync(path)) return [];
return readFileSync(path, 'utf8')
.split('\n')
.filter((line) => line.trim().length > 0)
.map((line) => JSON.parse(line));
}
describe('issue routes integration', async () => {
let server: http.Server | null = null;
let baseUrl = '';
let projectRoot = '';
before(async () => {
projectRoot = mkdtempSync(join(tmpdir(), 'ccw-issue-routes-project-'));
mock.method(console, 'log', () => {});
mock.method(console, 'error', () => {});
mod = await import(issueRoutesUrl.href);
server = http.createServer(async (req, res) => {
const url = new URL(req.url || '/', 'http://localhost');
const pathname = url.pathname;
const ctx = {
pathname,
url,
req,
res,
initialPath: projectRoot,
handlePostRequest,
};
try {
const handled = await mod.handleIssueRoutes(ctx);
if (!handled) {
res.writeHead(404, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: 'Not Found' }));
}
} catch (err: any) {
res.writeHead(500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: err?.message || String(err) }));
}
});
await new Promise<void>((resolve) => server!.listen(0, () => resolve()));
const addr = server.address();
const port = typeof addr === 'object' && addr ? addr.port : 0;
baseUrl = `http://127.0.0.1:${port}`;
});
beforeEach(() => {
rmSync(join(projectRoot, '.workflow'), { recursive: true, force: true });
});
after(async () => {
mock.restoreAll();
if (server) {
await new Promise<void>((resolve) => server!.close(() => resolve()));
server = null;
}
if (projectRoot) {
rmSync(projectRoot, { recursive: true, force: true });
projectRoot = '';
}
});
it('GET /api/issues returns empty issues list with metadata', async () => {
const res = await requestJson(baseUrl, 'GET', '/api/issues');
assert.equal(res.status, 200);
assert.ok(res.json);
assert.equal(Array.isArray(res.json.issues), true);
assert.equal(res.json.issues.length, 0);
assert.equal(res.json._metadata.storage, 'jsonl');
});
it('POST /api/issues creates a new issue and writes JSONL', async () => {
const issueId = 'ISS-IR-1';
const res = await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Issue routes test' });
assert.equal(res.status, 200);
assert.equal(res.json?.success, true);
assert.equal(res.json.issue.id, issueId);
const issuesPath = join(projectRoot, '.workflow', 'issues', 'issues.jsonl');
const lines = readJsonl(issuesPath);
assert.equal(lines.length, 1);
assert.equal(lines[0].id, issueId);
assert.equal(typeof lines[0].created_at, 'string');
});
it('GET /api/issues returns enriched issue list with counts', async () => {
const issueId = 'ISS-IR-2';
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Counts' });
const res = await requestJson(baseUrl, 'GET', '/api/issues');
assert.equal(res.status, 200);
const issue = res.json.issues.find((i: any) => i.id === issueId);
assert.ok(issue);
assert.equal(issue.solution_count, 0);
assert.equal(issue.task_count, 0);
});
it('GET /api/issues/:id returns issue detail with solutions/tasks arrays', async () => {
const issueId = 'ISS-IR-3';
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Detail' });
const res = await requestJson(baseUrl, 'GET', `/api/issues/${encodeURIComponent(issueId)}`);
assert.equal(res.status, 200);
assert.equal(res.json.id, issueId);
assert.equal(Array.isArray(res.json.solutions), true);
assert.equal(Array.isArray(res.json.tasks), true);
assert.equal(res.json.solutions.length, 0);
assert.equal(res.json.tasks.length, 0);
});
it('POST /api/issues/:id/solutions appends a solution to solutions JSONL', async () => {
const issueId = 'ISS-IR-4';
const solutionId = 'SOL-ISS-IR-4-1';
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Solution add' });
const tasks = [{ id: 'T1', title: 'Do thing' }];
const res = await requestJson(baseUrl, 'POST', `/api/issues/${encodeURIComponent(issueId)}/solutions`, { id: solutionId, tasks });
assert.equal(res.status, 200);
assert.equal(res.json?.success, true);
assert.equal(res.json.solution.id, solutionId);
assert.equal(res.json.solution.is_bound, false);
const solutionsPath = join(projectRoot, '.workflow', 'issues', 'solutions', `${issueId}.jsonl`);
const lines = readJsonl(solutionsPath);
assert.equal(lines.length, 1);
assert.equal(lines[0].id, solutionId);
assert.equal(Array.isArray(lines[0].tasks), true);
});
it('PATCH /api/issues/:id binds solution and updates planned status', async () => {
const issueId = 'ISS-IR-5';
const solutionId = 'SOL-ISS-IR-5-1';
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Bind' });
await requestJson(baseUrl, 'POST', `/api/issues/${encodeURIComponent(issueId)}/solutions`, { id: solutionId, tasks: [{ id: 'T1' }] });
const res = await requestJson(baseUrl, 'PATCH', `/api/issues/${encodeURIComponent(issueId)}`, { bound_solution_id: solutionId });
assert.equal(res.status, 200);
assert.equal(res.json?.success, true);
assert.ok(res.json.updated.includes('bound_solution_id'));
const detail = await requestJson(baseUrl, 'GET', `/api/issues/${encodeURIComponent(issueId)}`);
assert.equal(detail.status, 200);
assert.equal(detail.json.bound_solution_id, solutionId);
assert.equal(detail.json.status, 'planned');
assert.ok(detail.json.planned_at);
assert.equal(detail.json.tasks.length, 1);
const solutionsPath = join(projectRoot, '.workflow', 'issues', 'solutions', `${issueId}.jsonl`);
const lines = readJsonl(solutionsPath);
assert.equal(lines.length, 1);
assert.equal(lines[0].is_bound, true);
});
it('PATCH /api/issues/:id/tasks/:taskId updates bound solution task fields', async () => {
const issueId = 'ISS-IR-6';
const solutionId = 'SOL-ISS-IR-6-1';
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Task update' });
await requestJson(baseUrl, 'POST', `/api/issues/${encodeURIComponent(issueId)}/solutions`, { id: solutionId, tasks: [{ id: 'T1', status: 'pending' }] });
await requestJson(baseUrl, 'PATCH', `/api/issues/${encodeURIComponent(issueId)}`, { bound_solution_id: solutionId });
const res = await requestJson(baseUrl, 'PATCH', `/api/issues/${encodeURIComponent(issueId)}/tasks/T1`, { status: 'completed', result: { ok: true } });
assert.equal(res.status, 200);
assert.equal(res.json?.success, true);
assert.ok(res.json.updated.includes('status'));
assert.ok(res.json.updated.includes('result'));
const solutionsPath = join(projectRoot, '.workflow', 'issues', 'solutions', `${issueId}.jsonl`);
const lines = readJsonl(solutionsPath);
const task = lines[0].tasks.find((t: any) => t.id === 'T1');
assert.equal(task.status, 'completed');
assert.deepEqual(task.result, { ok: true });
assert.ok(task.updated_at);
});
it('DELETE /api/issues/:id removes issue and deletes solutions JSONL', async () => {
const issueId = 'ISS-IR-7';
const solutionId = 'SOL-ISS-IR-7-1';
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Delete me' });
await requestJson(baseUrl, 'POST', `/api/issues/${encodeURIComponent(issueId)}/solutions`, { id: solutionId, tasks: [{ id: 'T1' }] });
const res = await requestJson(baseUrl, 'DELETE', `/api/issues/${encodeURIComponent(issueId)}`);
assert.equal(res.status, 200);
assert.equal(res.json?.success, true);
const issuesPath = join(projectRoot, '.workflow', 'issues', 'issues.jsonl');
assert.equal(readJsonl(issuesPath).length, 0);
const solutionsPath = join(projectRoot, '.workflow', 'issues', 'solutions', `${issueId}.jsonl`);
assert.equal(existsSync(solutionsPath), false);
});
it('GET /api/queue returns grouped queue structure', async () => {
const res = await requestJson(baseUrl, 'GET', '/api/queue');
assert.equal(res.status, 200);
assert.ok(res.json);
assert.equal(Array.isArray(res.json.execution_groups), true);
assert.equal(typeof res.json.grouped_items, 'object');
});
});

118
ccw/tests/integration/litellm-api-routes.test.ts Normal file
View File

@@ -0,0 +1,118 @@
/**
* Integration tests for LiteLLM API routes (providers + model discovery).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Calls route handler directly (no HTTP server required).
* - Uses temporary CCW_DATA_DIR to isolate ~/.ccw config writes.
*/
import { after, before, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const CCW_HOME = mkdtempSync(join(tmpdir(), 'ccw-litellm-api-home-'));
const PROJECT_ROOT = mkdtempSync(join(tmpdir(), 'ccw-litellm-api-project-'));
const litellmApiRoutesUrl = new URL('../../dist/core/routes/litellm-api-routes.js', import.meta.url);
litellmApiRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
const originalEnv = { CCW_DATA_DIR: process.env.CCW_DATA_DIR };
async function callLiteLLMApi(
initialPath: string,
method: string,
path: string,
body?: any,
): Promise<{ handled: boolean; status: number; json: any; broadcasts: any[] }> {
const url = new URL(path, 'http://localhost');
let status = 0;
let text = '';
const broadcasts: any[] = [];
const res = {
writeHead(code: number) {
status = code;
},
end(chunk?: any) {
text = chunk === undefined ? '' : String(chunk);
},
};
const handlePostRequest = async (_req: any, _res: any, handler: (parsed: any) => Promise<any>) => {
const result = await handler(body ?? {});
const errorValue = result && typeof result === 'object' ? (result as any).error : undefined;
const statusValue = result && typeof result === 'object' ? (result as any).status : undefined;
if (typeof errorValue === 'string' && errorValue.length > 0) {
res.writeHead(typeof statusValue === 'number' ? statusValue : 500);
res.end(JSON.stringify({ error: errorValue }));
return;
}
res.writeHead(200);
res.end(JSON.stringify(result));
};
const handled = await mod.handleLiteLLMApiRoutes({
pathname: url.pathname,
url,
req: { method },
res,
initialPath,
handlePostRequest,
broadcastToClients(data: unknown) {
broadcasts.push(data);
},
});
return { handled, status, json: text ? JSON.parse(text) : null, broadcasts };
}
describe('litellm-api routes integration', async () => {
before(async () => {
process.env.CCW_DATA_DIR = CCW_HOME;
mock.method(console, 'log', () => {});
mock.method(console, 'warn', () => {});
mock.method(console, 'error', () => {});
mod = await import(litellmApiRoutesUrl.href);
});
after(() => {
mock.restoreAll();
process.env.CCW_DATA_DIR = originalEnv.CCW_DATA_DIR;
rmSync(CCW_HOME, { recursive: true, force: true });
rmSync(PROJECT_ROOT, { recursive: true, force: true });
});
it('GET /api/litellm-api/models/openai returns static model list', async () => {
const res = await callLiteLLMApi(PROJECT_ROOT, 'GET', '/api/litellm-api/models/openai');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(res.json.providerType, 'openai');
assert.equal(Array.isArray(res.json.models), true);
assert.ok(res.json.models.length > 0);
});
it('GET /api/litellm-api/providers returns default empty config', async () => {
const res = await callLiteLLMApi(PROJECT_ROOT, 'GET', '/api/litellm-api/providers');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(Array.isArray(res.json.providers), true);
assert.equal(typeof res.json.count, 'number');
});
it('POST /api/litellm-api/providers validates required fields', async () => {
const res = await callLiteLLMApi(PROJECT_ROOT, 'POST', '/api/litellm-api/providers', { name: 'x' });
assert.equal(res.handled, true);
assert.equal(res.status, 400);
assert.ok(String(res.json.error).includes('required'));
assert.equal(res.broadcasts.length, 0);
});
});

182
ccw/tests/integration/nav-status-routes.test.ts Normal file
View File

@@ -0,0 +1,182 @@
/**
* Integration tests for nav-status routes (badge count aggregation).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Calls route handler directly (no HTTP server required).
* - Uses temporary HOME/USERPROFILE and project root to isolate filesystem reads.
*/
import { after, before, beforeEach, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const navStatusRoutesUrl = new URL('../../dist/core/routes/nav-status-routes.js', import.meta.url);
navStatusRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
const originalEnv = {
HOME: process.env.HOME,
USERPROFILE: process.env.USERPROFILE,
HOMEDRIVE: process.env.HOMEDRIVE,
HOMEPATH: process.env.HOMEPATH,
};
async function getNavStatus(projectRoot: string): Promise<{ status: number; json: any }> {
const url = new URL('/api/nav-status', 'http://localhost');
let status = 0;
let body = '';
const res = {
writeHead(code: number) {
status = code;
},
end(chunk?: any) {
body = chunk === undefined ? '' : String(chunk);
},
};
const handled = await mod.handleNavStatusRoutes({
pathname: '/api/nav-status',
url,
req: { method: 'GET' },
res,
initialPath: projectRoot,
});
assert.equal(handled, true);
return { status, json: JSON.parse(body) };
}
describe('nav-status routes integration', async () => {
let homeDir = '';
let projectRoot = '';
before(async () => {
homeDir = mkdtempSync(join(tmpdir(), 'ccw-nav-home-'));
projectRoot = mkdtempSync(join(tmpdir(), 'ccw-nav-project-'));
process.env.HOME = homeDir;
process.env.USERPROFILE = homeDir;
process.env.HOMEDRIVE = undefined;
process.env.HOMEPATH = undefined;
mock.method(console, 'error', () => {});
mod = await import(navStatusRoutesUrl.href);
});
beforeEach(() => {
// Reset relevant trees per test.
rmSync(join(projectRoot, '.workflow'), { recursive: true, force: true });
rmSync(join(projectRoot, '.claude'), { recursive: true, force: true });
rmSync(join(homeDir, '.claude'), { recursive: true, force: true });
const rootClaude = join(projectRoot, 'CLAUDE.md');
if (existsSync(rootClaude)) rmSync(rootClaude, { force: true });
});
after(() => {
mock.restoreAll();
process.env.HOME = originalEnv.HOME;
process.env.USERPROFILE = originalEnv.USERPROFILE;
process.env.HOMEDRIVE = originalEnv.HOMEDRIVE;
process.env.HOMEPATH = originalEnv.HOMEPATH;
rmSync(projectRoot, { recursive: true, force: true });
rmSync(homeDir, { recursive: true, force: true });
});
it('returns zero counts when no data exists', async () => {
const res = await getNavStatus(projectRoot);
assert.equal(res.status, 200);
assert.ok(res.json);
for (const key of ['issues', 'discoveries', 'skills', 'rules', 'claude', 'hooks', 'timestamp']) {
assert.ok(Object.prototype.hasOwnProperty.call(res.json, key), `missing key: ${key}`);
}
assert.equal(res.json.issues.count, 0);
assert.equal(res.json.discoveries.count, 0);
assert.equal(res.json.skills.count, 0);
assert.equal(res.json.rules.count, 0);
assert.equal(res.json.claude.count, 0);
assert.equal(res.json.hooks.count, 0);
assert.equal(typeof res.json.timestamp, 'string');
});
it('counts issues.jsonl lines and discovery index entries', async () => {
const issuesDir = join(projectRoot, '.workflow', 'issues');
const discoveriesDir = join(issuesDir, 'discoveries');
mkdirSync(discoveriesDir, { recursive: true });
writeFileSync(join(issuesDir, 'issues.jsonl'), '{"id":"ISS-1"}\n{"id":"ISS-2"}\n', 'utf8');
writeFileSync(join(discoveriesDir, 'index.json'), JSON.stringify({ discoveries: [{ id: 'DSC-1' }, { id: 'DSC-2' }, { id: 'DSC-3' }] }), 'utf8');
const res = await getNavStatus(projectRoot);
assert.equal(res.status, 200);
assert.equal(res.json.issues.count, 2);
assert.equal(res.json.discoveries.count, 3);
});
it('aggregates skills, rules, CLAUDE.md files, and hooks across user/project', async () => {
// Skills
mkdirSync(join(projectRoot, '.claude', 'skills', 'proj-skill'), { recursive: true });
writeFileSync(join(projectRoot, '.claude', 'skills', 'proj-skill', 'SKILL.md'), '# skill\n', 'utf8');
mkdirSync(join(homeDir, '.claude', 'skills', 'user-skill-1'), { recursive: true });
mkdirSync(join(homeDir, '.claude', 'skills', 'user-skill-2'), { recursive: true });
writeFileSync(join(homeDir, '.claude', 'skills', 'user-skill-1', 'SKILL.md'), '# skill\n', 'utf8');
writeFileSync(join(homeDir, '.claude', 'skills', 'user-skill-2', 'SKILL.md'), '# skill\n', 'utf8');
// Rules (recursive)
mkdirSync(join(projectRoot, '.claude', 'rules', 'nested'), { recursive: true });
writeFileSync(join(projectRoot, '.claude', 'rules', 'a.md'), '# a\n', 'utf8');
writeFileSync(join(projectRoot, '.claude', 'rules', 'nested', 'b.md'), '# b\n', 'utf8');
mkdirSync(join(homeDir, '.claude', 'rules'), { recursive: true });
writeFileSync(join(homeDir, '.claude', 'rules', 'c.md'), '# c\n', 'utf8');
// CLAUDE.md files (user main + project main + root + module)
mkdirSync(join(homeDir, '.claude'), { recursive: true });
writeFileSync(join(homeDir, '.claude', 'CLAUDE.md'), '# user\n', 'utf8');
mkdirSync(join(projectRoot, '.claude'), { recursive: true });
writeFileSync(join(projectRoot, '.claude', 'CLAUDE.md'), '# project\n', 'utf8');
writeFileSync(join(projectRoot, 'CLAUDE.md'), '# root\n', 'utf8');
const moduleDir = join(projectRoot, 'module-a');
mkdirSync(moduleDir, { recursive: true });
writeFileSync(join(moduleDir, 'CLAUDE.md'), '# module\n', 'utf8');
// Hooks in settings.json
mkdirSync(join(homeDir, '.claude'), { recursive: true });
writeFileSync(
join(homeDir, '.claude', 'settings.json'),
JSON.stringify({ hooks: { PreToolUse: [{}, {}], PostToolUse: {} } }),
'utf8',
);
writeFileSync(
join(projectRoot, '.claude', 'settings.json'),
JSON.stringify({ hooks: { PreToolUse: [{}] } }),
'utf8',
);
const res = await getNavStatus(projectRoot);
assert.equal(res.status, 200);
assert.equal(res.json.skills.project, 1);
assert.equal(res.json.skills.user, 2);
assert.equal(res.json.skills.count, 3);
assert.equal(res.json.rules.project, 2);
assert.equal(res.json.rules.user, 1);
assert.equal(res.json.rules.count, 3);
assert.equal(res.json.claude.count, 4);
assert.equal(res.json.hooks.global, 3);
assert.equal(res.json.hooks.project, 1);
assert.equal(res.json.hooks.count, 4);
});
});

153
ccw/tests/integration/rules-routes.test.ts Normal file
View File

@@ -0,0 +1,153 @@
/**
* Integration tests for rules routes (rules management CRUD).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Calls route handler directly (no HTTP server required).
* - Uses temporary HOME/USERPROFILE to isolate user rules directory.
*/
import { after, before, beforeEach, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const rulesRoutesUrl = new URL('../../dist/core/routes/rules-routes.js', import.meta.url);
rulesRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
const originalEnv = {
HOME: process.env.HOME,
USERPROFILE: process.env.USERPROFILE,
HOMEDRIVE: process.env.HOMEDRIVE,
HOMEPATH: process.env.HOMEPATH,
};
async function callRules(
initialPath: string,
method: string,
path: string,
body?: any,
): Promise<{ handled: boolean; status: number; json: any }> {
const url = new URL(path, 'http://localhost');
let status = 0;
let text = '';
let postPromise: Promise<void> | null = null;
const res = {
writeHead(code: number) {
status = code;
},
end(chunk?: any) {
text = chunk === undefined ? '' : String(chunk);
},
};
const handlePostRequest = (_req: any, _res: any, handler: (parsed: any) => Promise<any>) => {
postPromise = (async () => {
const result = await handler(body ?? {});
const errorValue = result && typeof result === 'object' ? (result as any).error : undefined;
const statusValue = result && typeof result === 'object' ? (result as any).status : undefined;
if (typeof errorValue === 'string' && errorValue.length > 0) {
res.writeHead(typeof statusValue === 'number' ? statusValue : 500);
res.end(JSON.stringify({ error: errorValue }));
return;
}
res.writeHead(200);
res.end(JSON.stringify(result));
})();
};
const handled = await mod.handleRulesRoutes({
pathname: url.pathname,
url,
req: { method },
res,
initialPath,
handlePostRequest,
});
if (postPromise) await postPromise;
return { handled, status, json: text ? JSON.parse(text) : null };
}
describe('rules routes integration', async () => {
let homeDir = '';
let projectRoot = '';
before(async () => {
homeDir = mkdtempSync(join(tmpdir(), 'ccw-rules-home-'));
projectRoot = mkdtempSync(join(tmpdir(), 'ccw-rules-project-'));
process.env.HOME = homeDir;
process.env.USERPROFILE = homeDir;
process.env.HOMEDRIVE = undefined;
process.env.HOMEPATH = undefined;
mock.method(console, 'log', () => {});
mock.method(console, 'warn', () => {});
mock.method(console, 'error', () => {});
mod = await import(rulesRoutesUrl.href);
});
beforeEach(() => {
rmSync(join(homeDir, '.claude'), { recursive: true, force: true });
rmSync(join(projectRoot, '.claude'), { recursive: true, force: true });
});
after(() => {
mock.restoreAll();
process.env.HOME = originalEnv.HOME;
process.env.USERPROFILE = originalEnv.USERPROFILE;
process.env.HOMEDRIVE = originalEnv.HOMEDRIVE;
process.env.HOMEPATH = originalEnv.HOMEPATH;
rmSync(projectRoot, { recursive: true, force: true });
rmSync(homeDir, { recursive: true, force: true });
});
it('GET /api/rules returns projectRules and userRules arrays', async () => {
const res = await callRules(projectRoot, 'GET', '/api/rules');
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(Array.isArray(res.json.projectRules), true);
assert.equal(Array.isArray(res.json.userRules), true);
});
it('POST /api/rules/create writes a project rule and GET reflects it', async () => {
const create = await callRules(projectRoot, 'POST', '/api/rules/create', {
fileName: 'test-rule.md',
content: '# Hello rule\n',
paths: ['src/**'],
location: 'project',
});
assert.equal(create.handled, true);
assert.equal(create.status, 200);
assert.equal(create.json.success, true);
assert.ok(typeof create.json.path === 'string' && create.json.path.length > 0);
assert.equal(existsSync(create.json.path), true);
const config = await callRules(projectRoot, 'GET', '/api/rules');
assert.equal(config.status, 200);
assert.equal(config.json.projectRules.length, 1);
assert.equal(config.json.projectRules[0].name, 'test-rule.md');
const detail = await callRules(projectRoot, 'GET', '/api/rules/test-rule.md?location=project');
assert.equal(detail.status, 200);
assert.equal(detail.json.rule.name, 'test-rule.md');
assert.ok(String(detail.json.rule.content).includes('Hello rule'));
// Ensure frontmatter was persisted.
const raw = readFileSync(create.json.path, 'utf8');
assert.ok(raw.startsWith('---'));
assert.ok(raw.includes('paths: [src/**]'));
});
});

140
ccw/tests/integration/skills-routes.test.ts Normal file
View File

@@ -0,0 +1,140 @@
/**
* Integration tests for skills routes (skills listing + details).
*
* Notes:
* - Targets runtime implementation shipped in `ccw/dist`.
* - Calls route handler directly (no HTTP server required).
* - Uses temporary HOME/USERPROFILE to isolate user skills directory.
*/
import { after, before, beforeEach, describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const skillsRoutesUrl = new URL('../../dist/core/routes/skills-routes.js', import.meta.url);
skillsRoutesUrl.searchParams.set('t', String(Date.now()));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let mod: any;
const originalEnv = {
HOME: process.env.HOME,
USERPROFILE: process.env.USERPROFILE,
HOMEDRIVE: process.env.HOMEDRIVE,
HOMEPATH: process.env.HOMEPATH,
};
async function callSkills(
initialPath: string,
method: string,
path: string,
): Promise<{ handled: boolean; status: number; json: any }> {
const url = new URL(path, 'http://localhost');
let status = 0;
let body = '';
const res = {
writeHead(code: number) {
status = code;
},
end(chunk?: any) {
body = chunk === undefined ? '' : String(chunk);
},
};
const handled = await mod.handleSkillsRoutes({
pathname: url.pathname,
url,
req: { method },
res,
initialPath,
handlePostRequest() {
throw new Error('handlePostRequest should not be called for these tests');
},
});
return { handled, status, json: body ? JSON.parse(body) : null };
}
describe('skills routes integration', async () => {
let homeDir = '';
let projectRoot = '';
before(async () => {
homeDir = mkdtempSync(join(tmpdir(), 'ccw-skills-home-'));
projectRoot = mkdtempSync(join(tmpdir(), 'ccw-skills-project-'));
process.env.HOME = homeDir;
process.env.USERPROFILE = homeDir;
process.env.HOMEDRIVE = undefined;
process.env.HOMEPATH = undefined;
mock.method(console, 'error', () => {});
mod = await import(skillsRoutesUrl.href);
});
beforeEach(() => {
rmSync(join(homeDir, '.claude'), { recursive: true, force: true });
rmSync(join(projectRoot, '.claude'), { recursive: true, force: true });
const skillDir = join(projectRoot, '.claude', 'skills', 'test-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(
join(skillDir, 'SKILL.md'),
`---
name: "Test Skill"
description: "A test skill"
version: "1.0.0"
allowed-tools: [ccw issue next]
---
# Test
`,
'utf8',
);
writeFileSync(join(skillDir, 'extra.txt'), 'extra', 'utf8');
});
after(() => {
mock.restoreAll();
process.env.HOME = originalEnv.HOME;
process.env.USERPROFILE = originalEnv.USERPROFILE;
process.env.HOMEDRIVE = originalEnv.HOMEDRIVE;
process.env.HOMEPATH = originalEnv.HOMEPATH;
rmSync(projectRoot, { recursive: true, force: true });
rmSync(homeDir, { recursive: true, force: true });
});
it('GET /api/skills lists projectSkills and userSkills', async () => {
const res = await callSkills(projectRoot, 'GET', `/api/skills?path=${encodeURIComponent(projectRoot)}`);
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(Array.isArray(res.json.projectSkills), true);
assert.equal(Array.isArray(res.json.userSkills), true);
assert.equal(res.json.projectSkills.length, 1);
assert.equal(res.json.projectSkills[0].folderName, 'test-skill');
assert.equal(res.json.projectSkills[0].name, 'Test Skill');
assert.ok(res.json.projectSkills[0].supportingFiles.includes('extra.txt'));
});
it('GET /api/skills/:name returns skill detail with parsed content', async () => {
const res = await callSkills(projectRoot, 'GET', `/api/skills/test-skill?location=project&path=${encodeURIComponent(projectRoot)}`);
assert.equal(res.handled, true);
assert.equal(res.status, 200);
assert.equal(res.json.skill.folderName, 'test-skill');
assert.equal(res.json.skill.name, 'Test Skill');
assert.equal(Array.isArray(res.json.skill.allowedTools), true);
assert.ok(String(res.json.skill.content).includes('# Test'));
});
it('returns 404 when skill is missing', async () => {
const res = await callSkills(projectRoot, 'GET', `/api/skills/nope?location=project&path=${encodeURIComponent(projectRoot)}`);
assert.equal(res.handled, true);
assert.equal(res.status, 404);
assert.ok(res.json.error);
});
});