tycono-server 0.1.0-beta.0

package/src/api/src/services/port-registry.ts

@@ -0,0 +1,222 @@
+/**
+ * port-registry.ts — Session port allocation and tracking
+ *
+ * Manages port assignments for parallel dev server sessions.
+ * Each job/session gets unique API + Vite ports to avoid conflicts.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import net from 'node:net';
+import { COMPANY_ROOT } from './file-reader.js';
+
+/* ─── Types ──────────────────────────────── */
+
+export interface PortAllocation {
+  api: number;
+  vite: number;
+  hmr?: number;
+}
+
+export interface SessionPort {
+  sessionId: string;
+  roleId: string;
+  task: string;
+  ports: PortAllocation;
+  worktreePath?: string;
+  pid?: number;
+  startedAt: string;
+  status: 'active' | 'idle' | 'dead';
+}
+
+interface RegistryFile {
+  sessions: SessionPort[];
+}
+
+/* ─── Port Pools ─────────────────────────── */
+
+const API_PORT_START = 3001;
+const VITE_PORT_START = 5173;
+const HMR_PORT_START = 24678;
+const POOL_SIZE = 10;
+
+/* ─── Helpers ────────────────────────────── */
+
+function getRegistryPath(): string {
+  return path.join(COMPANY_ROOT, '.tycono', 'port-registry.json');
+}
+
+function readRegistry(): RegistryFile {
+  const filePath = getRegistryPath();
+  try {
+    if (fs.existsSync(filePath)) {
+      return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+  } catch { /* ignore corrupt file */ }
+  return { sessions: [] };
+}
+
+function writeRegistry(data: RegistryFile): void {
+  const filePath = getRegistryPath();
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isPortAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port, '127.0.0.1');
+  });
+}
+
+/* ─── PortRegistry ───────────────────────── */
+
+class PortRegistry {
+  /** Allocate ports for a new session */
+  async allocate(sessionId: string, roleId: string, task: string): Promise<PortAllocation> {
+    const registry = readRegistry();
+    const usedApi = new Set(registry.sessions.map(s => s.ports.api));
+    const usedVite = new Set(registry.sessions.map(s => s.ports.vite));
+    const usedHmr = new Set(registry.sessions.filter(s => s.ports.hmr).map(s => s.ports.hmr!));
+
+    // Find first available port in pool
+    let api = 0;
+    let vite = 0;
+    let hmr = 0;
+
+    for (let i = 0; i < POOL_SIZE; i++) {
+      const candidate = API_PORT_START + i;
+      if (!usedApi.has(candidate) && await isPortAvailable(candidate)) {
+        api = candidate;
+        break;
+      }
+    }
+
+    for (let i = 0; i < POOL_SIZE; i++) {
+      const candidate = VITE_PORT_START + i;
+      if (!usedVite.has(candidate) && await isPortAvailable(candidate)) {
+        vite = candidate;
+        break;
+      }
+    }
+
+    for (let i = 0; i < POOL_SIZE; i++) {
+      const candidate = HMR_PORT_START + i;
+      if (!usedHmr.has(candidate) && await isPortAvailable(candidate)) {
+        hmr = candidate;
+        break;
+      }
+    }
+
+    // Fallback: let OS pick
+    if (!api) api = 0;
+    if (!vite) vite = 0;
+
+    const ports: PortAllocation = { api, vite };
+    if (hmr) ports.hmr = hmr;
+
+    const session: SessionPort = {
+      sessionId,
+      roleId,
+      task: task.slice(0, 80),
+      ports,
+      startedAt: new Date().toISOString(),
+      status: 'active',
+    };
+
+    registry.sessions.push(session);
+    writeRegistry(registry);
+
+    return ports;
+  }
+
+  /** Release ports when a session ends */
+  release(sessionId: string): boolean {
+    const registry = readRegistry();
+    const before = registry.sessions.length;
+    registry.sessions = registry.sessions.filter(s => s.sessionId !== sessionId);
+    if (registry.sessions.length < before) {
+      writeRegistry(registry);
+      return true;
+    }
+    return false;
+  }
+
+  /** Update session info (e.g., set PID, worktree path) */
+  update(sessionId: string, patch: Partial<Pick<SessionPort, 'pid' | 'worktreePath' | 'status' | 'task'>>): boolean {
+    const registry = readRegistry();
+    const session = registry.sessions.find(s => s.sessionId === sessionId);
+    if (!session) return false;
+
+    if (patch.pid !== undefined) session.pid = patch.pid;
+    if (patch.worktreePath !== undefined) session.worktreePath = patch.worktreePath;
+    if (patch.status !== undefined) session.status = patch.status;
+    if (patch.task !== undefined) session.task = patch.task.slice(0, 80);
+
+    writeRegistry(registry);
+    return true;
+  }
+
+  /** Get all sessions */
+  getAll(): SessionPort[] {
+    return readRegistry().sessions;
+  }
+
+  /** Get a specific session */
+  get(sessionId: string): SessionPort | null {
+    return readRegistry().sessions.find(s => s.sessionId === sessionId) ?? null;
+  }
+
+  /** Detect and clean up dead sessions (PID gone) */
+  cleanup(): { cleaned: SessionPort[]; remaining: SessionPort[] } {
+    const registry = readRegistry();
+    const cleaned: SessionPort[] = [];
+    const remaining: SessionPort[] = [];
+
+    for (const session of registry.sessions) {
+      if (session.pid && !isProcessAlive(session.pid)) {
+        session.status = 'dead';
+        cleaned.push(session);
+      } else {
+        remaining.push(session);
+      }
+    }
+
+    if (cleaned.length > 0) {
+      registry.sessions = remaining;
+      writeRegistry(registry);
+    }
+
+    return { cleaned, remaining };
+  }
+
+  /** Get summary stats */
+  getSummary(): { active: number; totalPorts: number } {
+    const sessions = this.getAll();
+    const active = sessions.filter(s => s.status === 'active').length;
+    return {
+      active,
+      totalPorts: active * 2, // api + vite per session
+    };
+  }
+}
+
+/* ─── Export singleton ───────────────────── */
+
+export const portRegistry = new PortRegistry();

package/src/api/src/services/preferences.ts

@@ -0,0 +1,150 @@
+/**
+ * preferences.ts — .tycono/preferences.json 관리
+ *
+ * 캐릭터 외모, 오피스 테마 등 사용자 설정을 서버 파일로 영속화한다.
+ * company-config.ts의 readConfig/writeConfig 패턴을 따른다.
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export interface CharacterAppearance {
+  skinColor: string;
+  hairColor: string;
+  shirtColor: string;
+  pantsColor: string;
+  shoeColor: string;
+}
+
+export interface SpeechSettings {
+  /** 'template' = static pool only, 'llm' = AI generation, 'auto' = detect engine */
+  mode: 'template' | 'llm' | 'auto';
+  /** Interval between ambient speech in seconds */
+  intervalSec: number;
+  /** Daily budget for LLM speech in USD (0 = unlimited) */
+  dailyBudgetUsd: number;
+}
+
+export interface FurnitureOverride {
+  offsetX: number;
+  offsetY: number;
+}
+
+export interface DeskOverride {
+  dx: number;
+  dy: number;
+}
+
+export interface AddedFurniture {
+  id: string;
+  type: string;
+  room: string;
+  zone: 'wall' | 'floor';
+  anchorX?: 'left' | 'right';
+  offsetX: number;
+  offsetY: number;
+  accent?: string;
+}
+
+export interface OfficeExpansion {
+  /** Each entry = one floor. floors[0] = 1F, floors[1] = 2F, etc. Max 3 floors. */
+  floors: Array<{ rooms: 4 | 6 }>;
+  purchaseHistory: Array<{ type: string; cost: number; ts: string }>;
+}
+
+export interface Preferences {
+  instanceId?: string; // anonymous persistent token — auto-generated on first read
+  appearances: Record<string, CharacterAppearance>;
+  theme: string;
+  speech?: SpeechSettings;
+  language?: string; // 'en' | 'ko' | 'ja' | 'auto'
+  furnitureOverrides?: Record<string, FurnitureOverride>; // keyed by FurnitureDef.id
+  deskOverrides?: Record<string, DeskOverride>; // keyed by role id
+  removedFurniture?: string[]; // FurnitureDef.id list
+  addedFurniture?: AddedFurniture[];
+  officeExpansion?: OfficeExpansion;
+  purchasedItems?: string[]; // item IDs purchased with coins (hair, outfit, accessory)
+}
+
+const CONFIG_DIR = '.tycono';
+const PREFS_FILE = 'preferences.json';
+const DEFAULT: Preferences = { appearances: {}, theme: 'default' };
+
+function prefsPath(companyRoot: string): string {
+  return path.join(companyRoot, CONFIG_DIR, PREFS_FILE);
+}
+
+/** Read preferences from .tycono/preferences.json. Returns defaults if missing.
+ *  Auto-generates instanceId on first access and persists it. */
+export function readPreferences(companyRoot: string): Preferences {
+  const p = prefsPath(companyRoot);
+  let data: Record<string, unknown> = {};
+  if (fs.existsSync(p)) {
+    try { data = JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { /* use defaults */ }
+  }
+
+  const prefs: Preferences = {
+    instanceId: (data.instanceId as string) ?? undefined,
+    appearances: (data.appearances as Record<string, CharacterAppearance>) ?? {},
+    theme: (data.theme as string) ?? 'default',
+    speech: (data.speech as SpeechSettings) ?? undefined,
+    language: (data.language as string) ?? undefined,
+    furnitureOverrides: (data.furnitureOverrides as Record<string, FurnitureOverride>) ?? undefined,
+    deskOverrides: (data.deskOverrides as Record<string, DeskOverride>) ?? undefined,
+    removedFurniture: (data.removedFurniture as string[]) ?? undefined,
+    addedFurniture: (data.addedFurniture as AddedFurniture[]) ?? undefined,
+    officeExpansion: (data.officeExpansion as OfficeExpansion) ?? undefined,
+    purchasedItems: (data.purchasedItems as string[]) ?? undefined,
+  };
+
+  // Auto-generate instanceId on first access
+  if (!prefs.instanceId) {
+    prefs.instanceId = crypto.randomUUID();
+    writePreferences(companyRoot, prefs);
+  }
+
+  return prefs;
+}
+
+/** Write preferences to .tycono/preferences.json. Creates dir if needed. */
+export function writePreferences(companyRoot: string, prefs: Preferences): void {
+  const dir = path.join(companyRoot, CONFIG_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(prefsPath(companyRoot), JSON.stringify(prefs, null, 2) + '\n');
+}
+
+/** Merge partial preferences into existing. instanceId is never overwritten by client. */
+export function mergePreferences(companyRoot: string, partial: Partial<Preferences>): Preferences {
+  const current = readPreferences(companyRoot);
+  const merged: Preferences = {
+    instanceId: current.instanceId, // preserve — never overwrite from client
+    appearances: partial.appearances !== undefined
+      ? { ...current.appearances, ...partial.appearances }
+      : current.appearances,
+    theme: partial.theme ?? current.theme,
+    speech: partial.speech !== undefined
+      ? { ...current.speech, ...partial.speech }
+      : current.speech,
+    language: partial.language !== undefined ? partial.language : current.language,
+    furnitureOverrides: partial.furnitureOverrides !== undefined
+      ? { ...current.furnitureOverrides, ...partial.furnitureOverrides }
+      : current.furnitureOverrides,
+    deskOverrides: partial.deskOverrides !== undefined
+      ? { ...current.deskOverrides, ...partial.deskOverrides }
+      : current.deskOverrides,
+    removedFurniture: partial.removedFurniture !== undefined
+      ? partial.removedFurniture
+      : current.removedFurniture,
+    addedFurniture: partial.addedFurniture !== undefined
+      ? partial.addedFurniture
+      : current.addedFurniture,
+    officeExpansion: partial.officeExpansion !== undefined
+      ? partial.officeExpansion
+      : current.officeExpansion,
+    purchasedItems: partial.purchasedItems !== undefined
+      ? partial.purchasedItems
+      : current.purchasedItems,
+  };
+  writePreferences(companyRoot, merged);
+  return merged;
+}

package/src/api/src/services/preset-loader.ts

@@ -0,0 +1,149 @@
+/**
+ * preset-loader.ts — Load presets from knowledge/presets/
+ *
+ * Scans knowledge/presets/ for:
+ *   - _default.yaml (auto-generated from existing knowledge/roles/)
+ *   - {name}/preset.yaml (installed presets with roles/skills/knowledge)
+ *
+ * Returns PresetSummary[] for TUI display and full LoadedPreset for wave creation.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+import type { PresetDefinition, LoadedPreset, PresetSummary } from '../../../shared/types.js';
+
+const PRESETS_DIR = 'knowledge/presets';
+const DEFAULT_PRESET_FILE = '_default.yaml';
+
+/**
+ * Build a default preset definition from existing roles/ directory.
+ * This is generated on-the-fly — no need to persist _default.yaml.
+ */
+function buildDefaultPreset(companyRoot: string): LoadedPreset {
+  const rolesDir = path.join(companyRoot, 'knowledge', 'roles');
+  const roles: string[] = [];
+
+  if (fs.existsSync(rolesDir)) {
+    const entries = fs.readdirSync(rolesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const yamlPath = path.join(rolesDir, entry.name, 'role.yaml');
+      if (fs.existsSync(yamlPath)) {
+        roles.push(entry.name);
+      }
+    }
+  }
+
+  return {
+    definition: {
+      spec: 'preset/v1',
+      id: 'default',
+      name: 'Default Team',
+      tagline: 'Your current team',
+      version: '1.0.0',
+      roles,
+    },
+    path: null,
+    isDefault: true,
+  };
+}
+
+/**
+ * Load a single preset from a directory containing preset.yaml.
+ */
+function loadPresetFromDir(presetDir: string): LoadedPreset | null {
+  const yamlPath = path.join(presetDir, 'preset.yaml');
+  if (!fs.existsSync(yamlPath)) return null;
+
+  try {
+    const raw = YAML.parse(fs.readFileSync(yamlPath, 'utf-8')) as PresetDefinition;
+    if (!raw.id || !raw.name || !Array.isArray(raw.roles)) return null;
+
+    return {
+      definition: {
+        spec: raw.spec || 'preset/v1',
+        id: raw.id,
+        name: raw.name,
+        tagline: raw.tagline,
+        version: raw.version || '1.0.0',
+        description: raw.description,
+        author: raw.author,
+        category: raw.category,
+        industry: raw.industry,
+        stage: raw.stage,
+        use_case: raw.use_case,
+        roles: raw.roles,
+        knowledge_docs: raw.knowledge_docs,
+        skills_count: raw.skills_count,
+        pricing: raw.pricing,
+        tags: raw.tags,
+        languages: raw.languages,
+        stats: raw.stats,
+        wave_scoped: raw.wave_scoped,
+      },
+      path: presetDir,
+      isDefault: false,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load all presets from knowledge/presets/ + auto-generated default.
+ * Returns [default, ...installed] — default is always first.
+ */
+export function loadPresets(companyRoot: string): LoadedPreset[] {
+  const presets: LoadedPreset[] = [];
+
+  // 1. Default preset (always present)
+  const defaultPreset = buildDefaultPreset(companyRoot);
+
+  // Check if _default.yaml exists with overrides
+  const defaultYamlPath = path.join(companyRoot, PRESETS_DIR, DEFAULT_PRESET_FILE);
+  if (fs.existsSync(defaultYamlPath)) {
+    try {
+      const raw = YAML.parse(fs.readFileSync(defaultYamlPath, 'utf-8')) as Partial<PresetDefinition>;
+      if (raw.name) defaultPreset.definition.name = raw.name;
+      if (raw.tagline) defaultPreset.definition.tagline = raw.tagline;
+      if (raw.description) defaultPreset.definition.description = raw.description;
+    } catch { /* ignore malformed _default.yaml */ }
+  }
+
+  presets.push(defaultPreset);
+
+  // 2. Installed presets from knowledge/presets/{name}/preset.yaml
+  const presetsDir = path.join(companyRoot, PRESETS_DIR);
+  if (fs.existsSync(presetsDir)) {
+    const entries = fs.readdirSync(presetsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const preset = loadPresetFromDir(path.join(presetsDir, entry.name));
+      if (preset) presets.push(preset);
+    }
+  }
+
+  return presets;
+}
+
+/**
+ * Get preset summaries for TUI display.
+ */
+export function getPresetSummaries(companyRoot: string): PresetSummary[] {
+  return loadPresets(companyRoot).map(p => ({
+    id: p.definition.id,
+    name: p.definition.name,
+    description: p.definition.description ?? p.definition.tagline,
+    rolesCount: p.definition.roles.length,
+    roles: p.definition.roles,
+    isDefault: p.isDefault,
+  }));
+}
+
+/**
+ * Find a specific preset by ID.
+ */
+export function getPresetById(companyRoot: string, presetId: string): LoadedPreset | null {
+  const presets = loadPresets(companyRoot);
+  return presets.find(p => p.definition.id === presetId) ?? null;
+}

package/src/api/src/services/pricing.ts

@@ -0,0 +1,34 @@
+/* ── Model Pricing ──────────────────────── */
+
+export interface ModelPricing {
+  inputPer1M: number;   // USD per 1M input tokens
+  outputPer1M: number;  // USD per 1M output tokens
+}
+
+/**
+ * Anthropic model pricing table.
+ * Source: https://docs.anthropic.com/en/docs/about-claude/pricing
+ */
+export const MODEL_PRICING: Record<string, ModelPricing> = {
+  // Sonnet 4 family
+  'claude-sonnet-4-5':        { inputPer1M: 3.00,  outputPer1M: 15.00 },
+  'claude-sonnet-4-20250514': { inputPer1M: 3.00,  outputPer1M: 15.00 },
+  // Opus 4 family
+  'claude-opus-4-6':          { inputPer1M: 15.00, outputPer1M: 75.00 },
+  // Haiku 4.5 family
+  'claude-haiku-4-5':              { inputPer1M: 0.80,  outputPer1M: 4.00 },
+  'claude-haiku-4-5-20251001':     { inputPer1M: 0.80,  outputPer1M: 4.00 },
+};
+
+const DEFAULT_PRICING: ModelPricing = { inputPer1M: 3.00, outputPer1M: 15.00 };
+
+/** Estimate cost in USD for a given token usage */
+export function estimateCost(
+  inputTokens: number,
+  outputTokens: number,
+  model: string,
+): number {
+  const pricing = MODEL_PRICING[model] ?? DEFAULT_PRICING;
+  return (inputTokens * pricing.inputPer1M / 1_000_000)
+       + (outputTokens * pricing.outputPer1M / 1_000_000);
+}