aicodeman 1.4.1 → 1.5.0

package/dist/web/routes/case-routes.js

@@ -14,7 +14,8 @@ import { CreateCaseSchema, LinkCaseSchema, CaseOrderSchema, RemoteCaseLinkSchema
 import { exportDockerCase, importDockerBundle, listDockerExports, exportBundleName } from '../../docker-export.js';
 import { generateClaudeMd } from '../../templates/claude-md.js';
 import { writeHooksConfig } from '../../hooks-config.js';
-import { CASES_DIR, SETTINGS_PATH, validatePathWithinBase, parseBody, readJsonConfig } from '../route-helpers.js';
+import { canAccessOwned, getAuthUser, isAdmin, isWorkingDirAllowed, ownerFor, resolveCasesDir, SETTINGS_PATH, validatePathWithinBase, parseBody, readJsonConfig, } from '../route-helpers.js';
+import { isMultiUserMode } from '../../config/multiuser.js';
 import { SseEvent } from '../sse-events.js';
 import { dataPath, getDataDir } from '../../config/instance.js';
 import { checkDockerAvailable, checkDockerImagePresent, checkDockerTmuxAvailable, ensureAgentBaseImage, DEFAULT_AGENT_IMAGE, dockerContainerName, dockerDisplayPath, readDockerCases, readDockerHosts, toSessionDocker, writeDockerCases, writeDockerHosts, } from '../../docker-hosts.js';
@@ -40,12 +41,17 @@ const APP_VERSION = (() => {
 async function readLinkedCases() {
     return readJsonConfig(LINKED_CASES_FILE, 'linked cases', {});
 }
-/** Resolve a case name to its directory path, checking linked cases first, then CASES_DIR. */
-async function resolveCasePath(name) {
+/**
+ * Resolve a case name to its directory path, checking linked cases first, then the
+ * user's case space (per-user in multi-user mode, the shared CASES_DIR otherwise).
+ */
+async function resolveCasePath(name, user) {
     const linkedCases = await readLinkedCases();
-    if (linkedCases[name])
+    // Linked cases carry no owner (legacy/admin-only registry): a non-admin must not
+    // resolve arbitrary linked paths by name in multi-user mode (path-escape guard).
+    if (linkedCases[name] && (!isMultiUserMode() || user?.role === 'admin'))
         return linkedCases[name];
-    return join(CASES_DIR, name);
+    return join(resolveCasesDir(user), name);
 }
 /**
  * Gate a docker case on its base image, AUTO-BUILDING the default image on first
@@ -86,46 +92,54 @@ export function registerCaseRoutes(app, ctx) {
     // Case CRUD (list, create, link, detail, fix-plan)
     // ═══════════════════════════════════════════════════════════════
     // ========== List Cases ==========
-    app.get('/api/cases', async () => {
+    app.get('/api/cases', async (req) => {
         const cases = [];
-        // Get cases from CASES_DIR
+        const user = getAuthUser(req);
+        const admin = isAdmin(req);
+        // Non-admins enumerate their OWN case space; admins see the shared CASES_DIR.
+        const listBase = resolveCasesDir(user);
+        // Get cases from the user's (or shared) cases dir
         try {
-            const entries = await fs.readdir(CASES_DIR, { withFileTypes: true });
+            const entries = await fs.readdir(listBase, { withFileTypes: true });
             for (const e of entries) {
                 if (e.isDirectory() && SAFE_CASE_NAME.test(e.name)) {
                     cases.push({
                         name: e.name,
-                        path: join(CASES_DIR, e.name),
-                        hasClaudeMd: existsSync(join(CASES_DIR, e.name, 'CLAUDE.md')),
+                        path: join(listBase, e.name),
+                        hasClaudeMd: existsSync(join(listBase, e.name, 'CLAUDE.md')),
                         location: 'local',
                     });
                 }
             }
         }
         catch {
-            // CASES_DIR may not exist yet
+            // dir may not exist yet
         }
-        // Get linked cases
+        // Linked cases (v1 registry has no owner) are admin-only in multi-user mode.
         const linkedCases = await readLinkedCases();
         const existingNames = new Set(cases.map((c) => c.name));
-        for (const [name, path] of Object.entries(linkedCases)) {
-            if (!existingNames.has(name) && SAFE_CASE_NAME.test(name) && existsSync(path)) {
-                cases.push({
-                    name,
-                    path,
-                    hasClaudeMd: existsSync(join(path, 'CLAUDE.md')),
-                    linked: true,
-                    location: 'linked-local',
-                });
+        if (admin) {
+            for (const [name, path] of Object.entries(linkedCases)) {
+                if (!existingNames.has(name) && SAFE_CASE_NAME.test(name) && existsSync(path)) {
+                    cases.push({
+                        name,
+                        path,
+                        hasClaudeMd: existsSync(join(path, 'CLAUDE.md')),
+                        linked: true,
+                        location: 'linked-local',
+                    });
+                }
             }
         }
-        // Get remote cases
+        // Get remote cases (owner-scoped; legacy no-owner = admin-only)
         const remoteHosts = await readRemoteHosts(CODEMAN_CONFIG_DIR);
         const remoteHostMap = new Map(remoteHosts.map((host) => [host.id, host]));
         for (const remoteCase of await readRemoteCases(CODEMAN_CONFIG_DIR)) {
             const host = remoteHostMap.get(remoteCase.hostId);
             if (!host || !SAFE_CASE_NAME.test(remoteCase.name))
                 continue;
+            if (!admin && !canAccessOwned(user, remoteCase.owner))
+                continue;
             existingNames.add(remoteCase.name);
             const remoteCaseInfo = {
                 name: remoteCase.name,
@@ -154,6 +168,8 @@ export function registerCaseRoutes(app, ctx) {
             const host = dockerHostMap.get(dockerCase.hostId);
             if (!host || !SAFE_CASE_NAME.test(dockerCase.name))
                 continue;
+            if (!admin && !canAccessOwned(user, dockerCase.owner))
+                continue;
             existingNames.add(dockerCase.name);
             const container = dockerCase.container ?? dockerContainerName(dockerCase.name);
             const dockerCaseInfo = {
@@ -192,7 +208,7 @@ export function registerCaseRoutes(app, ctx) {
     });
     app.post('/api/cases', async (req) => {
         const { name, description } = parseBody(CreateCaseSchema, req.body);
-        const casePath = validatePathWithinBase(name, CASES_DIR);
+        const casePath = validatePathWithinBase(name, resolveCasesDir(getAuthUser(req)));
         if (!casePath) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case path');
         }
@@ -215,8 +231,17 @@ export function registerCaseRoutes(app, ctx) {
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, getErrorMessage(err));
         }
     });
-    app.get('/api/remote-hosts', async () => readRemoteHosts(CODEMAN_CONFIG_DIR));
-    app.post('/api/remote-hosts', async (req) => {
+    // Hosts are machine-level infra config (ssh users/identity paths): non-admins get an
+    // empty list in multi-user mode, matching the admin-only write side. No-op otherwise.
+    app.get('/api/remote-hosts', async (req) => isMultiUserMode() && !isAdmin(req) ? [] : readRemoteHosts(CODEMAN_CONFIG_DIR));
+    // Hosts are machine-level resources: only admins may define them in multi-user mode.
+    const adminOnly = (req, reply) => isAdmin(req)
+        ? null
+        : (reply.code(403), createErrorResponse(ApiErrorCode.FORBIDDEN, 'Admin only in multi-user mode'));
+    app.post('/api/remote-hosts', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const host = parseBody(RemoteHostSchema, req.body);
         const hosts = await readRemoteHosts(CODEMAN_CONFIG_DIR);
         if (hosts.some((item) => item.id === host.id)) {
@@ -225,7 +250,10 @@ export function registerCaseRoutes(app, ctx) {
         await writeRemoteHosts(CODEMAN_CONFIG_DIR, [...hosts, host]);
         return { success: true, data: { host } };
     });
-    app.put('/api/remote-hosts/:id', async (req) => {
+    app.put('/api/remote-hosts/:id', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { id } = req.params;
         const host = parseBody(RemoteHostSchema, { ...req.body, id });
         const hosts = await readRemoteHosts(CODEMAN_CONFIG_DIR);
@@ -237,7 +265,10 @@ export function registerCaseRoutes(app, ctx) {
         await writeRemoteHosts(CODEMAN_CONFIG_DIR, next);
         return { success: true, data: { host } };
     });
-    app.delete('/api/remote-hosts/:id', async (req) => {
+    app.delete('/api/remote-hosts/:id', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { id } = req.params;
         const cases = await readRemoteCases(CODEMAN_CONFIG_DIR);
         if (cases.some((item) => item.hostId === id)) {
@@ -248,7 +279,7 @@ export function registerCaseRoutes(app, ctx) {
         return { success: true, data: { id } };
     });
     app.post('/api/cases/remote-link', async (req) => {
-        const remoteCase = { ...parseBody(RemoteCaseLinkSchema, req.body), type: 'remote' };
+        const remoteCase = { ...parseBody(RemoteCaseLinkSchema, req.body), type: 'remote', owner: ownerFor(req) };
         const hosts = await readRemoteHosts(CODEMAN_CONFIG_DIR);
         const host = hosts.find((item) => item.id === remoteCase.hostId);
         if (!host)
@@ -257,7 +288,7 @@ export function registerCaseRoutes(app, ctx) {
         const remoteCases = await readRemoteCases(CODEMAN_CONFIG_DIR);
         if (remoteCases.some((item) => item.name === remoteCase.name) ||
             linkedCases[remoteCase.name] ||
-            existsSync(join(CASES_DIR, remoteCase.name))) {
+            existsSync(join(resolveCasesDir(getAuthUser(req)), remoteCase.name))) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
         }
         // Courtesy validation: tmux is a hard prerequisite for durable remote sessions.
@@ -272,8 +303,13 @@ export function registerCaseRoutes(app, ctx) {
         return { success: true, data: { case: remoteCase } };
     });
     // ========== Docker hosts + docker cases (COD-Docker) ==========
-    app.get('/api/docker-hosts', async () => readDockerHosts(CODEMAN_CONFIG_DIR));
-    app.post('/api/docker-hosts', async (req) => {
+    // Hosts are machine-level infra config (images/mounts/env): non-admins get an empty
+    // list in multi-user mode, matching the admin-only write side. No-op otherwise.
+    app.get('/api/docker-hosts', async (req) => isMultiUserMode() && !isAdmin(req) ? [] : readDockerHosts(CODEMAN_CONFIG_DIR));
+    app.post('/api/docker-hosts', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const host = parseBody(DockerHostSchema, req.body);
         const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
         if (hosts.some((item) => item.id === host.id)) {
@@ -282,7 +318,10 @@ export function registerCaseRoutes(app, ctx) {
         await writeDockerHosts(CODEMAN_CONFIG_DIR, [...hosts, host]);
         return { success: true, data: { host } };
     });
-    app.put('/api/docker-hosts/:id', async (req) => {
+    app.put('/api/docker-hosts/:id', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { id } = req.params;
         const host = parseBody(DockerHostSchema, { ...req.body, id });
         const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
@@ -294,7 +333,10 @@ export function registerCaseRoutes(app, ctx) {
         await writeDockerHosts(CODEMAN_CONFIG_DIR, next);
         return { success: true, data: { host } };
     });
-    app.delete('/api/docker-hosts/:id', async (req) => {
+    app.delete('/api/docker-hosts/:id', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { id } = req.params;
         const cases = await readDockerCases(CODEMAN_CONFIG_DIR);
         if (cases.some((item) => item.hostId === id)) {
@@ -305,7 +347,11 @@ export function registerCaseRoutes(app, ctx) {
         return { success: true, data: { id } };
     });
     app.post('/api/cases/docker-link', async (req) => {
-        const dockerCase = { ...parseBody(DockerCaseLinkSchema, req.body), type: 'docker' };
+        const dockerCase = {
+            ...parseBody(DockerCaseLinkSchema, req.body),
+            type: 'docker',
+            owner: ownerFor(req),
+        };
         const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
         const host = hosts.find((item) => item.id === dockerCase.hostId);
         if (!host)
@@ -314,9 +360,14 @@ export function registerCaseRoutes(app, ctx) {
         const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
         if (dockerCases.some((item) => item.name === dockerCase.name) ||
             linkedCases[dockerCase.name] ||
-            existsSync(join(CASES_DIR, dockerCase.name))) {
+            existsSync(join(resolveCasesDir(getAuthUser(req)), dockerCase.name))) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
         }
+        // Confine the bind-mounted workspace to the caller's own space BEFORE creating it
+        // (also removes the arbitrary-dir-creation primitive). No-op for admins/single-user.
+        if (!isWorkingDirAllowed(getAuthUser(req), dockerCase.hostWorkspacePath)) {
+            return createErrorResponse(ApiErrorCode.FORBIDDEN, 'hostWorkspacePath is outside your workspace');
+        }
         // The workspace is a REAL host directory (bind-mounted into the container), so
         // create it now if missing. Scaffolding (.claude/settings.local.json + CLAUDE.md)
         // is written by quick-start on first launch, matching local-case behaviour.
@@ -361,7 +412,7 @@ export function registerCaseRoutes(app, ctx) {
     app.post('/api/cases/docker-quickcreate', async (req) => {
         const body = parseBody(DockerQuickCreateSchema, req.body);
         const { name, description } = body;
-        const casePath = validatePathWithinBase(name, CASES_DIR);
+        const casePath = validatePathWithinBase(name, resolveCasesDir(getAuthUser(req)));
         if (!casePath)
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case path');
         // Collision across every case kind.
@@ -417,7 +468,13 @@ export function registerCaseRoutes(app, ctx) {
         if (!availability.ok) {
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, availability.error || 'docker daemon is not available');
         }
-        const dockerCase = { name, type: 'docker', hostId: host.id, hostWorkspacePath: casePath };
+        const dockerCase = {
+            name,
+            type: 'docker',
+            hostId: host.id,
+            hostWorkspacePath: casePath,
+            owner: ownerFor(req),
+        };
         const imageGate = await ensureCaseImage(ctx.broadcast, toSessionDocker(host, dockerCase), name);
         if (!imageGate.ok) {
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, imageGate.error);
@@ -525,9 +582,14 @@ export function registerCaseRoutes(app, ctx) {
         const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
         if (dockerCases.some((item) => item.name === newCaseName) ||
             linkedCases[newCaseName] ||
-            existsSync(join(CASES_DIR, newCaseName))) {
+            existsSync(join(resolveCasesDir(getAuthUser(req)), newCaseName))) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
         }
+        // Import extracts a tar into destWorkspacePath (later becomes Session.workingDir):
+        // confine it to the caller's own space. No-op for admins/single-user.
+        if (!isWorkingDirAllowed(getAuthUser(req), destWorkspacePath)) {
+            return createErrorResponse(ApiErrorCode.FORBIDDEN, 'destWorkspacePath is outside your workspace');
+        }
         const timestamp = Date.now();
         let result;
         try {
@@ -560,13 +622,19 @@ export function registerCaseRoutes(app, ctx) {
             hostId,
             hostWorkspacePath: destWorkspacePath,
             containerWorkdir: result.manifest.containerWorkdir,
+            owner: ownerFor(req),
         };
         await writeDockerCases(CODEMAN_CONFIG_DIR, [...dockerCases, newCase]);
         ctx.broadcast(SseEvent.DockerImportComplete, { name: newCaseName, path: destWorkspacePath, type: 'docker' });
         return { success: true, data: { case: newCase } };
     });
     // Link an existing folder as a case
-    app.post('/api/cases/link', async (req) => {
+    app.post('/api/cases/link', async (req, reply) => {
+        // Linking writes an arbitrary absolute path into the shared ownerless registry:
+        // admin-only in multi-user mode (mirrors host CRUD + the admin-only GET listing).
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { name, path: folderPath } = parseBody(LinkCaseSchema, req.body, 'Invalid request body');
         // Expand ~ to home directory
         const expandedPath = folderPath.startsWith('~') ? join(homedir(), folderPath.slice(1)) : folderPath;
@@ -575,7 +643,7 @@ export function registerCaseRoutes(app, ctx) {
             return createErrorResponse(ApiErrorCode.NOT_FOUND, `Folder not found: ${expandedPath}`);
         }
         // Check if case name already exists in CASES_DIR
-        const casePath = join(CASES_DIR, name);
+        const casePath = join(resolveCasesDir(getAuthUser(req)), name);
         if (existsSync(casePath)) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'A case with this name already exists in codeman-cases.');
         }
@@ -603,19 +671,23 @@ export function registerCaseRoutes(app, ctx) {
     // ========== Delete / Unlink Case ==========
     app.delete('/api/cases/:name', async (req) => {
         const { name } = req.params;
-        if (!validatePathWithinBase(name, CASES_DIR)) {
+        const user = getAuthUser(req);
+        if (!validatePathWithinBase(name, resolveCasesDir(user))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
+        // Fold ownership INTO the match (don't early-return): a non-owned same-named remote/
+        // docker case is skipped so control falls through to the caller's own local delete.
+        // canAccessOwned is all-true for admins/single-user, so flag-OFF stays byte-identical.
         const remoteCases = await readRemoteCases(CODEMAN_CONFIG_DIR);
-        if (remoteCases.some((item) => item.name === name)) {
-            await writeRemoteCases(CODEMAN_CONFIG_DIR, remoteCases.filter((item) => item.name !== name));
+        if (remoteCases.some((item) => item.name === name && canAccessOwned(user, item.owner))) {
+            await writeRemoteCases(CODEMAN_CONFIG_DIR, remoteCases.filter((item) => !(item.name === name && canAccessOwned(user, item.owner))));
             ctx.broadcast(SseEvent.CaseDeleted, { name, type: 'remote-unlinked' });
             return { success: true, data: { name } };
         }
         const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
-        const dockerCase = dockerCases.find((item) => item.name === name);
+        const dockerCase = dockerCases.find((item) => item.name === name && canAccessOwned(user, item.owner));
         if (dockerCase) {
-            await writeDockerCases(CODEMAN_CONFIG_DIR, dockerCases.filter((item) => item.name !== name));
+            await writeDockerCases(CODEMAN_CONFIG_DIR, dockerCases.filter((item) => item !== dockerCase));
             // Best-effort `docker rm -f` the per-case container (case-delete is the
             // explicit teardown that removes it; the bind-mounted workspace survives).
             const host = (await readDockerHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === dockerCase.hostId);
@@ -635,9 +707,11 @@ export function registerCaseRoutes(app, ctx) {
             ctx.broadcast(SseEvent.CaseDeleted, { name, type: 'docker-unlinked' });
             return { success: true, data: { name } };
         }
-        // Check linked cases first — unlink only, don't delete the actual directory
+        // Check linked cases first — unlink only, don't delete the actual directory.
+        // Linked cases carry no owner (admin-only WRITE in multi-user mode), so a non-admin
+        // must not unlink one either; skip so control falls through to their local delete.
         const linkedCases = await readLinkedCases();
-        if (linkedCases[name]) {
+        if (linkedCases[name] && (!isMultiUserMode() || isAdmin(req))) {
             delete linkedCases[name];
             try {
                 await fs.writeFile(LINKED_CASES_FILE, JSON.stringify(linkedCases, null, 2));
@@ -649,7 +723,7 @@ export function registerCaseRoutes(app, ctx) {
             }
         }
         // Case in CASES_DIR — delete the entire directory
-        const casePath = join(CASES_DIR, name);
+        const casePath = join(resolveCasesDir(getAuthUser(req)), name);
         if (!existsSync(casePath)) {
             return createErrorResponse(ApiErrorCode.NOT_FOUND, `Case "${name}" not found`);
         }
@@ -688,11 +762,15 @@ export function registerCaseRoutes(app, ctx) {
     });
     app.get('/api/cases/:name', async (req) => {
         const { name } = req.params;
-        if (!validatePathWithinBase(name, CASES_DIR)) {
+        if (!validatePathWithinBase(name, resolveCasesDir(getAuthUser(req)))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
+        // Fold ownership INTO the match (don't early-return): a non-owned same-named remote/
+        // docker case is skipped so control falls through to the caller's own LOCAL case
+        // (remote/docker names are globally unique, local names per-user). No metadata is
+        // disclosed for a foreign case. canAccessOwned is allow-all for admins/single-user.
         const remoteCases = await readRemoteCases(CODEMAN_CONFIG_DIR);
-        const remoteCase = remoteCases.find((item) => item.name === name);
+        const remoteCase = remoteCases.find((item) => item.name === name && canAccessOwned(getAuthUser(req), item.owner));
         if (remoteCase) {
             const host = (await readRemoteHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === remoteCase.hostId);
             if (!host)
@@ -710,7 +788,7 @@ export function registerCaseRoutes(app, ctx) {
                 },
             };
         }
-        const dockerCase = (await readDockerCases(CODEMAN_CONFIG_DIR)).find((item) => item.name === name);
+        const dockerCase = (await readDockerCases(CODEMAN_CONFIG_DIR)).find((item) => item.name === name && canAccessOwned(getAuthUser(req), item.owner));
         if (dockerCase) {
             const host = (await readDockerHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === dockerCase.hostId);
             if (!host)
@@ -730,11 +808,11 @@ export function registerCaseRoutes(app, ctx) {
                 },
             };
         }
-        const casePath = await resolveCasePath(name);
+        const casePath = await resolveCasePath(name, getAuthUser(req));
         if (!existsSync(casePath)) {
             return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Case not found');
         }
-        const linked = casePath !== join(CASES_DIR, name);
+        const linked = casePath !== join(resolveCasesDir(getAuthUser(req)), name);
         return {
             name,
             path: casePath,
@@ -745,11 +823,11 @@ export function registerCaseRoutes(app, ctx) {
     // Read @fix_plan.md from a case directory (for wizard to detect existing plans)
     app.get('/api/cases/:name/fix-plan', async (req) => {
         const { name } = req.params;
-        if (!validatePathWithinBase(name, CASES_DIR)) {
+        if (!validatePathWithinBase(name, resolveCasesDir(getAuthUser(req)))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
         // Get case path (check linked cases first, then CASES_DIR)
-        const casePath = await resolveCasePath(name);
+        const casePath = await resolveCasePath(name, getAuthUser(req));
         const fixPlanPath = join(casePath, '@fix_plan.md');
         if (!existsSync(fixPlanPath)) {
             return { exists: false, content: null, todos: [] };
@@ -834,10 +912,10 @@ export function registerCaseRoutes(app, ctx) {
     // ========== List Wizard Files ==========
     app.get('/api/cases/:caseName/ralph-wizard/files', async (req) => {
         const { caseName } = req.params;
-        if (!validatePathWithinBase(caseName, CASES_DIR)) {
+        if (!validatePathWithinBase(caseName, resolveCasesDir(getAuthUser(req)))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
-        const casePath = await resolveCasePath(caseName);
+        const casePath = await resolveCasePath(caseName, getAuthUser(req));
         const wizardDir = join(casePath, 'ralph-wizard');
         if (!existsSync(wizardDir)) {
             return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Ralph wizard directory not found');
@@ -868,14 +946,14 @@ export function registerCaseRoutes(app, ctx) {
     // Cache disabled to ensure fresh prompts when starting new plan generations
     app.get('/api/cases/:caseName/ralph-wizard/file/:filePath', async (req, reply) => {
         const { caseName, filePath } = req.params;
-        if (!validatePathWithinBase(caseName, CASES_DIR)) {
+        if (!validatePathWithinBase(caseName, resolveCasesDir(getAuthUser(req)))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
         // Prevent browser caching - prompts change between plan generations
         reply.header('Cache-Control', 'no-store, no-cache, must-revalidate');
         reply.header('Pragma', 'no-cache');
         reply.header('Expires', '0');
-        const casePath = await resolveCasePath(caseName);
+        const casePath = await resolveCasePath(caseName, getAuthUser(req));
         const wizardDir = join(casePath, 'ralph-wizard');
         // Decode the file path (it may be URL encoded)
         const decodedPath = decodeURIComponent(filePath);