tycono-server 0.1.0-beta.0

package/src/api/src/routes/roles.ts

@@ -0,0 +1,112 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { readFile, fileExists, listFiles } from '../services/file-reader.js';
+import { parseMarkdownTable } from '../services/markdown-parser.js';
+import YAML from 'yaml';
+
+export const rolesRouter = Router();
+
+// GET /api/roles — Role 목록
+rolesRouter.get('/', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const content = readFile('knowledge/roles/roles.md');
+    const rows = parseMarkdownTable(content);
+
+    const roles = rows.map(row => {
+      const id = row.id ?? '';
+      let name = row.role ?? row.name ?? '';
+
+      // role.yaml의 name이 있으면 우선 사용 (rename 반영)
+      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 ?? '',
+      };
+    });
+
+    res.json(roles);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /api/roles/:id — Role 상세
+rolesRouter.get('/:id', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { id } = req.params;
+
+    // 기본 정보 (roles.md 테이블에서)
+    const listContent = readFile('knowledge/roles/roles.md');
+    const rows = parseMarkdownTable(listContent);
+    const roleRow = rows.find(r => r.id === id);
+
+    if (!roleRow) {
+      res.status(404).json({ error: `Role not found: ${id}` });
+      return;
+    }
+
+    const role: Record<string, unknown> = {
+      id: roleRow.id,
+      name: roleRow.role ?? roleRow.name ?? '',
+      level: roleRow.level ?? '',
+      reportsTo: roleRow.reports_to ?? '',
+      status: roleRow.상태 ?? roleRow.status ?? '',
+      persona: '',
+      authority: { autonomous: [] as string[], needsApproval: [] as string[] },
+      journal: '',
+    };
+
+    // role.yaml에서 name + persona + authority + skills 읽기
+    const yamlPath = `knowledge/roles/${id}/role.yaml`;
+    if (fileExists(yamlPath)) {
+      const raw = YAML.parse(readFile(yamlPath)) as Record<string, unknown>;
+      if (raw.name) role.name = raw.name;
+      if (raw.persona) role.persona = raw.persona;
+      if (Array.isArray(raw.skills)) role.skills = raw.skills;
+      const auth = raw.authority as Record<string, string[]> | undefined;
+      if (auth) {
+        role.authority = {
+          autonomous: auth.autonomous ?? [],
+          needsApproval: auth.needs_approval ?? [],
+        };
+      }
+    }
+
+    // SKILL.md에서 스킬 메타 자동 추출
+    const skillMdPath = `.claude/skills/${id}/SKILL.md`;
+    if (fileExists(skillMdPath)) {
+      const skillContent = readFile(skillMdPath);
+      const fmMatch = skillContent.match(/^---\n([\s\S]*?)\n---/);
+      if (fmMatch) {
+        try {
+          const meta = YAML.parse(fmMatch[1]) as Record<string, unknown>;
+          role.skillMeta = {
+            name: meta.name || id,
+            description: meta.description || '',
+            ...(meta.allowedTools ? { allowedTools: meta.allowedTools } : {}),
+          };
+        } catch { /* ignore parse errors */ }
+      }
+    }
+
+    // 오늘 저널 읽기
+    const today = new Date().toISOString().slice(0, 10);
+    const journalPath = `knowledge/roles/${id}/journal/${today}.md`;
+    if (fileExists(journalPath)) {
+      role.journal = readFile(journalPath).slice(0, 3000);
+    }
+
+    res.json(role);
+  } catch (err) {
+    next(err);
+  }
+});

package/src/api/src/routes/save.ts

@@ -0,0 +1,152 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+import { getGitStatus, gitSave, gitHistory, gitRestore, gitInit, gitFetchStatus, gitPull, githubStatus, githubCreateRepo, gitAddRemote } from '../services/git-save.js';
+import type { RepoType } from '../services/git-save.js';
+
+export const saveRouter = Router();
+
+/** Extract repo type from query param, default 'akb' */
+function getRepo(req: Request): RepoType {
+  const repo = req.query.repo;
+  return repo === 'code' ? 'code' : 'akb';
+}
+
+// GET /api/save/status?repo=akb|code
+saveRouter.get('/status', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    res.json(getGitStatus(COMPANY_ROOT, getRepo(req)));
+  } catch (err) {
+    // Not a git repo (e.g. auto-created code dir) — return empty status
+    if (err instanceof Error && (err.message.includes('not a git repository') || err.message.includes('codeRoot'))) {
+      res.json({ isRepo: false, branch: '', staged: [], unstaged: [], untracked: [] });
+      return;
+    }
+    next(err);
+  }
+});
+
+// POST /api/save?repo=akb|code — commit + push
+saveRouter.post('/', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { message } = req.body ?? {};
+    const result = gitSave(COMPANY_ROOT, message, getRepo(req));
+    res.json({ ok: true, ...result });
+  } catch (err) {
+    if (err instanceof Error) {
+      if (err.message === 'No changes to save') {
+        res.status(400).json({ error: err.message });
+        return;
+      }
+      if (err.message.includes('Not a git repository') || err.message.includes('codeRoot')) {
+        res.status(400).json({ error: 'Repository not initialized. Run git init first.' });
+        return;
+      }
+    }
+    next(err);
+  }
+});
+
+// GET /api/save/history?repo=akb|code
+saveRouter.get('/history', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const limit = Math.min(Number(req.query.limit) || 20, 100);
+    res.json(gitHistory(COMPANY_ROOT, limit, getRepo(req)));
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/save/init — initialize git repo
+saveRouter.post('/init', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const result = gitInit(COMPANY_ROOT, getRepo(req));
+    if (!result.ok) {
+      res.status(500).json({ error: result.message });
+      return;
+    }
+    res.json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/save/restore?repo=akb|code
+saveRouter.post('/restore', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { sha, paths } = req.body ?? {};
+    if (!sha || typeof sha !== 'string') {
+      res.status(400).json({ error: 'sha is required' });
+      return;
+    }
+    const result = gitRestore(COMPANY_ROOT, sha, paths, getRepo(req));
+    res.json({ ok: true, ...result });
+  } catch (err) {
+    if (err instanceof Error && (err.message.includes('Not a git repository') || err.message.includes('codeRoot'))) {
+      res.status(400).json({ error: 'Repository not initialized. Run git init first.' });
+      return;
+    }
+    next(err);
+  }
+});
+
+// GET /api/save/sync-status?repo=akb|code — fetch + ahead/behind
+saveRouter.get('/sync-status', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    res.json(gitFetchStatus(COMPANY_ROOT, getRepo(req)));
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/save/pull?repo=akb|code — safe pull (ff-only)
+saveRouter.post('/pull', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const result = gitPull(COMPANY_ROOT, getRepo(req));
+    const statusCode = result.status === 'ok' || result.status === 'up-to-date' ? 200
+      : result.status === 'dirty' || result.status === 'diverged' ? 409
+      : result.status === 'no-remote' ? 404
+      : 500;
+    res.status(statusCode).json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /api/save/github-status?repo=akb|code — check gh CLI + auth + remote
+saveRouter.get('/github-status', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    res.json(githubStatus(COMPANY_ROOT, getRepo(req)));
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/save/github-create-repo?repo=akb|code — create GitHub repo + push
+saveRouter.post('/github-create-repo', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { name, visibility } = req.body ?? {};
+    if (!name || typeof name !== 'string') {
+      res.status(400).json({ ok: false, message: 'Repository name is required' });
+      return;
+    }
+    const result = githubCreateRepo(COMPANY_ROOT, name, visibility || 'private', getRepo(req));
+    res.status(result.ok ? 200 : 400).json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/save/remote?repo=akb|code — manually add git remote
+saveRouter.post('/remote', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { url } = req.body ?? {};
+    if (!url || typeof url !== 'string') {
+      res.status(400).json({ ok: false, message: 'Remote URL is required' });
+      return;
+    }
+    const result = gitAddRemote(COMPANY_ROOT, url, getRepo(req));
+    res.status(result.ok ? 200 : 400).json(result);
+  } catch (err) {
+    next(err);
+  }
+});

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

@@ -0,0 +1,288 @@
+import { Router } from 'express';
+import {
+  createSession,
+  getSession,
+  listSessions,
+  deleteSession,
+  deleteMany,
+  deleteEmpty,
+  updateSession,
+  addMessage,
+  type Message,
+} from '../services/session-store.js';
+import { executionManager } from '../services/execution-manager.js';
+import { isMessageActive, type MessageStatus } from '../../../shared/types.js';
+import { ActivityStream, type ActivityEvent } from '../services/activity-stream.js';
+import { updateFollowUpForReply } from '../services/wave-tracker.js';
+
+export const sessionsRouter = Router();
+
+/* POST /api/sessions — create session */
+sessionsRouter.post('/', (req, res) => {
+  const { roleId, mode } = req.body;
+  if (!roleId) {
+    res.status(400).json({ error: 'roleId is required' });
+    return;
+  }
+  const session = createSession(roleId, { mode: mode ?? 'talk' });
+  res.status(201).json(session);
+});
+
+/* GET /api/sessions — list sessions (meta only) */
+sessionsRouter.get('/', (_req, res) => {
+  res.json(listSessions());
+});
+
+/* GET /api/sessions/:id — session detail with messages */
+sessionsRouter.get('/:id', (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+  res.json(session);
+});
+
+/* PATCH /api/sessions/:id — update title/mode */
+sessionsRouter.patch('/:id', (req, res) => {
+  const { title, mode } = req.body;
+  const session = updateSession(req.params.id, { title, mode });
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+  res.json(session);
+});
+
+/* DELETE /api/sessions — bulk delete (body: { ids }) or ?empty=true */
+sessionsRouter.delete('/', (req, res) => {
+  console.log(`[Sessions] DELETE / called (empty=${req.query.empty}, origin=${req.headers.origin ?? req.headers.referer ?? 'unknown'})`);
+  if (req.query.empty === 'true') {
+    const result = deleteEmpty();
+    res.json(result);
+    return;
+  }
+  const { ids } = req.body ?? {};
+  if (!Array.isArray(ids) || ids.length === 0) {
+    res.status(400).json({ error: 'ids array is required' });
+    return;
+  }
+  const deleted = deleteMany(ids);
+  res.json({ deleted });
+});
+
+/* DELETE /api/sessions/:id — delete session */
+sessionsRouter.delete('/:id', (req, res) => {
+  console.log(`[Sessions] DELETE /${req.params.id} called (origin=${req.headers.origin ?? req.headers.referer ?? 'unknown'})`);
+  const ok = deleteSession(req.params.id);
+  if (!ok) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+  res.json({ ok: true });
+});
+
+/* ─── Session-based execution proxying ──── */
+
+/** GET /api/sessions/:id/stream — SSE proxy to linked execution's activity stream */
+sessionsRouter.get('/:id/stream', (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+
+  const exec = executionManager.getActiveExecution(req.params.id);
+  const fromSeq = parseInt(req.query.from as string ?? '0', 10);
+
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'X-Accel-Buffering': 'no',
+  });
+  res.flushHeaders();
+
+  const sendEvent = (event: string, data: unknown) => {
+    if (res.destroyed || res.writableEnded) return;
+    try { res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`); } catch { /* ignore */ }
+  };
+
+  // Read from session-keyed stream file
+  const streamId = exec?.sessionId ?? req.params.id;
+  if (ActivityStream.exists(streamId)) {
+    const pastEvents = ActivityStream.readFrom(streamId, fromSeq);
+    for (const event of pastEvents) {
+      sendEvent('activity', event);
+    }
+  }
+
+  if (!exec || !isMessageActive(exec.status as MessageStatus)) {
+    sendEvent('stream:end', { reason: exec ? exec.status : 'no-execution' });
+    res.end();
+    return;
+  }
+
+  const subscriber = (event: ActivityEvent) => {
+    if (event.seq >= fromSeq) {
+      sendEvent('activity', event);
+    }
+    if (event.type === 'msg:done' || event.type === 'msg:error') {
+      sendEvent('stream:end', { reason: event.type === 'msg:done' ? 'done' : 'error' });
+      res.end();
+      exec.stream.unsubscribe(subscriber);
+    } else if (event.type === 'msg:awaiting_input') {
+      sendEvent('stream:end', { reason: 'awaiting_input' });
+      res.end();
+      exec.stream.unsubscribe(subscriber);
+    } else if (event.type === 'msg:reply') {
+      sendEvent('stream:end', { reason: 'replied' });
+      res.end();
+      exec.stream.unsubscribe(subscriber);
+    }
+  };
+
+  exec.stream.subscribe(subscriber);
+
+  const heartbeat = setInterval(() => {
+    if (res.destroyed || res.writableEnded) {
+      clearInterval(heartbeat);
+      return;
+    }
+    try { res.write(': heartbeat\n\n'); } catch { /* ignore */ }
+  }, 15_000);
+
+  req.on('close', () => {
+    clearInterval(heartbeat);
+    exec.stream.unsubscribe(subscriber);
+  });
+});
+
+/** POST /api/sessions/:id/abort — abort linked execution */
+sessionsRouter.post('/:id/abort', (req, res) => {
+  const success = executionManager.abortSession(req.params.id);
+  if (!success) {
+    res.status(404).json({ error: 'No active execution for this session' });
+    return;
+  }
+
+  res.json({ ok: true, sessionId: req.params.id });
+});
+
+/** POST /api/sessions/:id/message — send a new message to the session */
+sessionsRouter.post('/:id/message', (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+
+  const { message, sourceRole, attachments } = req.body;
+  if (!message && (!attachments || attachments.length === 0)) {
+    res.status(400).json({ error: 'message or attachments required' });
+    return;
+  }
+
+  const ceoMsg: Message = {
+    id: `msg-${Date.now()}-ceo-msg`,
+    from: 'ceo',
+    content: message ?? '',
+    type: 'conversation',
+    status: 'done',
+    timestamp: new Date().toISOString(),
+    attachments,
+  };
+  addMessage(req.params.id, ceoMsg);
+
+  const newExec = executionManager.startExecution({
+    type: 'assign',
+    roleId: session.roleId,
+    task: message ?? '(image attached)',
+    sourceRole: sourceRole ?? 'ceo',
+    sessionId: req.params.id,
+    attachments,
+  });
+
+  const roleMsg: Message = {
+    id: `msg-${Date.now() + 1}-role-msg`,
+    from: 'role',
+    content: '',
+    type: 'conversation',
+    status: 'streaming',
+    timestamp: new Date().toISOString(),
+  };
+  addMessage(req.params.id, roleMsg, true);
+
+  res.json({ ok: true, sessionId: req.params.id });
+});
+
+/** POST /api/sessions/:id/reply — reply to awaiting_input execution via session */
+sessionsRouter.post('/:id/reply', (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+
+  const { message, responderRole, attachments } = req.body;
+  if (!message && (!attachments || attachments.length === 0)) {
+    res.status(400).json({ error: 'message or attachments required' });
+    return;
+  }
+
+  const ceoMsg: Message = {
+    id: `msg-${Date.now()}-ceo-reply`,
+    from: 'ceo',
+    content: message ?? '',
+    type: 'conversation',
+    status: 'done',
+    timestamp: new Date().toISOString(),
+    attachments,
+  };
+  addMessage(req.params.id, ceoMsg);
+
+  const exec = executionManager.getActiveExecution(req.params.id);
+  let newExec;
+
+  if (exec) {
+    newExec = executionManager.continueSession(req.params.id, message ?? '(image attached)', responderRole);
+    if (!newExec) {
+      res.status(400).json({ error: 'Execution not in a replyable state' });
+      return;
+    }
+  } else {
+    const prevMessages = session.messages
+      .filter(m => m.id !== ceoMsg.id)
+      .slice(-6)
+      .map(m => `${m.from === 'ceo' ? 'CEO' : m.from.toUpperCase()}: ${m.content.slice(0, 500)}`)
+      .join('\n');
+    const task = prevMessages
+      ? `[Conversation History]\n${prevMessages}\n\n[CEO Follow-up]\n${message ?? '(image attached)'}`
+      : (message ?? '(image attached)');
+
+    newExec = executionManager.startExecution({
+      type: 'assign',
+      roleId: session.roleId,
+      task,
+      sourceRole: responderRole ?? 'ceo',
+      sessionId: req.params.id,
+      attachments,
+    });
+  }
+
+  const roleMsg: Message = {
+    id: `msg-${Date.now() + 1}-role-reply`,
+    from: 'role',
+    content: '',
+    type: 'conversation',
+    status: 'streaming',
+    timestamp: new Date().toISOString(),
+  };
+  addMessage(req.params.id, roleMsg, true);
+
+  if (session.waveId) {
+    updateFollowUpForReply(session.waveId, session.roleId, req.params.id);
+  }
+
+  res.json({ ok: true, sessionId: req.params.id });
+});