Add tests for ensureUserWritable and file permission handling

Add unit tests (file-permissions.test.ts) covering:
- ensureUserWritable fixes read-only files
- ensureUserWritable is no-op for already-writable files
- Simulated Nix/deb scenario (copyFile from read-only source)

Extend create smoke test to verify all output files are user-writable.
Extract withTempDir() helper to tests/utils.ts for reuse. Permission
tests are skipped on Windows where chmod is not supported.

Author: cderv

tests/smoke/create/create.test.ts

@@ -7,6 +7,7 @@
 
 import { execProcess } from "../../../src/core/process.ts";
 import { join } from "../../../src/deno_ral/path.ts";
+import { walkSync } from "../../../src/deno_ral/fs.ts";
 import { CreateResult } from "../../../src/command/create/cmd-types.ts";
 import { assert } from "testing/asserts";
 import { quartoDevCmd } from "../../utils.ts";
@@ -61,6 +62,27 @@ for (const type of Object.keys(kCreateTypes)) {
         assert(process.success, process.stderr);
       });
 
+      // Verify all created files are user-writable.
+      // NOTE: In dev environments, resource files are already writable (0o644),
+      // so this test passes even without ensureUserWritable. It guards against
+      // regressions; the unit test in file-permissions.test.ts covers the
+      // read-only → writable transition directly.
+      await t.step({
+        name: `> check writable ${type} ${template}`,
+        ignore: Deno.build.os === "windows",
+        fn: () => {
+          for (const entry of walkSync(artifactPath)) {
+            if (entry.isFile) {
+              const stat = Deno.statSync(entry.path);
+              assert(
+                stat.mode !== null && (stat.mode! & 0o200) !== 0,
+                `File ${entry.path} is not user-writable (mode: ${stat.mode?.toString(8)})`,
+              );
+            }
+          }
+        },
+      });
+
       // Render the artifact
       await t.step(`> render ${type} ${template}`, async () => {
         const path = result!.path;

tests/unit/file-permissions.test.ts

@@ -0,0 +1,81 @@
+/*
+ * file-permissions.test.ts
+ *
+ * Copyright (C) 2020-2026 Posit Software, PBC
+ */
+
+import { unitTest } from "../test.ts";
+import { withTempDir } from "../utils.ts";
+import { assert, assertEquals } from "testing/asserts";
+import { join } from "../../src/deno_ral/path.ts";
+import { isWindows } from "../../src/deno_ral/platform.ts";
+import {
+  ensureUserWritable,
+  safeModeFromFile,
+} from "../../src/deno_ral/fs.ts";
+
+function writeFile(dir: string, name: string, content: string, mode: number): string {
+  const path = join(dir, name);
+  Deno.writeTextFileSync(path, content);
+  Deno.chmodSync(path, mode);
+  return path;
+}
+
+unitTest(
+  "file-permissions - ensureUserWritable fixes read-only files",
+  async () => withTempDir((dir) => {
+    const file = writeFile(dir, "readonly.txt", "test content", 0o444);
+
+    const modeBefore = safeModeFromFile(file);
+    assert(modeBefore !== undefined);
+    assert((modeBefore! & 0o200) === 0, "File should be read-only before fix");
+
+    ensureUserWritable(file);
+
+    assertEquals(safeModeFromFile(file), 0o644,
+      "Mode should be exactly 0o644 (0o444 | 0o200) — only user write bit added");
+  }),
+  { ignore: isWindows },
+);
+
+unitTest(
+  "file-permissions - ensureUserWritable leaves writable files unchanged",
+  async () => withTempDir((dir) => {
+    const file = writeFile(dir, "writable.txt", "test content", 0o644);
+    const modeBefore = safeModeFromFile(file);
+    assert(modeBefore !== undefined, "Mode should be readable");
+
+    ensureUserWritable(file);
+
+    assertEquals(safeModeFromFile(file), modeBefore,
+      "Mode should be unchanged for already-writable file");
+  }),
+  { ignore: isWindows },
+);
+
+// Simulates the Nix/deb scenario: Deno.copyFileSync from a read-only source
+// preserves the read-only mode on the copy. ensureUserWritable must fix it.
+unitTest(
+  "file-permissions - copyFileSync from read-only source then ensureUserWritable",
+  async () => withTempDir((dir) => {
+    const src = writeFile(dir, "source.lua", "-- filter code", 0o444);
+
+    // Copy it (this is what quarto create does internally)
+    const dest = join(dir, "dest.lua");
+    Deno.copyFileSync(src, dest);
+
+    // Without the fix, dest inherits 0o444 from src
+    const modeBefore = safeModeFromFile(dest);
+    assert(modeBefore !== undefined);
+    assert((modeBefore! & 0o200) === 0, "Copied file should inherit read-only mode from source");
+
+    // Make source writable so cleanup succeeds
+    Deno.chmodSync(src, 0o644);
+
+    ensureUserWritable(dest);
+
+    assertEquals(safeModeFromFile(dest), 0o644,
+      "Copied file should be user-writable after ensureUserWritable");
+  }),
+  { ignore: isWindows },
+);

tests/utils.ts

@@ -20,6 +20,18 @@ export function inTempDirectory(fn: (dir: string) => unknown): unknown {
   return fn(dir);
 }
 
+export async function withTempDir<T>(
+  fn: (dir: string) => T | Promise<T>,
+  prefix = "quarto-test",
+): Promise<T> {
+  const dir = Deno.makeTempDirSync({ prefix });
+  try {
+    return await fn(dir);
+  } finally {
+    Deno.removeSync(dir, { recursive: true });
+  }
+}
+
 // Find a _quarto.yaml file in the directory hierarchy of the input file
 export function findProjectDir(input: string, until?: RegExp | undefined): string | undefined {
   let dir = dirname(input);