feat(webdav): one OpenCoperLock.txt at the Drive ROOT (not per-space)

Corrects the previous per-space note. There is now a single, deletable
OpenCoperLock.txt at the personal Drive root - the place WebDAV/API let you
drop loose files that the web app intentionally does not show. It explains
that root files stay invisible in the app and to keep files inside spaces.

- Seeded once, lazily, on the first WebDAV root PROPFIND (new User flag
  rootReadmeSeeded, so deleting the note keeps it gone; a transient
  quota/storage error just retries next time).
- The ability to place files at the root is untouched.
- Reverted the space-creation seeding from the previous commit.

Author: softpython2884

apps/api/prisma/migrations/20260624130000_root_readme_seeded/migration.sql

@@ -0,0 +1,2 @@
+-- One-time flag: has the OpenCoperLock.txt readme been placed at the user's Drive root yet.
+ALTER TABLE "User" ADD COLUMN "rootReadmeSeeded" BOOLEAN NOT NULL DEFAULT false;

apps/api/prisma/schema.prisma

@@ -75,6 +75,10 @@ model User {
   // The build (git SHA) for which this user last dismissed the "What's new" dialog. null until
   // they first load the app; lets us show release notes exactly once per update, per user.
   lastSeenVersion String?
+  // Whether the one-time OpenCoperLock.txt readme has been placed at the Drive root. Seeded once
+  // (on first WebDAV root listing or registration); a flag, not an existence check, so deleting the
+  // file makes it stay gone.
+  rootReadmeSeeded Boolean @default(false)
   createdAt    DateTime @default(now())
   updatedAt    DateTime @updatedAt
 

apps/api/src/routes/folders.ts

@@ -1,52 +1,10 @@
 import type { FastifyPluginAsync } from 'fastify';
-import { Readable } from 'node:stream';
-import type { Folder } from '@prisma/client';
 import { createFolderSchema, randomToken, updateFolderSchema } from '@opencoperlock/shared';
 import { prisma } from '../db.js';
 import { parseOr400 } from '../lib/validate.js';
 import { toPublicFolder } from '../lib/serialize.js';
 import { hardDeleteFolder, trashFolder } from '../services/trash.js';
-import { storeUserFile } from '../services/upload.js';
 import { audit } from '../services/audit.js';
-import type { AppContext } from '../context.js';
-
-/** Bilingual welcome note dropped into the root of each new space. Users may delete it freely. */
-function welcomeText(space: Folder): string {
-  const mode = space.isPublic
-    ? 'Public / Open (plaintext, direct URLs)'
-    : 'Server-encrypted (AES-256-GCM at rest)';
-  return [
-    `OpenCoperLock - "${space.name}"`,
-    '='.repeat(40),
-    '',
-    `[FR] Ceci est un espace (${mode}). Les fichiers que vous deposez ICI apparaissent`,
-    'dans l\'application web OpenCoperLock. Bon a savoir : un fichier place a la RACINE du',
-    'Drive via WebDAV ou l\'API ne s\'affiche PAS dans l\'app web - rangez toujours vos',
-    'fichiers dans un espace comme celui-ci. Vous pouvez supprimer ce fichier sans risque.',
-    '',
-    `[EN] This is a space (${mode}). Files you drop HERE show up in the OpenCoperLock web`,
-    'app. Heads up: a file placed at the Drive ROOT over WebDAV or the API does NOT appear',
-    'in the web app - always keep your files inside a space like this one. You can delete',
-    'this file safely.',
-    '',
-  ].join('\n');
-}
-
-/** Best-effort: put an OpenCoperLock.txt in a brand-new space's root. Never fails folder creation. */
-async function seedWelcomeFile(ctx: AppContext, ownerId: string, space: Folder): Promise<void> {
-  try {
-    await storeUserFile(ctx, {
-      ownerId,
-      folderId: space.id,
-      stream: Readable.from([Buffer.from(welcomeText(space), 'utf8')]),
-      filename: 'OpenCoperLock.txt',
-      mimetype: 'text/plain',
-      public: space.isPublic,
-    });
-  } catch {
-    /* quota exhausted, storage hiccup, etc. - the space is still created. */
-  }
-}
 
 /** Collect a folder's id plus all descendant ids (breadth-first), scoped to one owner's personal
  *  Drive (Shared-Space folders carry a spaceId and are handled by the /spaces routes). */
@@ -112,9 +70,6 @@ export const folderRoutes: FastifyPluginAsync = async (app) => {
         },
       });
       await audit(req, 'folder.create', { target: folder.id });
-      // A brand-new top-level space (not a subfolder, not a blind ZK vault) gets a short readme in
-      // its root explaining how spaces work. Best-effort and deletable.
-      if (!body.parentId && !isZk) await seedWelcomeFile(app.ctx, req.user!.id, folder);
       return reply.code(201).send({ folder: toPublicFolder(folder) });
     } catch {
       return reply.code(409).send({ error: 'A folder with that name already exists here' });

apps/api/src/routes/webdav.ts

@@ -20,6 +20,7 @@ import { storeUserFile, QuotaExhaustedError } from '../services/upload.js';
 import { FileTooLargeError, InfectedFileError } from '../services/ingest.js';
 import { trashFile, trashFolder } from '../services/trash.js';
 import { remainingAllowance } from '../services/quota.js';
+import { ensureRootReadme } from '../services/welcome.js';
 
 const PREFIX = '/dav';
 const READ_METHODS = new Set(['GET', 'HEAD', 'OPTIONS', 'PROPFIND']);
@@ -186,6 +187,9 @@ export const webdavRoutes: FastifyPluginAsync = async (app) => {
 
     if (method === 'PROPFIND') {
       if (node.type === 'invalid' || node.type === 'missing') return reply.code(404).send();
+      // First time the root is browsed, drop a one-time OpenCoperLock.txt there (before we list, so
+      // it shows in this very response). Deleting it keeps it gone.
+      if (node.type === 'root') await ensureRootReadme(app.ctx, ownerId);
       const depth = String(req.headers.depth ?? '1');
       const parts: string[] = [];
       // Report the account quota on the queried collection so the mount shows the right size.

apps/api/src/services/welcome.ts

@@ -0,0 +1,50 @@
+import { Readable } from 'node:stream';
+import { prisma } from '../db.js';
+import { storeUserFile } from './upload.js';
+import type { AppContext } from '../context.js';
+
+/** The one-time note placed at the Drive ROOT (folderId = null). It's reachable over WebDAV / the
+ *  API, where you *can* drop loose files at the root - unlike the web app, which only shows spaces
+ *  (top-level folders). Kept ASCII so it reads cleanly in any editor. */
+const ROOT_README = [
+  'OpenCoperLock - Drive root',
+  '='.repeat(40),
+  '',
+  '[FR] Vous etes a la RACINE de votre Drive (accessible via WebDAV et l\'API).',
+  'Les dossiers que vous voyez ici sont vos ESPACES. Vous pouvez deposer des fichiers',
+  'directement a cette racine (comme ce .txt), MAIS ces fichiers-la ne s\'affichent PAS',
+  'dans l\'application web OpenCoperLock - seuls les espaces (dossiers) y apparaissent.',
+  'Pour retrouver vos fichiers dans l\'app, rangez-les dans un espace. Vous pouvez',
+  'supprimer ce fichier sans risque (il ne sera pas recree).',
+  '',
+  '[EN] You are at the ROOT of your Drive (reachable over WebDAV and the API).',
+  'The folders you see here are your SPACES. You can drop files directly at this root',
+  '(like this .txt), BUT those root files do NOT show in the OpenCoperLock web app -',
+  'only spaces (folders) appear there. To find your files in the app, keep them inside',
+  'a space. You can delete this file safely (it will not be recreated).',
+  '',
+].join('\n');
+
+/** Place OpenCoperLock.txt at the user's Drive root exactly once. Idempotent and best-effort: it
+ *  never throws, and the "seeded" flag (not a file-existence check) means a user who deletes the
+ *  note keeps it gone. */
+export async function ensureRootReadme(ctx: AppContext, ownerId: string): Promise<void> {
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: ownerId },
+      select: { rootReadmeSeeded: true },
+    });
+    if (!user || user.rootReadmeSeeded) return;
+    await storeUserFile(ctx, {
+      ownerId,
+      folderId: null,
+      stream: Readable.from([Buffer.from(ROOT_README, 'utf8')]),
+      filename: 'OpenCoperLock.txt',
+      mimetype: 'text/plain',
+    });
+    // Only mark as seeded once the write succeeds, so a transient quota/storage error retries later.
+    await prisma.user.update({ where: { id: ownerId }, data: { rootReadmeSeeded: true } });
+  } catch {
+    /* quota exhausted, storage hiccup, race - harmless; we'll try again next time. */
+  }
+}