tycono-server 0.1.0-beta.0

package/bin/cli.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+
+// Auto-increase heap if not already set
+if (!process.env.__TYCONO_HEAP_SET && !process.execArgv.some(a => a.includes('max-old-space-size'))) {
+  process.env.__TYCONO_HEAP_SET = '1';
+  try {
+    execFileSync(process.execPath, [
+      '--max-old-space-size=4096',
+      ...process.execArgv,
+      fileURLToPath(import.meta.url),
+      ...process.argv.slice(2),
+    ], { stdio: 'inherit', env: process.env });
+  } catch (e) {
+    process.exit(e.status ?? 1);
+  }
+  process.exit(0);
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Resolve tsx
+const require = createRequire(import.meta.url);
+const tsxApiPath = pathToFileURL(require.resolve('tsx/esm/api')).href;
+const tsx = await import(tsxApiPath);
+tsx.register();
+
+const entryPath = pathToFileURL(join(__dirname, 'server.ts')).href;
+const { main } = await import(entryPath);
+await main(process.argv.slice(2));

package/bin/server.ts

@@ -0,0 +1,160 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import net from 'node:net';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const VERSION = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf-8')
+).version;
+
+function printHelp(): void {
+  console.log(`
+  tycono-server v${VERSION}
+
+  AI team orchestration server. Headless by default.
+
+  Usage:
+    tycono-server [path]       Start API server (default: current directory)
+    tycono-server --help       Show this help
+    tycono-server --version    Show version
+
+  Examples:
+    tycono-server                    Start in current directory
+    tycono-server ./my-company       Start with company directory
+    PORT=3001 tycono-server          Use specific port
+
+  Environment:
+    PORT                     Server port (default: auto-detect free port)
+    COMPANY_ROOT             Company directory (default: current directory)
+`);
+}
+
+function findFreePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, () => {
+      const addr = server.address();
+      if (addr && typeof addr === 'object') {
+        const port = addr.port;
+        server.close(() => resolve(port));
+      } else {
+        reject(new Error('Could not find free port'));
+      }
+    });
+    server.on('error', reject);
+  });
+}
+
+function detectEngine(): string {
+  try {
+    execSync('claude --version', { stdio: 'pipe' });
+    return 'claude-cli';
+  } catch {}
+  if (process.env.ANTHROPIC_API_KEY) return 'direct-api';
+  return 'none';
+}
+
+export async function main(args: string[]): Promise<void> {
+  const command = args[0];
+
+  if (command === '--help' || command === '-h') {
+    printHelp();
+    return;
+  }
+
+  if (command === '--version' || command === '-v') {
+    console.log(VERSION);
+    return;
+  }
+
+  // Load .env
+  const dotenvPath = path.resolve(process.cwd(), '.env');
+  if (fs.existsSync(dotenvPath)) {
+    const { config } = await import('dotenv');
+    config({ path: dotenvPath });
+  }
+
+  // Company root
+  if (command && !command.startsWith('-')) {
+    process.env.COMPANY_ROOT = path.resolve(command);
+  }
+  if (!process.env.COMPANY_ROOT) {
+    process.env.COMPANY_ROOT = process.cwd();
+  }
+
+  // Check for knowledge/ subdirectory pattern
+  const knowledgeDir = path.join(process.env.COMPANY_ROOT, 'knowledge');
+  if (fs.existsSync(path.join(knowledgeDir, 'CLAUDE.md'))) {
+    // Company root is the parent of knowledge/
+  } else if (!fs.existsSync(path.join(process.env.COMPANY_ROOT, 'CLAUDE.md'))) {
+    // Scan one level deep
+    try {
+      const entries = fs.readdirSync(process.env.COMPANY_ROOT, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+        if (fs.existsSync(path.join(process.env.COMPANY_ROOT, entry.name, '.tycono', 'config.json'))) {
+          process.env.COMPANY_ROOT = path.join(process.env.COMPANY_ROOT, entry.name);
+          break;
+        }
+      }
+    } catch {}
+  }
+
+  process.env.NODE_ENV = 'production';
+
+  // Detect engine
+  const engine = detectEngine();
+  process.env.EXECUTION_ENGINE = engine;
+
+  // Port
+  const port = process.env.PORT ? Number(process.env.PORT) : await findFreePort();
+  process.env.PORT = String(port);
+
+  // Company name
+  let companyName = 'My Company';
+  try {
+    const claudeMdPath = path.join(process.env.COMPANY_ROOT, 'CLAUDE.md');
+    if (fs.existsSync(claudeMdPath)) {
+      const content = fs.readFileSync(claudeMdPath, 'utf-8');
+      const match = content.match(/^#\s+(.+)/m);
+      if (match) companyName = match[1].trim();
+    }
+  } catch {}
+
+  const url = `http://localhost:${port}`;
+
+  console.log(`  tycono-server v${VERSION}`);
+  console.log(`  API: ${url}`);
+  console.log(`  Company: ${companyName}`);
+  console.log(`  Engine: ${engine}`);
+  console.log(`  PID: ${process.pid}`);
+
+  // Write headless.json for discovery
+  const headlessInfo = { port, pid: process.pid, url, startedAt: new Date().toISOString() };
+  const headlessPath = path.join(process.env.COMPANY_ROOT, '.tycono', 'headless.json');
+  try {
+    fs.mkdirSync(path.dirname(headlessPath), { recursive: true });
+    fs.writeFileSync(headlessPath, JSON.stringify(headlessInfo, null, 2));
+  } catch {}
+
+  // Start server
+  const { createHttpServer } = await import('../src/api/src/create-server.js');
+  const server = createHttpServer();
+
+  const host = process.env.HOST || '0.0.0.0';
+  server.listen(port, host);
+
+  // Graceful shutdown
+  const shutdown = () => {
+    console.log('\n  Shutting down...');
+    try { fs.unlinkSync(headlessPath); } catch {}
+    server.close(() => process.exit(0));
+    setTimeout(() => process.exit(1), 5000);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "tycono-server",
+  "version": "0.1.0-beta.0",
+  "description": "Tycono AI team orchestration server. Dispatch, supervise, and observe AI agents working as a team.",
+  "type": "module",
+  "bin": {
+    "tycono-server": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node bin/cli.js"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
+    "better-sqlite3": "^12.8.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "express": "^5.0.1",
+    "glob": "^13.0.6",
+    "gray-matter": "^4.0.3",
+    "marked": "^15.0.6",
+    "tsx": "^4.19.3",
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.13.4",
+    "typescript": "^5.7.3"
+  },
+  "keywords": [
+    "ai", "tycono", "agent", "multi-agent", "orchestration",
+    "dispatch", "supervision", "agentic", "team"
+  ],
+  "author": "Tycono <hello@tycono.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/seongsu-kang/tycono.git",
+    "directory": "packages/server"
+  }
+}

package/src/api/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "tycono-api",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/server.ts",
+    "start": "tsx src/server.ts",
+    "test": "vitest run tests/smoke.test.ts",
+    "test:watch": "vitest tests/smoke.test.ts"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
+    "cors": "^2.8.5",
+    "express": "^5.0.1",
+    "glob": "^11.0.1",
+    "gray-matter": "^4.0.3",
+    "marked": "^15.0.6",
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.13.4",
+    "@types/supertest": "^7.2.0",
+    "supertest": "^7.2.2",
+    "tsx": "^4.19.3",
+    "typescript": "^5.7.3",
+    "vitest": "^4.0.18"
+  }
+}

package/src/api/src/create-app.ts

@@ -0,0 +1,90 @@
+/**
+ * create-app.ts — Express 앱 팩토리
+ *
+ * server.ts에서 분리하여 테스트에서 재사용 가능하게 한다.
+ * supertest 등에서 import 후 테스트용 앱으로 활용.
+ */
+import express from 'express';
+import cors from 'cors';
+import fs from 'node:fs';
+import path from 'node:path';
+import { COMPANY_ROOT } from './services/file-reader.js';
+import { rolesRouter } from './routes/roles.js';
+import { projectsRouter } from './routes/projects.js';
+import { operationsRouter } from './routes/operations.js';
+import { companyRouter } from './routes/company.js';
+import { engineRouter } from './routes/engine.js';
+import { sessionsRouter } from './routes/sessions.js';
+import { setupRouter } from './routes/setup.js';
+import { skillsRouter } from './routes/skills.js';
+import { presetsRouter } from './routes/presets.js';
+
+export function createApp() {
+  const app = express();
+
+  const corsOrigin = process.env.NODE_ENV === 'production' ? true : /^http:\/\/localhost:\d+$/;
+  app.use(cors({ origin: corsOrigin }));
+  app.use(express.json());
+
+  // Suppress favicon 404
+  app.get('/favicon.ico', (_req, res) => res.status(204).end());
+
+  // Setup / onboarding (always available)
+  app.use('/api/setup', setupRouter);
+
+  // Status — frontend checks this to decide wizard vs office
+  app.get('/api/status', (_req, res) => {
+    const claudeMdPath = path.join(COMPANY_ROOT, 'CLAUDE.md');
+    const initialized = fs.existsSync(claudeMdPath);
+    let companyName: string | null = null;
+    if (initialized) {
+      try {
+        const content = fs.readFileSync(claudeMdPath, 'utf-8');
+        const match = content.match(/^#\s+(.+)/m);
+        if (match) companyName = match[1].trim();
+      } catch { /* ignore */ }
+    }
+    res.json({ initialized, companyName, engine: process.env.EXECUTION_ENGINE || 'none', companyRoot: COMPANY_ROOT });
+  });
+
+  app.use('/api/roles', rolesRouter);
+  app.use('/api/projects', projectsRouter);
+  app.use('/api/operations', operationsRouter);
+  app.use('/api/company', companyRouter);
+  app.use('/api/engine', engineRouter);
+  app.use('/api/sessions', sessionsRouter);
+  app.use('/api/skills', skillsRouter);
+  app.use('/api/presets', presetsRouter);
+
+  app.get('/api/health', (_req, res) => {
+    res.json({ status: 'ok', companyRoot: COMPANY_ROOT });
+  });
+
+  // Debug: memory stats for leak detection
+  app.get('/api/debug/memory', (_req, res) => {
+    const mem = process.memoryUsage();
+    // Import dynamically to avoid circular deps
+    import('./services/execution-manager.js').then(({ executionManager }) => {
+      import('./services/session-store.js').then(({ listSessions }) => {
+        res.json({
+          heap: { used: Math.round(mem.heapUsed / 1024 / 1024), total: Math.round(mem.heapTotal / 1024 / 1024) },
+          rss: Math.round(mem.rss / 1024 / 1024),
+          execManager: executionManager.getMemoryStats(),
+          sessions: listSessions().length,
+        });
+      });
+    }).catch(() => {
+      res.json({
+        heap: { used: Math.round(mem.heapUsed / 1024 / 1024), total: Math.round(mem.heapTotal / 1024 / 1024) },
+        rss: Math.round(mem.rss / 1024 / 1024),
+      });
+    });
+  });
+
+  app.use((err: Error, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
+    const status = err.name === 'FileNotFoundError' ? 404 : 500;
+    res.status(status).json({ error: err.message });
+  });
+
+  return app;
+}

package/src/api/src/create-server.ts

@@ -0,0 +1,251 @@
+/**
+ * create-server.ts — HTTP 서버 팩토리
+ *
+ * server.ts에서 서버 생성 로직을 분리하여 테스트에서 재사용 가능하게 한다.
+ * 반환된 서버 인스턴스는 listen()을 직접 호출하지 않으므로,
+ * 호출자가 포트를 지정해서 기동할 수 있다.
+ */
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import express from 'express';
+import cors from 'cors';
+import { COMPANY_ROOT } from './services/file-reader.js';
+import { rolesRouter } from './routes/roles.js';
+import { projectsRouter } from './routes/projects.js';
+import { operationsRouter } from './routes/operations.js';
+import { companyRouter } from './routes/company.js';
+import { handleExecRequest } from './routes/execute.js';
+import { engineRouter } from './routes/engine.js';
+import { sessionsRouter } from './routes/sessions.js';
+import { setupRouter } from './routes/setup.js';
+// activity-tracker removed — executionManager resets on restart
+import { knowledgeRouter } from './routes/knowledge.js';
+import { preferencesRouter } from './routes/preferences.js';
+import { saveRouter } from './routes/save.js';
+import { speechRouter } from './routes/speech.js';
+import { costRouter } from './routes/cost.js';
+import { syncRouter } from './routes/sync.js';
+import { gitRouter } from './routes/git.js';
+import { skillsRouter } from './routes/skills.js';
+import { questsRouter } from './routes/quests.js';
+import { coinsRouter } from './routes/coins.js';
+import { activeSessionsRouter } from './routes/active-sessions.js';
+import { supervisionRouter } from './routes/supervision.js';
+import { presetsRouter } from './routes/presets.js';
+import { importKnowledge } from './services/knowledge-importer.js';
+import { AnthropicProvider, type LLMProvider } from './engine/llm-adapter.js';
+import { readConfig } from './services/company-config.js';
+import { ensureClaudeMd } from './services/claude-md-manager.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const isProd = process.env.NODE_ENV === 'production';
+const corsOrigin = isProd ? true : /^http:\/\/localhost:\d+$/;
+
+/* ─── Raw HTTP handler for import-knowledge SSE ─── */
+
+function handleImportKnowledge(req: http.IncomingMessage, res: http.ServerResponse): void {
+  let data = '';
+  req.on('data', (chunk) => { data += chunk; });
+  req.on('end', () => {
+    let body: Record<string, unknown>;
+    try { body = JSON.parse(data); } catch { body = {}; }
+
+    const importPaths = body.paths as string[] | undefined;
+    if (!importPaths || !Array.isArray(importPaths) || importPaths.length === 0) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'paths array is required' }));
+      return;
+    }
+
+    const root = (body.companyRoot as string) || COMPANY_ROOT;
+
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    });
+
+    const sendSSE = (event: string, eventData: unknown) => {
+      res.write(`event: ${event}\ndata: ${JSON.stringify(eventData)}\n\n`);
+    };
+
+    // Build LLMProvider from env if available
+    const llm: LLMProvider | undefined = process.env.ANTHROPIC_API_KEY
+      ? new AnthropicProvider({ model: 'claude-haiku-4-5-20251001' })
+      : undefined;
+
+    importKnowledge(importPaths, root, {
+      onScanning: (scanPath, fileCount) => sendSSE('scanning', { path: scanPath, fileCount }),
+      onProcessing: (file, index, total) => sendSSE('processing', { file, index, total }),
+      onCreated: (filePath, title, summary) => sendSSE('created', { path: filePath, title, summary }),
+      onSkipped: (file, reason) => sendSSE('skipped', { file, reason }),
+      onDone: (stats) => { sendSSE('done', stats); res.end(); },
+      onError: (message) => { sendSSE('error', { message }); res.end(); },
+    }, llm).catch((err) => {
+      sendSSE('error', { message: err instanceof Error ? err.message : 'Import failed' });
+      res.end();
+    });
+  });
+}
+
+export function createHttpServer(): http.Server {
+  // Only cleanup/ensure if a company is already initialized (avoid creating dirs in CWD)
+  if (COMPANY_ROOT && fs.existsSync(path.join(COMPANY_ROOT, 'knowledge', 'CLAUDE.md'))) {
+    ensureClaudeMd(COMPANY_ROOT);
+  }
+
+  const app = createExpressApp();
+
+  const server = http.createServer((req, res) => {
+    const url = req.url ?? '';
+    const method = req.method ?? '';
+
+    // GET /api/waves/active — restore active waves after refresh
+    if (url === '/api/waves/active' && method === 'GET') {
+      setExecCors(req, res);
+      handleExecRequest(req, res);
+      return;
+    }
+
+    // SSE multiplexed wave stream (GET /api/waves/:waveId/stream)
+    if (url.match(/^\/api\/waves\/[^/]+\/stream/) && method === 'GET') {
+      setExecCors(req, res);
+      handleExecRequest(req, res);
+      return;
+    }
+
+    // D-014: POST /api/sessions/:id/message — delegate to execute handler for SSE streaming
+    const sessionMessageMatch = url.match(/^\/api\/sessions\/([^/]+)\/message$/);
+    if (sessionMessageMatch && method === 'POST') {
+      setExecCors(req, res);
+      // Rewrite URL to legacy format for handleExecRequest
+      req.url = `/api/exec/session/${sessionMessageMatch[1]}/message`;
+      handleExecRequest(req, res);
+      return;
+    }
+
+    // SSE 엔드포인트: Express 우회하여 raw HTTP로 처리
+    // BUG-008: /api/waves/:waveId/directive and /api/waves/:waveId/question POST도 포함
+    if ((url.startsWith('/api/exec/') || url.startsWith('/api/jobs') || url.startsWith('/api/waves/') || url === '/api/waves/save' || url === '/api/setup/import-knowledge') && method === 'POST') {
+      setExecCors(req, res);
+      if (url === '/api/setup/import-knowledge') {
+        handleImportKnowledge(req, res);
+      } else {
+        handleExecRequest(req, res);
+      }
+      return;
+    }
+
+    // CORS preflight for exec/jobs/sessions endpoints
+    if ((url.startsWith('/api/exec/') || url.startsWith('/api/jobs') || url.match(/^\/api\/sessions\/[^/]+\/message$/)) && method === 'OPTIONS') {
+      setExecCors(req, res);
+      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    // Non-SSE exec/jobs endpoints (GET, DELETE)
+    if ((url.startsWith('/api/exec/') || url.startsWith('/api/jobs')) && (method === 'GET' || method === 'DELETE')) {
+      setExecCors(req, res);
+      handleExecRequest(req, res);
+      return;
+    }
+
+    // 나머지는 Express 처리
+    (app as (req: http.IncomingMessage, res: http.ServerResponse) => void)(req, res);
+  });
+
+  server.timeout = 0;
+  server.requestTimeout = 0;
+  server.headersTimeout = 0;
+
+  return server;
+}
+
+export function createExpressApp(): express.Application {
+  const app = express();
+
+  app.use(cors({ origin: corsOrigin }));
+  app.use(express.json());
+
+  // Setup / onboarding
+  app.use('/api/setup', setupRouter);
+
+  // Status — frontend checks this to decide wizard vs office
+  app.get('/api/status', (_req, res) => {
+    const config = readConfig(COMPANY_ROOT);
+    const tyconoDir = path.join(COMPANY_ROOT, '.tycono', 'config.json');
+    const initialized = fs.existsSync(tyconoDir);
+    let companyName: string | null = null;
+    if (initialized) {
+      try {
+        // Read company name from knowledge/company.md (user-owned data)
+        const companyMdPath = path.join(COMPANY_ROOT, 'knowledge', 'company.md');
+        const content = fs.readFileSync(companyMdPath, 'utf-8');
+        const match = content.match(/^#\s+(.+)/m);
+        if (match) companyName = match[1].trim();
+      } catch { /* ignore */ }
+    }
+    res.json({ initialized, companyName, engine: config.engine || process.env.EXECUTION_ENGINE || 'none', companyRoot: COMPANY_ROOT, codeRoot: config.codeRoot || null, hasApiKey: !!process.env.ANTHROPIC_API_KEY });
+  });
+
+  app.use('/api/roles', rolesRouter);
+  app.use('/api/projects', projectsRouter);
+  app.use('/api/operations', operationsRouter);
+  app.use('/api/company', companyRouter);
+  app.use('/api/engine', engineRouter);
+  app.use('/api/sessions', sessionsRouter);
+  app.use('/api/knowledge', knowledgeRouter);
+  app.use('/api/preferences', preferencesRouter);
+  app.use('/api/speech', speechRouter);
+  app.use('/api/save', saveRouter);
+  app.use('/api/cost', costRouter);
+  app.use('/api/sync', syncRouter);
+  app.use('/api/git', gitRouter);
+  app.use('/api/skills', skillsRouter);
+  app.use('/api/quests', questsRouter);
+  app.use('/api/coins', coinsRouter);
+  app.use('/api/active-sessions', activeSessionsRouter);
+  app.use('/api/supervision', supervisionRouter);
+  app.use('/api/presets', presetsRouter);
+
+  app.get('/api/health', (_req, res) => {
+    res.json({ status: 'ok', companyRoot: COMPANY_ROOT });
+  });
+
+  // Production: serve web build as static files (SPA fallback)
+  if (isProd) {
+    const distPath = path.resolve(__dirname, '../../web/dist');
+    app.use(express.static(distPath));
+    app.use((_req, res) => {
+      res.sendFile(path.join(distPath, 'index.html'));
+    });
+  }
+
+  app.use((err: Error, req: express.Request, res: express.Response, _next: express.NextFunction) => {
+    const status = err.name === 'FileNotFoundError' ? 404 : 500;
+    // Log server errors via console.error (redirected to log file in TUI mode)
+    // 404 errors are expected (e.g. fresh install, no company.md) — skip
+    if (status >= 500) {
+      console.error(`[ERROR] ${req.method} ${req.url} — ${err.message}`);
+    }
+    res.status(status).json({ error: err.message });
+  });
+
+  return app;
+}
+
+function setExecCors(req: http.IncomingMessage, res: http.ServerResponse): void {
+  const origin = req.headers.origin;
+  if (!origin) return;
+  if (isProd || /^http:\/\/localhost:\d+$/.test(origin)) {
+    res.setHeader('Access-Control-Allow-Origin', origin);
+    res.setHeader('Access-Control-Allow-Credentials', 'true');
+  }
+}