neondeck 1.0.0-beta.10

package/src/server/routes/repos.ts

@@ -0,0 +1,50 @@
+import { Hono } from 'hono';
+import {
+  readRepoHealthSnapshot,
+  readRepoRegistrySnapshot,
+} from '../../modules/repos';
+import { ConfigValidationError, type RuntimePaths } from '../../runtime-home';
+
+export function createReposRoutes(paths: RuntimePaths) {
+  const routes = new Hono();
+
+  routes.get('/', async (c) => {
+    try {
+      return c.json(await readRepoRegistrySnapshot(paths));
+    } catch (error) {
+      if (error instanceof ConfigValidationError) {
+        return c.json(
+          {
+            error: 'Invalid repo registry',
+            message: error.message,
+            path: error.path,
+          },
+          500,
+        );
+      }
+
+      throw error;
+    }
+  });
+
+  routes.get('/health', async (c) => {
+    try {
+      return c.json(await readRepoHealthSnapshot(paths));
+    } catch (error) {
+      if (error instanceof ConfigValidationError) {
+        return c.json(
+          {
+            error: 'Invalid repo registry',
+            message: error.message,
+            path: error.path,
+          },
+          500,
+        );
+      }
+
+      throw error;
+    }
+  });
+
+  return routes;
+}

package/src/server/routes/reviews.ts

@@ -0,0 +1,257 @@
+import { Hono } from 'hono';
+import {
+  listGitHubPrQueue,
+  type GitHubPullRequest,
+} from '../../modules/github';
+import {
+  readPrReview,
+  readPrReviewForTarget,
+  reconcilePrReviewSubmission,
+  recentPrReviews,
+  startPrReview,
+  type PrReviewOrigin,
+  type PrReviewRecord,
+} from '../../modules/pr-reviews';
+import type { RuntimePaths } from '../../runtime-home';
+import { safeJsonBody } from '../http';
+
+export function createReviewRoutes(paths: RuntimePaths) {
+  const routes = new Hono();
+
+  routes.get('/reviews', async (c) => {
+    const repo = c.req.query('repo')?.trim();
+    const prNumber = Number(c.req.query('prNumber'));
+    if (repo && Number.isInteger(prNumber) && prNumber > 0) {
+      const review = readPrReviewForTarget(repo, prNumber, paths);
+      const items = review ? [review] : [];
+      return c.json({
+        ok: true,
+        action: 'pr_reviews_list',
+        changed: false,
+        items,
+        groups: groupReviews(items, []),
+      });
+    }
+
+    const reviews = recentPrReviews(paths);
+    const queueResult = await listGitHubPrQueue(paths);
+    const queue = queueResult.ok
+      ? queueFromResult(queueResult.data)
+      : { items: [] as GitHubPullRequest[] };
+    const awaiting = queue.items
+      .filter((item) => item.relations.includes('review-requested'))
+      .map((pullRequest) => ({
+        pullRequest,
+        review:
+          reviews.find(
+            (review) =>
+              review.repoFullName.toLowerCase() ===
+                pullRequest.repo.toLowerCase() &&
+              review.prNumber === pullRequest.number,
+          ) ?? null,
+      }));
+
+    return c.json({
+      ok: true,
+      action: 'pr_reviews_list',
+      changed: false,
+      items: reviews,
+      groups: groupReviews(reviews, awaiting),
+      queueIssues: queueResult.ok ? [] : (queueResult.errors ?? []),
+    });
+  });
+
+  routes.get('/reviews/:id', (c) => {
+    const review = readPrReview(c.req.param('id'), paths);
+    return review
+      ? c.json({
+          ok: true,
+          action: 'pr_review_read',
+          changed: false,
+          review,
+        })
+      : c.json(
+          {
+            ok: false,
+            action: 'pr_review_read',
+            changed: false,
+            message: 'PR review not found.',
+          },
+          404,
+        );
+  });
+
+  routes.post('/reviews', async (c) => {
+    const body = objectBody(await safeJsonBody(c));
+    const ref = typeof body.ref === 'string' ? body.ref.trim() : '';
+    if (!ref) {
+      return c.json(
+        {
+          ok: false,
+          action: 'pr_review_start',
+          changed: false,
+          message: 'A pull request reference is required.',
+          requires: ['ref'],
+        },
+        400,
+      );
+    }
+    try {
+      const result = await startPrReview(
+        { ref, origin: reviewOrigin(body.origin) },
+        paths,
+      );
+      return c.json(
+        {
+          ok: true,
+          action: 'pr_review_start',
+          changed: true,
+          message: `Started review for ${result.review.repoFullName}#${result.review.prNumber}.`,
+          ...result,
+        },
+        202,
+      );
+    } catch (error) {
+      return c.json(
+        {
+          ok: false,
+          action: 'pr_review_start',
+          changed: false,
+          message: errorMessage(error),
+        },
+        400,
+      );
+    }
+  });
+
+  routes.post('/reviews/:id/review', async (c) => {
+    const existing = readPrReview(c.req.param('id'), paths);
+    if (!existing) {
+      return c.json(
+        {
+          ok: false,
+          action: 'pr_review_restart',
+          changed: false,
+          message: 'PR review not found.',
+        },
+        404,
+      );
+    }
+    try {
+      const result = await startPrReview(
+        { ref: existing.ref, origin: 'panel' },
+        paths,
+      );
+      return c.json(
+        {
+          ok: true,
+          action: 'pr_review_restart',
+          changed: true,
+          message: `Re-reviewing ${existing.repoFullName}#${existing.prNumber}.`,
+          ...result,
+        },
+        202,
+      );
+    } catch (error) {
+      return c.json(
+        {
+          ok: false,
+          action: 'pr_review_restart',
+          changed: false,
+          message: errorMessage(error),
+        },
+        400,
+      );
+    }
+  });
+
+  routes.post('/reviews/:id/reconcile', async (c) => {
+    try {
+      const result = await reconcilePrReviewSubmission(
+        { reviewId: c.req.param('id') },
+        paths,
+      );
+      const message =
+        result.outcome === 'submitted'
+          ? 'Recovered the submitted review from GitHub.'
+          : result.outcome === 'ready'
+            ? 'GitHub has no matching review; the local draft is ready to submit again.'
+            : result.outcome === 'pending'
+              ? 'GitHub has not reported the review yet. Wait a moment, then check again.'
+              : `The review is already ${result.review.status}.`;
+      return c.json(
+        {
+          ok: true,
+          action: 'pr_review_submission_reconcile',
+          changed: result.outcome === 'submitted' || result.outcome === 'ready',
+          message,
+          review: result.review,
+          reviewId: result.review.id,
+          runId: result.review.runId ?? '',
+        },
+        result.outcome === 'pending' ? 202 : 200,
+      );
+    } catch (error) {
+      const message = errorMessage(error);
+      return c.json(
+        {
+          ok: false,
+          action: 'pr_review_submission_reconcile',
+          changed: false,
+          message,
+        },
+        message === 'GITHUB_TOKEN is not configured.' ? 503 : 502,
+      );
+    }
+  });
+
+  return routes;
+}
+
+function groupReviews(
+  reviews: PrReviewRecord[],
+  awaiting: Array<{
+    pullRequest: GitHubPullRequest;
+    review: PrReviewRecord | null;
+  }>,
+) {
+  return {
+    awaiting,
+    inProgress: reviews.filter(
+      (review) =>
+        review.status === 'reviewing' || review.status === 'submitting',
+    ),
+    needsAction: reviews.filter(
+      (review) => review.status === 'ready' || review.status === 'failed',
+    ),
+    submitted: reviews.filter((review) => review.status === 'submitted'),
+  };
+}
+
+function queueFromResult(value: unknown): { items: GitHubPullRequest[] } {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return { items: [] };
+  }
+  const queue = (value as { queue?: unknown }).queue;
+  if (!queue || typeof queue !== 'object' || Array.isArray(queue)) {
+    return { items: [] };
+  }
+  const items = (queue as { items?: unknown }).items;
+  return { items: Array.isArray(items) ? (items as GitHubPullRequest[]) : [] };
+}
+
+function objectBody(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function reviewOrigin(value: unknown): PrReviewOrigin {
+  return value === 'chat' || value === 'panel' || value === 'api'
+    ? value
+    : 'api';
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/server/routes/runtime.ts

@@ -0,0 +1,48 @@
+import { Hono } from 'hono';
+import {
+  autopilotStateSchema,
+  readAutopilotState,
+} from '../../modules/autopilot/state';
+import {
+  localApiAuthHeader,
+  localApiTokenQueryParam,
+  readLocalApiToken,
+} from '../../modules/runtime';
+import type { RuntimePaths } from '../../runtime-home';
+import { readRuntimeStatus } from '../../modules/runtime';
+import * as v from 'valibot';
+
+export function createRuntimeRoutes(paths: RuntimePaths) {
+  const routes = new Hono();
+
+  routes.get('/health', (c) =>
+    c.json({
+      ok: true,
+      service: 'neondeck',
+      home: paths.home,
+      uptimeSeconds: Math.round(process.uptime()),
+    }),
+  );
+
+  routes.get('/runtime/status', async (c) => {
+    return c.json(await readRuntimeStatus(paths));
+  });
+
+  routes.get('/local-api/session', async (c) => {
+    return c.json({
+      ok: true,
+      action: 'local_api_session_read',
+      token: await readLocalApiToken(paths),
+      header: localApiAuthHeader,
+      queryParam: localApiTokenQueryParam,
+    });
+  });
+
+  routes.get('/autopilot/state', async (c) => {
+    return c.json(
+      v.parse(autopilotStateSchema, await readAutopilotState(paths)),
+    );
+  });
+
+  return routes;
+}

package/src/server/routes/safety.ts

@@ -0,0 +1,13 @@
+import { Hono } from 'hono';
+import type { RuntimePaths } from '../../runtime-home';
+import { readSafetyPolicy } from '../../modules/safety';
+
+export function createSafetyRoutes(paths: RuntimePaths) {
+  const routes = new Hono();
+
+  routes.get('/policy', (c) => {
+    return c.json(readSafetyPolicy(paths));
+  });
+
+  return routes;
+}

package/src/server/routes/scheduled-tasks.ts

@@ -0,0 +1,60 @@
+import { Hono } from 'hono';
+import {
+  createAgentInstructionTask,
+  createBriefingTask,
+  listTaskRecords,
+  readTaskRecord,
+  removeTask,
+  setTaskEnabled,
+} from '../../modules/scheduled-tasks';
+import type { RuntimePaths } from '../../runtime-home';
+import { safeJsonObject } from '../http';
+
+export function createScheduledTaskRoutes(paths: RuntimePaths) {
+  const routes = new Hono();
+
+  routes.get('/scheduled-tasks', async (c) =>
+    c.json(await listTaskRecords(paths)),
+  );
+  routes.post('/scheduled-tasks/briefings', async (c) => {
+    const result = await createBriefingTask(await safeJsonObject(c), paths);
+    return c.json(result, result.ok ? 200 : 400);
+  });
+  routes.post('/scheduled-tasks/instructions', async (c) => {
+    const result = await createAgentInstructionTask(
+      await safeJsonObject(c),
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+  routes.get('/scheduled-tasks/:id', async (c) => {
+    const result = await readTaskRecord(c.req.param('id'), paths);
+    return c.json(result, result.ok ? 200 : 404);
+  });
+  routes.post('/scheduled-tasks/:id/pause', async (c) => {
+    const result = await setTaskEnabled(c.req.param('id'), false, paths);
+    return c.json(result, result.ok ? 200 : 404);
+  });
+  routes.post('/scheduled-tasks/:id/resume', async (c) => {
+    const result = await setTaskEnabled(c.req.param('id'), true, paths);
+    return c.json(result, result.ok ? 200 : 404);
+  });
+  routes.delete('/scheduled-tasks/:id', async (c) => {
+    if (c.req.query('confirm') !== 'true') {
+      return c.json(
+        {
+          ok: false,
+          action: 'scheduled_task_delete',
+          changed: false,
+          message: 'Deleting a scheduled task requires confirm=true.',
+          requires: ['confirm'],
+        },
+        400,
+      );
+    }
+    const result = await removeTask(c.req.param('id'), paths);
+    return c.json(result, result.ok ? 200 : 404);
+  });
+
+  return routes;
+}

package/src/server/routes/scheduler.ts

@@ -0,0 +1,13 @@
+import { Hono } from 'hono';
+import type { RuntimePaths } from '../../runtime-home';
+import { runObservedSchedulerTick } from '../scheduler-workflow';
+
+export function createSchedulerRoutes(paths: RuntimePaths) {
+  const routes = new Hono();
+
+  routes.post('/scheduler/tick', async (c) => {
+    return c.json(await runObservedSchedulerTick(paths));
+  });
+
+  return routes;
+}

package/src/server/routes/sessions.ts

@@ -0,0 +1,229 @@
+import { Hono } from 'hono';
+import type { RuntimePaths } from '../../runtime-home';
+import {
+  archiveChatSession,
+  createChatSession,
+  createChatSessionCommandEvent,
+  linkChatSessionContext,
+  listChatSessionActivity,
+  listChatSessionCommandEvents,
+  listChatSessions,
+  pinChatSession,
+  readChatSession,
+  readChatSessionMessages,
+  readNeonSessionState,
+  referenceChatSession,
+  renameChatSession,
+  refreshChatSessionSummary,
+  restoreChatSession,
+  searchChatSessions,
+  switchChatSession,
+  updateChatSessionCommandEvent,
+} from '../../modules/sessions';
+import { safeJsonBody, safeJsonObject } from '../http';
+
+export function createSessionRoutes(paths: RuntimePaths) {
+  const routes = new Hono();
+
+  routes.get('/session', async (c) => {
+    return c.json(await readNeonSessionState(paths, c.req.query('surface')));
+  });
+
+  routes.get('/sessions', async (c) => {
+    return c.json(
+      await listChatSessions(
+        {
+          includeArchived: c.req.query('includeArchived') === '1',
+          kind: sessionKind(c.req.query('kind')),
+          surface: c.req.query('surface') || undefined,
+        },
+        paths,
+      ),
+    );
+  });
+
+  routes.post('/sessions/search', async (c) => {
+    const result = await searchChatSessions(
+      (await safeJsonBody(c)) as Parameters<typeof searchChatSessions>[0],
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions', async (c) => {
+    const result = await createChatSession(
+      (await safeJsonBody(c)) as Parameters<typeof createChatSession>[0],
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.get('/sessions/:id', async (c) => {
+    const result = await readChatSession(
+      {
+        id: c.req.param('id'),
+        surface: c.req.query('surface') || undefined,
+        reason: c.req.query('reason') || undefined,
+      },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 404);
+  });
+
+  routes.get('/sessions/:id/messages', async (c) => {
+    const rawLimit = Number(c.req.query('limit'));
+    const result = await readChatSessionMessages(
+      {
+        id: c.req.param('id'),
+        cursor: c.req.query('cursor') || undefined,
+        limit: Number.isFinite(rawLimit) ? rawLimit : undefined,
+        surface: c.req.query('surface') || undefined,
+        reason: c.req.query('reason') || undefined,
+        explicitUserRequest: c.req.query('explicitUserRequest') === '1',
+      },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 'requires' in result ? 400 : 404);
+  });
+
+  routes.get('/sessions/:id/command-events', async (c) => {
+    const rawLimit = Number(c.req.query('limit'));
+    const result = await listChatSessionCommandEvents(
+      {
+        sessionId: c.req.param('id'),
+        limit: Number.isFinite(rawLimit) ? rawLimit : undefined,
+      },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 404);
+  });
+
+  routes.get('/sessions/:id/activity', async (c) => {
+    const rawLimit = Number(c.req.query('limit'));
+    const result = await listChatSessionActivity(
+      {
+        sessionId: c.req.param('id'),
+        limit: Number.isFinite(rawLimit) ? rawLimit : undefined,
+      },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 404);
+  });
+
+  routes.post('/sessions/:id/command-events', async (c) => {
+    const result = await createChatSessionCommandEvent(
+      {
+        ...(await safeJsonObject(c)),
+        sessionId: c.req.param('id'),
+      } as Parameters<typeof createChatSessionCommandEvent>[0],
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions/:id/command-events/:eventId', async (c) => {
+    const result = await updateChatSessionCommandEvent(
+      {
+        ...(await safeJsonObject(c)),
+        sessionId: c.req.param('id'),
+        eventId: c.req.param('eventId'),
+      } as Parameters<typeof updateChatSessionCommandEvent>[0],
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions/:id/summary/refresh', async (c) => {
+    const result = await refreshChatSessionSummary(
+      {
+        ...(await safeJsonObject(c)),
+        id: c.req.param('id'),
+      } as Parameters<typeof refreshChatSessionSummary>[0],
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions/:id/reference', async (c) => {
+    const result = await referenceChatSession(
+      {
+        ...(await safeJsonObject(c)),
+        id: c.req.param('id'),
+      } as Parameters<typeof referenceChatSession>[0],
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions/:id/switch', async (c) => {
+    const result = await switchChatSession(
+      { ...(await safeJsonObject(c)), id: c.req.param('id') },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions/:id/rename', async (c) => {
+    const result = await renameChatSession(
+      {
+        ...(await safeJsonObject(c)),
+        id: c.req.param('id'),
+      } as Parameters<typeof renameChatSession>[0],
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions/:id/pin', async (c) => {
+    const result = await pinChatSession(
+      {
+        ...(await safeJsonObject(c)),
+        id: c.req.param('id'),
+      } as Parameters<typeof pinChatSession>[0],
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions/:id/archive', async (c) => {
+    const result = await archiveChatSession(
+      { ...(await safeJsonObject(c)), id: c.req.param('id') },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions/:id/restore', async (c) => {
+    const result = await restoreChatSession(
+      { ...(await safeJsonObject(c)), id: c.req.param('id') },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  routes.post('/sessions/:id/link-context', async (c) => {
+    const result = await linkChatSessionContext(
+      { ...(await safeJsonObject(c)), id: c.req.param('id') },
+      paths,
+    );
+    return c.json(result, result.ok ? 200 : 400);
+  });
+
+  return routes;
+}
+
+function sessionKind(value: string | undefined) {
+  if (
+    value === 'main' ||
+    value === 'scratch' ||
+    value === 'general' ||
+    value === 'repo' ||
+    value === 'watch' ||
+    value === 'task' ||
+    value === 'briefing'
+  ) {
+    return value;
+  }
+
+  return undefined;
+}