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

package/lib/types/host/services/git-graph/routes.js

@@ -0,0 +1,241 @@
+import { isBranchesView, isCommitDiffView, isGitError, isGitMutationResult, isGraphView, isRepoStatus, } from "../../../core/git-graph/protocol.js";
+import { accessTrustOf } from "../access-trust/index.js";
+import { registerResources } from "../resources.js";
+const BAD_REQUEST = { code: 'internal', message: 'malformed request' };
+const MALFORMED_VIEW = { code: 'internal', message: 'malformed git response' };
+const STATUS_TIMEOUT_MS = 15_000;
+/**
+ * Whether this request may drive the Git workbench: the shared host access
+ * fence (loopback, or a deployment trusted authority with an authenticated
+ * browser session), and nothing else. The workbench is served through the
+ * deployment's canonical browser entry, so a bare loopback check refused every
+ * remote browser behind the documented reverse proxy.
+ *
+ * A paired-device claim used to be a second allow path here. Nothing in this
+ * plugin or in the installed DSH packages provides `remoteWebUiPairing`, so the
+ * branch could never admit anything - it only widened the documented rule, the
+ * same shape as the `dsh_remote_pair` marker the worktree fence dropped.
+ */
+function isAllowed(ctx, request) {
+    return accessTrustOf(ctx).isTrusted(request);
+}
+async function readBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const bytes = chunk;
+        size += bytes.length;
+        if (size > 1024 * 1024)
+            return null;
+        chunks.push(bytes);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(response, status, body) {
+    response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'referrer-policy': 'no-referrer' });
+    response.end(JSON.stringify(body));
+}
+function ok(value) { return { ok: true, value }; }
+function fail(error) { return { ok: false, error }; }
+function payloadPath(payload) {
+    const path = typeof payload === 'object' && payload !== null ? payload.path : undefined;
+    return typeof path === 'string' && path !== '' ? path : null;
+}
+function checkedView(response, value, guard) {
+    writeJson(response, 200, value !== null && !guard(value) ? fail(MALFORMED_VIEW) : ok(value));
+}
+async function statusWithDeadline(service, path, controller = new AbortController()) {
+    let timer;
+    try {
+        return await Promise.race([
+            service.status(path, controller.signal),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    const error = new Error('git status timed out');
+                    controller.abort(error);
+                    reject(error);
+                }, STATUS_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export function registerGitRoutes(ctx, service) {
+    const subscribers = new Set();
+    let poll;
+    let heartbeat;
+    let polling = false;
+    const stopIfIdle = () => {
+        if (subscribers.size !== 0)
+            return;
+        if (poll !== undefined)
+            clearInterval(poll);
+        if (heartbeat !== undefined)
+            clearInterval(heartbeat);
+        poll = heartbeat = undefined;
+    };
+    const runPoll = async () => {
+        if (polling)
+            return;
+        polling = true;
+        try {
+            await Promise.all([...subscribers].map(async (subscriber) => {
+                try {
+                    const status = await statusWithDeadline(service, subscriber.path);
+                    const key = status === null ? 'no-repo' : `${status.root}|${status.branch}|${status.head}`;
+                    if (key === subscriber.last)
+                        return;
+                    subscriber.last = key;
+                    subscriber.response.write(`event: change\ndata: ${JSON.stringify({ path: subscriber.path, status })}\n\n`);
+                }
+                catch (error) {
+                    ctx.logger.warn(`dsh-git-graph: status poll failed for ${subscriber.path}: ${String(error)}`);
+                }
+            }));
+        }
+        finally {
+            polling = false;
+        }
+    };
+    const jsonHandler = async (request, response) => {
+        if (!isAllowed(ctx, request))
+            return writeJson(response, 403, { error: 'forbidden: loopback-only' });
+        if (request.method !== 'POST') {
+            response.writeHead(405);
+            response.end();
+            return;
+        }
+        if (!String(request.headers['content-type'] ?? '').toLowerCase().startsWith('application/json')) {
+            response.writeHead(415);
+            response.end();
+            return;
+        }
+        const payload = await readBody(request);
+        const path = payloadPath(payload);
+        if (path === null)
+            return writeJson(response, 200, fail(BAD_REQUEST));
+        const row = payload;
+        switch (new URL(request.url ?? '/', 'http://dsh.local').pathname) {
+            case '/git/status':
+                try {
+                    checkedView(response, await statusWithDeadline(service, path), isRepoStatus);
+                }
+                catch {
+                    writeJson(response, 200, fail({ code: 'internal', message: 'git status timed out' }));
+                }
+                return;
+            case '/git/branches':
+                checkedView(response, await service.branches(path), isBranchesView);
+                return;
+            case '/git/graph': {
+                const limit = typeof row.limit === 'number' && Number.isInteger(row.limit) && row.limit > 0 ? Math.min(row.limit, 200) : undefined;
+                const cursor = typeof row.cursor === 'string' && /^\d+$/.test(row.cursor) ? row.cursor : undefined;
+                if (row.cursor !== undefined && cursor === undefined)
+                    return writeJson(response, 200, fail(BAD_REQUEST));
+                checkedView(response, await service.graph(path, limit, cursor), isGraphView);
+                return;
+            }
+            case '/git/commit-diff': {
+                if (typeof row.oid !== 'string')
+                    return writeJson(response, 200, fail(BAD_REQUEST));
+                const value = await service.commitDiff(path, row.oid);
+                writeJson(response, 200, isGitError(value) ? fail(value) : isCommitDiffView(value) ? ok(value) : fail(MALFORMED_VIEW));
+                return;
+            }
+            case '/git/diff': {
+                const file = typeof row.file === 'string' && row.file !== '' ? row.file : undefined;
+                const value = await service.diff(path, file, row.staged === true);
+                writeJson(response, 200, value === null ? fail({ code: 'internal', message: 'git diff failed' }) : ok({ diff: value }));
+                return;
+            }
+            case '/git/stage':
+            case '/git/unstage': {
+                const file = typeof row.file === 'string' && row.file !== '' ? row.file : undefined;
+                const success = new URL(request.url ?? '/', 'http://dsh.local').pathname === '/git/stage' ? await service.stage(path, file) : await service.unstage(path, file);
+                writeJson(response, 200, success ? ok({ changed: true }) : fail({ code: 'internal', message: 'git index update failed' }));
+                return;
+            }
+            case '/git/commit': {
+                if (typeof row.message !== 'string' || row.message.trim() === '')
+                    return writeJson(response, 200, fail(BAD_REQUEST));
+                const success = await service.commit(path, row.message);
+                writeJson(response, 200, success ? ok({ committed: true }) : fail({ code: 'internal', message: 'git commit failed' }));
+                return;
+            }
+            case '/git/switch': {
+                if (typeof row.branch !== 'string' || row.branch === '')
+                    return writeJson(response, 200, fail(BAD_REQUEST));
+                const result = await service.switchBranch(path, row.branch);
+                writeJson(response, 200, result.ok ? ok({ branch: result.branch }) : fail(isGitError(result.error) ? result.error : MALFORMED_VIEW));
+                return;
+            }
+            case '/git/create-branch': {
+                if (typeof row.name !== 'string' || row.name === '')
+                    return writeJson(response, 200, fail(BAD_REQUEST));
+                const result = await service.createBranch(path, row.name);
+                writeJson(response, 200, result.ok ? ok({ branch: result.branch }) : fail(isGitError(result.error) ? result.error : MALFORMED_VIEW));
+                return;
+            }
+            case '/git/discard': {
+                if (typeof row.file !== 'string')
+                    return writeJson(response, 200, fail(BAD_REQUEST));
+                const result = await service.discardFile(path, row.file);
+                writeJson(response, 200, result.ok && isGitMutationResult(result.value) ? ok(result.value) : !result.ok && isGitError(result.error) ? fail(result.error) : fail(MALFORMED_VIEW));
+                return;
+            }
+            case '/git/revert':
+            case '/git/cherry-pick': {
+                if (typeof row.oid !== 'string')
+                    return writeJson(response, 200, fail(BAD_REQUEST));
+                const route = new URL(request.url ?? '/', 'http://dsh.local').pathname;
+                const result = route === '/git/revert' ? await service.revert(path, row.oid) : await service.cherryPick(path, row.oid);
+                writeJson(response, 200, result.ok && isGitMutationResult(result.value) ? ok(result.value) : !result.ok && isGitError(result.error) ? fail(result.error) : fail(MALFORMED_VIEW));
+                return;
+            }
+            default:
+                response.writeHead(404);
+                response.end();
+        }
+    };
+    const eventsHandler = (request, response) => {
+        if (!isAllowed(ctx, request))
+            return writeJson(response, 403, { error: 'forbidden: loopback-only' });
+        const path = new URL(request.url ?? '/', 'http://dsh.local').searchParams.get('path');
+        if (!path) {
+            response.writeHead(400);
+            response.end();
+            return;
+        }
+        response.writeHead(200, { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache', connection: 'keep-alive' });
+        response.write('retry: 2000\n\n');
+        const subscriber = { path, last: '', response };
+        subscribers.add(subscriber);
+        const remove = () => { subscribers.delete(subscriber); stopIfIdle(); };
+        request.on('close', remove);
+        response.on('error', remove);
+        poll ??= setInterval(() => { void runPoll(); }, 30_000);
+        heartbeat ??= setInterval(() => { for (const current of subscribers)
+            current.response.write(': ping\n\n'); }, 15_000);
+    };
+    return registerResources(own => {
+        own(() => {
+            if (poll !== undefined)
+                clearInterval(poll);
+            if (heartbeat !== undefined)
+                clearInterval(heartbeat);
+            for (const subscriber of subscribers)
+                subscriber.response.end();
+            subscribers.clear();
+        });
+        own(ctx.webServer.register({ kind: 'prefix', path: '/git', handler: jsonHandler }));
+        own(ctx.webServer.register({ kind: 'exact', path: '/git/events', handler: eventsHandler }));
+    });
+}

package/lib/types/host/services/git-graph/service.d.ts

@@ -0,0 +1,52 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type BranchesView, type CommitDiffView, type GitError, type GitMutationResponse, type GraphView, type RepoStatus, type SwitchResult } from '../../../core/git-graph/protocol.ts';
+export interface GitRunResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+export interface GitRunner {
+    run(argv: readonly string[], cwd: string, signal?: AbortSignal): Promise<GitRunResult>;
+}
+export type WorkspaceVerdict = {
+    ok: true;
+    canonical: string;
+} | {
+    ok: false;
+    error: GitError;
+};
+export type WorkspaceGate = (path: string) => Promise<WorkspaceVerdict>;
+export declare function gitSpawnArgv(platform: NodeJS.Platform, argv: readonly string[]): readonly string[];
+export declare function subprocessRunner(ctx: Context): GitRunner;
+export declare class GitService {
+    private readonly runner;
+    private readonly gate;
+    private readonly statusFlights;
+    constructor(runner: GitRunner, gate: WorkspaceGate);
+    status(path: string, signal?: AbortSignal): Promise<RepoStatus | null>;
+    private statusFresh;
+    branches(path: string): Promise<BranchesView | null>;
+    switchBranch(path: string, branch: string): Promise<SwitchResult>;
+    createBranch(path: string, branch: string): Promise<SwitchResult>;
+    diff(path: string, file?: string, staged?: boolean): Promise<string | null>;
+    stage(path: string, file?: string): Promise<boolean>;
+    unstage(path: string, file?: string): Promise<boolean>;
+    commit(path: string, message: string): Promise<boolean>;
+    graph(path: string, limit?: number, cursor?: string): Promise<GraphView | null>;
+    commitDiff(path: string, oid: string): Promise<CommitDiffView | GitError>;
+    discardFile(path: string, file: string): Promise<GitMutationResponse>;
+    revert(path: string, oid: string): Promise<GitMutationResponse>;
+    cherryPick(path: string, oid: string): Promise<GitMutationResponse>;
+    private commitTarget;
+    private applyCommit;
+    private readHead;
+    private gatedRoot;
+    private mutate;
+    private snapshot;
+    private repoRoot;
+    private operationInProgress;
+    private mutationGuard;
+}
+export declare function classifyApplyFailure(stderr: string): GitError;
+export declare function createWorkspaceGate(ctx: Context): WorkspaceGate;
+//# sourceMappingURL=service.d.ts.map

package/lib/types/host/services/git-graph/service.d.ts.map

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

package/lib/types/host/services/git-graph/service.js

@@ -0,0 +1,301 @@
+/** Workspace-gated Git reads and guarded mutations. */
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { checkRefFormatArgv, cherryPickArgv, classifySwitchFailure, commitArgv, commitDiffArgv, createBranchArgv, diffArgv, discardFileArgv, forEachRefArgv, gitPathArgv, graphLogArgv, headBranchArgv, headShortArgv, operationMarkersArgv, OPERATION_MARKERS, revertArgv, stageArgv, statusPorcelainArgv, switchArgv, topLevelArgv, unmergedArgv, unstageArgv, validateBranchName, validateObjectId, validateRepoRelativePath, verifyCommitArgv, verifyRefArgv, verifyTrackedPathArgv, worktreeListArgv, } from "../../../core/git-graph/commands.js";
+import { parseBranches, parseGraph, parsePorcelain, parseWorktreeBranches, } from "../../../core/git-graph/protocol.js";
+const OUTPUT_CAP_BYTES = 1 << 20;
+const UNKNOWN_WORKSPACE = { code: 'workspace-unknown', message: 'path is not a registered workspace' };
+export function gitSpawnArgv(platform, argv) {
+    return [platform === 'win32' ? 'git.exe' : 'git', ...argv];
+}
+export function subprocessRunner(ctx) {
+    return {
+        async run(argv, cwd, signal) {
+            signal?.throwIfAborted();
+            const processHandle = ctx.subprocess.spawn({
+                argv: gitSpawnArgv(process.platform, argv),
+                cwd,
+                stdio: { stdin: 'ignore', stdout: { maxBytes: OUTPUT_CAP_BYTES }, stderr: { maxBytes: OUTPUT_CAP_BYTES } },
+                graceMs: 10_000,
+                signal,
+            });
+            const result = await processHandle.done;
+            signal?.throwIfAborted();
+            return {
+                exitCode: result.exitCode,
+                stdout: processHandle.collected.stdout?.readFrom(0).text ?? '',
+                stderr: processHandle.collected.stderr?.readFrom(0).text ?? '',
+            };
+        },
+    };
+}
+export class GitService {
+    runner;
+    gate;
+    statusFlights = new Map();
+    constructor(runner, gate) {
+        this.runner = runner;
+        this.gate = gate;
+    }
+    status(path, signal) {
+        const existing = this.statusFlights.get(path);
+        if (existing !== undefined)
+            return existing;
+        const flight = this.statusFresh(path, signal);
+        this.statusFlights.set(path, flight);
+        const clear = () => { if (this.statusFlights.get(path) === flight)
+            this.statusFlights.delete(path); };
+        void flight.then(clear, clear);
+        return flight;
+    }
+    async statusFresh(path, signal) {
+        const snapshot = await this.snapshot(path, signal);
+        if (snapshot === null)
+            return null;
+        const head = await this.runner.run(headShortArgv(), snapshot.root, signal);
+        return { ...snapshot, head: head.stdout.trim() };
+    }
+    async branches(path) {
+        const snapshot = await this.snapshot(path);
+        if (snapshot === null)
+            return null;
+        const refs = await this.runner.run(forEachRefArgv(), snapshot.root);
+        return { ...snapshot, branches: parseBranches(refs.stdout) };
+    }
+    async switchBranch(path, branch) {
+        const gated = await this.gate(path);
+        if (!gated.ok)
+            return { ok: false, error: UNKNOWN_WORKSPACE };
+        const root = await this.repoRoot(gated.canonical);
+        if (root === null)
+            return { ok: false, error: { code: 'internal', message: 'not a git repository' } };
+        const valid = await this.runner.run(checkRefFormatArgv(branch), root);
+        if (valid.exitCode !== 0)
+            return { ok: false, error: { code: 'invalid-branch-name', message: valid.stderr.trim() || 'invalid branch name' } };
+        const exists = await this.runner.run(verifyRefArgv(branch), root);
+        if (exists.exitCode !== 0)
+            return { ok: false, error: { code: 'target-branch-not-found', message: `branch "${branch}" does not exist locally` } };
+        const current = await this.runner.run(headBranchArgv(), root);
+        if (current.stdout.trim() === branch)
+            return { ok: true, branch, opened: true };
+        const guarded = await this.mutationGuard(root, branch);
+        if (guarded !== null)
+            return { ok: false, error: guarded };
+        const switched = await this.runner.run(switchArgv(branch), root);
+        return switched.exitCode === 0 ? { ok: true, branch, opened: true } : { ok: false, error: classifySwitchFailure(switched.stderr) };
+    }
+    async createBranch(path, branch) {
+        const reason = validateBranchName(branch);
+        if (reason !== null)
+            return { ok: false, error: { code: 'invalid-branch-name', message: `invalid branch name: ${reason}` } };
+        const gated = await this.gate(path);
+        if (!gated.ok)
+            return { ok: false, error: UNKNOWN_WORKSPACE };
+        const root = await this.repoRoot(gated.canonical);
+        if (root === null)
+            return { ok: false, error: { code: 'internal', message: 'not a git repository' } };
+        const valid = await this.runner.run(checkRefFormatArgv(branch), root);
+        if (valid.exitCode !== 0)
+            return { ok: false, error: { code: 'invalid-branch-name', message: valid.stderr.trim() || 'invalid branch name' } };
+        if ((await this.runner.run(verifyRefArgv(branch), root)).exitCode === 0) {
+            return { ok: false, error: { code: 'branch-already-exists', message: `branch "${branch}" already exists` } };
+        }
+        const guarded = await this.mutationGuard(root);
+        if (guarded !== null)
+            return { ok: false, error: guarded };
+        const created = await this.runner.run(createBranchArgv(branch), root);
+        return created.exitCode === 0 ? { ok: true, branch, opened: true } : { ok: false, error: classifySwitchFailure(created.stderr) };
+    }
+    async diff(path, file, staged = false) {
+        const root = await this.gatedRoot(path);
+        if (root === null)
+            return null;
+        const result = await this.runner.run(diffArgv(file, staged), root);
+        return result.exitCode === 0 ? result.stdout : null;
+    }
+    async stage(path, file) { return this.mutate(path, stageArgv(file)); }
+    async unstage(path, file) { return this.mutate(path, unstageArgv(file)); }
+    async commit(path, message) {
+        if (message.trim() === '' || message.length > 10_000 || message.includes('\0'))
+            return false;
+        return this.mutate(path, commitArgv(message));
+    }
+    async graph(path, limit = 50, cursor) {
+        const offset = cursor === undefined ? 0 : Number(cursor);
+        if (!Number.isSafeInteger(offset) || offset < 0)
+            return null;
+        const gated = await this.gate(path);
+        if (!gated.ok)
+            return null;
+        const root = await this.repoRoot(gated.canonical);
+        if (root === null)
+            return null;
+        const [log, branch] = await Promise.all([
+            this.runner.run(graphLogArgv(limit + 1, offset), root),
+            this.runner.run(headBranchArgv(), root),
+        ]);
+        if (log.exitCode !== 0)
+            return null;
+        const commits = parseGraph(log.stdout);
+        const hasMore = commits.length > limit;
+        return {
+            root,
+            branch: branch.stdout.trim() === 'HEAD' ? '' : branch.stdout.trim(),
+            commits: commits.slice(0, limit),
+            hasMore,
+            ...(hasMore ? { nextCursor: String(offset + limit) } : {}),
+        };
+    }
+    async commitDiff(path, oid) {
+        const target = await this.commitTarget(path, oid);
+        if (!target.ok)
+            return target.error;
+        const result = await this.runner.run(commitDiffArgv(oid), target.root);
+        return result.exitCode === 0
+            ? { root: target.root, oid, diff: result.stdout }
+            : { code: 'internal', message: firstError(result.stderr, 'git show failed') };
+    }
+    async discardFile(path, file) {
+        const pathError = validateRepoRelativePath(file);
+        if (pathError !== null)
+            return mutationError('invalid-file-path', `invalid repository path: ${pathError}`);
+        const root = await this.gatedRoot(path);
+        if (root === null)
+            return mutationError('workspace-unknown', UNKNOWN_WORKSPACE.message);
+        const guarded = await this.mutationGuard(root);
+        if (guarded !== null)
+            return { ok: false, error: guarded };
+        const tracked = await this.runner.run(verifyTrackedPathArgv(file), root);
+        if (tracked.exitCode !== 0)
+            return mutationError('file-not-tracked', `file is not tracked: ${file}`);
+        const result = await this.runner.run(discardFileArgv(file), root);
+        if (result.exitCode !== 0)
+            return mutationError('internal', firstError(result.stderr, 'git restore failed'));
+        return { ok: true, value: { changed: true, kind: 'discard', head: await this.readHead(root) } };
+    }
+    async revert(path, oid) {
+        return this.applyCommit(path, oid, 'revert');
+    }
+    async cherryPick(path, oid) {
+        return this.applyCommit(path, oid, 'cherry-pick');
+    }
+    async commitTarget(path, oid) {
+        const invalid = validateObjectId(oid);
+        if (invalid !== null)
+            return { ok: false, error: { code: 'invalid-object-id', message: `invalid commit id: ${invalid}` } };
+        const root = await this.gatedRoot(path);
+        if (root === null)
+            return { ok: false, error: UNKNOWN_WORKSPACE };
+        const verified = await this.runner.run(verifyCommitArgv(oid), root);
+        return verified.exitCode === 0
+            ? { ok: true, root }
+            : { ok: false, error: { code: 'commit-not-found', message: `commit was not found: ${oid}` } };
+    }
+    async applyCommit(path, oid, kind) {
+        const target = await this.commitTarget(path, oid);
+        if (!target.ok)
+            return target;
+        const guarded = await this.mutationGuard(target.root, undefined, true);
+        if (guarded !== null)
+            return { ok: false, error: guarded };
+        const result = await this.runner.run(kind === 'revert' ? revertArgv(oid) : cherryPickArgv(oid), target.root);
+        if (result.exitCode !== 0)
+            return { ok: false, error: classifyApplyFailure(result.stderr) };
+        return { ok: true, value: { changed: true, kind, head: await this.readHead(target.root) } };
+    }
+    async readHead(root) {
+        const result = await this.runner.run(headShortArgv(), root);
+        return result.exitCode === 0 ? result.stdout.trim() : '';
+    }
+    async gatedRoot(path) {
+        const gated = await this.gate(path);
+        return gated.ok ? this.repoRoot(gated.canonical) : null;
+    }
+    async mutate(path, argv) {
+        const root = await this.gatedRoot(path);
+        if (root === null || await this.mutationGuard(root) !== null)
+            return false;
+        return (await this.runner.run(argv, root)).exitCode === 0;
+    }
+    async snapshot(path, signal) {
+        const gated = await this.gate(path);
+        if (!gated.ok)
+            return null;
+        const root = await this.repoRoot(gated.canonical, signal);
+        if (root === null)
+            return null;
+        const [branch, porcelain, operationInProgress] = await Promise.all([
+            this.runner.run(headBranchArgv(), root, signal),
+            this.runner.run(statusPorcelainArgv(), root, signal),
+            this.operationInProgress(root, signal),
+        ]);
+        const current = branch.stdout.trim();
+        return { root, branch: current === 'HEAD' ? '' : current, ...parsePorcelain(porcelain.stdout), operationInProgress };
+    }
+    async repoRoot(path, signal) {
+        const result = await this.runner.run(topLevelArgv(), path, signal);
+        const root = result.stdout.trim();
+        return result.exitCode === 0 && root !== '' ? root : null;
+    }
+    async operationInProgress(root, signal) {
+        const combined = await this.runner.run(operationMarkersArgv(), root, signal);
+        if (combined.exitCode === 0) {
+            return combined.stdout.split('\n').some((path) => path.trim() !== '' && existsSync(resolve(root, path.trim())));
+        }
+        for (const marker of OPERATION_MARKERS) {
+            const single = await this.runner.run(gitPathArgv(marker), root, signal);
+            if (single.stdout.trim() !== '' && existsSync(resolve(root, single.stdout.trim())))
+                return true;
+        }
+        return false;
+    }
+    async mutationGuard(root, target, requireClean = false) {
+        const [conflicts, operationInProgress, worktrees, porcelain] = await Promise.all([
+            this.runner.run(unmergedArgv(), root),
+            this.operationInProgress(root),
+            target === undefined ? Promise.resolve(null) : this.runner.run(worktreeListArgv(), root),
+            requireClean ? this.runner.run(statusPorcelainArgv(), root) : Promise.resolve(null),
+        ]);
+        const conflictCount = conflicts.stdout.split('\n').filter(Boolean).length;
+        if (conflictCount > 0)
+            return { code: 'conflicts-present', message: `repository has ${conflictCount} unresolved conflict(s)` };
+        if (operationInProgress)
+            return { code: 'operation-in-progress', message: 'a git operation is in progress' };
+        if (porcelain !== null && porcelain.stdout.trim() !== '')
+            return { code: 'dirty-worktree', message: 'revert and cherry-pick require a clean worktree' };
+        if (target !== undefined && worktrees !== null && parseWorktreeBranches(worktrees.stdout).includes(target)) {
+            return { code: 'branch-in-other-worktree', message: `branch "${target}" is checked out in another worktree` };
+        }
+        return null;
+    }
+}
+function mutationError(code, message) {
+    return { ok: false, error: { code, message } };
+}
+function firstError(stderr, fallback) {
+    return stderr.trim().split('\n')[0] || fallback;
+}
+export function classifyApplyFailure(stderr) {
+    const message = firstError(stderr, 'git operation failed');
+    if (/nothing to commit|nothing to apply|previous cherry-pick is now empty|patch is empty/i.test(stderr)) {
+        return { code: 'nothing-to-apply', message };
+    }
+    if (/CONFLICT|could not (?:apply|revert)|after resolving the conflicts/i.test(stderr)) {
+        return { code: 'apply-conflict', message };
+    }
+    return { code: 'internal', message };
+}
+export function createWorkspaceGate(ctx) {
+    return async (path) => {
+        try {
+            const { realpath } = await import('node:fs/promises');
+            const canonical = await realpath(path);
+            return ctx.workspaceRegistry.list().some((workspace) => workspace.path === canonical)
+                ? { ok: true, canonical }
+                : { ok: false, error: UNKNOWN_WORKSPACE };
+        }
+        catch {
+            return { ok: false, error: { code: 'workspace-unknown', message: 'path does not resolve on disk' } };
+        }
+    };
+}

package/lib/types/host/services/index.d.ts

@@ -0,0 +1,23 @@
+/** Host service-domain assembly for the sole web-all Cordis entity. */
+import type { Context } from '@deepseek-ai/cordis';
+import { type ServiceRegistrationDiagnostic } from './lifecycle.ts';
+export interface ServiceAssemblyDeps {
+    dshHome?: string;
+    agentsHome?: string;
+    codexProxyDir?: string;
+    noBrowserAuth?: boolean;
+    worktree?: import('./worktree/index.ts').WorktreeServiceConfig;
+    /** Playwright sessions options; `liveView` toggles the agent-browser live view. */
+    playwright?: import('../../core/playwright-sessions/contracts.ts').PlaywrightSessionsConfig;
+    /** Structured registration/disposal diagnostics, primarily for tests. */
+    onDiagnostic?: (diagnostic: ServiceRegistrationDiagnostic) => void;
+}
+/**
+ * Mount every service domain beneath one owner. Synchronous failures remain
+ * tolerant and observable; asynchronous registration is tracked, aborted and
+ * awaited during unload so no disposer can arrive after the owner disappeared.
+ */
+export declare function assembleServices(ctx: Context, deps?: ServiceAssemblyDeps): () => Promise<void>;
+export { createServiceLifecycleOwner } from './lifecycle.ts';
+export type { ServiceLifecycleOwner, ServiceRegistrationDiagnostic } from './lifecycle.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/host/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/host/services/index.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAiBlD,OAAO,EAA+B,KAAK,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AAEhG,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,OAAO,qBAAqB,EAAE,qBAAqB,CAAA;IAC9D,mFAAmF;IACnF,UAAU,CAAC,EAAE,OAAO,6CAA6C,EAAE,wBAAwB,CAAA;IAC3F,yEAAyE;IACzE,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,6BAA6B,KAAK,IAAI,CAAA;CACnE;AAOD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,GAAE,mBAAwB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAgDlG;AAED,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAA;AAC5D,YAAY,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA"}