neondeck 1.0.0-beta.4

package/src/server/routes/learning.ts

@@ -0,0 +1,384 @@
+import { invoke } from '@flue/runtime';
+import { Hono } from 'hono';
+import * as v from 'valibot';
+import {
+  decideMemoryCandidate,
+  listMemoryCandidates,
+} from '../../modules/memory';
+import { listLearningReviews } from '../../modules/learning/reviews';
+import { readLearningOperatorState } from '../../modules/learning';
+import type { RuntimePaths } from '../../runtime-home';
+import {
+  applySkillPatchCandidate,
+  listSkillPatchCandidates,
+  rejectSkillPatchCandidate,
+} from '../../modules/learning/skill-patches';
+import { readChatSession } from '../../modules/sessions';
+import curateLearningStoreWorkflow from '../../workflows/curate_learning_store';
+import reviewConversationForLearningWorkflow from '../../workflows/review_conversation_for_learning';
+import reviewPrBatchForLearningWorkflow from '../../workflows/review_pr_batch_for_learning';
+import { boundedQueryLimit, safeJsonBody } from '../http';
+
+export function createLearningRoutes(paths: RuntimePaths) {
+  const routes = new Hono();
+
+  routes.post('/curate', async (c) => {
+    const parsed = v.safeParse(
+      v.object({
+        mode: v.optional(v.picklist(['off', 'review', 'auto'])),
+        reason: v.optional(v.string()),
+      }),
+      await safeJsonBody(c),
+    );
+    if (!parsed.success) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_curate',
+          changed: false,
+          message: v.summarize(parsed.issues),
+        },
+        400,
+      );
+    }
+    const receipt = await invoke(curateLearningStoreWorkflow, {
+      input: { ...parsed.output, trigger: 'manual' },
+    });
+    return c.json({
+      ok: true,
+      action: 'learning_curate',
+      changed: true,
+      runId: receipt.runId,
+      message: 'Queued memory curation learning workflow.',
+    });
+  });
+
+  routes.get('/state', async (c) => {
+    const input = {
+      limit: boundedQueryLimit(c.req.query('limit'), 25),
+      reviewKind: learningReviewKind(c.req.query('reviewKind')),
+      reviewStatus: learningReviewStatus(c.req.query('reviewStatus')),
+      candidateStatus: learningCandidateStatus(c.req.query('candidateStatus')),
+      candidateTarget: learningCandidateTarget(c.req.query('candidateTarget')),
+      memoryId: c.req.query('memoryId') || undefined,
+    };
+    if (c.req.query('limit') && input.limit === undefined) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_operator_state',
+          changed: false,
+          message: `Invalid learning state limit "${c.req.query('limit')}".`,
+        },
+        400,
+      );
+    }
+    if (c.req.query('reviewKind') && !input.reviewKind) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_operator_state',
+          changed: false,
+          message: `Invalid review kind "${c.req.query('reviewKind')}".`,
+        },
+        400,
+      );
+    }
+    if (c.req.query('reviewStatus') && !input.reviewStatus) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_operator_state',
+          changed: false,
+          message: `Invalid review status "${c.req.query('reviewStatus')}".`,
+        },
+        400,
+      );
+    }
+    if (c.req.query('candidateStatus') && !input.candidateStatus) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_operator_state',
+          changed: false,
+          message: `Invalid candidate status "${c.req.query('candidateStatus')}".`,
+        },
+        400,
+      );
+    }
+    if (c.req.query('candidateTarget') && !input.candidateTarget) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_operator_state',
+          changed: false,
+          message: `Invalid candidate target "${c.req.query('candidateTarget')}".`,
+        },
+        400,
+      );
+    }
+    const result = await readLearningOperatorState(input, paths);
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.get('/reviews', (c) => {
+    const kind = learningReviewKind(c.req.query('kind'));
+    const status = learningReviewStatus(c.req.query('status'));
+    const limit = boundedQueryLimit(c.req.query('limit'), 50);
+    if (c.req.query('kind') && !kind) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_review_list',
+          changed: false,
+          message: `Invalid learning review kind "${c.req.query('kind')}".`,
+        },
+        400,
+      );
+    }
+    if (c.req.query('status') && !status) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_review_list',
+          changed: false,
+          message: `Invalid learning review status "${c.req.query('status')}".`,
+        },
+        400,
+      );
+    }
+    if (c.req.query('limit') && limit === undefined) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_review_list',
+          changed: false,
+          message: `Invalid review limit "${c.req.query('limit')}".`,
+        },
+        400,
+      );
+    }
+    return c.json(
+      listLearningReviews(
+        {
+          kind,
+          status,
+          limit,
+        },
+        paths,
+      ),
+    );
+  });
+
+  routes.post('/reviews/conversation', async (c) => {
+    const parsed = v.safeParse(
+      v.object({
+        sessionId: v.optional(v.pipe(v.string(), v.minLength(1))),
+        reason: v.optional(v.string()),
+      }),
+      await safeJsonBody(c),
+    );
+    if (!parsed.success) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_review_conversation',
+          changed: false,
+          message: v.summarize(parsed.issues),
+        },
+        400,
+      );
+    }
+    if (parsed.output.sessionId) {
+      const session = await readChatSession(
+        {
+          id: parsed.output.sessionId,
+          reason: 'manual-conversation-learning-review',
+          surface: 'learning',
+        },
+        paths,
+      );
+      if (!session.ok) return c.json(session, 400);
+    }
+    const receipt = await invoke(reviewConversationForLearningWorkflow, {
+      input: { ...parsed.output, trigger: 'manual' },
+    });
+    return c.json({
+      ok: true,
+      action: 'learning_review_conversation',
+      changed: true,
+      runId: receipt.runId,
+      message: 'Queued conversation learning review workflow.',
+    });
+  });
+
+  routes.post('/reviews/prs', async (c) => {
+    const parsed = v.safeParse(
+      v.object({
+        repoId: v.optional(v.pipe(v.string(), v.minLength(1))),
+        reason: v.optional(v.string()),
+        limit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
+      }),
+      await safeJsonBody(c),
+    );
+    if (!parsed.success) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_review_pr_batch',
+          changed: false,
+          message: v.summarize(parsed.issues),
+        },
+        400,
+      );
+    }
+    const receipt = await invoke(reviewPrBatchForLearningWorkflow, {
+      input: { ...parsed.output, trigger: 'manual' },
+    });
+    return c.json({
+      ok: true,
+      action: 'learning_review_pr_batch',
+      changed: true,
+      runId: receipt.runId,
+      message: 'Queued PR/autopilot learning retrospective workflow.',
+    });
+  });
+
+  routes.get('/candidates', async (c) => {
+    const status = learningCandidateStatus(c.req.query('status'));
+    if (c.req.query('status') && !status) {
+      return c.json(
+        {
+          ok: false,
+          action: 'memory_candidate_list',
+          changed: false,
+          message: `Invalid candidate status "${c.req.query('status')}".`,
+        },
+        400,
+      );
+    }
+    const limit = Number(c.req.query('limit') ?? '100');
+    if (c.req.query('limit') && !boundedQueryLimit(c.req.query('limit'), 100)) {
+      return c.json(
+        {
+          ok: false,
+          action: 'learning_candidate_list',
+          changed: false,
+          message: `Invalid candidate limit "${c.req.query('limit')}".`,
+        },
+        400,
+      );
+    }
+    const boundedLimit = Number.isFinite(limit) ? limit : undefined;
+    const [memoryCandidates, skillCandidates] = await Promise.all([
+      listMemoryCandidates({ status, limit: boundedLimit }, paths),
+      listSkillPatchCandidates({ status, limit: boundedLimit }, paths),
+    ]);
+    return c.json({
+      ok: memoryCandidates.ok && skillCandidates.ok,
+      action: 'learning_candidate_list',
+      changed: false,
+      candidates: [
+        ...(memoryCandidates.candidates ?? []),
+        ...(skillCandidates.candidates ?? []),
+      ],
+      memoryCandidates: memoryCandidates.candidates ?? [],
+      skillCandidates: skillCandidates.candidates ?? [],
+      fetchedAt: new Date().toISOString(),
+    });
+  });
+
+  routes.post('/candidates/:id/approve', async (c) => {
+    const body = (await safeJsonBody(c)) as Record<string, unknown>;
+    const result = await decideMemoryCandidate(
+      {
+        ...body,
+        id: c.req.param('id'),
+        decision: 'apply',
+      },
+      paths,
+    );
+    if (result.ok) return c.json(result);
+    if (!memoryCandidateWasNotFound(result)) return c.json(result, 400);
+    const skillResult = await applySkillPatchCandidate(
+      { ...body, id: c.req.param('id') },
+      paths,
+    );
+    return c.json(skillResult, skillResult.ok ? 200 : 400);
+  });
+
+  routes.post('/candidates/:id/reject', async (c) => {
+    const body = (await safeJsonBody(c)) as Record<string, unknown>;
+    const result = await decideMemoryCandidate(
+      {
+        ...body,
+        id: c.req.param('id'),
+        decision: 'reject',
+      },
+      paths,
+    );
+    if (result.ok) return c.json(result);
+    if (!memoryCandidateWasNotFound(result)) return c.json(result, 400);
+    const skillResult = await rejectSkillPatchCandidate(
+      { ...body, id: c.req.param('id') },
+      paths,
+    );
+    return c.json(skillResult, skillResult.ok ? 200 : 400);
+  });
+
+  return routes;
+}
+
+export function learningCandidateStatus(
+  value: string | undefined,
+): 'proposed' | 'applied' | 'rejected' | 'archived' | undefined {
+  if (
+    value === 'proposed' ||
+    value === 'applied' ||
+    value === 'rejected' ||
+    value === 'archived'
+  ) {
+    return value;
+  }
+
+  return undefined;
+}
+
+function learningCandidateTarget(
+  value: string | undefined,
+): 'memory' | 'skill' | undefined {
+  if (value === 'memory' || value === 'skill') return value;
+  return undefined;
+}
+
+function learningReviewKind(
+  value: string | undefined,
+): 'conversation' | 'curation' | 'pr-batch' | undefined {
+  if (
+    value === 'conversation' ||
+    value === 'curation' ||
+    value === 'pr-batch'
+  ) {
+    return value;
+  }
+  return undefined;
+}
+
+function learningReviewStatus(
+  value: string | undefined,
+): 'running' | 'completed' | 'failed' | undefined {
+  if (value === 'running' || value === 'completed' || value === 'failed') {
+    return value;
+  }
+  return undefined;
+}
+
+function memoryCandidateWasNotFound(result: unknown) {
+  if (!result || typeof result !== 'object') return false;
+  const record = result as { message?: unknown; requires?: unknown };
+  return (
+    record.message === 'Memory candidate was not found.' &&
+    Array.isArray(record.requires) &&
+    record.requires.includes('id')
+  );
+}

package/src/server/routes/mcp.ts

@@ -0,0 +1,301 @@
+import type { Context } from 'hono';
+import { Hono } from 'hono';
+import {
+  addMcpServer,
+  completeMcpOAuthCallback,
+  getMcpRegistry,
+  listMcpApprovals,
+  listMcpAudit,
+  logoutMcpOAuthServer,
+  readPublicMcpOAuthLogin,
+  removeMcpServer,
+  resolveMcpApprovalWithPaths,
+  setMcpServerEnabled,
+  startMcpOAuthLogin,
+  updateMcpServer,
+} from '../../domains/mcp';
+import type { RuntimePaths } from '../../runtime-home';
+import { queryNumber, safeJsonBody, safeJsonObject } from '../http';
+
+export function createMcpRoutes(paths: RuntimePaths) {
+  const routes = new Hono();
+
+  routes.get('/servers', async (c) => {
+    return c.json({
+      ok: true,
+      action: 'mcp_servers_list',
+      changed: false,
+      message: 'Read MCP server statuses.',
+      servers: await getMcpRegistry(paths).status(),
+    });
+  });
+
+  routes.post('/servers', async (c) => {
+    const result = await addMcpServer(await safeJsonBody(c), paths);
+    if (result.ok) {
+      const id = readIdFromResultData(result.data);
+      await getMcpRegistry(paths).refresh(id);
+    }
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.patch('/servers/:id', async (c) => {
+    const id = c.req.param('id');
+    const result = await updateMcpServer(
+      { ...(await safeJsonObject(c)), id },
+      paths,
+    );
+    if (result.ok) await getMcpRegistry(paths).refresh(id);
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.delete('/servers/:id', async (c) => {
+    const body = await safeJsonObject(c);
+    const id = c.req.param('id');
+    const result = await removeMcpServer(
+      {
+        ...body,
+        id,
+        confirm: body.confirm === true || c.req.query('confirm') === 'true',
+      },
+      paths,
+    );
+    if (result.ok) await getMcpRegistry(paths).refresh(id);
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/servers/:id/enable', async (c) => {
+    const id = c.req.param('id');
+    const result = await setMcpServerEnabled({ id }, true, paths);
+    if (result.ok) await getMcpRegistry(paths).refresh(id);
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/servers/:id/disable', async (c) => {
+    const id = c.req.param('id');
+    const result = await setMcpServerEnabled({ id }, false, paths);
+    if (result.ok) await getMcpRegistry(paths).refresh(id);
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.get('/servers/:id/tools', async (c) => {
+    return c.json({
+      ok: true,
+      action: 'mcp_tools_list',
+      changed: false,
+      message: 'Read cached MCP tools.',
+      tools: await getMcpRegistry(paths).listTools(c.req.param('id')),
+    });
+  });
+
+  routes.post('/servers/:id/refresh', async (c) => {
+    const id = c.req.param('id');
+    const refreshed = await getMcpRegistry(paths).refresh(id);
+    if (!refreshed) {
+      return c.json(
+        {
+          ok: false,
+          action: 'mcp_server_refresh',
+          changed: false,
+          message: `MCP server "${id}" was not found.`,
+          requires: ['id'],
+        },
+        404,
+      );
+    }
+    return c.json({
+      ok: true,
+      action: 'mcp_server_refresh',
+      changed: false,
+      message: `Refreshed MCP server "${id}".`,
+    });
+  });
+
+  routes.post('/servers/:id/login', async (c) => {
+    const body = await safeJsonObject(c);
+    const redirectUrl =
+      typeof body.redirectUrl === 'string'
+        ? body.redirectUrl
+        : `${requestOrigin(c)}/api/mcp/oauth/callback`;
+    const result = await startMcpOAuthLogin(
+      { id: c.req.param('id'), redirectUrl },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.get('/logins/:id', async (c) => {
+    const login = await readPublicMcpOAuthLogin(c.req.param('id'), paths);
+    if (!login) {
+      return c.json(
+        {
+          ok: false,
+          action: 'mcp_login_read',
+          changed: false,
+          message: 'MCP OAuth login was not found.',
+        },
+        404,
+      );
+    }
+    return c.json({
+      ok: true,
+      action: 'mcp_login_read',
+      changed: false,
+      message: `Read MCP OAuth login "${login.id}".`,
+      login,
+    });
+  });
+
+  routes.get('/oauth/callback', async (c) => {
+    const result = await completeMcpOAuthCallback(
+      {
+        state: c.req.query('state'),
+        code: c.req.query('code'),
+        error: c.req.query('error'),
+      },
+      paths,
+    );
+    const login =
+      'login' in result && isRecord(result.login) ? result.login : null;
+    const serverId =
+      login && typeof login.serverId === 'string' ? login.serverId : undefined;
+    if (result.ok && serverId) {
+      await getMcpRegistry(paths).refresh(serverId);
+    }
+    return c.html(
+      oauthCallbackHtml(result.ok, result.message),
+      result.ok ? 200 : 400,
+    );
+  });
+
+  routes.post('/servers/:id/logout', async (c) => {
+    const body = await safeJsonObject(c);
+    const id = c.req.param('id');
+    const result = await logoutMcpOAuthServer(
+      {
+        id,
+        confirm: body.confirm === true,
+      },
+      paths,
+    );
+    if (result.ok) await getMcpRegistry(paths).refresh(id);
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.get('/approvals', async (c) => {
+    return c.json({
+      ok: true,
+      action: 'mcp_approvals_list',
+      changed: false,
+      message: 'Read MCP approvals.',
+      approvals: await listMcpApprovals(paths, {
+        includeResolved: c.req.query('includeResolved') === '1',
+      }),
+    });
+  });
+
+  routes.post('/approvals/:id/resolve', async (c) => {
+    const result = await resolveMcpApprovalWithPaths(
+      { ...(await safeJsonObject(c)), id: c.req.param('id') } as {
+        id: string;
+        decision: 'approve' | 'deny';
+        approverSurface?: string;
+      },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.get('/audit', async (c) => {
+    return c.json({
+      ok: true,
+      action: 'mcp_audit_list',
+      changed: false,
+      message: 'Read MCP audit rows.',
+      audit: await listMcpAudit(paths, {
+        serverId: c.req.query('serverId') || undefined,
+        limit: queryNumber(c.req.query('limit')),
+      }),
+    });
+  });
+
+  return routes;
+}
+
+function requestOrigin(c: Context) {
+  return new URL(c.req.url).origin;
+}
+
+function readIdFromResultData(data: unknown) {
+  if (!isRecord(data)) return undefined;
+  const id = data.id ?? data.serverId;
+  if (typeof id === 'string') return id;
+  const server = data.server;
+  return isRecord(server) && typeof server.id === 'string'
+    ? server.id
+    : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function oauthCallbackHtml(ok: boolean, message: string) {
+  const title = ok ? 'MCP login complete' : 'MCP login failed';
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(title)}</title>
+    <style>
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        background: #0a0b10;
+        color: #d7f7ff;
+        font: 14px/1.5 system-ui, sans-serif;
+      }
+      main {
+        max-width: 36rem;
+        border: 1px solid #ffffff1f;
+        padding: 24px;
+      }
+      h1 {
+        margin: 0 0 8px;
+        color: ${ok ? '#69e6ff' : '#ff4fb8'};
+        font: 600 16px/1.2 ui-monospace, SFMono-Regular, Menlo, monospace;
+      }
+      p {
+        margin: 0;
+        color: #d7f7ffb3;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${escapeHtml(title)}</h1>
+      <p>${escapeHtml(message)}</p>
+    </main>
+  </body>
+</html>`;
+}
+
+function escapeHtml(value: string) {
+  return value.replace(/[&<>"']/g, (char) => {
+    switch (char) {
+      case '&':
+        return '&amp;';
+      case '<':
+        return '&lt;';
+      case '>':
+        return '&gt;';
+      case '"':
+        return '&quot;';
+      default:
+        return '&#39;';
+    }
+  });
+}