tycono-server 0.1.0-beta.1 → 0.1.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono-server",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.3",
   "description": "Tycono AI team orchestration server. Dispatch, supervise, and observe AI agents working as a team.",
   "type": "module",
   "bin": {

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

@@ -101,7 +101,8 @@ export function createHttpServer(): http.Server {
   const app = createExpressApp();
 
   const server = http.createServer((req, res) => {
-    const url = req.url ?? '';
+    const rawUrl = req.url ?? '';
+    const url = rawUrl.split('?')[0]; // Strip query string for route matching
     const method = req.method ?? '';
 
     // GET /api/waves/active — restore active waves after refresh
@@ -150,8 +151,8 @@ export function createHttpServer(): http.Server {
       return;
     }
 
-    // Non-SSE exec/jobs endpoints (GET, DELETE)
-    if ((url.startsWith('/api/exec/') || url.startsWith('/api/jobs')) && (method === 'GET' || method === 'DELETE')) {
+    // Non-SSE exec/jobs/waves endpoints (GET, DELETE)
+    if ((url.startsWith('/api/exec/') || url.startsWith('/api/jobs') || url.startsWith('/api/waves/')) && (method === 'GET' || method === 'DELETE')) {
       setExecCors(req, res);
       handleExecRequest(req, res);
       return;

package/src/api/src/routes/execute.ts

@@ -126,6 +126,32 @@ export function handleExecRequest(req: IncomingMessage, res: ServerResponse): vo
     return;
   }
 
+  // ── GET /api/waves/:waveId — Single wave status ──
+  const waveDetailMatch = url.match(/^\/api\/waves\/([^/]+)$/);
+  if (method === 'GET' && waveDetailMatch) {
+    const waveId = waveDetailMatch[1];
+    // Try active waves first
+    const activeWaves = waveMultiplexer.getActiveWaves();
+    const active = activeWaves.find((w: { waveId: string }) => w.waveId === waveId);
+    if (active) {
+      jsonResponse(res, 200, active);
+      return;
+    }
+    // Fallback: read wave file from disk
+    const wavePath = path.join(COMPANY_ROOT, '.tycono', 'waves', `${waveId}.json`);
+    if (fs.existsSync(wavePath)) {
+      try {
+        const waveData = JSON.parse(fs.readFileSync(wavePath, 'utf-8'));
+        jsonResponse(res, 200, waveData);
+      } catch {
+        jsonResponse(res, 500, { error: 'Failed to read wave file' });
+      }
+      return;
+    }
+    jsonResponse(res, 404, { error: 'Wave not found' });
+    return;
+  }
+
   // ── Legacy /api/exec/* routes ──
   const sessionMatch = url.match(/\/api\/exec\/session\/([^/]+)\/message$/);
 

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

@@ -9,6 +9,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { execSync } from 'node:child_process';
 import YAML from 'yaml';
 import type { PresetDefinition, LoadedPreset, PresetSummary } from '../../../shared/types.js';
 
@@ -123,6 +124,19 @@ export function loadPresets(companyRoot: string): LoadedPreset[] {
     }
   }
 
+  // 3. Bundled presets (shipped with tycono-server, fallback if not in user's project)
+  const bundledPresetsDir = path.resolve(__dirname, '../../../../presets');
+  if (fs.existsSync(bundledPresetsDir)) {
+    const loadedIds = new Set(presets.map(p => p.definition.id));
+    const entries = fs.readdirSync(bundledPresetsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (loadedIds.has(entry.name)) continue; // user's preset takes priority
+      const preset = loadPresetFromDir(path.join(bundledPresetsDir, entry.name));
+      if (preset) presets.push(preset);
+    }
+  }
+
   return presets;
 }
 
@@ -142,8 +156,58 @@ export function getPresetSummaries(companyRoot: string): PresetSummary[] {
 
 /**
  * Find a specific preset by ID.
+ * Falls back to remote download from tycono.ai if not found locally.
  */
 export function getPresetById(companyRoot: string, presetId: string): LoadedPreset | null {
   const presets = loadPresets(companyRoot);
-  return presets.find(p => p.definition.id === presetId) ?? null;
+  const local = presets.find(p => p.definition.id === presetId);
+  if (local) return local;
+
+  // Try downloading from tycono.ai preset registry
+  const downloaded = downloadPreset(companyRoot, presetId);
+  return downloaded;
+}
+
+/**
+ * Download a preset from the remote registry (tycono.ai).
+ * Saves to knowledge/presets/{id}/ for future use.
+ */
+function downloadPreset(companyRoot: string, presetId: string): LoadedPreset | null {
+  const REGISTRY_URL = process.env.TYCONO_PRESET_REGISTRY || 'https://tycono.ai/api/presets';
+
+  try {
+    // Synchronous HTTP request (preset download is a blocking init step)
+    const response = execSync(
+      `curl -s --max-time 10 "${REGISTRY_URL}/${presetId}/download"`,
+      { encoding: 'utf-8' },
+    );
+
+    const data = JSON.parse(response);
+    if (!data.preset || !data.files) return null;
+
+    // Save to local presets directory
+    const targetDir = path.join(companyRoot, PRESETS_DIR, presetId);
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    // Write preset.yaml
+    fs.writeFileSync(
+      path.join(targetDir, 'preset.yaml'),
+      YAML.stringify(data.preset),
+    );
+
+    // Write knowledge files
+    if (data.files && typeof data.files === 'object') {
+      for (const [filePath, content] of Object.entries(data.files)) {
+        const fullPath = path.join(targetDir, filePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content as string);
+      }
+    }
+
+    console.log(`[Preset] Downloaded "${presetId}" from ${REGISTRY_URL}`);
+    return loadPresetFromDir(targetDir);
+  } catch (err) {
+    console.warn(`[Preset] Failed to download "${presetId}": ${(err as Error).message}`);
+    return null;
+  }
 }

package/src/api/src/services/wave-multiplexer.ts

@@ -300,14 +300,14 @@ class WaveMultiplexer {
   getActiveWaves(): Array<{
     id: string;
     directive: string;
-    dispatches: Array<{ sessionId: string; roleId: string; roleName: string }>;
+    dispatches: Array<{ sessionId: string; roleId: string; roleName: string; status: string }>;
     startedAt: number;
     sessionIds: string[];
   }> {
     const result: Array<{
       id: string;
       directive: string;
-      dispatches: Array<{ sessionId: string; roleId: string; roleName: string }>;
+      dispatches: Array<{ sessionId: string; roleId: string; roleName: string; status: string }>;
       startedAt: number;
       sessionIds: string[];
     }> = [];
@@ -316,12 +316,13 @@ class WaveMultiplexer {
       const hasActive = Array.from(sessions.values()).some(e => e.status === 'running' || e.status === 'awaiting_input');
       if (!hasActive) continue;
 
+      // Include ALL sessions (not just root) so plugin can show full team status
       const rootSessions = Array.from(sessions.values())
-        .filter(e => !e.parentSessionId || !sessions.has(e.parentSessionId))
         .map(e => ({
           sessionId: e.sessionId,
           roleId: e.roleId,
           roleName: e.roleId.toUpperCase(),
+          status: e.status,
         }));
 
       const firstExec = rootSessions.length > 0