neondeck 1.0.0-beta.4

package/src/repo-edit/path-safety.ts

@@ -0,0 +1,294 @@
+import { lstat, realpath } from 'node:fs/promises';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import type { RepoConfig, RuntimePaths } from '../runtime-home';
+import {
+  ensureRuntimeHome,
+  parseRepoRegistry,
+  readRuntimeJson,
+  runtimePaths,
+} from '../runtime-home';
+import { readManagedWorktree } from '../modules/worktrees';
+import type { RepoEditError } from './schemas';
+
+export type RepoPathIntent = 'read' | 'write' | 'delete' | 'move';
+
+export type ResolvedRepoPath = {
+  repo: RepoConfig;
+  worktreeId?: string;
+  repoRoot: string;
+  relativePath: string;
+  fullPath: string;
+  exists: boolean;
+  sensitive: boolean;
+  generatedLike: boolean;
+};
+
+const deniedExactNames = new Set([
+  'id_rsa',
+  'id_ed25519',
+  'id_ecdsa',
+  'id_dsa',
+]);
+const deniedExtensions = new Set(['.pem', '.key', '.p12']);
+const sensitiveExactNames = new Set(['.env']);
+const sensitiveFragments = ['secret', 'secrets', 'token', 'tokens'];
+const generatedExtensions = new Set(['.lock']);
+const generatedNames = new Set([
+  'package-lock.json',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+  'bun.lock',
+  'bun.lockb',
+  'Cargo.lock',
+  'Gemfile.lock',
+  'poetry.lock',
+]);
+
+export class RepoPathPolicyError extends Error {
+  readonly code: RepoEditError['code'];
+  readonly path?: string;
+  readonly details?: unknown;
+
+  constructor(code: RepoEditError['code'], message: string, path?: string) {
+    super(message);
+    this.name = 'RepoPathPolicyError';
+    this.code = code;
+    this.path = path;
+  }
+}
+
+export async function resolveRepoPath(
+  input: {
+    repoId: string;
+    worktreeId?: string;
+    path: string;
+    intent?: RepoPathIntent;
+    createParentDirectories?: boolean;
+  },
+  paths: RuntimePaths = runtimePaths(),
+): Promise<ResolvedRepoPath> {
+  await ensureRuntimeHome(paths);
+  const registry = await readRuntimeJson(paths.repos, parseRepoRegistry);
+  const repo = registry.repos.find((item) => item.id === input.repoId);
+  if (!repo) {
+    throw new RepoPathPolicyError(
+      'REPO_NOT_FOUND',
+      `Repository "${input.repoId}" is not configured.`,
+    );
+  }
+
+  const relativePath = normalizeRepoRelativePath(input.path);
+  assertAllowedSegments(relativePath);
+
+  const worktree = input.worktreeId
+    ? await readManagedWorktree(input.worktreeId, repo.id, paths)
+    : undefined;
+  const repoRoot = await realpath(worktree?.localPath ?? repo.path);
+  const fullPath = resolve(repoRoot, relativePath);
+  if (!isInside(repoRoot, fullPath)) {
+    throw new RepoPathPolicyError(
+      'PATH_OUTSIDE_WORKSPACE',
+      `Path "${input.path}" resolves outside configured repo "${repo.id}".`,
+      input.path,
+    );
+  }
+
+  const existing = await lstat(fullPath).catch(() => undefined);
+  if (existing?.isSymbolicLink() && input.intent !== 'read') {
+    throw new RepoPathPolicyError(
+      'PATH_DENIED',
+      `Refusing to mutate symlink "${relativePath}".`,
+      relativePath,
+    );
+  }
+
+  if (existing) {
+    const target = await realpath(fullPath);
+    if (!isInside(repoRoot, target)) {
+      throw new RepoPathPolicyError(
+        'PATH_OUTSIDE_WORKSPACE',
+        `Path "${relativePath}" resolves outside configured repo "${repo.id}".`,
+        relativePath,
+      );
+    }
+  } else {
+    const parent = input.createParentDirectories
+      ? await nearestExistingAncestor(dirname(fullPath), repoRoot)
+      : await realpath(dirname(fullPath)).catch(() => undefined);
+    if (!parent || !isInside(repoRoot, parent)) {
+      throw new RepoPathPolicyError(
+        'PATH_OUTSIDE_WORKSPACE',
+        `Parent directory for "${relativePath}" is outside configured repo "${repo.id}" or does not exist.`,
+        relativePath,
+      );
+    }
+  }
+
+  return {
+    repo,
+    worktreeId: worktree?.id,
+    repoRoot,
+    relativePath,
+    fullPath,
+    exists: Boolean(existing),
+    sensitive: isSensitivePath(relativePath),
+    generatedLike: isGeneratedLike(relativePath),
+  };
+}
+
+async function nearestExistingAncestor(path: string, repoRoot: string) {
+  let current = path;
+  while (isInside(repoRoot, current)) {
+    const resolved = await realpath(current).catch(() => undefined);
+    if (resolved) return resolved;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return undefined;
+}
+
+export function normalizeRepoRelativePath(path: string) {
+  const trimmed = path.trim();
+  if (!trimmed) {
+    throw new RepoPathPolicyError('PATH_DENIED', 'Path must not be empty.');
+  }
+  if (trimmed === '.') {
+    return '.';
+  }
+  if (isAbsolute(trimmed)) {
+    throw new RepoPathPolicyError(
+      'PATH_OUTSIDE_WORKSPACE',
+      `Absolute paths are not allowed: ${path}`,
+      path,
+    );
+  }
+
+  const normalized = trimmed.replaceAll('\\', '/').replace(/^\.\/+/, '');
+  const parts = normalized.split('/').filter(Boolean);
+  if (parts.length === 0) {
+    throw new RepoPathPolicyError('PATH_DENIED', 'Path must not be empty.');
+  }
+  if (parts.some((part) => part === '..' || part === '.')) {
+    throw new RepoPathPolicyError(
+      'PATH_OUTSIDE_WORKSPACE',
+      `Path traversal is not allowed: ${path}`,
+      path,
+    );
+  }
+  return parts.join('/');
+}
+
+export function isInside(root: string, candidate: string) {
+  const rel = relative(root, candidate);
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+export function isSensitivePath(path: string) {
+  const parts = path.split('/');
+  const name = parts.at(-1) ?? path;
+  const lower = name.toLowerCase();
+  return (
+    sensitiveExactNames.has(name) ||
+    name.startsWith('.env.') ||
+    sensitiveFragments.some((fragment) => lower.includes(fragment))
+  );
+}
+
+export function isGeneratedLike(path: string) {
+  const name = path.split('/').at(-1) ?? path;
+  if (generatedNames.has(name)) return true;
+  return [...generatedExtensions].some((extension) => name.endsWith(extension));
+}
+
+function assertAllowedSegments(path: string) {
+  if (path === '.') return;
+  const parts = path.split('/');
+  if (parts.includes('.git') || parts.includes('.ssh')) {
+    throw new RepoPathPolicyError(
+      'PATH_DENIED',
+      `Path "${path}" is denied by workspace policy.`,
+      path,
+    );
+  }
+
+  const name = parts.at(-1) ?? '';
+  const lowerName = name.toLowerCase();
+  if (
+    deniedExactNames.has(name) ||
+    [...deniedExtensions].some((extension) => lowerName.endsWith(extension))
+  ) {
+    throw new RepoPathPolicyError(
+      'PATH_DENIED',
+      `Path "${path}" is denied by workspace policy.`,
+      path,
+    );
+  }
+}
+
+export function toRepoEditError(error: unknown): RepoEditError {
+  if (error instanceof RepoPathPolicyError) {
+    return {
+      code: error.code,
+      message: error.message,
+      path: error.path,
+      details: error.details,
+    };
+  }
+
+  if (
+    error &&
+    typeof error === 'object' &&
+    'code' in error &&
+    typeof (error as { code?: unknown }).code === 'string' &&
+    isRepoEditErrorCode((error as { code: string }).code)
+  ) {
+    const code = (error as { code: RepoEditError['code'] }).code;
+    return {
+      code,
+      message: error instanceof Error ? error.message : String(error),
+      path:
+        'path' in error &&
+        typeof (error as { path?: unknown }).path === 'string'
+          ? (error as { path: string }).path
+          : undefined,
+      details:
+        'details' in error
+          ? (error as { details?: unknown }).details
+          : undefined,
+    };
+  }
+
+  return {
+    code: 'IO_ERROR',
+    message: error instanceof Error ? error.message : String(error),
+  };
+}
+
+function isRepoEditErrorCode(value: string): value is RepoEditError['code'] {
+  return [
+    'INVALID_INPUT',
+    'REPO_NOT_FOUND',
+    'PATH_OUTSIDE_WORKSPACE',
+    'PATH_DENIED',
+    'FILE_NOT_FOUND',
+    'BINARY_FILE',
+    'FILE_TOO_LARGE',
+    'STALE_FILE',
+    'NO_MATCH',
+    'AMBIGUOUS_MATCH',
+    'LOW_CONFIDENCE',
+    'PATCH_PARSE_ERROR',
+    'PATCH_VALIDATE_ERROR',
+    'GIT_ERROR',
+    'WORKTREE_NOT_FOUND',
+    'WORKTREE_DELETED',
+    'WORKTREE_NOT_READY',
+    'WORKTREE_LOCKED',
+    'PATH_OUTSIDE_WORKTREE_ROOT',
+    'REPO_MISMATCH',
+    'CORRUPT_WORKTREE_ROW',
+    'WORKTREE_ERROR',
+    'IO_ERROR',
+  ].includes(value);
+}

package/src/repo-edit/schemas.ts

@@ -0,0 +1,220 @@
+import * as v from 'valibot';
+
+export const maxReadBytes = 256 * 1024;
+export const defaultReadLimit = 400;
+export const maxReadLimit = 2_000;
+export const maxSearchResults = 100;
+export const maxPatchBytes = 256 * 1024;
+
+export const nonEmptyStringSchema = v.pipe(v.string(), v.minLength(1));
+export const repoIdSchema = nonEmptyStringSchema;
+export const repoRelativePathSchema = v.pipe(
+  nonEmptyStringSchema,
+  v.check((value) => {
+    const trimmed = value.trim();
+    return (
+      trimmed === '.' ||
+      (!trimmed.startsWith('/') &&
+        !trimmed.startsWith('-') &&
+        !trimmed.split(/[\\/]/).includes('..'))
+    );
+  }, 'Expected a safe repo-relative path.'),
+);
+export const gitRefSchema = v.pipe(
+  nonEmptyStringSchema,
+  v.check((value) => {
+    return (
+      !value.startsWith('-') &&
+      !value.includes('\u0000') &&
+      !/[\s\\~^:?*[\]]/.test(value)
+    );
+  }, 'Expected a safe git ref name.'),
+);
+
+export const fileStampSchema = v.object({
+  mtimeMs: v.number(),
+  size: v.number(),
+  sha256: nonEmptyStringSchema,
+});
+
+export const repoReadInputSchema = v.object({
+  repoId: repoIdSchema,
+  worktreeId: v.optional(nonEmptyStringSchema),
+  path: repoRelativePathSchema,
+  sessionId: v.optional(nonEmptyStringSchema),
+  offset: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+  limit: v.optional(
+    v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(maxReadLimit)),
+  ),
+  includeLineNumbers: v.optional(v.boolean()),
+});
+
+export const repoSearchInputSchema = v.object({
+  repoId: repoIdSchema,
+  worktreeId: v.optional(nonEmptyStringSchema),
+  query: nonEmptyStringSchema,
+  globs: v.optional(v.array(repoRelativePathSchema)),
+  maxResults: v.optional(
+    v.pipe(
+      v.number(),
+      v.integer(),
+      v.minValue(1),
+      v.maxValue(maxSearchResults),
+    ),
+  ),
+  contextLines: v.optional(
+    v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(5)),
+  ),
+});
+
+export const repoWriteInputSchema = v.object({
+  repoId: repoIdSchema,
+  worktreeId: v.optional(nonEmptyStringSchema),
+  worktreeLockId: v.optional(nonEmptyStringSchema),
+  path: repoRelativePathSchema,
+  content: v.string(),
+  sessionId: v.optional(nonEmptyStringSchema),
+  createParentDirectories: v.optional(v.boolean()),
+  expectedStamp: v.optional(fileStampSchema),
+  reason: v.optional(v.string()),
+  dryRun: v.optional(v.boolean()),
+});
+
+export const repoReplaceInputSchema = v.object({
+  repoId: repoIdSchema,
+  worktreeId: v.optional(nonEmptyStringSchema),
+  worktreeLockId: v.optional(nonEmptyStringSchema),
+  path: repoRelativePathSchema,
+  oldString: nonEmptyStringSchema,
+  newString: v.string(),
+  sessionId: v.optional(nonEmptyStringSchema),
+  replaceAll: v.optional(v.boolean()),
+  expectedStamp: v.optional(fileStampSchema),
+  fuzzy: v.optional(v.picklist(['off', 'safe'])),
+  dryRun: v.optional(v.boolean()),
+  reason: v.optional(v.string()),
+});
+
+export const repoPatchInputSchema = v.object({
+  repoId: repoIdSchema,
+  worktreeId: v.optional(nonEmptyStringSchema),
+  worktreeLockId: v.optional(nonEmptyStringSchema),
+  patch: v.pipe(v.string(), v.minLength(1), v.maxLength(maxPatchBytes)),
+  sessionId: v.optional(nonEmptyStringSchema),
+  expectedStamps: v.optional(v.record(v.string(), fileStampSchema)),
+  dryRun: v.optional(v.boolean()),
+  reason: v.optional(v.string()),
+});
+
+export const repoDiffInputSchema = v.object({
+  repoId: repoIdSchema,
+  worktreeId: v.optional(nonEmptyStringSchema),
+  base: v.optional(gitRefSchema),
+  paths: v.optional(v.array(repoRelativePathSchema)),
+  includePatch: v.optional(v.boolean()),
+  maxPatchBytes: v.optional(
+    v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(maxPatchBytes)),
+  ),
+});
+
+export const repoStatusInputSchema = v.object({
+  repoId: repoIdSchema,
+  worktreeId: v.optional(nonEmptyStringSchema),
+});
+
+export const repoEditOutputSchema = v.looseObject({
+  ok: v.boolean(),
+  action: v.string(),
+  changed: v.boolean(),
+  message: v.string(),
+});
+
+export type FileStamp = v.InferOutput<typeof fileStampSchema>;
+export type RepoReadInput = v.InferOutput<typeof repoReadInputSchema>;
+export type RepoSearchInput = v.InferOutput<typeof repoSearchInputSchema>;
+export type RepoWriteInput = v.InferOutput<typeof repoWriteInputSchema>;
+export type RepoReplaceInput = v.InferOutput<typeof repoReplaceInputSchema>;
+export type RepoPatchInput = v.InferOutput<typeof repoPatchInputSchema>;
+export type RepoDiffInput = v.InferOutput<typeof repoDiffInputSchema>;
+export type RepoStatusInput = v.InferOutput<typeof repoStatusInputSchema>;
+
+export type RepoEditStatus = 'preview' | 'applied' | 'failed' | 'blocked';
+
+export type RepoEditErrorCode =
+  | 'INVALID_INPUT'
+  | 'REPO_NOT_FOUND'
+  | 'PATH_OUTSIDE_WORKSPACE'
+  | 'PATH_DENIED'
+  | 'FILE_NOT_FOUND'
+  | 'BINARY_FILE'
+  | 'FILE_TOO_LARGE'
+  | 'STALE_FILE'
+  | 'NO_MATCH'
+  | 'AMBIGUOUS_MATCH'
+  | 'LOW_CONFIDENCE'
+  | 'PATCH_PARSE_ERROR'
+  | 'PATCH_VALIDATE_ERROR'
+  | 'GIT_ERROR'
+  | 'WORKTREE_NOT_FOUND'
+  | 'WORKTREE_DELETED'
+  | 'WORKTREE_NOT_READY'
+  | 'WORKTREE_LOCKED'
+  | 'PATH_OUTSIDE_WORKTREE_ROOT'
+  | 'REPO_MISMATCH'
+  | 'CORRUPT_WORKTREE_ROW'
+  | 'WORKTREE_ERROR'
+  | 'IO_ERROR';
+
+export type RepoEditError = {
+  code: RepoEditErrorCode;
+  message: string;
+  path?: string;
+  details?: unknown;
+};
+
+export type DiffSummary = {
+  files: number;
+  additions: number;
+  deletions: number;
+  binaryFiles: number;
+};
+
+export type RepoEditResult = {
+  ok: boolean;
+  action: string;
+  changed: boolean;
+  message: string;
+  repoId?: string;
+  path?: string;
+  files?: unknown[];
+  diff?: string;
+  diffSummary?: DiffSummary;
+  dryRun?: boolean;
+  stale?: boolean | Array<{ path: string; reason: string }>;
+  eventId?: string;
+  errors?: string[];
+  error?: RepoEditError;
+  data?: unknown;
+};
+
+export function failedResult(
+  action: string,
+  message: string,
+  error: RepoEditError,
+): RepoEditResult {
+  return {
+    ok: false,
+    action,
+    changed: false,
+    message,
+    errors: [message],
+    error,
+  };
+}
+
+export function invalidInputResult(action: string, message: string) {
+  return failedResult(action, message, {
+    code: 'INVALID_INPUT',
+    message,
+  });
+}