@kabmo-labs/kabmo 0.6.1 → 0.8.0

package/src/server/routes/index.ts

@@ -12,6 +12,7 @@ import { waitingBindings } from '@/server/routes/waiting/bindings';
 import { settingsBindings } from '@/server/routes/settings';
 import { fsBindings } from '@/server/routes/fs';
 import { foldersBindings } from '@/server/routes/folders';
+import { worktreesBindings } from '@/server/routes/worktrees';
 import { filesBindings } from '@/server/routes/files';
 import { telemetryBindings } from '@/server/routes/telemetry';
 import { terminalBindings } from '@/server/routes/terminal';
@@ -42,6 +43,7 @@ const allBindings: HandlerBinding[] = [
   ...settingsBindings,
   ...fsBindings,
   ...foldersBindings,
+  ...worktreesBindings,
   ...filesBindings,
   ...telemetryBindings,
   ...terminalBindings,

package/src/server/routes/updates/desktop.ts

@@ -0,0 +1,37 @@
+import { json, NO_STORE_HEADERS } from '@/server/lib/remix-compat';
+import { fetchShellRelease, type ShellRelease } from '@/server/lib/updates/shell-release';
+import { isDesktopShellKind, type DesktopShellKind } from '@/shared/lib/updates/shell-ua';
+
+/**
+ * GET /api/updates/desktop?kind=macos|windows|linux — the newest desktop shell.
+ *
+ * ONE route with an explicit `kind`, unlike the mobile pair's two routes, and
+ * the difference is deliberate. `?kind` here is REQUIRED and refused when it is
+ * missing or names no desktop shell, so no absence can silently mean a platform:
+ * the mobile pair's split exists precisely because a defaulted parameter would
+ * have made "the newest shell" mean Android without anyone saying so.
+ *
+ * Only an INSTALLED desktop shell asks for this — the page reports its own
+ * version over the shell bridge (`__kabmoDesktop.shellVersion`), because a
+ * desktop app carries no User-Agent token. The `url` it answers with is the
+ * RELEASE PAGE rather than a file: every desktop artifact is per-architecture,
+ * and the server cannot know which architecture the window is running on.
+ *
+ * A failed probe is a valid answer (`url: null`), never a 500: the sidebar's job
+ * is to omit a button it cannot back with a link.
+ */
+export async function loader({ request }: { request: Request }) {
+  const kind = new URL(request.url).searchParams.get('kind');
+  if (!isDesktopShellKind(kind ?? '')) {
+    return json(
+      { error: 'kind must be one of macos, windows, linux' },
+      { status: 400, headers: NO_STORE_HEADERS },
+    );
+  }
+
+  const release: ShellRelease | null = await fetchShellRelease(kind as DesktopShellKind);
+  return json(
+    release ?? { url: null, latest: null, releaseUrl: null },
+    { headers: NO_STORE_HEADERS },
+  );
+}

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

@@ -3,6 +3,7 @@ import * as updatesAndroid from '@/server/routes/updates/android';
 import * as updatesApply from '@/server/routes/updates/apply';
 import * as updatesChangelog from '@/server/routes/updates/changelog';
 import * as updatesCheck from '@/server/routes/updates/check';
+import * as updatesDesktop from '@/server/routes/updates/desktop';
 import * as updatesIos from '@/server/routes/updates/ios';
 
 export const updatesBindings: HandlerBinding[] = [
@@ -10,5 +11,6 @@ export const updatesBindings: HandlerBinding[] = [
   ...bindingsFor(updatesApply, '/api/updates/apply'),
   ...bindingsFor(updatesChangelog, '/api/updates/changelog'),
   ...bindingsFor(updatesCheck, '/api/updates/check'),
+  ...bindingsFor(updatesDesktop, '/api/updates/desktop'),
   ...bindingsFor(updatesIos, '/api/updates/ios'),
 ];

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,124 @@
+/**
+ * @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 } 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);
+    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);
+  }
+}