aicodeman 1.46.0 → 1.48.0

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

@@ -1,13 +1,13 @@
 {
-  "version": "1.46.0",
+  "version": "1.48.0",
   "highlights": [
-    "Fetch from the Git status window (#714)",
-    "Start a session beside any tab (#712, opt-in)",
-    "The phone keyboard no longer costs Claude its transcript (#711)",
-    "Typing stays smooth in a long prompt (#713)",
-    "Links survive wrapping and spaces (#686, #687)",
-    "`codeman agent spawn` in a project directory (#708)",
-    "Read saved Codex conversations offline (#707)",
-    "Experimental: bounded inspection and guarded submission for agents (#694, opt-in)"
+    "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)"
   ]
 }

package/dist/web/request-body-parser.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Accept empty, untyped API POSTs even when a reverse proxy frames them as chunked.
+ *
+ * Cloudflare Tunnel (cloudflared, Go's HTTP client) forwards a bodyless POST as an HTTP/1.1
+ * chunked request with no Content-Type and a zero-length body. Fastify only skips its
+ * content-type check for a `Content-Length: 0` request, so this framing was refused 415
+ * (`FST_ERR_CTP_INVALID_MEDIA_TYPE`) before the route ran, breaking actions such as opening a
+ * saved web tab. This parser lets such a request reach its route with `request.body === undefined`,
+ * exactly as a `Content-Length: 0` request does.
+ *
+ * Scope is POST under `/api/` only: Go frames an empty body of unknown length as chunked for
+ * POST, PUT and PATCH and drops it for DELETE, and every PUT/PATCH the frontend sends carries a
+ * JSON body. Anything else (another method, a non-API route, a Content-Type, a non-zero
+ * Content-Length, or a single body byte) is still the 415 Fastify would have answered.
+ *
+ * ⚠️ It owns the ROOT `'*'` content-type slot. The JSON, `text/plain` (kept RAW, see the CSRF
+ * note in CLAUDE.md) and multipart parsers match first; the web-tab proxy registers its own
+ * `'*'` in an encapsulated scope and is unaffected. Fastify refuses a second root `'*'` parser at
+ * boot (`FST_ERR_CTP_ALREADY_PRESENT`), so extend this function instead of adding one.
+ */
+import { type FastifyInstance } from 'fastify';
+export declare function installEmptyApiPostParser(app: FastifyInstance): void;
+//# sourceMappingURL=request-body-parser.d.ts.map

package/dist/web/request-body-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-body-parser.d.ts","sourceRoot":"","sources":["../../src/web/request-body-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAc,KAAK,eAAe,EAAuB,MAAM,SAAS,CAAC;AAGhF,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,CAmCpE"}

package/dist/web/request-body-parser.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Accept empty, untyped API POSTs even when a reverse proxy frames them as chunked.
+ *
+ * Cloudflare Tunnel (cloudflared, Go's HTTP client) forwards a bodyless POST as an HTTP/1.1
+ * chunked request with no Content-Type and a zero-length body. Fastify only skips its
+ * content-type check for a `Content-Length: 0` request, so this framing was refused 415
+ * (`FST_ERR_CTP_INVALID_MEDIA_TYPE`) before the route ran, breaking actions such as opening a
+ * saved web tab. This parser lets such a request reach its route with `request.body === undefined`,
+ * exactly as a `Content-Length: 0` request does.
+ *
+ * Scope is POST under `/api/` only: Go frames an empty body of unknown length as chunked for
+ * POST, PUT and PATCH and drops it for DELETE, and every PUT/PATCH the frontend sends carries a
+ * JSON body. Anything else (another method, a non-API route, a Content-Type, a non-zero
+ * Content-Length, or a single body byte) is still the 415 Fastify would have answered.
+ *
+ * ⚠️ It owns the ROOT `'*'` content-type slot. The JSON, `text/plain` (kept RAW, see the CSRF
+ * note in CLAUDE.md) and multipart parsers match first; the web-tab proxy registers its own
+ * `'*'` in an encapsulated scope and is unaffected. Fastify refuses a second root `'*'` parser at
+ * boot (`FST_ERR_CTP_ALREADY_PRESENT`), so extend this function instead of adding one.
+ */
+import { errorCodes } from 'fastify';
+export function installEmptyApiPostParser(app) {
+    // Existing JSON, text and multipart parsers take precedence. The webview
+    // proxy installs its own parser in an encapsulated scope.
+    app.addContentTypeParser('*', async (req, payload) => {
+        // Fastify normally skips an unsupported parser on its 404 path. Preserve
+        // that behavior, including the unread stream used by referer fallbacks.
+        if (req.is404)
+            return undefined;
+        if (req.method !== 'POST' ||
+            !req.routeOptions.url?.startsWith('/api/') ||
+            req.headers['content-type'] !== undefined ||
+            (req.headers['content-length'] !== undefined && req.headers['content-length'] !== '0')) {
+            throw new errorCodes.FST_ERR_CTP_INVALID_MEDIA_TYPE();
+        }
+        // Wait for the terminating chunk to prove the body is empty. Reject on the
+        // first byte instead of buffering an unsupported body. Leave the socket
+        // alive so Fastify can send its 415 and close the connection on parser errors.
+        try {
+            for await (const chunk of payload.iterator({ destroyOnReturn: false })) {
+                if (Buffer.byteLength(chunk) > 0)
+                    throw new errorCodes.FST_ERR_CTP_INVALID_MEDIA_TYPE();
+            }
+        }
+        catch (error) {
+            // Match Fastify's body reader: an interrupted request is a client error.
+            const err = error;
+            if (typeof err.statusCode !== 'number' || err.statusCode < 400)
+                err.statusCode = 400;
+            throw err;
+        }
+        // No synthetic JSON or header rewriting: required-body validation still
+        // sees the same undefined value as a direct Content-Length: 0 request.
+        return undefined;
+    });
+}
+//# sourceMappingURL=request-body-parser.js.map

package/dist/web/request-body-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-body-parser.js","sourceRoot":"","sources":["../../src/web/request-body-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,UAAU,EAA6C,MAAM,SAAS,CAAC;AAGhF,MAAM,UAAU,yBAAyB,CAAC,GAAoB;IAC5D,yEAAyE;IACzE,0DAA0D;IAC1D,GAAG,CAAC,oBAAoB,CAAC,GAAG,EAAE,KAAK,EAAE,GAAmB,EAAE,OAAiB,EAAE,EAAE;QAC7E,yEAAyE;QACzE,wEAAwE;QACxE,IAAI,GAAG,CAAC,KAAK;YAAE,OAAO,SAAS,CAAC;QAEhC,IACE,GAAG,CAAC,MAAM,KAAK,MAAM;YACrB,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC;YAC1C,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,KAAK,SAAS;YACzC,CAAC,GAAG,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,SAAS,IAAI,GAAG,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,GAAG,CAAC,EACtF,CAAC;YACD,MAAM,IAAI,UAAU,CAAC,8BAA8B,EAAE,CAAC;QACxD,CAAC;QAED,2EAA2E;QAC3E,wEAAwE;QACxE,+EAA+E;QAC/E,IAAI,CAAC;YACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,OAAO,CAAC,QAAQ,CAAC,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;gBACvE,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC;oBAAE,MAAM,IAAI,UAAU,CAAC,8BAA8B,EAAE,CAAC;YAC1F,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,yEAAyE;YACzE,MAAM,GAAG,GAAG,KAAwC,CAAC;YACrD,IAAI,OAAO,GAAG,CAAC,UAAU,KAAK,QAAQ,IAAI,GAAG,CAAC,UAAU,GAAG,GAAG;gBAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC;YACrF,MAAM,GAAG,CAAC;QACZ,CAAC;QAED,wEAAwE;QACxE,uEAAuE;QACvE,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,CAAC;AACL,CAAC"}

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;AAiF1C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAG3F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AA4D9C;;;;;;;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,CA+9DN"}
+{"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"}

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

@@ -15,6 +15,8 @@ import { ApiErrorCode, createErrorResponse, getErrorMessage } from '../../types.
 import { CreateCaseSchema, CloneCaseSchema, ClonePreflightSchema, LinkCaseSchema, CaseOrderSchema, CaseDefaultGroupSchema, RenameCaseSchema, RemoteCaseLinkSchema, RemoteHostSchema, DockerCaseLinkSchema, DockerCaseAdoptSchema, DockerAdoptPreflightSchema, DockerBrowseSchema, DockerHostSchema, DockerExportSchema, DockerImportSchema, DockerQuickCreateSchema, } from '../schemas.js';
 import { exportDockerCase, importDockerBundle, listDockerExports, exportBundleName } from '../../docker-export.js';
 import { cloneRepository, isGitAvailable, isSafeGitRef, parseGitRepositoryUrl, probeGitRemote, } from '../../git-clone.js';
+import { isPathWithin } from '../../git-worktrees.js';
+import { defaultDockerWorkspaces } from './git-status-routes.js';
 import { generateClaudeMd } from '../../templates/claude-md.js';
 import { prepareNewCasePath } from '../case-path.js';
 import { CaseRenameError, isCaseSessionStarting, moveCaseFolder, moveClaudeHistory, renameInOrder, siblingPath, withCaseLock, } from '../../case-rename.js';
@@ -54,6 +56,8 @@ const APP_VERSION = (() => {
  * `/api/cases/link` is admin-only for).
  */
 const LOCAL_CLONE_ADMIN_ONLY = 'Cloning from a local path is admin-only in multi-user mode. Use a repository URL instead.';
+/** Refusal text for a clone at or inside a Docker case workspace (git would run its hooks on the host). */
+const DOCKER_CLONE_REFUSAL = 'Cloning is not available into a folder inside a Docker case workspace: a container can write there, and git would run the new repository’s hooks and filters on this machine. Clone outside the workspace and link it, or clone from inside the container.';
 /**
  * Whether a clone or preflight must run with git's credential helpers cleared:
  * a non-admin in multi-user mode. Every user's git runs as the one server
@@ -519,7 +523,8 @@ export function registerCaseRoutes(app, ctx) {
      * request died mid-clone still sees the case appear over SSE when git finishes.
      *
      * Deliberately NOT admin-gated in multi-user mode: unlike `/api/cases/link`,
-     * this writes only inside the caller's own `resolveCasesDir`. Two things would
+     * this writes only inside the caller's own `resolveCasesDir`, EXCEPT with a `path` (a custom folder,
+     * registered as a linked case in the shared registry), which is admin-only like Link Existing. Two things would
      * otherwise read through that boundary: a `local`-transport source (refused for
      * non-admins) and the server account's git credential helpers, which every user
      * shares (cleared for non-admins, see `cloneWithoutCredentialHelpers`).
@@ -531,7 +536,7 @@ export function registerCaseRoutes(app, ctx) {
      * user's machine the moment a session starts in the case.
      */
     app.post('/api/cases/clone', async (req, reply) => {
-        const { name, repository, ref, shallow, description } = parseBody(CloneCaseSchema, req.body);
+        const { name, repository, ref, shallow, description, path: customPath } = parseBody(CloneCaseSchema, req.body);
         const user = getAuthUser(req);
         const parsed = parseGitRepositoryUrl(repository);
         if (!parsed.cloneable)
@@ -546,8 +551,52 @@ export function registerCaseRoutes(app, ctx) {
         if (!isGitAvailable()) {
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, 'git is not installed on this machine (or not on the server’s PATH).');
         }
+        // A custom folder writes outside the cases directory and registers the path in the shared,
+        // ownerless linked-cases registry, so it carries the same bar as POST /api/cases/link.
+        if (customPath !== undefined) {
+            const denied = adminOnly(req, reply);
+            if (denied)
+                return denied;
+        }
         const casesDir = resolveCasesDir(user);
-        const casePath = validatePathWithinBase(name, casesDir);
+        let casePath;
+        let intoEmptyDir = false;
+        if (customPath !== undefined) {
+            const prepared = await prepareNewCasePath(customPath, {
+                home: homedir(),
+                dataDir: getDataDir(),
+                casesDirs: [...new Set([casesDir, resolveCasesDir()])],
+                casesDirAdvice: 'clone there without a custom folder',
+            });
+            if (!prepared.ok) {
+                reply.code(prepared.code === 'UNREACHABLE'
+                    ? 422
+                    : prepared.code === 'NOT_FOUND'
+                        ? 404
+                        : prepared.code === 'EXISTS'
+                            ? 409
+                            : 400);
+                return createErrorResponse(prepared.code === 'UNREACHABLE'
+                    ? ApiErrorCode.OPERATION_FAILED
+                    : prepared.code === 'NOT_FOUND'
+                        ? ApiErrorCode.NOT_FOUND
+                        : 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.`
+                    : prepared.reason);
+            }
+            intoEmptyDir = prepared.existedEmpty;
+            casePath = prepared.path;
+            // The same folder listed as a local case in the cases dir would make deleting it remove files.
+            if (existsSync(join(casesDir, name))) {
+                reply.code(409);
+                return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'A case with this name already exists in codeman-cases.');
+            }
+        }
+        else {
+            casePath = validatePathWithinBase(name, casesDir);
+        }
         if (!casePath)
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case path');
         // Reject a duplicate name across EVERY case kind before invoking git, so a
@@ -556,22 +605,52 @@ export function registerCaseRoutes(app, ctx) {
         const linkedCases = await readLinkedCases();
         const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
         const remoteCases = await readRemoteCases(CODEMAN_CONFIG_DIR);
-        if (existsSync(casePath) ||
+        const linkedAs = Object.entries(linkedCases).find(([, p]) => p === casePath)?.[0];
+        if (linkedAs && customPath !== undefined) {
+            reply.code(409);
+            return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, `That folder is already the case "${linkedAs}"`);
+        }
+        if (
+        // A custom folder was judged by prepareNewCasePath (an existing empty one is fine).
+        (customPath === undefined && existsSync(casePath)) ||
             linkedCases[name] ||
             dockerCases.some((item) => item.name === name) ||
             remoteCases.some((item) => item.name === name)) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
         }
-        // git creates the leaf, not necessarily the case space above it.
+        // git creates the leaf, not necessarily the case space above it (a custom folder's parent
+        // already exists: prepareNewCasePath refused a missing one).
+        if (customPath === undefined) {
+            try {
+                mkdirSync(casesDir, { recursive: true });
+            }
+            catch (err) {
+                return createErrorResponse(ApiErrorCode.OPERATION_FAILED, getErrorMessage(err));
+            }
+        }
+        // git runs the new repository's hooks and filters on THIS machine once the clone finishes, and a container
+        // with the workspace bind-mounted can write both while it fetches. Like git status, fetch and worktrees,
+        // never clone at or inside a Docker case workspace. Fails closed when the Docker case list cannot be read.
         try {
-            mkdirSync(casesDir, { recursive: true });
+            // Probed first (#516): a case's workspace can sit on a mount that stopped answering, and an unbounded
+            // realpath there would hold this request and a threadpool worker. Such a root is judged as spelled.
+            const roots = await Promise.all((await defaultDockerWorkspaces()).map(async (root) => (await probePathKind(root, { pastCap: true })) === 'unknown'
+                ? resolve(root)
+                : fs.realpath(root).catch(() => resolve(root))));
+            // A custom folder is already symlink-resolved; the default one is judged through its real cases dir.
+            const dest = customPath !== undefined ? casePath : join(await fs.realpath(casesDir).catch(() => casesDir), name);
+            if (roots.some((root) => isPathWithin(dest, root))) {
+                return createErrorResponse(ApiErrorCode.INVALID_INPUT, DOCKER_CLONE_REFUSAL);
+            }
         }
-        catch (err) {
-            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, getErrorMessage(err));
+        catch {
+            reply.code(503);
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, 'Could not read the Docker case list, so Codeman cannot tell whether that folder is a Docker case workspace. Try again.');
         }
         const clone = await cloneRepository({
             repository: parsed.repository,
             destination: casePath,
+            ...(intoEmptyDir ? { intoEmptyDir: true } : {}),
             withoutCredentialHelpers: cloneWithoutCredentialHelpers(req),
             ...(ref ? { ref } : {}),
             ...(shallow ? { shallow: true } : {}),
@@ -628,6 +707,23 @@ export function registerCaseRoutes(app, ctx) {
             // problem, rather than deleting a tree the user just waited for.
             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.
+            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));
+            }
+            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.`);
+            }
+        }
         ctx.broadcast(SseEvent.CaseCreated, { name, path: casePath });
         return {
             success: true,