@kabmo-labs/kabmo 0.7.0 → 0.9.0

package/src/server/routes/worktrees/create.ts

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * POST /api/worktrees — create a worktree, and POST /api/worktrees/validate —
+ * the same plan without touching disk.
+ *
+ * Both go through `planWorktree`, so the dialog cannot be told "fine" by a check
+ * that the create then contradicts: every refusal a create can raise is raised
+ * by the validate call first, with the same code and the same field.
+ *
+ * The body carries the DIALOG's state, never a resolved path: a client that
+ * could name the directory could name one outside the project.
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { getDb } from '@/server/db.server';
+import { emitRealtimeSignal } from '@/server/lib/realtime/signals.server';
+import { getDataDir } from '@/server/lib/lifecycle/paths';
+import { putWorktreeRow, worktreeIdentityFor } from '@/server/lib/db/worktree-registry.server';
+import { asWorktreeFailure } from '@/server/lib/fs/worktree/errors';
+import { createWorktree, planWorktree } from '@/server/lib/fs/worktree/create';
+import { invalidateWorktreeTopology } from '@/server/lib/fs/worktree/topology';
+import { readWorktreeSettings } from '@/server/lib/fs/worktree/settings.server';
+import type { WorktreeValidation } from '@/shared/lib/workspace/worktree/types';
+import { isMock, mockRefusal, resolveWorktreeProject, worktreeFailureResponse } from '@/server/routes/worktrees/shared';
+
+interface CreateBody {
+  mode?: unknown;
+  branch?: unknown;
+  worktreeName?: unknown;
+  startRef?: unknown;
+  carryIgnored?: unknown;
+}
+
+function readBody(body: CreateBody) {
+  return {
+    mode: body.mode === 'existing' ? ('existing' as const) : ('new' as const),
+    branch: typeof body.branch === 'string' ? body.branch : '',
+    worktreeName: typeof body.worktreeName === 'string' ? body.worktreeName : '',
+    startRef: typeof body.startRef === 'string' ? body.startRef : undefined,
+    carryIgnored: typeof body.carryIgnored === 'boolean' ? body.carryIgnored : undefined,
+  };
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+  if (request.method !== 'POST') return methodNotAllowed({ request, params: {} });
+  if (isMock()) return mockRefusal();
+
+  const url = new URL(request.url);
+  const resolved = await resolveWorktreeProject(url.searchParams.get('root'), url.searchParams.get('folderId'));
+  if (resolved.error) return resolved.error;
+  const projectPath = resolved.root as string;
+
+  const body = (await request.json().catch(() => ({}))) as CreateBody;
+  const parsed = readBody(body);
+  const settings = await readWorktreeSettings();
+  const db = await getDb();
+  const deps = {
+    identityFor: (candidate: string) => worktreeIdentityFor(db, candidate),
+    carryIgnored: settings.carryIgnored,
+    dataDir: getDataDir(),
+    configuredDirectory: settings.directory,
+    record: async (row: {
+      path: string;
+      primaryRoot: string;
+      projectId: string;
+      branch: string;
+      startRef: string;
+      createdAt: string;
+    }) => {
+      await putWorktreeRow(db, {
+        path: row.path,
+        primary_root: row.primaryRoot,
+        project_id: row.projectId,
+        branch: row.branch,
+        start_ref: row.startRef,
+        created_at: row.createdAt,
+      });
+    },
+  };
+
+  try {
+    const created = await createWorktree({ projectPath, ...parsed }, deps);
+    await invalidateWorktreeTopology(created.primaryRoot);
+    // The new folder is structure: every sidebar re-reads, and the panels that
+    // already point at this repository drop their cached topology.
+    emitRealtimeSignal('sidebar-structure');
+    emitRealtimeSignal('workspace-dirty');
+    return json({ worktree: created, carried: created.carried });
+  } catch (error) {
+    return worktreeFailureResponse(error);
+  }
+}
+
+/**
+ * The same plan, without creating anything. Answers every failure rather than
+ * the first, because a dialog that shows one error at a time makes the user
+ * discover the second one after fixing the first.
+ */
+export async function validateAction({ request }: ActionFunctionArgs) {
+  if (request.method !== 'POST') return methodNotAllowed({ request, params: {} });
+  if (isMock()) return mockRefusal();
+
+  const url = new URL(request.url);
+  const resolved = await resolveWorktreeProject(url.searchParams.get('root'), url.searchParams.get('folderId'));
+  if (resolved.error) return resolved.error;
+  const projectPath = resolved.root as string;
+
+  const body = (await request.json().catch(() => ({}))) as CreateBody;
+  const parsed = readBody(body);
+  const settings = await readWorktreeSettings();
+  const db = await getDb();
+
+  try {
+    const plan = await planWorktree(
+      { projectPath, ...parsed },
+      {
+        identityFor: (candidate: string) => worktreeIdentityFor(db, candidate),
+        dataDir: getDataDir(),
+        configuredDirectory: settings.directory,
+      },
+    );
+    const payload: WorktreeValidation = {
+      ok: true,
+      failures: [],
+      resolved: { name: plan.name, directory: plan.directory, branch: plan.branch },
+    };
+    return json(payload);
+  } catch (error) {
+    const payload: WorktreeValidation = { ok: false, failures: [asWorktreeFailure(error)] };
+    return json(payload, { status: 400 });
+  }
+}

package/src/server/routes/worktrees/index.ts

@@ -0,0 +1,25 @@
+import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
+import * as worktreesList from '@/server/routes/worktrees/list';
+import { action as createAction, validateAction } from '@/server/routes/worktrees/create';
+import { action as removeAction } from '@/server/routes/worktrees/remove';
+
+/**
+ * `/api/worktrees` — list, create, validate, remove.
+ *
+ * Every binding is explicit rather than `actionBindings`, and that is the whole
+ * reason this file exists: `actionBindings` mounts all four mutating verbs AND a
+ * 405 GET fallback, and Elysia lets a later registration win — so mounting the
+ * create module that way would replace the list loader with a "method not
+ * allowed" response on the same path. (`sessions/index.ts` records the same trap
+ * for the batch-delete routes.)
+ *
+ * `validate` is a STATIC segment registered before the collection path.
+ * `DELETE` takes the worktree path in its BODY, not in the URL: a path contains
+ * separators, and a wildcard segment would also answer for `/validate`.
+ */
+export const worktreesBindings: HandlerBinding[] = [
+  ...bindingsFor(worktreesList, '/api/worktrees'),
+  { method: 'POST', path: '/api/worktrees/validate', handler: validateAction },
+  { method: 'POST', path: '/api/worktrees', handler: createAction },
+  { method: 'DELETE', path: '/api/worktrees', handler: removeAction },
+];

package/src/server/routes/worktrees/list.ts

@@ -0,0 +1,134 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * GET /api/worktrees — the worktrees of one project, with the facts a row shows.
+ *
+ * Deliberately NOT on the realtime `git:` topic: that payload is republished on
+ * every tool call, and this read costs a `git status` per worktree. It is opened
+ * by hand (Settings → Projects → Worktrees, and the delete dialog), exactly the
+ * reasoning `git-repo-details.ts` records for keeping the repo modal off it.
+ *
+ * `sessions` counts chats whose cwd is inside a worktree, from the same topology
+ * the sidebar uses — so the number a row shows is the number of rows the user
+ * can see under it.
+ */
+
+import path from 'node:path';
+import { json } from '@/server/lib/remix-compat';
+import type { LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { getDataDir } from '@/server/lib/lifecycle/paths';
+import { resolveProjectRoot } from '@/server/lib/omp/core/worktree';
+import { listSessionFiles } from '@/server/lib/omp/session/files';
+import { scanSessionInfoCached } from '@/server/lib/omp/session/files';
+import { canonicalPath } from '@/server/lib/fs/canonical';
+import { worktreeIdentityFor, listWorktreeRows } from '@/server/lib/db/worktree-registry.server';
+import { dirtyCount, commitsAheadOf } from '@/server/lib/fs/worktree/remove';
+import { listWorktrees, isWorkTree } from '@/server/lib/fs/worktree/list';
+import {
+  defaultWorktreeRoot,
+  resolveConfiguredWorktreeRoot,
+} from '@/server/lib/fs/worktree/location';
+import { readWorktreeSettings } from '@/server/lib/fs/worktree/settings.server';
+import { resolveProjectId } from '@/server/lib/fs/worktree/project-id';
+import { getDb } from '@/server/db.server';
+import { isMock } from '@/server/routes/worktrees/shared';
+import { mockRefusal, resolveWorktreeProject, worktreeFailureResponse } from '@/server/routes/worktrees/shared';
+import type { WorktreeInfo, WorktreeListPayload } from '@/shared/lib/workspace/worktree/types';
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  if (isMock()) return mockRefusal();
+
+  const url = new URL(request.url);
+  const resolved = await resolveWorktreeProject(url.searchParams.get('root'), url.searchParams.get('folderId'));
+  if (resolved.error) return resolved.error;
+  const root = resolved.root as string;
+
+  try {
+    const db = await getDb();
+    const primaryRoot = await resolveProjectRoot(root);
+    // "This folder is not a Git repository" is an ANSWER, not a failure. The
+    // payload has carried `isRepo` for exactly this, and a plain directory (a
+    // notes folder bound as a workspace) must read as "no worktrees here" —
+    // a 500 would make the composer report a broken feature for a folder that
+    // simply has nothing to offer. The probe runs before the identity read,
+    // which is what throws for a directory with no root commit.
+    if (!(await isWorkTree(primaryRoot))) {
+      const empty: WorktreeListPayload = { worktrees: [], base: '', isRepo: false };
+      return json(empty);
+    }
+    const settings = await readWorktreeSettings();
+    const projectId = await resolveProjectId(primaryRoot, (candidate) => worktreeIdentityFor(db, candidate));
+    const base = resolveConfiguredWorktreeRoot(settings.directory, primaryRoot)
+      ?? defaultWorktreeRoot(getDataDir(), projectId);
+
+    const entries = await listWorktrees(primaryRoot);
+    const [rows, sessionCwds] = await Promise.all([
+      listWorktreeRows(db, primaryRoot),
+      // Every tree that can be counted, not just the repository: a worktree does
+      // NOT have to live inside it. Kabmo's own default puts one under the data
+      // directory (`<data>/worktrees/<projectId>/<name>`), so a `primaryRoot`
+      // prefix test counted ZERO sessions for every worktree at the default
+      // location — the number the delete dialog warns with.
+      sessionCwdsUnder([primaryRoot, ...entries.map((entry) => entry.path)]),
+    ]);
+    const rowByPath = new Map(rows.map((row) => [row.path, row]));
+
+    const worktrees: WorktreeInfo[] = [];
+    for (const entry of entries) {
+      const row = rowByPath.get(entry.path);
+      const dirty = entry.isPrimary ? 0 : await dirtyCount(entry.path).catch(() => 0);
+      const ahead = entry.isPrimary
+        ? 0
+        : (await commitsAheadOf(primaryRoot, row?.start_ref ?? '', entry.branch)) ?? 0;
+      worktrees.push({
+        path: entry.path,
+        branch: entry.branch,
+        head: entry.head,
+        detached: entry.detached,
+        missing: entry.missing,
+        isPrimary: entry.isPrimary,
+        dirty,
+        aheadOfStart: ahead,
+        startRef: row?.start_ref ?? '',
+        sessions: sessionCwds.filter((cwd) => cwd === entry.path || cwd.startsWith(`${entry.path}${path.sep}`)).length,
+      });
+    }
+
+    const payload: WorktreeListPayload = { worktrees, base, isRepo: true };
+    return json(payload);
+  } catch (error) {
+    // A failed listing is REPORTED, never substituted with an empty list: "no
+    // worktrees" and "git could not answer" are different answers, and only one
+    // of them means the user has nothing there.
+    return worktreeFailureResponse(error, 500);
+  }
+}
+
+/**
+ * Every session's recorded cwd, canonicalized, restricted to the trees that can
+ * be counted — the primary checkout and each worktree.
+ *
+ * Both sides are canonicalized, for the same reason `canonicalPath` exists: the
+ * recorded cwd is the spelling the agent was spawned with while a worktree path
+ * comes back realpath'd from git, and on macOS those differ for anything under
+ * `/var` (a symlink to `/private/var`) — a raw prefix test would then count zero
+ * for a worktree that is right there.
+ */
+async function sessionCwdsUnder(roots: string[]): Promise<string[]> {
+  const files = await listSessionFiles();
+  const infos = await Promise.all(files.map((file) => scanSessionInfoCached(file)));
+  const canonicalRoots = [...new Set(await Promise.all(roots.map((root) => canonicalPath(root))))];
+  const cwds: string[] = [];
+  const seen = new Set<string>();
+  for (const info of infos) {
+    if (!info?.cwd || seen.has(info.cwd)) continue;
+    seen.add(info.cwd);
+    const cwd = await canonicalPath(info.cwd);
+    if (!canonicalRoots.some((root) => cwd === root || cwd.startsWith(`${root}${path.sep}`))) continue;
+    cwds.push(cwd);
+  }
+  return cwds;
+}

package/src/server/routes/worktrees/remove.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * DELETE /api/worktrees — remove one worktree.
+ *
+ * Order, and it is the point: stop the live children, archive and delete their
+ * sessions, THEN remove the directory. The reverse — which is what a plain
+ * `git worktree remove` alone does — leaves a child whose cwd no longer exists,
+ * and `resolveSpawnCwd` then quietly runs that session in the server's own
+ * directory: a chat the user deleted, alive somewhere else.
+ *
+ * The dirty refusal happens AFTER the sessions are stopped, so a refusal leaves a
+ * worktree the user can still see and retry rather than a half-deleted state.
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { getDataDir } from '@/server/lib/lifecycle/paths';
+import { getDb } from '@/server/db.server';
+import { emitRealtimeSignal } from '@/server/lib/realtime/signals.server';
+import { pathHolds } from '@/server/lib/fs/canonical';
+import { removeWorktreeRow, worktreeRowFor } from '@/server/lib/db/worktree-registry.server';
+import { removeWorktree } from '@/server/lib/fs/worktree/remove';
+import { invalidateWorktreeTopology } from '@/server/lib/fs/worktree/topology';
+import { resolveProjectRoot } from '@/server/lib/omp/core/worktree';
+import { listRpcSessions } from '@/server/lib/omp/rpc/session-registry';
+import { removeSession } from '@/server/lib/omp/session/delete-flow.server';
+import { isMock, mockRefusal, resolveWorktreeProject, worktreeFailureResponse } from '@/server/routes/worktrees/shared';
+
+interface RemoveBody {
+  path?: unknown;
+  deleteBranch?: unknown;
+}
+
+/**
+ * Stop and delete every session whose cwd is inside `worktreePath`.
+ *
+ * A session this process does not manage has no child to stop — its transcript
+ * is removed the same way, and the owning instance learns on its next spawn
+ * (`resolveSpawnCwd` finds no directory and the row is already gone).
+ */
+async function stopSessionsIn(worktreePath: string): Promise<string[]> {
+  const handled: string[] = [];
+  for (const session of liveSessions()) {
+    if (!(await pathHolds(worktreePath, session.cwd))) continue;
+    // `removeSession` IS the single-delete sequence: pending-id refusal, id
+    // shape, the busy-child 409, `destroyAndWait`, then the purge. Repeating any
+    // of it here is how the batch path would drift from `DELETE /api/sessions/:id`.
+    const removal = await removeSession(session.id);
+    if (removal.ok) handled.push(session.id);
+  }
+  return handled;
+}
+
+/** Live wrappers, as the registry reports them. */
+function liveSessions(): { id: string; cwd: string }[] {
+  return listRpcSessions().map((session) => ({ id: session.sessionId, cwd: session.cwd }));
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+  if (request.method !== 'DELETE') return methodNotAllowed({ request, params: {} });
+  if (isMock()) return mockRefusal();
+
+  const url = new URL(request.url);
+  const resolved = await resolveWorktreeProject(url.searchParams.get('root'), url.searchParams.get('folderId'));
+  if (resolved.error) return resolved.error;
+  const projectPath = resolved.root as string;
+
+  const body = (await request.json().catch(() => ({}))) as RemoveBody;
+  const worktreePath = typeof body.path === 'string' ? body.path.trim() : '';
+  if (!worktreePath) {
+    return json({ error: 'path is required', code: 'invalid_name', field: 'location' }, { status: 400 });
+  }
+
+  const db = await getDb();
+  try {
+    const primaryRoot = await resolveProjectRoot(projectPath);
+    const removed = await removeWorktree(
+      {
+        worktreePath,
+        projectPath,
+        deleteBranch: body.deleteBranch === true,
+        managedRoot: `${getDataDir()}/worktrees`,
+        stopSessions: stopSessionsIn,
+      },
+      {
+        rowFor: (candidate) => worktreeRowFor(db, candidate),
+        removeRow: (candidate) => removeWorktreeRow(db, candidate),
+      },
+    );
+    await invalidateWorktreeTopology(primaryRoot);
+    emitRealtimeSignal('sidebar-structure');
+    emitRealtimeSignal('workspace-dirty');
+    return json(removed);
+  } catch (error) {
+    return worktreeFailureResponse(error);
+  }
+}