aicodeman 1.48.0 → 1.49.0

package/dist/web/public/whats-new.json

@@ -1,13 +1,13 @@
 {
-  "version": "1.48.0",
+  "version": "1.49.0",
   "highlights": [
-    "Talk to your agents from Discord (#741)",
-    "Edit history panel (#693)",
-    "Custom endpoints go further (#752, #755, #757)",
-    "Clone into a custom folder, and make a folder from the picker (#744, #745)",
-    "Relative links follow your `cd` (#740)",
-    "File links keep the whole name (#735)",
-    "A failed settings save says so (#736)",
-    "Phone keys show a press (#737)"
+    "Open the tmux sessions you started yourself (#510)",
+    "Install without administrator rights (#768)",
+    "Docker Compose starts in two commands (#573)",
+    "Codex sessions can drive other sessions (#753)",
+    "Persian, Arabic and Hebrew read right to left (#715)",
+    "Edit history for remote sessions (#766)",
+    "The Files panel follows the agent into a git worktree (#772, #765)",
+    "One big folder no longer hides the rest (#614)"
   ]
 }

package/dist/web/routes/case-routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"case-routes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/case-routes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAmF1C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAG3F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAgE9C;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAE1E;AAgID,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,aAAa,GACxD,IAAI,CA4kEN"}
+{"version":3,"file":"case-routes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/case-routes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAoF1C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAG3F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AA+D9C;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAE1E;AA0ID,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,aAAa,GACxD,IAAI,CA4kEN"}

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

@@ -25,6 +25,7 @@ import { readAgentCaseMarker } from '../../agent-case-marker.js';
 import { settingsWriteBlocker, writeHooksConfig } from '../../hooks-config.js';
 import { canAccessOwned, getAuthUser, isAdmin, isWorkingDirAllowed, ownerFor, requireAdmin, resolveCasesDir, SETTINGS_PATH, validatePathWithinBase, parseBody, readJsonConfig, } from '../route-helpers.js';
 import { assertSettingsWritable, mutateSettingsFile, SettingsWriteRefusedError, settingsWriteErrorResponse, } from '../settings-writer.js';
+import { LinkedCasesWriteRefusedError, linkedCasesPath, mutateLinkedCases } from '../linked-cases-writer.js';
 import { isMultiUserMode } from '../../config/multiuser.js';
 import { SseEvent } from '../sse-events.js';
 import { ownerLayoutKey } from '../../tab-layout-persistence.js';
@@ -33,7 +34,6 @@ import { dataPath, getDataDir } from '../../config/instance.js';
 import { checkDockerAvailable, checkDockerImagePresent, checkDockerTmuxAvailable, ensureAgentBaseImage, DEFAULT_AGENT_IMAGE, dockerContainerName, dockerDisplayPath, probeAdoptableContainer, classifyAdoptContainerConflict, listDockerContainers, browseInContainer, dockerAdoptProbeModes, readDockerCases, readDockerHosts, removeDockerContainer, toSessionDocker, writeDockerCases, writeDockerHosts, } from '../../docker-hosts.js';
 import { buildDockerRemoveCommand } from '../../tmux-manager.js';
 import { checkRemoteTmuxAvailable, listRemoteCodemanSessions, readRemoteCases, readRemoteHosts, remoteDisplayPath, writeRemoteCases, writeRemoteHosts, } from '../../remote-hosts.js';
-const LINKED_CASES_FILE = dataPath('linked-cases.json');
 const CODEMAN_CONFIG_DIR = getDataDir();
 const SAFE_CASE_NAME = /^[a-zA-Z0-9_-]+$/;
 const DOCKER_EXPORTS_DIR = dataPath('docker-exports');
@@ -110,10 +110,19 @@ function agentCreatedInfo(marker) {
         ...(marker.mode ? { mode: marker.mode } : {}),
     };
 }
-/** Read and parse linked-cases.json, returning empty object on missing/invalid file. */
+/**
+ * Read and parse linked-cases.json, returning empty object on missing/invalid file. For reads only:
+ * every write goes through `mutateLinkedCases()`, which re-reads the file inside its own critical
+ * section and refuses one that does not parse.
+ */
 async function readLinkedCases() {
-    return readJsonConfig(LINKED_CASES_FILE, 'linked cases', {});
+    return readJsonConfig(linkedCasesPath(), 'linked cases', {});
+}
+/** A conflict thrown from inside a `mutateLinkedCases()` callback: answered 409, nothing written. */
+function linkedConflict(message) {
+    return Object.assign(new Error(message), { conflict: true });
 }
+const isLinkedConflict = (err) => err.conflict === true;
 /**
  * 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).
@@ -422,17 +431,12 @@ export function registerCaseRoutes(app, ctx) {
             made.push(join(casePath, 'CLAUDE.md'));
             made.push(join(casePath, '.claude')); // before the write, so a half-written one is undone too
             await writeHooksConfig(casePath);
-            const codemanDir = getDataDir();
-            if (!existsSync(codemanDir))
-                mkdirSync(codemanDir, { recursive: true });
-            // Re-read right before writing, so a case linked since the check above is not dropped. This only
-            // narrows the window: like POST /api/cases/link, the registry write is not serialized, and two
-            // requests that both read before either writes can still lose one entry.
-            const fresh = await readLinkedCases();
-            if (fresh[name])
-                throw Object.assign(new Error(`Case "${name}" was just linked`), { conflict: true });
-            fresh[name] = casePath;
-            await fs.writeFile(LINKED_CASES_FILE, JSON.stringify(fresh, null, 2));
+            // The check above ran before the scaffold; a case linked since then wins and this call is undone.
+            await mutateLinkedCases((current) => {
+                if (current[name])
+                    throw linkedConflict(`Case "${name}" was just linked`);
+                return { ...current, [name]: casePath };
+            });
             ctx.broadcast(SseEvent.CaseCreated, { name, path: casePath });
             return { success: true, data: { case: { name, path: casePath } } };
         }
@@ -441,10 +445,14 @@ export function registerCaseRoutes(app, ctx) {
             // entries inside the empty folder the user picked; never anything else.
             for (const p of made.reverse())
                 await fs.rm(p, { recursive: true, force: true }).catch(() => undefined);
-            if (err.conflict) {
+            if (isLinkedConflict(err)) {
                 reply.code(409);
                 return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, getErrorMessage(err));
             }
+            if (err instanceof LinkedCasesWriteRefusedError) {
+                reply.code(409);
+                return createErrorResponse(ApiErrorCode.CONFLICT, err.message);
+            }
             reply.code(500);
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, getErrorMessage(err));
         }
@@ -583,7 +591,7 @@ export function registerCaseRoutes(app, ctx) {
                         : prepared.code === 'EXISTS'
                             ? ApiErrorCode.ALREADY_EXISTS
                             : ApiErrorCode.INVALID_INPUT, prepared.code === 'EXISTS'
-                    ? `${customPath} already has files in it. Pick an empty folder, or a folder that does not exist yet.`
+                    ? `${customPath} already has files in it. The clone target must be empty or not exist yet.`
                     : prepared.reason);
             }
             intoEmptyDir = prepared.existedEmpty;
@@ -708,20 +716,21 @@ export function registerCaseRoutes(app, ctx) {
             warnings.push(`Case scaffolding was incomplete: ${getErrorMessage(err)}`);
         }
         if (customPath !== undefined) {
-            // Re-read right before writing so a case linked while git ran is not dropped. Like
-            // POST /api/cases/link the write is not serialized, so this only narrows the window.
+            // The name was checked before git ran, which can take minutes. Checked again where the entry is
+            // written, so of two clones that claimed one name only the first to finish links it.
             try {
-                const fresh = await readLinkedCases();
-                if (fresh[name])
-                    throw Object.assign(new Error(`Case "${name}" was linked while the clone ran`), { conflict: true });
-                fresh[name] = casePath;
-                await fs.writeFile(LINKED_CASES_FILE, JSON.stringify(fresh, null, 2));
+                await mutateLinkedCases((current) => {
+                    if (current[name])
+                        throw linkedConflict(`Case "${name}" was linked while the clone ran`);
+                    return { ...current, [name]: casePath };
+                });
             }
             catch (err) {
                 // The clone itself succeeded: keep the folder (the user waited for it) and say where it is.
-                const conflict = err.conflict;
-                reply.code(conflict ? 409 : 500);
-                return createErrorResponse(conflict ? ApiErrorCode.ALREADY_EXISTS : ApiErrorCode.OPERATION_FAILED, `Cloned into ${casePath} but could not register the case (${getErrorMessage(err)}). Use Link Existing to add it.`);
+                const conflict = isLinkedConflict(err);
+                const refused = err instanceof LinkedCasesWriteRefusedError;
+                reply.code(conflict || refused ? 409 : 500);
+                return createErrorResponse(conflict ? ApiErrorCode.ALREADY_EXISTS : refused ? ApiErrorCode.CONFLICT : ApiErrorCode.OPERATION_FAILED, `Cloned into ${casePath} but could not register the case (${getErrorMessage(err)}). Use Link Existing to add it.`);
             }
         }
         ctx.broadcast(SseEvent.CaseCreated, { name, path: casePath });
@@ -1397,24 +1406,21 @@ export function registerCaseRoutes(app, ctx) {
         if (existsSync(casePath)) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'A case with this name already exists in codeman-cases.');
         }
-        // Load existing linked cases
-        const linkedCases = await readLinkedCases();
-        // Check if name is already linked
-        if (linkedCases[name]) {
-            return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, `Case "${name}" is already linked to ${linkedCases[name]}`);
-        }
-        // Save the linked case
-        linkedCases[name] = expandedPath;
+        // The name check and the write are one step, so two links of one name cannot both succeed.
         try {
-            const codemanDir = getDataDir();
-            if (!existsSync(codemanDir)) {
-                mkdirSync(codemanDir, { recursive: true });
-            }
-            await fs.writeFile(LINKED_CASES_FILE, JSON.stringify(linkedCases, null, 2));
+            await mutateLinkedCases((current) => {
+                if (current[name])
+                    throw linkedConflict(`Case "${name}" is already linked to ${current[name]}`);
+                return { ...current, [name]: expandedPath };
+            });
             ctx.broadcast(SseEvent.CaseLinked, { name, path: expandedPath });
             return { success: true, data: { case: { name, path: expandedPath } } };
         }
         catch (err) {
+            if (isLinkedConflict(err))
+                return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, getErrorMessage(err));
+            if (err instanceof LinkedCasesWriteRefusedError)
+                return createErrorResponse(ApiErrorCode.CONFLICT, err.message);
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, getErrorMessage(err));
         }
     });
@@ -1484,14 +1490,22 @@ export function registerCaseRoutes(app, ctx) {
         // must not unlink one either; skip so control falls through to their local delete.
         const linkedCases = await readLinkedCases();
         if (linkedCases[name] && (!isMultiUserMode() || isAdmin(req))) {
-            delete linkedCases[name];
             try {
-                await fs.writeFile(LINKED_CASES_FILE, JSON.stringify(linkedCases, null, 2));
+                // Removes this one entry from the registry as it is now, keeping any linked since the read above.
+                await mutateLinkedCases((current) => {
+                    if (!Object.hasOwn(current, name))
+                        return undefined;
+                    const next = { ...current };
+                    delete next[name];
+                    return next;
+                });
                 ctx.broadcast(SseEvent.CaseDeleted, { name, type: 'unlinked' });
                 await forgetCaseDefault();
                 return { success: true, data: { name } };
             }
             catch (err) {
+                if (err instanceof LinkedCasesWriteRefusedError)
+                    return createErrorResponse(ApiErrorCode.CONFLICT, err.message);
                 return createErrorResponse(ApiErrorCode.OPERATION_FAILED, getErrorMessage(err));
             }
         }
@@ -1660,7 +1674,6 @@ export function registerCaseRoutes(app, ctx) {
                 }
                 if (moveFolder)
                     await moveCaseFolder(oldPath, newPath);
-                const originalLinks = isLinked ? await readLinkedCases() : undefined;
                 // The settings.json values this rename replaced, set only once it wrote them. A failure puts back
                 // these keys alone, so a settings save that landed in between is kept.
                 let settingsUndo;
@@ -1681,17 +1694,20 @@ export function registerCaseRoutes(app, ctx) {
                             settingsUndo = Object.fromEntries(keys.map((k) => [k, before[k]]));
                         }
                     }
-                    if (originalLinks) {
-                        const links = { ...originalLinks };
-                        delete links[name];
-                        links[newName] = newPath;
-                        try {
-                            await fs.writeFile(LINKED_CASES_FILE, JSON.stringify(links, null, 2));
-                        }
-                        catch (err) {
-                            await fs.writeFile(LINKED_CASES_FILE, JSON.stringify(originalLinks, null, 2)).catch(() => { });
-                            throw err;
-                        }
+                    if (isLinked) {
+                        // Checked again where the entry is written: the checks above ran before the sessions were
+                        // stopped and the folder moved. A failed write leaves the registry as it was.
+                        await mutateLinkedCases((current) => {
+                            if (current[newName])
+                                throw new CaseRenameError('EXISTS', `A case named "${newName}" already exists`);
+                            if (current[name] !== oldPath) {
+                                throw new CaseRenameError('BUSY', `Case "${name}" was changed while it was being renamed`);
+                            }
+                            const links = { ...current };
+                            delete links[name];
+                            links[newName] = newPath;
+                            return links;
+                        });
                     }
                 }
                 catch (err) {
@@ -1738,6 +1754,9 @@ export function registerCaseRoutes(app, ctx) {
                         : ApiErrorCode.OPERATION_FAILED;
                 return fail(status, code, err.message, { renameCode: err.code, stoppedSessions: stopped });
             }
+            if (err instanceof LinkedCasesWriteRefusedError) {
+                return fail(409, ApiErrorCode.CONFLICT, err.message, { stoppedSessions: stopped });
+            }
             return fail(500, ApiErrorCode.OPERATION_FAILED, getErrorMessage(err), { stoppedSessions: stopped });
         }
     });