repoburg 1.3.188 → 1.3.196

package/agent-pane/backend/src/routes/sessions.ts

@@ -1,10 +1,11 @@
 import type { FastifyInstance } from 'fastify';
 import { v4 as uuidv4 } from 'uuid';
 import { getDb } from '../db/index.ts';
+import { getProvider } from '../providers/registry.ts';
 import type { Session, SessionDetail, Turn, Item } from '../db/schema.ts';
 
-/** Raw DB row for turns — token_usage is a JSON string, not parsed. */
-interface TurnRow extends Omit<Turn, 'token_usage'> {
+/** Raw DB row for turns — token_usage is a JSON string, not parsed; no items field. */
+interface TurnRow extends Omit<Turn, 'token_usage' | 'items'> {
   token_usage: string | null;
 }
 
@@ -30,10 +31,14 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       return reply.code(404).send({ error: 'Session not found' });
     }
 
-    const turnRows = db.prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at ASC').all(id) as TurnRow[];
-    const itemRows = db.prepare(
-      'SELECT * FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?) ORDER BY created_at ASC',
-    ).all(id) as ItemRow[];
+    const turnRows = db
+      .prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at ASC')
+      .all(id) as TurnRow[];
+    const itemRows = db
+      .prepare(
+        'SELECT * FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?) ORDER BY created_at ASC',
+      )
+      .all(id) as ItemRow[];
 
     // Parse item data from JSON string and group by turn_id
     const itemsByTurn = new Map<string, Item[]>();
@@ -60,22 +65,44 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
   });
 
   // POST /api/sessions — create session
-  fastify.post<{ Body: { title?: string; runtime_type?: string; model?: string; cwd?: string } }>(
-    '/api/sessions',
-    async (request) => {
-      const { title = null, runtime_type = 'codex', model = null, cwd = null } = request.body || {};
-      const id = uuidv4();
-      const now = new Date().toISOString();
+  fastify.post<{
+    Body: { title?: string; runtime_type?: string; model?: string; model_reasoning_effort?: string; cwd?: string; runtime_config?: string };
+  }>('/api/sessions', {
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          runtime_type: { type: 'string' },
+          model: { type: ['string', 'null'] },
+          model_reasoning_effort: { type: ['string', 'null'] },
+          cwd: { type: ['string', 'null'] },
+          runtime_config: { type: ['string', 'null'] },
+        },
+      },
+    },
+  }, async (request) => {
+    const {
+      title = null,
+      runtime_type = 'codex',
+      model = null,
+      model_reasoning_effort = null,
+      cwd = null,
+      runtime_config = null,
+    } = request.body || {};
+    const id = uuidv4();
+    const now = new Date().toISOString();
 
-      getDb().prepare(
-        `INSERT INTO sessions (id, title, runtime_type, model, cwd, external_thread_id, status, is_running, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, NULL, 'active', 0, ?, ?)`,
-      ).run(id, title, runtime_type, model, cwd, now, now);
+    getDb()
+      .prepare(
+        `INSERT INTO sessions (id, title, runtime_type, model, model_reasoning_effort, cwd, external_thread_id, status, is_running, created_at, updated_at, runtime_config)
+         VALUES (?, ?, ?, ?, ?, ?, NULL, 'active', 0, ?, ?, ?)`,
+      )
+      .run(id, title, runtime_type, model, model_reasoning_effort, cwd, now, now, runtime_config);
 
-      const session = getDb().prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
-      return session;
-    },
-  );
+    const session = getDb().prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
+    return session;
+  });
 
   // DELETE /api/sessions/:id — delete session (cascade)
   fastify.delete<{ Params: { id: string } }>('/api/sessions/:id', async (request, reply) => {
@@ -95,40 +122,266 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
     return { success: true };
   });
 
-  // PATCH /api/sessions/:id — update session (title, lifecycle, has_unreviewed)
-  fastify.patch<{ Params: { id: string }; Body: { title?: string; lifecycle?: string; has_unreviewed?: number } }>(
-    '/api/sessions/:id',
+  // PATCH /api/sessions/:id — update session (title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config)
+  fastify.patch<{
+    Params: { id: string };
+    Body: {
+      title?: string;
+      lifecycle?: string;
+      has_unreviewed?: number;
+      model?: string | null;
+      model_reasoning_effort?: string | null;
+      runtime_config?: string | null;
+      runtime_type?: string;
+    };
+  }>('/api/sessions/:id', {
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          lifecycle: { type: 'string' },
+          has_unreviewed: { type: 'number' },
+          model: { type: ['string', 'null'] },
+          model_reasoning_effort: { type: ['string', 'null'] },
+          runtime_config: { type: ['string', 'null'] },
+          runtime_type: { type: 'string' },
+        },
+      },
+    },
+  }, async (request, reply) => {
+    const { id } = request.params;
+    const { title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config, runtime_type } = request.body || {};
+    const db = getDb();
+
+    const existing = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
+    if (!existing) {
+      return reply.code(404).send({ error: 'Session not found' });
+    }
+
+    // Block provider switch while a turn is running
+    if (runtime_type !== undefined && runtime_type !== existing.runtime_type && existing.is_running) {
+      return reply.code(409).send({ error: 'Cannot switch provider while a turn is running' });
+    }
+
+    const now = new Date().toISOString();
+    const updates: string[] = ['updated_at = ?'];
+    const params: (string | number | null)[] = [now];
+
+    let modelChanged = false;
+
+    if (title !== undefined) {
+      updates.push('title = ?');
+      params.push(title);
+    }
+    if (lifecycle !== undefined) {
+      updates.push('lifecycle = ?');
+      params.push(lifecycle);
+    }
+    if (has_unreviewed !== undefined) {
+      updates.push('has_unreviewed = ?');
+      params.push(has_unreviewed);
+    }
+
+    // Provider switch — clear model/reasoning if not explicitly provided
+    if (runtime_type !== undefined && runtime_type !== existing.runtime_type) {
+      modelChanged = true; // old model is invalid for new provider
+      updates.push('runtime_type = ?');
+      params.push(runtime_type);
+
+      // Clear model if not explicitly set in this request
+      if (model === undefined) {
+        updates.push('model = ?');
+        params.push(null);
+      }
+      // Clear reasoning if not explicitly set
+      if (model_reasoning_effort === undefined) {
+        updates.push('model_reasoning_effort = ?');
+        params.push(null);
+      }
+    }
+
+    if (model !== undefined) {
+      updates.push('model = ?');
+      params.push(model);
+      if (model !== existing.model) modelChanged = true;
+    }
+    if (model_reasoning_effort !== undefined) {
+      updates.push('model_reasoning_effort = ?');
+      params.push(model_reasoning_effort);
+      if (model_reasoning_effort !== existing.model_reasoning_effort) modelChanged = true;
+    }
+    if (runtime_config !== undefined) {
+      updates.push('runtime_config = ?');
+      params.push(runtime_config);
+    }
+
+    db.prepare(`UPDATE sessions SET ${updates.join(', ')} WHERE id = ?`).run(...params, id);
+
+    // If provider or model changed, clear the cached thread and clean up old provider
+    if (modelChanged && existing.external_thread_id) {
+      db.prepare('UPDATE sessions SET external_thread_id = NULL, updated_at = ? WHERE id = ?').run(now, id);
+      // Use old provider to clear its in-memory thread state
+      getProvider(existing.runtime_type).clearThread(id);
+    }
+
+    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
+    return session;
+  });
+
+  // POST /api/sessions/:id/rewind — delete turns after target turn, reset Codex thread
+  fastify.post<{ Params: { id: string }; Body: { turn_id: string } }>(
+    '/api/sessions/:id/rewind',
+    {
+      schema: {
+        body: {
+          type: 'object',
+          required: ['turn_id'],
+          properties: {
+            turn_id: { type: 'string' },
+          },
+        },
+      },
+    },
     async (request, reply) => {
       const { id } = request.params;
-      const { title, lifecycle, has_unreviewed } = request.body || {};
-      const db = getDb();
+      const { turn_id } = request.body || {};
+      if (!turn_id) {
+        return reply.code(400).send({ error: 'turn_id is required' });
+      }
 
-      const existing = db.prepare('SELECT id FROM sessions WHERE id = ?').get(id);
-      if (!existing) {
+      const db = getDb();
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
+      if (!session) {
         return reply.code(404).send({ error: 'Session not found' });
       }
+      if (session.is_running) {
+        return reply.code(409).send({ error: 'Cannot rewind while a turn is running' });
+      }
+
+      const targetTurn = db.prepare('SELECT created_at FROM turns WHERE id = ? AND session_id = ?').get(turn_id, id) as
+        { created_at: string } | undefined;
+      if (!targetTurn) {
+        return reply.code(404).send({ error: 'Turn not found' });
+      }
 
+      // Delete turns after the target (cascade deletes items via FK)
+      db.prepare('DELETE FROM turns WHERE session_id = ? AND created_at > ?').run(id, targetTurn.created_at);
+
+      // Null out external_thread_id — next turn creates a fresh Codex thread
       const now = new Date().toISOString();
-      const updates: string[] = ['updated_at = ?'];
-      const params: (string | number | null)[] = [now];
+      db.prepare('UPDATE sessions SET external_thread_id = NULL, updated_at = ? WHERE id = ?').run(now, id);
+
+      // Clear in-memory thread entry
+      getProvider(session.runtime_type).clearThread(id);
 
-      if (title !== undefined) {
-        updates.push('title = ?');
-        params.push(title);
+      const updated = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
+      return updated;
+    },
+  );
+
+  // POST /api/sessions/:id/branch — create new session with turns up to and including target turn
+  fastify.post<{ Params: { id: string }; Body: { turn_id: string; title?: string } }>(
+    '/api/sessions/:id/branch',
+    {
+      schema: {
+        body: {
+          type: 'object',
+          required: ['turn_id'],
+          properties: {
+            turn_id: { type: 'string' },
+            title: { type: 'string' },
+          },
+        },
+      },
+    },
+    async (request, reply) => {
+      const { id } = request.params;
+      const { turn_id, title } = request.body || {};
+      if (!turn_id) {
+        return reply.code(400).send({ error: 'turn_id is required' });
       }
-      if (lifecycle !== undefined) {
-        updates.push('lifecycle = ?');
-        params.push(lifecycle);
+
+      const db = getDb();
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
+      if (!session) {
+        return reply.code(404).send({ error: 'Session not found' });
       }
-      if (has_unreviewed !== undefined) {
-        updates.push('has_unreviewed = ?');
-        params.push(has_unreviewed);
+
+      const targetTurn = db.prepare('SELECT created_at FROM turns WHERE id = ? AND session_id = ?').get(turn_id, id) as
+        { created_at: string } | undefined;
+      if (!targetTurn) {
+        return reply.code(404).send({ error: 'Turn not found' });
       }
 
-      db.prepare(`UPDATE sessions SET ${updates.join(', ')} WHERE id = ?`).run(...params, id);
+      // Create new session
+      const newSessionId = uuidv4();
+      const now = new Date().toISOString();
+      const newTitle = title || `Branch of ${session.title || session.id.slice(0, 8)}`;
+
+      db.prepare(
+        `INSERT INTO sessions (id, title, runtime_type, model, model_reasoning_effort, cwd, external_thread_id, status, is_running, lifecycle, has_unreviewed, created_at, updated_at, runtime_config)
+         VALUES (?, ?, ?, ?, ?, ?, NULL, 'active', 0, 'working', 0, ?, ?, ?)`,
+      ).run(
+        newSessionId,
+        newTitle,
+        session.runtime_type,
+        session.model,
+        session.model_reasoning_effort,
+        session.cwd,
+        now,
+        now,
+        session.runtime_config,
+      );
+
+      // Copy turns up to and including the target turn
+      const turnRows = db
+        .prepare('SELECT * FROM turns WHERE session_id = ? AND created_at <= ? ORDER BY created_at ASC')
+        .all(id, targetTurn.created_at) as TurnRow[];
+
+      for (const turn of turnRows) {
+        const newTurnId = uuidv4();
+        db.prepare(
+          `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        ).run(
+          newTurnId,
+          newSessionId,
+          turn.user_prompt,
+          turn.agent_response,
+          turn.thoughts,
+          turn.token_usage,
+          turn.external_turn_id,
+          turn.status,
+          turn.error,
+          turn.created_at,
+          turn.updated_at,
+        );
 
-      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
-      return session;
+        // Copy items for this turn
+        const itemRows = db
+          .prepare('SELECT * FROM items WHERE turn_id = ? ORDER BY created_at ASC')
+          .all(turn.id) as ItemRow[];
+        for (const item of itemRows) {
+          const newItemId = uuidv4();
+          db.prepare(
+            `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+          ).run(
+            newItemId,
+            newTurnId,
+            item.external_item_id,
+            item.type,
+            item.data,
+            item.status,
+            item.created_at,
+            item.updated_at,
+          );
+        }
+      }
+
+      const newSession = db.prepare('SELECT * FROM sessions WHERE id = ?').get(newSessionId) as Session;
+      return newSession;
     },
   );
-}
+}

package/agent-pane/backend/src/routes/skills.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Fastify, { type FastifyInstance } from 'fastify';
+
+// Mock shared-app-server to return a mock client
+const mockRequest = vi.fn();
+
+vi.mock('../codex/shared-app-server.ts', () => ({
+  getSharedAppServer: vi.fn(() => ({
+    request: mockRequest,
+    isClosed: vi.fn(() => false),
+    initialize: vi.fn(() => Promise.resolve()),
+    close: vi.fn(() => Promise.resolve()),
+  })),
+}));
+
+// Mock node:fs for readFileSync used in GET /api/skills/:name
+vi.mock('node:fs', () => ({
+  readFileSync: vi.fn(),
+}));
+
+import { registerSkillRoutes } from './skills.ts';
+import { readFileSync } from 'node:fs';
+import type { SkillsListResult } from '../codex/app-server-types.ts';
+
+const MOCK_SKILLS_RESULT: SkillsListResult = {
+  data: [
+    {
+      cwd: '/tmp',
+      skills: [
+        {
+          name: 'cloudflare',
+          description: 'Cloudflare skill',
+          path: '/home/.codex/skills/cloudflare/SKILL.md',
+          scope: 'user',
+          enabled: true,
+        },
+        {
+          name: 'imagegen',
+          description: 'Image generation skill',
+          path: '/home/.codex/skills/.system/imagegen/SKILL.md',
+          scope: 'system',
+          enabled: true,
+          interface: {
+            displayName: 'Image Gen',
+            shortDescription: 'Generate images',
+          },
+        },
+      ],
+      errors: [],
+    },
+  ],
+};
+
+describe('Skill routes', () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    mockRequest.mockResolvedValue(MOCK_SKILLS_RESULT);
+    app = Fastify();
+    await registerSkillRoutes(app);
+  });
+
+  describe('GET /api/skills', () => {
+    it('returns skills from app-server', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/skills' });
+      expect(res.statusCode).toBe(200);
+      const skills = res.json();
+      expect(skills).toHaveLength(2);
+      expect(skills[0].name).toBe('cloudflare');
+      expect(skills[0].type).toBe('skill');
+      expect(skills[0].metadata.scope).toBe('user');
+      expect(skills[1].name).toBe('Image Gen');
+      expect(skills[1].metadata.scope).toBe('system');
+    });
+
+    it('calls skills/list with cwd from query', async () => {
+      await app.inject({ method: 'GET', url: '/api/skills?cwd=/custom/path' });
+      expect(mockRequest).toHaveBeenCalledWith('skills/list', { cwds: ['/custom/path'] });
+    });
+
+    it('defaults cwd to process.cwd()', async () => {
+      await app.inject({ method: 'GET', url: '/api/skills' });
+      expect(mockRequest).toHaveBeenCalledWith('skills/list', {
+        cwds: [process.cwd()],
+      });
+    });
+
+    it('returns empty array when app-server returns no skills', async () => {
+      mockRequest.mockResolvedValue({ data: [{ cwd: '/tmp', skills: [], errors: [] }] });
+      const res = await app.inject({ method: 'GET', url: '/api/skills' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual([]);
+    });
+  });
+
+  describe('GET /api/skills/:name', () => {
+    it('returns 404 for unknown skill', async () => {
+      mockRequest.mockResolvedValue(MOCK_SKILLS_RESULT);
+      const res = await app.inject({ method: 'GET', url: '/api/skills/nonexistent' });
+      expect(res.statusCode).toBe(404);
+      expect(res.json()).toEqual({ error: 'Skill not found' });
+    });
+
+    it('returns SKILL.md content for known skill', async () => {
+      vi.mocked(readFileSync).mockReturnValue('# Cloudflare\nSkill content here');
+      const res = await app.inject({ method: 'GET', url: '/api/skills/cloudflare' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json().name).toBe('cloudflare');
+      expect(res.json().content).toContain('# Cloudflare');
+      expect(res.json().path).toBe('/home/.codex/skills/cloudflare/SKILL.md');
+    });
+  });
+});

package/agent-pane/backend/src/routes/skills.ts

@@ -0,0 +1,70 @@
+import type { FastifyInstance } from 'fastify';
+import { readFileSync } from 'node:fs';
+import type { Extension } from '@agentpane/shared';
+import { getSharedAppServer } from '../codex/shared-app-server.ts';
+import type { SkillsListResult, AppServerSkill } from '../codex/app-server-types.ts';
+
+/** Map an app-server skill to the shared Extension type. */
+function mapSkill(skill: AppServerSkill): Extension {
+  return {
+    id: skill.name,
+    name: skill.interface?.displayName ?? skill.name,
+    description: skill.shortDescription ?? skill.interface?.shortDescription ?? skill.description,
+    type: 'skill',
+    enabled: skill.enabled,
+    metadata: {
+      scope: skill.scope,
+      path: skill.path,
+    },
+  };
+}
+
+/** Register skill routes. */
+export async function registerSkillRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /api/skills — list all skills from the app-server
+  fastify.get<{ Querystring: { cwd?: string } }>('/api/skills', async (request) => {
+    const cwd = request.query.cwd ?? process.cwd();
+    const result = await getSharedAppServer().request<SkillsListResult>('skills/list', { cwds: [cwd] });
+
+    // Flatten all skills from all cwds in the response
+    const allSkills: Extension[] = [];
+    for (const entry of result.data) {
+      for (const skill of entry.skills) {
+        allSkills.push(mapSkill(skill));
+      }
+    }
+    return allSkills;
+  });
+
+  // GET /api/skills/:name — get full SKILL.md content
+  fastify.get<{ Params: { name: string }; Querystring: { cwd?: string } }>(
+    '/api/skills/:name',
+    async (request, reply) => {
+      const { name } = request.params;
+      const cwd = request.query.cwd ?? process.cwd();
+
+      // Fetch skills list to find the path for this skill
+      const result = await getSharedAppServer().request<SkillsListResult>('skills/list', { cwds: [cwd] });
+
+      let skillPath: string | null = null;
+      for (const entry of result.data) {
+        const skill = entry.skills.find((s) => s.name === name);
+        if (skill) {
+          skillPath = skill.path;
+          break;
+        }
+      }
+
+      if (!skillPath) {
+        return reply.code(404).send({ error: 'Skill not found' });
+      }
+
+      try {
+        const content = readFileSync(skillPath, 'utf-8');
+        return { name, content, path: skillPath };
+      } catch {
+        return reply.code(500).send({ error: 'Failed to read skill' });
+      }
+    },
+  );
+}