tycono-server 0.1.0-beta.0

package/src/api/src/routes/active-sessions.ts

@@ -0,0 +1,134 @@
+/**
+ * active-sessions.ts — Active session visibility API
+ *
+ * Exposes session + port + worktree state for both UI and AI agents.
+ */
+import { Router } from 'express';
+import { portRegistry } from '../services/port-registry.js';
+import { executionManager } from '../services/execution-manager.js';
+import { getSession } from '../services/session-store.js';
+
+export const activeSessionsRouter = Router();
+
+/**
+ * GET /api/active-sessions
+ */
+activeSessionsRouter.get('/', (_req, res) => {
+  const sessions = portRegistry.getAll();
+
+  const enriched = sessions.map(s => {
+    const exec = executionManager.getActiveExecution(s.sessionId);
+    const session = getSession(s.sessionId);
+    return {
+      ...s,
+      waveId: session?.waveId ?? null,
+      messageStatus: exec?.status ?? null,
+      roleName: exec?.roleId ?? s.roleId,
+      alive: s.pid ? isAlive(s.pid) : null,
+    };
+  });
+
+  res.json({
+    sessions: enriched,
+    summary: portRegistry.getSummary(),
+  });
+});
+
+/**
+ * GET /api/active-sessions/:id
+ */
+activeSessionsRouter.get('/:id', (req, res) => {
+  const session = portRegistry.get(req.params.id);
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+
+  const exec = executionManager.getActiveExecution(session.sessionId);
+
+  res.json({
+    ...session,
+    messageStatus: exec?.status ?? null,
+    roleName: exec?.roleId ?? session.roleId,
+    alive: session.pid ? isAlive(session.pid) : null,
+    execution: exec ? { id: exec.id, status: exec.status, roleId: exec.roleId, task: exec.task } : null,
+  });
+});
+
+/**
+ * DELETE /api/active-sessions/:id
+ */
+activeSessionsRouter.delete('/:id', (req, res) => {
+  const sessionId = req.params.id;
+  const session = portRegistry.get(sessionId);
+
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+
+  executionManager.abortSession(sessionId);
+  portRegistry.release(sessionId);
+
+  res.json({ ok: true, released: session.ports });
+});
+
+/**
+ * POST /api/active-sessions/cleanup
+ */
+activeSessionsRouter.post('/cleanup', (_req, res) => {
+  const result = portRegistry.cleanup();
+  res.json({
+    cleaned: result.cleaned.length,
+    remaining: result.remaining.length,
+    sessions: result.cleaned.map(s => ({
+      sessionId: s.sessionId,
+      roleId: s.roleId,
+      ports: s.ports,
+    })),
+  });
+});
+
+/**
+ * POST /api/active-sessions/register
+ */
+activeSessionsRouter.post('/register', async (req, res) => {
+  const { sessionId, roleId, task, pid, worktreePath } = req.body;
+
+  if (!sessionId || !roleId) {
+    res.status(400).json({ error: 'sessionId and roleId are required' });
+    return;
+  }
+
+  const existing = portRegistry.get(sessionId);
+  if (existing) {
+    res.json({ ok: true, ports: existing.ports, existing: true });
+    return;
+  }
+
+  const ports = await portRegistry.allocate(
+    sessionId,
+    roleId,
+    task || 'Manual session',
+  );
+
+  if (pid || worktreePath) {
+    portRegistry.update(sessionId, {
+      pid: pid ?? undefined,
+      worktreePath: worktreePath ?? undefined,
+    });
+  }
+
+  res.json({ ok: true, ports, existing: false });
+});
+
+/* ─── Helpers ────────────────────────────── */
+
+function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/api/src/routes/coins.ts

@@ -0,0 +1,153 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+
+export const coinsRouter = Router();
+
+/* ── Types ── */
+
+interface CoinTransaction {
+  ts: string;
+  amount: number;
+  reason: string;
+  ref?: string; // questId, jobId, etc.
+}
+
+interface CoinsData {
+  balance: number;
+  totalEarned: number;
+  totalSpent: number;
+  transactions: CoinTransaction[];
+}
+
+/* ── Persistence ── */
+
+const COINS_FILE = () => join(COMPANY_ROOT, '.tycono', 'coins.json');
+
+const DEFAULT_DATA: CoinsData = {
+  balance: 0,
+  totalEarned: 0,
+  totalSpent: 0,
+  transactions: [],
+};
+
+function readCoins(): CoinsData {
+  try {
+    if (existsSync(COINS_FILE())) {
+      return JSON.parse(readFileSync(COINS_FILE(), 'utf-8'));
+    }
+  } catch { /* use defaults */ }
+  return { ...DEFAULT_DATA, transactions: [] };
+}
+
+function writeCoins(data: CoinsData) {
+  mkdirSync(join(COMPANY_ROOT, '.tycono'), { recursive: true });
+  writeFileSync(COINS_FILE(), JSON.stringify(data, null, 2) + '\n');
+}
+
+/* ── Internal API (for server-side use) ── */
+
+export function earnCoinsInternal(amount: number, reason: string, ref?: string): { balance: number; skipped: boolean } {
+  const data = readCoins();
+  // Idempotency
+  if (ref && data.transactions.some(t => t.ref === ref && t.amount > 0)) {
+    return { balance: data.balance, skipped: true };
+  }
+  const tx: CoinTransaction = { ts: new Date().toISOString(), amount, reason, ref };
+  data.balance += amount;
+  data.totalEarned += amount;
+  data.transactions.push(tx);
+  writeCoins(data);
+  return { balance: data.balance, skipped: false };
+}
+
+/* ── Routes ── */
+
+// GET /api/coins — current balance + summary
+coinsRouter.get('/', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    res.json(readCoins());
+  } catch (err) { next(err); }
+});
+
+// POST /api/coins/earn — add coins
+coinsRouter.post('/earn', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { amount, reason, ref } = req.body;
+    if (typeof amount !== 'number' || amount <= 0) {
+      res.status(400).json({ error: 'amount must be a positive number' });
+      return;
+    }
+    const data = readCoins();
+    // Idempotency: skip if same ref already earned (prevents double quest rewards)
+    if (ref && data.transactions.some(t => t.ref === ref && t.amount > 0)) {
+      res.json({ ok: true, balance: data.balance, skipped: true });
+      return;
+    }
+    const tx: CoinTransaction = {
+      ts: new Date().toISOString(),
+      amount,
+      reason: reason || 'earn',
+      ref,
+    };
+    data.balance += amount;
+    data.totalEarned += amount;
+    data.transactions.push(tx);
+    writeCoins(data);
+    res.json({ ok: true, balance: data.balance, transaction: tx });
+  } catch (err) { next(err); }
+});
+
+// POST /api/coins/spend — deduct coins
+coinsRouter.post('/spend', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { amount, reason, ref } = req.body;
+    if (typeof amount !== 'number' || amount <= 0) {
+      res.status(400).json({ error: 'amount must be a positive number' });
+      return;
+    }
+    const data = readCoins();
+    if (data.balance < amount) {
+      res.status(400).json({ error: 'insufficient balance', balance: data.balance, required: amount });
+      return;
+    }
+    const tx: CoinTransaction = {
+      ts: new Date().toISOString(),
+      amount: -amount,
+      reason: reason || 'spend',
+      ref,
+    };
+    data.balance -= amount;
+    data.totalSpent += amount;
+    data.transactions.push(tx);
+    writeCoins(data);
+    res.json({ ok: true, balance: data.balance, transaction: tx });
+  } catch (err) { next(err); }
+});
+
+// POST /api/coins/migrate — initial coin grant for existing users
+coinsRouter.post('/migrate', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const data = readCoins();
+    // Only migrate once
+    if (data.totalEarned > 0) {
+      res.json({ ok: true, skipped: true, balance: data.balance });
+      return;
+    }
+    const { completedQuests = 0 } = req.body;
+    const grantAmount = completedQuests > 0 ? completedQuests * 2000 : 5000;
+    const reason = completedQuests > 0 ? `migration: ${completedQuests} quests × 2,000` : 'welcome bonus';
+    const tx: CoinTransaction = {
+      ts: new Date().toISOString(),
+      amount: grantAmount,
+      reason,
+      ref: 'migration',
+    };
+    data.balance = grantAmount;
+    data.totalEarned = grantAmount;
+    data.transactions.push(tx);
+    writeCoins(data);
+    res.json({ ok: true, balance: data.balance, granted: grantAmount, reason });
+  } catch (err) { next(err); }
+});

package/src/api/src/routes/company.ts

@@ -0,0 +1,57 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import YAML from 'yaml';
+import { readFile, fileExists } from '../services/file-reader.js';
+import { parseMarkdownTable, extractBoldKeyValues } from '../services/markdown-parser.js';
+
+export const companyRouter = Router();
+
+// GET /api/company — 회사 기본 정보
+companyRouter.get('/', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const companyContent = readFile('knowledge/company.md');
+    const kv = extractBoldKeyValues(companyContent);
+
+    // blockquote에서 미션 추출
+    const missionMatch = companyContent.match(/^>\s*(.+)/m);
+    const mission = missionMatch ? missionMatch[1].trim() : '';
+
+    // Role 목록
+    const rolesContent = readFile('knowledge/roles/roles.md');
+    const roleRows = parseMarkdownTable(rolesContent);
+    const roles = roleRows
+      .filter(row => (row.id ?? '').toLowerCase() !== 'ceo')
+      .map(row => {
+        const id = row.id ?? '';
+        let name = row.role ?? row.name ?? '';
+
+        // role.yaml의 name이 있으면 우선 사용 (커스텀 이름 반영)
+        const yamlPath = `knowledge/roles/${id}/role.yaml`;
+        if (id && fileExists(yamlPath)) {
+          try {
+            const raw = YAML.parse(readFile(yamlPath)) as Record<string, unknown>;
+            if (raw.name) name = raw.name as string;
+          } catch { /* fallback to roles.md name */ }
+        }
+
+        return {
+          id,
+          name,
+          level: row.level ?? '',
+          reportsTo: row.reports_to ?? '',
+          status: row.상태 ?? row.status ?? '',
+        };
+      });
+
+    const company = {
+      name: companyContent.split('\n').find(l => l.startsWith('# '))?.replace(/^#\s+/, '') ?? '',
+      domain: kv['도메인'] ?? kv['domain'] ?? '',
+      founded: kv['설립일'] ?? kv['founded'] ?? '',
+      mission,
+      roles,
+    };
+
+    res.json(company);
+  } catch (err) {
+    next(err);
+  }
+});

package/src/api/src/routes/cost.ts

@@ -0,0 +1,141 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+import { getTokenLedger } from '../services/token-ledger.js';
+import { estimateCost } from '../services/pricing.js';
+
+export const costRouter = Router();
+
+/* ── W-T601: GET /api/cost/summary ───────── */
+
+costRouter.get('/summary', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const from = req.query.from as string | undefined;
+    const to = req.query.to as string | undefined;
+
+    const ledger = getTokenLedger(COMPANY_ROOT);
+    const summary = ledger.query({ from, to });
+
+    // Role-by-role aggregation
+    const byRole: Record<string, { inputTokens: number; outputTokens: number; costUsd: number }> = {};
+    // Model-by-model aggregation
+    const byModel: Record<string, { inputTokens: number; outputTokens: number; costUsd: number }> = {};
+
+    for (const entry of summary.entries) {
+      // By role
+      if (!byRole[entry.roleId]) {
+        byRole[entry.roleId] = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+      }
+      byRole[entry.roleId].inputTokens += entry.inputTokens;
+      byRole[entry.roleId].outputTokens += entry.outputTokens;
+      byRole[entry.roleId].costUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+
+      // By model
+      if (!byModel[entry.model]) {
+        byModel[entry.model] = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+      }
+      byModel[entry.model].inputTokens += entry.inputTokens;
+      byModel[entry.model].outputTokens += entry.outputTokens;
+      byModel[entry.model].costUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    const totalCostUsd = estimateCost(summary.totalInput, summary.totalOutput, '');
+
+    // Compute total cost from individual entries (more accurate with mixed models)
+    let totalCostFromEntries = 0;
+    for (const entry of summary.entries) {
+      totalCostFromEntries += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    res.json({
+      from: from ?? null,
+      to: to ?? null,
+      totalInputTokens: summary.totalInput,
+      totalOutputTokens: summary.totalOutput,
+      totalCostUsd: totalCostFromEntries,
+      byRole,
+      byModel,
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ── W-T602: GET /api/cost/jobs/:jobId ───── */
+/* @deprecated D-014: use /api/cost/sessions/:sessionId */
+
+costRouter.get('/jobs/:jobId', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const jobId = req.params.jobId as string;
+    const ledger = getTokenLedger(COMPANY_ROOT);
+    const summary = ledger.query({ jobId });
+
+    if (summary.entries.length === 0) {
+      res.status(404).json({ error: `No cost data found for job ${jobId}` });
+      return;
+    }
+
+    let totalCostUsd = 0;
+    for (const entry of summary.entries) {
+      totalCostUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    res.json({
+      jobId,
+      totalInputTokens: summary.totalInput,
+      totalOutputTokens: summary.totalOutput,
+      totalCostUsd,
+      entries: summary.entries.map((e) => ({
+        ts: e.ts,
+        roleId: e.roleId,
+        model: e.model,
+        inputTokens: e.inputTokens,
+        outputTokens: e.outputTokens,
+        costUsd: estimateCost(e.inputTokens, e.outputTokens, e.model),
+      })),
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ── D-014: GET /api/cost/sessions/:sessionId ───── */
+
+costRouter.get('/sessions/:sessionId', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const sessionId = req.params.sessionId as string;
+    const ledger = getTokenLedger(COMPANY_ROOT);
+
+    // D-014: Try sessionId field first, fall back to jobId for legacy entries
+    let summary = ledger.query({ sessionId });
+    if (summary.entries.length === 0) {
+      summary = ledger.query({ jobId: sessionId });
+    }
+
+    if (summary.entries.length === 0) {
+      res.status(404).json({ error: `No cost data found for session ${sessionId}` });
+      return;
+    }
+
+    let totalCostUsd = 0;
+    for (const entry of summary.entries) {
+      totalCostUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    res.json({
+      sessionId,
+      totalInputTokens: summary.totalInput,
+      totalOutputTokens: summary.totalOutput,
+      totalCostUsd,
+      entries: summary.entries.map((e) => ({
+        ts: e.ts,
+        roleId: e.roleId,
+        model: e.model,
+        inputTokens: e.inputTokens,
+        outputTokens: e.outputTokens,
+        costUsd: estimateCost(e.inputTokens, e.outputTokens, e.model),
+      })),
+    });
+  } catch (err) {
+    next(err);
+  }
+});

package/src/api/src/routes/engine.ts

@@ -0,0 +1,220 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+import {
+  buildOrgTree,
+  assembleContext,
+  validateDispatch,
+  RoleLifecycleManager,
+  formatOrgChart,
+} from '../engine/index.js';
+import { createRunner } from '../engine/runners/index.js';
+
+export const engineRouter = Router();
+
+/* ─── GET /api/engine/org — Org tree ─────────── */
+
+engineRouter.get('/org', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const tree = buildOrgTree(COMPANY_ROOT);
+
+    // Serialize Map to plain object
+    const nodes: Record<string, unknown> = {};
+    for (const [id, node] of tree.nodes) {
+      nodes[id] = {
+        id: node.id,
+        name: node.name,
+        level: node.level,
+        reportsTo: node.reportsTo,
+        children: node.children,
+      };
+    }
+
+    res.json({
+      root: tree.root,
+      nodes,
+      chart: formatOrgChart(tree),
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── GET /api/engine/context/:roleId — Preview assembled context ── */
+
+engineRouter.get('/context/:roleId', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const roleId = String(req.params.roleId ?? '');
+    const sourceRole = String(req.query.source ?? 'ceo');
+    const task = String(req.query.task ?? '(preview — no task specified)');
+
+    const tree = buildOrgTree(COMPANY_ROOT);
+    const context = assembleContext(COMPANY_ROOT, roleId as string, task, sourceRole, tree);
+
+    res.json({
+      targetRole: context.targetRole,
+      sourceRole: context.sourceRole,
+      metadata: context.metadata,
+      systemPromptLength: context.systemPrompt.length,
+      systemPromptPreview: context.systemPrompt.slice(0, 3000),
+      task: context.task,
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── POST /api/engine/dispatch/validate — Check dispatch authority ── */
+
+engineRouter.post('/dispatch/validate', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { sourceRole, targetRole } = req.body;
+
+    if (!sourceRole || !targetRole) {
+      res.status(400).json({ error: 'sourceRole and targetRole are required' });
+      return;
+    }
+
+    const tree = buildOrgTree(COMPANY_ROOT);
+    const result = validateDispatch(tree, sourceRole, targetRole);
+
+    res.json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── POST /api/engine/roles — Create a new role ── */
+
+engineRouter.post('/roles', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const def = req.body;
+
+    if (!def.id || !def.name || !def.reportsTo) {
+      res.status(400).json({ error: 'id, name, and reportsTo are required' });
+      return;
+    }
+
+    const manager = new RoleLifecycleManager(COMPANY_ROOT);
+    await manager.createRole(def);
+
+    res.status(201).json({ ok: true, roleId: def.id });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── PATCH /api/engine/roles/:id — Update a role ── */
+
+engineRouter.patch('/roles/:id', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const id = String(req.params.id);
+    const changes = req.body;
+
+    if (!changes || Object.keys(changes).length === 0) {
+      res.status(400).json({ error: 'No changes provided' });
+      return;
+    }
+
+    const manager = new RoleLifecycleManager(COMPANY_ROOT);
+    await manager.updateRole(id, changes);
+
+    res.json({ ok: true, roleId: id });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── DELETE /api/engine/roles/:id — Remove a role ── */
+
+engineRouter.delete('/roles/:id', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const id = String(req.params.id);
+    const manager = new RoleLifecycleManager(COMPANY_ROOT);
+    await manager.removeRole(id);
+
+    res.json({ ok: true, removed: id });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── GET /api/engine/roles/validate — Validate all roles ── */
+
+engineRouter.get('/roles/validate', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const manager = new RoleLifecycleManager(COMPANY_ROOT);
+    const results = manager.validateAll();
+
+    const output: Record<string, unknown> = {};
+    for (const [id, result] of results) {
+      output[id] = result;
+    }
+
+    res.json(output);
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── POST /api/engine/roles/:id/skill/regenerate — Regenerate SKILL.md ── */
+
+engineRouter.post('/roles/:id/skill/regenerate', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const id = String(req.params.id);
+    const manager = new RoleLifecycleManager(COMPANY_ROOT);
+    await manager.regenerateSkill(id);
+
+    res.json({ ok: true, roleId: id });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── POST /api/engine/ask/:roleId — Ask a role a question (read-only) ── */
+
+engineRouter.post('/ask/:roleId', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const roleId = String(req.params.roleId);
+    const { question, sourceRole } = req.body;
+
+    if (!question) {
+      res.status(400).json({ error: 'question is required' });
+      return;
+    }
+
+    const source = sourceRole || 'ceo';
+    const orgTree = buildOrgTree(COMPANY_ROOT);
+
+    if (!orgTree.nodes.has(roleId)) {
+      res.status(404).json({ error: `Role not found: ${roleId}` });
+      return;
+    }
+
+    // Ask is read-only: no authority check required (anyone can ask anyone)
+    const handle = createRunner().execute(
+      {
+        companyRoot: COMPANY_ROOT,
+        roleId,
+        task: `[Question from ${source}] ${question}`,
+        sourceRole: source,
+        orgTree,
+        readOnly: true,
+        maxTurns: 5,
+        sessionId: `ask-${Date.now()}`,
+      },
+      {},
+    );
+
+    const result = await handle.promise;
+
+    res.json({
+      roleId,
+      question,
+      answer: result.output,
+      turns: result.turns,
+      tokens: result.totalTokens,
+    });
+  } catch (err) {
+    next(err);
+  }
+});