@dsh-cove/dsh-web-all 0.0.0-stage → 0.4.3

package/lib/types/host/services/worktree/manager.d.ts

@@ -0,0 +1,410 @@
+/**
+ * Host worktree manager: owns the per-repo worktree list, the on-disk
+ * manifest under `<repo>/.dsh/workspaces/`, and the workspace-registry
+ * bookkeeping. All mutations go through this class so the HTTP layer only
+ * knows how to translate envelopes and the browser half only ever sees the
+ * stable `WorktreeProject` / `WorktreeView` shapes from `core/types.ts`.
+ *
+ * Persistence model
+ *  - Each repo has its own manifest at `<repo>/.dsh/workspaces/manifest.json`
+ *  - We never write the manifest from the browser; the host owns the file
+ *  - The manifest records every worktree we ever created; a missing
+ *    directory is the "orphan" state, not a hard error
+ *
+ * Concurrency
+ *  - Per-repo lock prevents two `POST /worktree/create` calls from racing
+ *    on the same repo (one would otherwise see the other's worktree
+ *    directory and 409)
+ *  - The lock is in-process only; out-of-process git contention is the
+ *    user's responsibility (we do not lock across processes)
+ *
+ * Data flow
+ *  - The host returns a worktree-only index (`WorktreeIndex`) on
+ *    `GET /worktree/tree`. Session data lives in the official client
+ *    service `ctx.sessions.list` and is never carried through the HTTP
+ *    layer; the browser merges both sides.
+ * @module dsh-client-ui-worktree/host/manager
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import { type GitRunner } from './git-runner.ts';
+import { type CleanupWorktreeInput, type CreateLaneInput, type CreateWorktreeInput, type InitWorktreeInput, type LaneHandle, type LaneLookupInput, type LaneView, type PrCreateInput, type PrCreateResult, type RemoveWorktreeInput, type StatusInput, type WorktreeIndex, type WorktreeStatusIndex, type WorktreeView } from '../../../core/worktree/types.ts';
+import { WORKSPACE_DIR, worktreeDir, worktreeRoot } from '../../../core/worktree/paths.ts';
+/** Optional knobs for the worktree manager (mainly test seams). */
+export interface WorktreeManagerOptions {
+    /** GitHub token env-var reference (credential-ref) for PR creation via the REST API. */
+    tokenEnv?: string;
+    /** Runner override for tests; defaults to the shared subprocess runner. */
+    runner?: GitRunner;
+    /** Deadlines (ms) for the network-touching git calls; a test seam narrows them. */
+    timeouts?: {
+        networkMs?: number;
+        pushMs?: number;
+    };
+    /** Status cache lifetime in ms (0 disables the cache). */
+    statusTtlMs?: number;
+}
+/** Public surface used by `routes.ts`. */
+export declare class WorktreeManager {
+    private readonly ctx;
+    private readonly options;
+    private readonly runner;
+    private readonly locks;
+    /** Last status answer per repo root, invalidated by every manifest write. */
+    private readonly statusCache;
+    /** Required services: the subprocess seam and the workspace registry. */
+    constructor(ctx: Context, options?: WorktreeManagerOptions);
+    /** Status cache lifetime for this manager (0 disables it). */
+    private get statusTtlMs();
+    /** Network deadline for this manager (the options seam may narrow it). */
+    private get networkTimeoutMs();
+    /** Push deadline for this manager (the options seam may narrow it). */
+    private get pushTimeoutMs();
+    /**
+     * Return the host-side worktree index: every registered workspace that
+     * lives under a git repo, plus the main worktree branch + dirty count
+     * and every linked worktree under `<repo>/.dsh/workspaces/`.
+     */
+    getIndex(): Promise<WorktreeIndex>;
+    /**
+     * Create a linked worktree that cuts a NEW branch (`input.branch`) at
+     * `input.base`, and register it as a DSH workspace. Registration is
+     * best-effort here (a failure only surfaces as `workspaceId: null`);
+     * `createForSession` is the variant that requires it.
+     */
+    create(input: CreateWorktreeInput): Promise<WorktreeView>;
+    /**
+     * Ensure the worktree behind one branch exists, and that its directory is a
+     * DSH workspace.
+     *
+     * This is the single creation path for a session-bound lane, and it merges
+     * what used to be two separate actions:
+     *   - the branch already exists locally  -> ATTACH it (git checks that
+     *     branch out in its own directory; no new branch is invented);
+     *   - the branch does not exist yet      -> CUT it at `base` with `-b`.
+     * Either way the caller gets a directory that is that branch's checkout.
+     *
+     * Idempotent: an existing lane directory is returned as-is, so "switch to
+     * this branch" is safe to repeat and two sessions can share a branch.
+     *
+     * The workspace registration is not decoration and not ownership: the
+     * platform accounts a session to a workspace only while its cwd equals that
+     * workspace's path (`WorkspaceEntity.sessionIds`), and a blank conversation
+     * that no workspace accounts for renders an inert composer. Teardown
+     * unregisters the workspace with the directory, so the sidebar only carries
+     * lanes that are still alive.
+     */
+    ensureLane(input: CreateLaneInput): Promise<LaneHandle>;
+    /**
+     * The lane's DSH workspace, registered once and reused afterwards.
+     *
+     * Required, not a taste: `WorkspaceEntity.sessionIds` only accounts sessions
+     * whose cwd equals the workspace path, `attachSession` refuses any other cwd,
+     * and a blank conversation that no workspace accounts for shows an inert
+     * composer ("choose a workspace to start"). Registration failure is not fatal
+     * here — the worktree is real, so the caller reports the lane without a
+     * workspace and the browser declines to claim the conversation moved.
+     */
+    private ensureLaneWorkspace;
+    /** The lane already present at `dir`, when git reports one there. The
+     *  workspace half is resolved by the caller (see ensureLane). */
+    private worktreeBranchAt;
+    /** Shared create body; the caller holds the per-repo lock. */
+    private createLocked;
+    /**
+     * The manifest record for one lane: its directory when the repository's
+     * manifest records that branch, null otherwise.
+     *
+     * The bind path reads this instead of trusting `laneForPath`, which
+     * synthesizes a lane view for a directory the manifest does not know about —
+     * so "the lane exists on disk" and "the host recorded this lane" are two
+     * different answers, and only the second may authorize a binding.
+     */
+    laneEntry(repoPath: string, name: string): Promise<{
+        root: string;
+        path: string;
+    } | null>;
+    /**
+     * Record the session bound to a lane. Called right after the session exists,
+     * so the header chip and the teardown guards can resolve `sessionId -> lane`
+     * without re-deriving it from the filesystem.
+     * @param repoPath - repository root.
+     * @param name - worktree (branch) name.
+     * @param sessionId - the session to record.
+     * @param permissionPresetApplied - whether the lane's access preset landed.
+     */
+    bindSession(repoPath: string, name: string, sessionId: SessionId, permissionPresetApplied: boolean): Promise<void>;
+    /**
+     * Undo a lane creation. Used when the lane exists but its session could
+     * not be created, so a failed create never leaves half a lane behind:
+     * worktree directory, local branch, admin records, manifest entry and the
+     * registered workspace all go away.
+     */
+    rollbackCreate(input: {
+        repoPath: string;
+        name: string;
+    }): Promise<void>;
+    /**
+     * Resolve the lane a path (or a session's cwd) belongs to. Returns null
+     * for the main checkout and for any path outside `<repo>/.dsh/workspaces/`.
+     *
+     * Deliberately network-free: this feeds the conversation header chip, so
+     * it must stay cheap. `merged` is therefore only the locally knowable
+     * half (branch pushed AND its tip is an ancestor of the base); the
+     * "remote branch deleted on merge" signal needs a `fetch --prune` and
+     * stays with the panel's `POST /worktree/status` probe.
+     */
+    laneForPath(input: LaneLookupInput): Promise<LaneView | null>;
+    /** One lane record for a directory git reports as a linked worktree. */
+    private laneForDirectory;
+    /** One lane record from a manifest entry, with the git state filled in. */
+    private laneFromEntry;
+    /** The manifest entry a session is bound to, within one repo. */
+    private manifestEntryForSession;
+    /**
+     * Archive the session a lane was bound to, when one is recorded. Once the
+     * lane directory is gone the conversation would otherwise keep pointing at
+     * a deleted path; archiving hides the record instead of letting it dangle.
+     * Best-effort — the workspace registry may be unavailable.
+     *
+     * DSH 0.2 refuses to archive a session that reports active work (a running
+     * turn, a job, a subagent, an active schedule) unless `stopActivity` is
+     * requested; the lane's own session is exactly the one this teardown is
+     * allowed to take down, so the archive must write first and then ask the
+     * activity owners to stop.
+     */
+    private archiveBoundSession;
+    /**
+     * Refuse to create a lane when the repository does not ignore the lane
+     * root. Without the ignore rule the lane directory shows up as untracked
+     * in the main checkout, and a `git add -A` there would sweep an entire
+     * lane into the trunk — exactly the trunk pollution that lanes exist to
+     * prevent.
+     */
+    private ensureIgnored;
+    /** Whether a local branch of that name already exists. */
+    private branchExists;
+    /** The cwd recorded on a live session header, when the host can see it. */
+    private sessionCwd;
+    /** Patch one manifest entry in place; a missing entry is a no-op. */
+    private updateManifestEntry;
+    /** Best-effort teardown of a lane that never became usable. */
+    private rollbackLocked;
+    /**
+     * Remove a worktree without silently discarding user state. A live session
+     * always blocks removal; a dirty checkout requires the caller's explicit
+     * force confirmation. Cleanup remains the preferred merged-aware flow.
+     */
+    remove(input: RemoveWorktreeInput): Promise<{
+        name: string;
+        path: string;
+    }>;
+    /**
+     * `git init -b <initialBranch>` on a directory that is not yet a git
+     * repository; idempotent (a no-op if the directory is already a repo).
+     * The host-side caller is the browser dialog that asks "convert this
+     * workspace into a git project so I can use worktrees on it".
+     */
+    init(input: InitWorktreeInput): Promise<{
+        repoPath: string;
+        initialBranch: string;
+    }>;
+    /**
+     * Push the worktree branch and open (or create) a pull request. Always
+     * pushes to `origin`; a PR page is then produced either through the
+     * GitHub compare URL (default, no credentials) or through the GitHub
+     * REST API when a `tokenEnv` credential is configured. The resulting
+     * URL and metadata are recorded in the manifest so the panel can resume
+     * the PR later.
+     */
+    prCreate(input: PrCreateInput): Promise<PrCreateResult>;
+    /**
+     * PR / merge status for one repo (or one named worktree of it): whether
+     * the branch was pushed, whether the remote branch is gone, and whether
+     * it is merged into the base. Runs a best-effort `git fetch origin
+     * --prune` first so a merged-and-deleted remote branch reads as merged.
+     *
+     * A full-repo answer is cached: this endpoint is polled whenever the panel
+     * opens, while every mutation this manager performs invalidates the entry, so
+     * a poll is a memory read in the normal flow. `force` (the explicit refresh
+     * action) and a name-filtered probe always go to git.
+     */
+    status(input: StatusInput): Promise<WorktreeStatusIndex>;
+    /** The cached status for a repo, or undefined when absent or past its TTL. */
+    private cachedStatus;
+    /** Drop the cached status for a repo; every manifest write calls this. */
+    private invalidateStatus;
+    /** One uncached probe of the repository. */
+    private probeStatus;
+    /**
+     * Clean up a merged worktree: validate no sessions are running, verify
+     * the branch is merged (or the user forced), remove the worktree
+     * directory, delete the local branch, unregister the workspace, and
+     * archive its sessions. `force` abandons an unmerged branch and drops
+     * uncommitted changes.
+     */
+    cleanup(input: CleanupWorktreeInput): Promise<{
+        name: string;
+        path: string;
+    }>;
+    /**
+     * Retire the workspace registration of a lane whose conversation was archived.
+     *
+     * A lane's directory must be a registered workspace while its conversation
+     * runs — the platform accounts a session to a workspace only when the session
+     * cwd equals that workspace's path, and a blank conversation no workspace
+     * accounts for renders an inert composer — so the sidebar row is unavoidable
+     * while the lane is alive. It does not have to outlive the conversation:
+     * archiving retires the registration, which keeps the worktree, the branch and
+     * the binding, so picking that branch again re-registers the directory in one
+     * call and nothing the user did is discarded.
+     *
+     * The `workspace/session-activity` waterfall runs BEFORE the durable archive
+     * write, so this waits for the archive set to show the session instead of
+     * assuming the write lands: an archive refused for running work retires
+     * nothing. A lane that still has an unarchived conversation keeps its
+     * workspace, or that conversation would lose the workspace it runs in.
+     * @param sessionId - the conversation that was archived.
+     * @param options - bounded-poll knobs (test seam).
+     * @returns whether a lane workspace was retired.
+     */
+    retireArchivedLane(sessionId: string, options?: {
+        attempts?: number;
+        pollMs?: number;
+    }): Promise<boolean>;
+    /**
+     * Retire every lane workspace whose recorded conversation is archived.
+     *
+     * Rows left behind by an earlier build, or by an archive that happened while
+     * this plugin was absent, must not survive a restart; this walks the registered
+     * workspaces once and drops exactly those lanes. Anything else is left alone: a
+     * workspace outside `<repo>/.dsh/workspaces/`, a lane whose manifest records no
+     * conversation, a lane whose recorded conversation is still live, and a lane
+     * that still has an unarchived conversation.
+     * @returns how many lane workspaces were retired.
+     */
+    reconcileLaneWorkspaces(): Promise<number>;
+    /**
+     * Run one git command under a deadline. An aborted command surfaces as
+     * exitCode 124 with the reason on stderr, so every caller keeps its existing
+     * exitCode check as the single failure path. Without this a stalled
+     * `git fetch` held the per-repo lock forever and left the panel loading.
+     */
+    private runBounded;
+    /** Acquire the per-repo lock for the duration of `fn`. */
+    private withLock;
+    /**
+     * Resolve the canonical git common-dir for `path`, or null when `path`
+     * is not inside a git working tree. We do this with `git rev-parse
+     * --path-format=absolute --git-common-dir` so the result follows
+     * `git`'s notion of canonicalization (worktrees resolve to the main
+     * repo), not `realpath`'s.
+     */
+    private repoRoot;
+    /** Resolve the `origin` remote URL, or null when no remote is configured. */
+    private originRemoteUrl;
+    /** Remote default branch (`refs/remotes/origin/HEAD`), or null when unset. */
+    private remoteDefaultBranch;
+    /** Best-effort `git fetch origin --prune`; a failure (offline) is ignored. */
+    private fetchPruneBestEffort;
+    /** Whether `refs/remotes/origin/<branch>` exists after the last fetch. */
+    private remoteBranchPushed;
+    /** Whether the remote branch is gone (ls-remote --exit-code non-zero). */
+    private remoteBranchGone;
+    /** Whether `origin/<branch>` is an ancestor of `origin/<base>` (or local `<base>`). */
+    private isAncestorOfBase;
+    /**
+     * Whether the LOCAL branch tip is an ancestor of the base. Used when the
+     * tracking ref is already pruned: the remote signal is gone, but the local
+     * branch still answers whether its work landed in the base.
+     */
+    private isLocalAncestorOfBase;
+    /**
+     * Whether the local branch moved past the commit the lane was cut from. A
+     * lane that never committed is an ancestor of its base too, so this is what
+     * separates "merged work" from "no work yet".
+     */
+    private branchTipMoved;
+    /**
+     * The merged signal for one branch, in two independent halves:
+     *
+     * 1. the remote branch still exists -> merged when its tip is an ancestor of
+     *    the base tip;
+     * 2. the tracking ref is pruned -> either the branch was never pushed, or it
+     *    was deleted on merge ("delete branch on merge" is GitHub's default).
+     *    `remoteBranch` on the manifest only records a push this plugin made, so
+     *    a manually pushed branch would read as unmerged forever; the manifest's
+     *    `baseCommit` plus the local tip answer the same question without it.
+     */
+    private worktreeStatus;
+    /**
+     * Create the PR through the GitHub REST API when a token is configured
+     * and the remote is GitHub. Returns null to fall back to the compare URL
+     * when no token is configured, the remote is not GitHub, or the API call
+     * fails (the compare URL remains the zero-credential default).
+     */
+    private createPullRequestViaApi;
+    /** Resolve the DSH workspace registered for a worktree directory, or null. */
+    private workspaceForPath;
+    /** Whether the registry's durable archive set holds this session. */
+    private isArchivedSession;
+    /** Whether every conversation a workspace accounts for has been archived. */
+    private hasNoLiveConversation;
+    /** Retire the workspace of the lane that records this conversation. */
+    private retireLaneWorkspaceOf;
+    /**
+     * Drop one lane's workspace registration and the id recorded for it. The
+     * directory, the worktree record, the branch and the session binding survive,
+     * so picking that branch again re-registers the directory in one call.
+     */
+    private retireLaneWorkspace;
+    /** Session ids recorded on a workspace (structural — avoids registry type churn). */
+    private sessionIdsOf;
+    /** Whether a session id is currently live in the session store. */
+    private isLiveSession;
+    /**
+     * The live session still using this lane, if any.
+     *
+     * Two sources: the lane's workspace accounts for the sessions whose cwd is that
+     * directory, and the manifest entry records the session this plugin created
+     * there. The manifest half is what stops `cleanup`/`remove` from deleting the
+     * directory a running conversation is working in.
+     *
+     * `self` is the conversation asking for the teardown through its own lane
+     * chip. It may excuse itself — otherwise the interlock would make a lane the
+     * conversation sits on impossible to ever tear down (the chip is the only
+     * surface left once the conversation is gone), and the teardown archives that
+     * session anyway. The excusal is not a bypass: the lane has to actually
+     * record the id (as its bound session, or as a session of its workspace), so
+     * an unrecorded or foreign id excuses nothing.
+     */
+    private liveSessionOnLane;
+    /** Archive every session of a worktree workspace, then unregister it. */
+    private archiveAndDeleteWorkspace;
+    /**
+     * Resolve the DSH workspace registered for a path. `resolveByPath` compares
+     * the literal string, but git reports canonicalized paths (`/private/tmp/...`
+     * on macOS while the registry holds `/tmp/...`), so a miss falls back to
+     * comparing realpaths. Without this the main row's Open / New session buttons
+     * stay disabled for every workspace behind a symlinked path.
+     */
+    private workspaceIdFor;
+    /**
+     * Build the per-repo project view: main + linked worktrees under
+     * `<repo>/.dsh/workspaces/`. The `git worktree list --porcelain`
+     * output is parsed by hand because it is the only stable format and
+     * we want zero dependencies.
+     */
+    private buildProject;
+    /** Read the manifest from disk; return an empty manifest when missing. */
+    private readManifest;
+    private writeManifest;
+    private appendManifestEntry;
+    private removeManifestEntry;
+    private ensureWorkspaceDir;
+    private headBranch;
+    private headShort;
+    private dirtyCount;
+}
+export { WORKSPACE_DIR, worktreeDir, worktreeRoot };
+//# sourceMappingURL=manager.d.ts.map

package/lib/types/host/services/worktree/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/worktree/manager.ts"],"names":[],"mappings":"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"}