neondeck 1.0.0-beta.4

package/src/modules/execution/actions.ts

@@ -0,0 +1,35 @@
+import { defineAction } from '@flue/runtime';
+import { requestExecutionApproval } from './approvals';
+import { runApprovedExecution } from './run';
+import {
+  executionOutputSchema,
+  requestApprovalInputSchema,
+  runExecutionInputSchema,
+} from './schemas';
+
+export const executionRequestApprovalAction = defineAction({
+  name: 'neondeck_execution_request_approval',
+  description:
+    'Create a pending approval request for a non-preapproved local or exe.dev command without running it.',
+  input: requestApprovalInputSchema,
+  output: executionOutputSchema,
+  async run({ input }) {
+    return requestExecutionApproval(input);
+  },
+});
+
+export const executionRunAction = defineAction({
+  name: 'neondeck_execution_run',
+  description:
+    'Run one approved local or exe.dev command through the Neondeck execution approval policy and audit log.',
+  input: runExecutionInputSchema,
+  output: executionOutputSchema,
+  async run({ input }) {
+    return runApprovedExecution(input);
+  },
+});
+
+export const neondeckExecutionActions = [
+  executionRequestApprovalAction,
+  executionRunAction,
+];

package/src/modules/execution/approvals.ts

@@ -0,0 +1,322 @@
+import { asJsonValue } from '../../lib/action-result';
+import { openDb } from '../../lib/sqlite';
+import { updateExecutionPolicy } from '../config';
+import { currentFlueExecutionContext } from '../flue/execution-context';
+import {
+  ensureRuntimeHome,
+  parseAppConfig,
+  readRuntimeJson,
+  runtimePaths,
+  type RuntimePaths,
+} from '../../runtime-home';
+import { checkExecutionPolicy } from './policy';
+import { failedResult, hasShellOperator } from './utils';
+import { authorizeExecutionScope, approvalExecutionScopeKey } from './scope';
+import {
+  insertApproval,
+  readApproval,
+  readExecutionApprovalRow,
+} from './store';
+import { createApprovalResolutionNudge } from '../sessions';
+import {
+  requestApprovalInputSchema,
+  resolveApprovalInputSchema,
+  type ExecutionApprovalRecord,
+  type ExecutionApprovalStatus,
+} from './schemas';
+import * as v from 'valibot';
+
+export async function listExecutionApprovals(
+  paths = runtimePaths(),
+  options: { includeResolved?: boolean } = {},
+) {
+  await ensureRuntimeHome(paths);
+  const database = openDb(paths.neondeckDatabase, { readOnly: true });
+
+  try {
+    return {
+      ok: true,
+      action: 'execution_approvals_list',
+      changed: false,
+      approvals: database
+        .prepare(
+          `
+          SELECT *
+          FROM execution_approvals
+          ${options.includeResolved ? '' : "WHERE status = 'pending'"}
+          ORDER BY updated_at DESC, created_at DESC
+          LIMIT 100;
+        `,
+        )
+        .all()
+        .map(readExecutionApprovalRow),
+      fetchedAt: new Date().toISOString(),
+    };
+  } finally {
+    database.close();
+  }
+}
+
+export async function requestExecutionApproval(
+  rawInput: unknown,
+  paths = runtimePaths(),
+) {
+  await ensureRuntimeHome(paths);
+  const parsed = v.safeParse(requestApprovalInputSchema, rawInput);
+  if (!parsed.success) {
+    return failedResult(
+      'execution_request_approval',
+      `Invalid execution approval request: ${v.summarize(parsed.issues)}`,
+      ['command'],
+    );
+  }
+
+  const input = {
+    ...parsed.output,
+    sessionId:
+      nonEmpty(parsed.output.sessionId) ??
+      currentFlueExecutionContext()?.instanceId,
+  };
+  const policyCheck = await checkExecutionPolicy(
+    {
+      command: input.command,
+      backend: input.backend,
+      context: input.context ?? 'interactive',
+    },
+    paths,
+  );
+  const requestContextResult = await authorizeExecutionScope(
+    input.requestContext,
+    input,
+    policyCheck,
+    paths,
+  );
+  if (!requestContextResult.ok) return requestContextResult.result;
+
+  if (policyCheck.decision === 'deny') {
+    const record = insertApproval(paths, {
+      command: policyCheck.command,
+      backend: policyCheck.backend,
+      cwd: input.cwd,
+      context: policyCheck.context,
+      risk: policyCheck.risk,
+      policyDecision: policyCheck.decision,
+      status: 'blocked',
+      sessionId: input.sessionId,
+      requestContext: requestContextResult.requestContext,
+      error: policyCheck.reason,
+    });
+    return {
+      ok: false,
+      action: 'execution_request_approval',
+      changed: true,
+      message: policyCheck.reason,
+      requires: policyCheck.requires ?? [],
+      policyCheck,
+      approval: record,
+    };
+  }
+
+  if (policyCheck.decision === 'allow') {
+    return {
+      ok: true,
+      action: 'execution_request_approval',
+      changed: false,
+      message:
+        'Command is already preapproved by execution policy; no pending approval was created.',
+      policyCheck,
+    };
+  }
+
+  const record = insertApproval(paths, {
+    command: policyCheck.command,
+    backend: policyCheck.backend,
+    cwd: input.cwd,
+    context: policyCheck.context,
+    risk: policyCheck.risk,
+    policyDecision: policyCheck.decision,
+    status: 'pending',
+    sessionId: input.sessionId,
+    requestContext: requestContextResult.requestContext,
+  });
+  return {
+    ok: true,
+    action: 'execution_request_approval',
+    changed: true,
+    message: `Created pending approval for ${record.backend} command.`,
+    policyCheck,
+    approval: record,
+  };
+}
+
+export async function resolveExecutionApproval(
+  rawInput: unknown,
+  paths = runtimePaths(),
+) {
+  await ensureRuntimeHome(paths);
+  const parsed = v.safeParse(resolveApprovalInputSchema, rawInput);
+  if (!parsed.success) {
+    return failedResult(
+      'execution_resolve_approval',
+      `Invalid approval resolution: ${v.summarize(parsed.issues)}`,
+      ['id', 'decision'],
+    );
+  }
+
+  const input = parsed.output;
+  const existing = readApproval(paths, input.id);
+  if (!existing) {
+    return failedResult(
+      'execution_resolve_approval',
+      `Execution approval "${input.id}" was not found.`,
+      ['id'],
+    );
+  }
+
+  if (existing.status !== 'pending') {
+    return {
+      ok: false,
+      action: 'execution_resolve_approval',
+      changed: false,
+      message: `Execution approval "${input.id}" is already ${existing.status}.`,
+      approval: existing,
+    };
+  }
+
+  if (input.decision === 'allow-always') {
+    const preapproval = await addAlwaysPreapproval(existing, paths);
+    if (!preapproval.ok) return preapproval;
+  }
+
+  const now = new Date().toISOString();
+  const nextStatus: ExecutionApprovalStatus =
+    input.decision === 'deny' ? 'denied' : 'approved';
+  const result =
+    input.note === undefined ? existing.result : { note: input.note };
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    database
+      .prepare(
+        `
+        UPDATE execution_approvals
+        SET
+          status = ?,
+          approval_decision = ?,
+          approver_surface = ?,
+          result_json = ?,
+          resolved_at = ?,
+          updated_at = ?
+        WHERE id = ?;
+      `,
+      )
+      .run(
+        nextStatus,
+        input.decision,
+        input.approverSurface ?? 'api',
+        result === null ? null : JSON.stringify(asJsonValue(result)),
+        now,
+        now,
+        existing.id,
+      );
+  } finally {
+    database.close();
+  }
+
+  const approval = readApproval(paths, existing.id);
+  let nudgeErrors: string[] = [];
+  if (approval) {
+    const nudge = await createApprovalResolutionNudge(
+      {
+        family: 'execution',
+        sessionId: approval.sessionId,
+        approvalId: approval.id,
+        decision: nextStatus === 'approved' ? 'approved' : 'denied',
+        subject: approval.command,
+        retryInstruction: `Retry the command with approvalId ${approval.id}.`,
+      },
+      paths,
+    );
+    if (!nudge.ok) nudgeErrors = nudge.errors;
+  }
+  return {
+    ok: true,
+    action: 'execution_resolve_approval',
+    changed: true,
+    message:
+      input.decision === 'deny'
+        ? 'Denied execution approval.'
+        : `Approved execution ${input.decision.replace('-', ' ')}.`,
+    approval,
+    ...(nudgeErrors.length > 0
+      ? { requires: ['approvalNudge'], errors: nudgeErrors }
+      : {}),
+  };
+}
+
+function nonEmpty(value: string | undefined) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+async function addAlwaysPreapproval(
+  approval: ExecutionApprovalRecord,
+  paths: RuntimePaths,
+) {
+  if (approvalExecutionScopeKey(approval) !== null) {
+    return failedResult(
+      'execution_resolve_approval',
+      'Scoped exe.dev repo/worktree execution approvals cannot be promoted into global command preapprovals. Update execution policy explicitly if that broader trust boundary is intended.',
+      ['preapprovedCommands'],
+    );
+  }
+
+  if (hasShellOperator(approval.command)) {
+    return failedResult(
+      'execution_resolve_approval',
+      'Commands with shell operators cannot be added to preapproved policy.',
+      ['singleCommand'],
+    );
+  }
+
+  const config = await readRuntimeJson(paths.config, parseAppConfig);
+  const existing = config.execution?.preapprovedCommands ?? [];
+  if (
+    existing.some(
+      (item) =>
+        item.command === approval.command &&
+        (item.backends ?? ['local']).includes(approval.backend),
+    )
+  ) {
+    return { ok: true as const };
+  }
+
+  const id = `approved-${approval.backend.replace(/[^a-z0-9]+/gi, '-')}-${Date.now()}`;
+  const result = await updateExecutionPolicy(
+    {
+      preapprovedCommands: [
+        ...existing,
+        {
+          id,
+          command: approval.command,
+          match: 'exact',
+          backends: [approval.backend],
+          description: `Approved from execution request ${approval.id}.`,
+        },
+      ],
+    },
+    paths,
+  );
+  if (!result.ok) {
+    return {
+      ok: false as const,
+      action: 'execution_resolve_approval',
+      changed: false,
+      message: result.message,
+      requires: result.requires ?? ['preapprovedCommands'],
+      errors: result.errors,
+    };
+  }
+
+  return { ok: true as const };
+}

package/src/modules/execution/exedev/checkouts.ts

@@ -0,0 +1,356 @@
+import { defineAction } from '@flue/runtime';
+import * as v from 'valibot';
+import {
+  exedevTargetInputSchema,
+  remoteParent,
+  resolveExeDevCheckoutTarget,
+  shellArg,
+} from './context';
+import { runApprovedExecution } from '../run';
+import {
+  ensureRuntimeHome,
+  runtimePaths,
+  type RuntimePaths,
+} from '../../../runtime-home';
+
+const nonEmptyStringSchema = v.pipe(v.string(), v.minLength(1));
+const safeGitRefSchema = v.pipe(
+  nonEmptyStringSchema,
+  v.check((value) => {
+    return (
+      !value.startsWith('-') &&
+      !value.includes('\u0000') &&
+      !/[\s\\~^:?*[\]]/.test(value)
+    );
+  }, 'Expected a safe git ref or SHA.'),
+);
+const syncStepSchema = v.picklist([
+  'mkdir-parent',
+  'probe',
+  'clone',
+  'fetch',
+  'fetch-worktree-head',
+  'verify-ref',
+  'checkout',
+  'head',
+]);
+const syncInputSchema = v.object({
+  ...exedevTargetInputSchema(),
+  ref: v.optional(safeGitRefSchema),
+  fetch: v.optional(v.boolean()),
+  approvals: v.optional(v.record(syncStepSchema, nonEmptyStringSchema)),
+  context: v.optional(v.picklist(['interactive', 'unattended'])),
+  sessionId: v.optional(nonEmptyStringSchema),
+  timeoutMs: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
+  maxOutputBytes: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
+});
+const outputSchema = v.looseObject({
+  ok: v.boolean(),
+  action: v.string(),
+  changed: v.boolean(),
+  message: v.string(),
+});
+
+export const exedevCheckoutSyncAction = defineAction({
+  name: 'neondeck_exedev_checkout_sync',
+  description:
+    'Checkout or sync a declared repo or Neondeck-managed worktree on the configured existing exe.dev VM through the execution approval policy.',
+  input: syncInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return syncExeDevCheckout(input);
+  },
+});
+
+export const neondeckExeDevCheckoutActions = [exedevCheckoutSyncAction];
+
+type SyncDependencies = {
+  runExecution?: (
+    rawInput: unknown,
+    paths?: RuntimePaths,
+  ) => Promise<Record<string, unknown>>;
+};
+
+export async function syncExeDevCheckout(
+  rawInput: unknown,
+  paths: RuntimePaths = runtimePaths(),
+  dependencies: SyncDependencies = {},
+) {
+  await ensureRuntimeHome(paths);
+  const parsed = v.safeParse(syncInputSchema, rawInput);
+  if (!parsed.success) {
+    return failure(
+      `Invalid exe.dev checkout sync input: ${v.summarize(parsed.issues)}`,
+      ['repoId'],
+    );
+  }
+  const input = parsed.output;
+  if (!input.repoId && !input.worktreeId) {
+    return failure('A repoId or worktreeId is required.', ['repoId']);
+  }
+
+  try {
+    const target = await resolveExeDevCheckoutTarget(input, paths);
+    if (!target)
+      return failure('A repoId or worktreeId is required.', ['repoId']);
+    const runExecution = dependencies.runExecution ?? runApprovedExecution;
+    const ref = input.ref ?? checkoutRefForTarget(target);
+    const steps: unknown[] = [];
+    const runStep = async (
+      step: v.InferOutput<typeof syncStepSchema>,
+      command: string,
+    ) => {
+      const result = await runExecution(
+        {
+          command,
+          backend: 'exe.dev',
+          approvalId: input.approvals?.[step],
+          context: input.context ?? 'interactive',
+          sessionId: input.sessionId,
+          timeoutMs: input.timeoutMs,
+          maxOutputBytes: input.maxOutputBytes,
+          forwardEnv: false,
+          requestContext: {
+            action: 'exedev_checkout_sync',
+            step,
+            repoId: target.repo.id,
+            repoFullName: target.repoFullName,
+            worktreeId: target.worktree?.id ?? null,
+            remotePath: target.remotePath,
+          },
+        },
+        paths,
+      );
+      steps.push({
+        step,
+        command,
+        ok: Boolean(result.ok),
+        approvalId: approvalId(result),
+        message: stringField(result, 'message'),
+      });
+      return result;
+    };
+
+    const mkdir = await runStep(
+      'mkdir-parent',
+      `mkdir -p ${shellArg(remoteParent(target.remotePath))}`,
+    );
+    if (!mkdir.ok) return blocked('mkdir-parent', mkdir, target, steps);
+
+    const probe = await runStep(
+      'probe',
+      `git -C ${shellArg(target.remotePath)} rev-parse --is-inside-work-tree`,
+    );
+    if (!probe.ok && !executionFinished(probe)) {
+      return blocked('probe', probe, target, steps);
+    }
+    const exists = Boolean(probe.ok);
+    if (!exists) {
+      const clone = await runStep(
+        'clone',
+        `git clone ${shellArg(target.remoteUrl)} ${shellArg(target.remotePath)}`,
+      );
+      if (!clone.ok) return blocked('clone', clone, target, steps);
+    }
+
+    if (exists && input.fetch !== false) {
+      const fetch = await runStep(
+        'fetch',
+        `git -C ${shellArg(target.remotePath)} fetch --all --prune`,
+      );
+      if (!fetch.ok) return blocked('fetch', fetch, target, steps);
+    }
+
+    if (target.worktree && shouldFetchWorktreeHead(target)) {
+      const fetchHead = await runStep(
+        'fetch-worktree-head',
+        `git -C ${shellArg(target.remotePath)} fetch ${shellArg(
+          worktreeHeadRemoteUrl(target),
+        )} ${shellArg(target.worktree.headRef)}`,
+      );
+      if (!fetchHead.ok) {
+        return blocked('fetch-worktree-head', fetchHead, target, steps);
+      }
+    }
+
+    if (target.worktree?.headSha && !input.ref) {
+      const verifyRef = await runStep(
+        'verify-ref',
+        `git -C ${shellArg(target.remotePath)} cat-file -e ${shellArg(
+          `${target.worktree.headSha}^{commit}`,
+        )}`,
+      );
+      if (!verifyRef.ok) {
+        if (executionFinished(verifyRef)) {
+          return unreachableWorktreeHead(verifyRef, target, steps);
+        }
+        return blocked('verify-ref', verifyRef, target, steps);
+      }
+    }
+
+    const checkout = await runStep(
+      'checkout',
+      `git -C ${shellArg(target.remotePath)} checkout --detach ${shellArg(ref)}`,
+    );
+    if (!checkout.ok) return blocked('checkout', checkout, target, steps);
+
+    const head = await runStep(
+      'head',
+      `git -C ${shellArg(target.remotePath)} rev-parse HEAD`,
+    );
+    if (!head.ok) return blocked('head', head, target, steps);
+
+    return {
+      ok: true,
+      action: 'exedev_checkout_sync',
+      changed: !exists || input.fetch !== false,
+      message: `Synced exe.dev checkout for ${target.repoFullName}.`,
+      checkout: {
+        repoId: target.repo.id,
+        repoFullName: target.repoFullName,
+        worktreeId: target.worktree?.id ?? null,
+        remotePath: target.remotePath,
+        ref,
+        headSha: stdout(head).trim() || null,
+      },
+      steps,
+    };
+  } catch (error) {
+    return failure(error instanceof Error ? error.message : String(error), [
+      'exe.dev',
+    ]);
+  }
+}
+
+function blocked(
+  step: string,
+  result: Record<string, unknown>,
+  target: NonNullable<Awaited<ReturnType<typeof resolveExeDevCheckoutTarget>>>,
+  steps: unknown[],
+) {
+  return {
+    ok: false,
+    action: 'exedev_checkout_sync',
+    changed: true,
+    message: `exe.dev checkout sync stopped at ${step}: ${stringField(
+      result,
+      'message',
+    )}`,
+    requires: Array.isArray(result.requires) ? result.requires : ['approval'],
+    checkout: {
+      repoId: target.repo.id,
+      repoFullName: target.repoFullName,
+      worktreeId: target.worktree?.id ?? null,
+      remotePath: target.remotePath,
+    },
+    blockedStep: step,
+    execution: result,
+    steps,
+  };
+}
+
+function failure(message: string, requires: string[]) {
+  return {
+    ok: false,
+    action: 'exedev_checkout_sync',
+    changed: false,
+    message,
+    requires,
+  };
+}
+
+function shouldFetchWorktreeHead(
+  target: NonNullable<Awaited<ReturnType<typeof resolveExeDevCheckoutTarget>>>,
+) {
+  const worktree = target.worktree;
+  if (!worktree?.headOwner || !worktree.headName) return false;
+  return (
+    worktree.headOwner !== target.repo.github.owner ||
+    worktree.headName !== target.repo.github.name
+  );
+}
+
+function checkoutRefForTarget(
+  target: NonNullable<Awaited<ReturnType<typeof resolveExeDevCheckoutTarget>>>,
+) {
+  if (target.worktree) {
+    if (target.worktree.headSha) return target.worktree.headSha;
+    if (shouldFetchWorktreeHead(target)) return 'FETCH_HEAD';
+    return `origin/${target.worktree.headRef}`;
+  }
+  return `origin/${target.defaultRef}`;
+}
+
+function worktreeHeadRemoteUrl(
+  target: NonNullable<Awaited<ReturnType<typeof resolveExeDevCheckoutTarget>>>,
+) {
+  const worktree = target.worktree;
+  if (!worktree?.headOwner || !worktree.headName) return target.remoteUrl;
+  return `https://github.com/${worktree.headOwner}/${worktree.headName}.git`;
+}
+
+function unreachableWorktreeHead(
+  result: Record<string, unknown>,
+  target: NonNullable<Awaited<ReturnType<typeof resolveExeDevCheckoutTarget>>>,
+  steps: unknown[],
+) {
+  return {
+    ok: false,
+    action: 'exedev_checkout_sync',
+    changed: true,
+    message: `Worktree "${target.worktree?.id}" head SHA "${target.worktree?.headSha}" is not reachable on the exe.dev checkout after fetching GitHub refs. Push or transfer the local worktree commit before syncing to exe.dev.`,
+    requires: ['reachable-ref'],
+    checkout: {
+      repoId: target.repo.id,
+      repoFullName: target.repoFullName,
+      worktreeId: target.worktree?.id ?? null,
+      remotePath: target.remotePath,
+    },
+    blockedStep: 'verify-ref',
+    execution: result,
+    steps,
+  };
+}
+
+function executionFinished(result: unknown) {
+  const approval = objectField(result, 'approval');
+  if (
+    approval?.status === 'executed' ||
+    approval?.status === 'failed' ||
+    approval?.executedAt
+  ) {
+    return true;
+  }
+  const executionResult = objectField(result, 'result');
+  return typeof executionResult?.exitCode === 'number';
+}
+
+function approvalId(result: unknown) {
+  const approval = objectField(result, 'approval');
+  return typeof approval?.id === 'string' ? approval.id : null;
+}
+
+function stdout(result: unknown) {
+  const executionResult = objectField(result, 'result');
+  return typeof executionResult?.stdout === 'string'
+    ? executionResult.stdout
+    : '';
+}
+
+function stringField(value: unknown, key: string) {
+  const object = objectField(value, undefined);
+  const field = key && object ? object[key] : undefined;
+  return typeof field === 'string' ? field : '';
+}
+
+function objectField(value: unknown, key: string | undefined) {
+  const object =
+    value && typeof value === 'object'
+      ? (value as Record<string, unknown>)
+      : null;
+  if (!object || key === undefined) return object;
+  const field = object[key];
+  return field && typeof field === 'object'
+    ? (field as Record<string, unknown>)
+    : null;
+}