neondeck 1.0.0-beta.10

package/src/modules/config/history.ts

@@ -0,0 +1,74 @@
+import { openDb } from '../../lib/sqlite';
+import type { RuntimePaths } from '../../runtime-home';
+import { configEventFromChange, publishConfigEvent } from './events';
+
+export function recordConfigChange(
+  paths: RuntimePaths,
+  change: {
+    action: string;
+    file: string;
+    target?: string;
+    before: unknown;
+    after: unknown;
+  },
+) {
+  const database = openDb(paths.neondeckDatabase);
+  const now = new Date().toISOString();
+
+  try {
+    const result = database
+      .prepare(
+        `
+        INSERT INTO config_history (
+          action,
+          file,
+          target,
+          before_json,
+          after_json,
+          changed_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?);
+      `,
+      )
+      .run(
+        change.action,
+        change.file,
+        change.target ?? null,
+        JSON.stringify(redactLocalApiToken(change.before)),
+        JSON.stringify(redactLocalApiToken(change.after)),
+        now,
+      );
+    publishConfigEvent(
+      configEventFromChange(paths, {
+        id: result.lastInsertRowid,
+        action: change.action,
+        changed: true,
+        files: [change.file],
+        target: change.target,
+        changedAt: now,
+      }),
+    );
+  } finally {
+    database.close();
+  }
+}
+
+function redactLocalApiToken(value: unknown): unknown {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return value;
+  }
+
+  const record = value as Record<string, unknown>;
+  const localApi = record.localApi;
+  if (!localApi || typeof localApi !== 'object' || Array.isArray(localApi)) {
+    return value;
+  }
+
+  return {
+    ...record,
+    localApi: {
+      ...(localApi as Record<string, unknown>),
+      token: '[redacted-local-api-token]',
+    },
+  };
+}

package/src/modules/config/index.ts

@@ -0,0 +1,9 @@
+export * from './actions';
+export * from './events';
+export * from './mutations/dashboard';
+export * from './mutations/execution';
+export * from './mutations/models';
+export * from './mutations/providers';
+export * from './mutations/repos';
+export * from './read';
+export * from './schemas';

package/src/modules/config/mutations/dashboard.ts

@@ -0,0 +1,333 @@
+import { readFile } from 'node:fs/promises';
+import { parseActionInput, okResult, errorMessage } from '../result';
+import { recordConfigChange } from '../history';
+import { writeJson } from '../files';
+import { dashboardPresetSchema, type ConfigActionResult } from '../schemas';
+import {
+  type DashboardConfig,
+  dashboardSchemaVersion,
+  ensureRuntimeHome,
+  dashboardConfigSchema,
+  parseDashboardConfig,
+  runtimePaths,
+  type RuntimePaths,
+} from '../../../runtime-home';
+
+export async function updateDashboardLayout(
+  rawInput: unknown,
+  paths = runtimePaths(),
+): Promise<ConfigActionResult> {
+  await ensureRuntimeHome(paths);
+  const parsed = parseActionInput(
+    dashboardConfigSchema,
+    rawInput,
+    'config_update_dashboard_layout',
+    paths,
+    [paths.dashboard],
+  );
+  if (!parsed.ok) return parsed.result;
+
+  const current = await readDashboardForHistory(paths);
+  const next = parsed.input;
+  const changed = JSON.stringify(current) !== JSON.stringify(next);
+
+  if (changed) {
+    await writeJson(paths.dashboard, next);
+    recordConfigChange(paths, {
+      action: 'config_update_dashboard_layout',
+      file: paths.dashboard,
+      target: 'layout',
+      before: current,
+      after: next,
+    });
+  }
+
+  return okResult(
+    'config_update_dashboard_layout',
+    changed,
+    paths,
+    [paths.dashboard],
+    {
+      message: changed
+        ? 'Updated dashboard layout.'
+        : 'Dashboard layout already matched the requested value.',
+      data: { dashboard: next },
+    },
+  );
+}
+
+export async function applyDashboardPreset(
+  rawInput: unknown,
+  paths = runtimePaths(),
+): Promise<ConfigActionResult> {
+  await ensureRuntimeHome(paths);
+  const parsed = parseActionInput(
+    dashboardPresetSchema,
+    rawInput,
+    'config_apply_dashboard_preset',
+    paths,
+    [paths.dashboard],
+  );
+  if (!parsed.ok) return parsed.result;
+
+  const current = await readDashboardForHistory(paths);
+  const next = dashboardPresetConfig(
+    parsed.input.preset,
+    parsed.input.statuslinePosition ?? 'top',
+  );
+  const changed = JSON.stringify(current) !== JSON.stringify(next);
+
+  if (changed) {
+    await writeJson(paths.dashboard, next);
+    recordConfigChange(paths, {
+      action: 'config_apply_dashboard_preset',
+      file: paths.dashboard,
+      target: parsed.input.preset,
+      before: current,
+      after: next,
+    });
+  }
+
+  return okResult(
+    'config_apply_dashboard_preset',
+    changed,
+    paths,
+    [paths.dashboard],
+    {
+      message: changed
+        ? `Applied dashboard preset "${parsed.input.preset}".`
+        : `Dashboard preset "${parsed.input.preset}" was already active.`,
+      data: {
+        preset: parsed.input.preset,
+        dashboard: next,
+      },
+    },
+  );
+}
+
+async function readDashboardForHistory(paths: RuntimePaths): Promise<unknown> {
+  const source = await readFile(paths.dashboard, 'utf8').catch(() => undefined);
+  if (!source) return null;
+
+  try {
+    return parseDashboardConfig(JSON.parse(source), paths.dashboard);
+  } catch (error) {
+    return {
+      invalidDashboard: paths.dashboard,
+      error: errorMessage(error),
+    };
+  }
+}
+
+function dashboardPresetConfig(
+  preset: 'classic' | 'cockpit',
+  statuslinePosition: 'top' | 'bottom',
+): DashboardConfig {
+  if (preset === 'classic') {
+    return parseDashboardConfig(
+      {
+        $schema: './dashboard.schema.json',
+        schemaVersion: dashboardSchemaVersion,
+        display: { preset: 'xeneon-edge', width: 2560, height: 720 },
+        appearance: { density: 'comfortable' },
+        theme: 'dark',
+        statusline: {
+          position: statuslinePosition,
+          pluginId: 'host-metrics',
+          config: {},
+        },
+        layout: {
+          mode: 'auto',
+          columns: 12,
+          rows: 5,
+          regions: [
+            {
+              id: 'work',
+              title: 'WORK',
+              column: 1,
+              row: 1,
+              columnSpan: 4,
+              rowSpan: 5,
+              defaultTab: 'reviews',
+              tabs: [
+                reviewsTab(),
+                {
+                  id: 'github',
+                  title: 'GITHUB',
+                  pluginId: 'github-pr-list',
+                  config: { limit: 12 },
+                },
+                reportsTab(),
+              ],
+            },
+            {
+              id: 'neon',
+              title: 'NEON',
+              column: 5,
+              row: 1,
+              columnSpan: 8,
+              rowSpan: 5,
+              defaultTab: 'chat',
+              tabs: [chatTab()],
+            },
+          ],
+        },
+      },
+      'dashboard:preset:classic',
+    );
+  }
+
+  return parseDashboardConfig(
+    {
+      $schema: './dashboard.schema.json',
+      schemaVersion: dashboardSchemaVersion,
+      display: { preset: 'xeneon-edge', width: 2560, height: 720 },
+      appearance: { density: 'comfortable' },
+      theme: 'dark',
+      statusline: {
+        position: statuslinePosition,
+        pluginId: 'host-metrics',
+        config: {},
+      },
+      layout: {
+        mode: 'auto',
+        columns: 12,
+        rows: 5,
+        regions: [
+          {
+            id: 'work',
+            title: 'WORK',
+            column: 1,
+            row: 1,
+            columnSpan: 4,
+            rowSpan: 5,
+            defaultTab: 'reviews',
+            tabs: [
+              reviewsTab(),
+              {
+                id: 'github',
+                title: 'GITHUB',
+                pluginId: 'github-pr-list',
+                config: { limit: 12 },
+              },
+              {
+                id: 'watches',
+                title: 'WATCHES',
+                pluginId: 'active-watches',
+                config: { limit: 8 },
+              },
+              reportsTab(),
+            ],
+          },
+          {
+            id: 'neon',
+            title: 'NEON',
+            column: 5,
+            row: 1,
+            columnSpan: 8,
+            rowSpan: 5,
+            defaultTab: 'chat',
+            tabs: [
+              chatTab(),
+              {
+                id: 'briefing',
+                title: 'BRIEFING',
+                pluginId: 'briefing-panel',
+                config: { actionLimit: 4 },
+              },
+              {
+                id: 'memory',
+                title: 'MEMORY',
+                pluginId: 'memory-panel',
+                config: { limit: 5 },
+              },
+              {
+                id: 'learning',
+                title: 'LEARNING',
+                pluginId: 'learning-operator',
+                config: { limit: 16, refreshSeconds: 30 },
+              },
+              {
+                id: 'runtime',
+                title: 'RUNTIME',
+                pluginId: 'runtime-overview',
+                config: {
+                  repoLimit: 5,
+                  jobLimit: 5,
+                  skillLimit: 5,
+                  memoryLimit: 5,
+                  workflowEventLimit: 6,
+                },
+              },
+              {
+                id: 'workflows',
+                title: 'WORKFLOWS',
+                pluginId: 'workflow-observability',
+                config: {
+                  eventLimit: 16,
+                  refreshSeconds: 20,
+                },
+              },
+              {
+                id: 'subagents',
+                title: 'SUBAGENTS',
+                pluginId: 'subagent-summary',
+                config: { eventLimit: 4 },
+              },
+            ],
+          },
+        ],
+      },
+    },
+    'dashboard:preset:cockpit',
+  );
+}
+
+function reportsTab() {
+  return {
+    id: 'reports',
+    title: 'REPORTS',
+    pluginId: 'reports-panel',
+    config: { limit: 12, refreshSeconds: 60 },
+  };
+}
+
+function reviewsTab() {
+  return {
+    id: 'reviews',
+    title: 'REVIEWS',
+    pluginId: 'reviews-panel',
+    config: {},
+  };
+}
+
+function chatTab() {
+  return {
+    id: 'chat',
+    title: 'CHAT',
+    pluginId: 'flue-chat',
+    config: {
+      agentName: 'display-assistant',
+      sessions: [
+        {
+          id: 'neondeck-main',
+          label: 'Primary',
+          placeholder: 'Ask about your active work...',
+        },
+      ],
+      quickCommands: [
+        { label: 'Repo', command: '/repo-status' },
+        { label: 'Queue', command: '/review-queue' },
+        { label: 'Review PR', command: '/review-pr' },
+        { label: 'CI', command: '/explain-ci' },
+        { label: 'Fix CI', command: '/fix-ci' },
+        { label: 'PR', command: '/summarize-pr' },
+        { label: 'Draft', command: '/draft-pr-description' },
+        { label: 'Prep', command: '/prepare-pr' },
+        { label: 'Review', command: '/review-local' },
+        { label: 'Memory', command: '/memory' },
+        { label: 'Doctor', command: '/dev-doctor' },
+      ],
+    },
+  };
+}

package/src/modules/config/mutations/execution.ts

@@ -0,0 +1,89 @@
+import * as v from 'valibot';
+import { parseActionInput, failResult, okResult } from '../result';
+import { recordConfigChange } from '../history';
+import { writeJson } from '../files';
+import {
+  ensureRuntimeHome,
+  parseAppConfig,
+  readRuntimeJson,
+  runtimePaths,
+} from '../../../runtime-home';
+import {
+  asExecutionPolicyData,
+  executionPolicyFromConfig,
+  executionPolicyUpdateSchema,
+  hasExecutionPolicyUpdate,
+  mergeExecutionConfig,
+} from '../../execution-policy';
+import type { ConfigActionResult } from '../schemas';
+
+export async function updateExecutionPolicy(
+  rawInput: v.InferInput<typeof executionPolicyUpdateSchema>,
+  paths = runtimePaths(),
+): Promise<ConfigActionResult> {
+  await ensureRuntimeHome(paths);
+  const parsed = parseActionInput(
+    executionPolicyUpdateSchema,
+    rawInput,
+    'config_update_execution_policy',
+    paths,
+    [paths.config],
+  );
+  if (!parsed.ok) return parsed.result;
+
+  const input = parsed.input;
+  if (!hasExecutionPolicyUpdate(input)) {
+    return failResult('config_update_execution_policy', paths, [paths.config], {
+      message: 'At least one execution policy setting is required.',
+      requires: [
+        'defaultBackend',
+        'enabledBackends',
+        'approvalMode',
+        'unattended',
+        'preapprovedCommands',
+        'exeDev',
+      ],
+    });
+  }
+
+  const config = await readRuntimeJson(paths.config, parseAppConfig);
+  const nextExecution = mergeExecutionConfig(config.execution, input);
+  const next = parseAppConfig(
+    {
+      ...config,
+      execution: nextExecution,
+    },
+    paths.config,
+  );
+  const changed =
+    JSON.stringify(config.execution ?? {}) !==
+    JSON.stringify(next.execution ?? {});
+
+  if (changed) {
+    await writeJson(paths.config, next);
+    recordConfigChange(paths, {
+      action: 'config_update_execution_policy',
+      file: paths.config,
+      target: 'execution',
+      before: config,
+      after: next,
+    });
+  }
+
+  const policy = executionPolicyFromConfig({ execution: next.execution });
+  return okResult(
+    'config_update_execution_policy',
+    changed,
+    paths,
+    [paths.config],
+    {
+      message: changed
+        ? 'Updated execution approval policy. Approved execution actions will use the new policy immediately when they read config.'
+        : 'Execution approval policy already matched the requested values.',
+      data: {
+        execution: next.execution,
+        policy: asExecutionPolicyData(policy),
+      },
+    },
+  );
+}