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

package/lib/types/client/conversation/worktree/api.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Browser HTTP client for the /worktree/* endpoints. Mirrors the host
+ * `WorktreeResponse<T>` envelope so success/error paths land on the same
+ * type unions as the manager.
+ *
+ * Every request carries a deadline: a host stalled on `git fetch` (or a dropped
+ * network) has to fail visibly instead of leaving the panel loading forever.
+ * Failures also keep their kind, because "the fence refused this browser" and
+ * "git failed" must not render as the same message — or, worse, as the empty
+ * state that means "no registered git repository workspaces".
+ * @module dsh-client-ui-worktree/client/api
+ */
+import type { BindLaneInput, BindLaneResult, CleanupWorktreeInput, CreateLaneInput, CreateLaneResult, CreateWorktreeInput, InitWorktreeInput, LaneLookupInput, LaneView, PrCreateInput, PrCreateResult, RemoveWorktreeInput, StatusInput, WorktreeIndex, WorktreeStatusIndex, WorktreeView } from '../../../core/worktree/types.ts';
+import type { WorktreeErrorCode } from '../../../core/worktree/invariant.ts';
+import type { WorkspaceModelPreset, WorkspaceModelView } from '../../../core/worktree/workspace-model.ts';
+/**
+ * How a request failed. `permission` is the host access fence refusing this
+ * browser; `domain` is a shaped `ok:false` refusal (git state, busy lane, ...);
+ * `transport` is a network/deadline failure; `malformed` is a protocol break.
+ */
+export type WorktreeApiErrorKind = 'transport' | 'permission' | 'domain' | 'malformed';
+/**
+ * Thrown by the client when the HTTP layer rejects the request before the
+ * envelope. The browser side treats these as transient and surfaces them in
+ * the toast/error banner instead of crashing the sidebar.
+ */
+export declare class WorktreeApiError extends Error {
+    readonly status: number;
+    readonly kind: WorktreeApiErrorKind;
+    readonly code?: WorktreeErrorCode | undefined;
+    constructor(message: string, status: number, kind?: WorktreeApiErrorKind, code?: WorktreeErrorCode | undefined);
+}
+/** The browser-side worktree API surface. */
+export declare class WorktreeApi {
+    /**
+     * GET /worktree/tree — the registered projects and their lanes.
+     * Returns null only for a host half that does not serve the route (404);
+     * a refusal, a failure or a broken envelope throws so the panel can say so
+     * instead of rendering the "no git repository workspaces" empty state.
+     */
+    tree(): Promise<WorktreeIndex | null>;
+    /** POST /worktree/create */
+    create(input: CreateWorktreeInput): Promise<WorktreeView>;
+    /** POST /worktree/remove */
+    remove(input: RemoveWorktreeInput): Promise<{
+        name: string;
+        path: string;
+    }>;
+    /** POST /worktree/init */
+    init(input: InitWorktreeInput): Promise<{
+        repoPath: string;
+        initialBranch: string;
+    }>;
+    /** POST /worktree/pr-create — push the branch and obtain a PR page. */
+    prCreate(input: PrCreateInput): Promise<PrCreateResult>;
+    /** POST /worktree/status — per-repo PR/merge status. */
+    status(input: StatusInput): Promise<WorktreeStatusIndex>;
+    /** POST /worktree/cleanup — teardown a merged worktree. */
+    cleanup(input: CleanupWorktreeInput): Promise<{
+        name: string;
+        path: string;
+    }>;
+    /**
+     * POST /worktree/lane — resolve the lane a session (or a path) belongs to.
+     * Never throws: this feeds the conversation header chip, which must
+     * degrade to "no chip" rather than break the header, so a missing route
+     * (older host half), a fence refusal, an envelope error and a transport
+     * failure all yield `null`.
+     */
+    lane(input: LaneLookupInput): Promise<LaneView | null>;
+    /** POST /worktree/lane/create — create the lane (worktree + workspace).
+     *  The session itself is created by the platform's own create path. */
+    createLane(input: CreateLaneInput): Promise<CreateLaneResult>;
+    /** POST /worktree/lane/bind — attach the created session to its lane and
+     *  apply the lane's permission preset. */
+    bindLane(input: BindLaneInput): Promise<BindLaneResult>;
+    /** POST /worktree/lane/rollback — undo a lane whose session never came up. */
+    rollbackLane(input: {
+        repoPath: string;
+        branch: string;
+    }): Promise<void>;
+}
+/** Browser-side workspace-model API surface (for the /workspace-model/* routes). */
+export declare class WorkspaceModelApi {
+    /** POST /workspace-model/get — the preset for one workspace path. Reads
+     *  never block the UI: a missing route (host half not yet loaded), a
+     *  transport failure, or an errored envelope all yield `preset: undefined`
+     *  so the caller can still open the editor with empty fields. */
+    get(path: string): Promise<WorkspaceModelView>;
+    /** GET /workspace-model/list — every preset keyed by workspace path. */
+    list(): Promise<WorkspaceModelView[]>;
+    /** POST /workspace-model/set — store a preset for one workspace path. */
+    set(path: string, preset: WorkspaceModelPreset): Promise<WorkspaceModelPreset>;
+    /** POST /workspace-model/clear — remove a workspace's preset. */
+    clear(path: string): Promise<boolean>;
+}
+//# sourceMappingURL=api.d.ts.map

package/lib/types/client/conversation/worktree/api.d.ts.map

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

package/lib/types/client/conversation/worktree/api.js

@@ -0,0 +1,239 @@
+/**
+ * Browser HTTP client for the /worktree/* endpoints. Mirrors the host
+ * `WorktreeResponse<T>` envelope so success/error paths land on the same
+ * type unions as the manager.
+ *
+ * Every request carries a deadline: a host stalled on `git fetch` (or a dropped
+ * network) has to fail visibly instead of leaving the panel loading forever.
+ * Failures also keep their kind, because "the fence refused this browser" and
+ * "git failed" must not render as the same message — or, worse, as the empty
+ * state that means "no registered git repository workspaces".
+ * @module dsh-client-ui-worktree/client/api
+ */
+/** Default API prefix — must match `host/routes.ts`. */
+const API_PREFIX = '/worktree';
+/** Default API prefix for workspace-model endpoints — must match `host/workspace-model-routes.ts`. */
+const MODEL_API_PREFIX = '/workspace-model';
+/** Deadline for a read; `status` runs a network `git fetch` on the host. */
+const READ_TIMEOUT_MS = 30_000;
+/** Deadline for a mutation that only touches the local repository. */
+const MUTATION_TIMEOUT_MS = 60_000;
+/** Deadline for a mutation that pushes to the remote. */
+const PUSH_TIMEOUT_MS = 180_000;
+/**
+ * Thrown by the client when the HTTP layer rejects the request before the
+ * envelope. The browser side treats these as transient and surfaces them in
+ * the toast/error banner instead of crashing the sidebar.
+ */
+export class WorktreeApiError extends Error {
+    status;
+    kind;
+    code;
+    constructor(message, status, kind = 'transport', code) {
+        super(message);
+        this.status = status;
+        this.kind = kind;
+        this.code = code;
+        this.name = 'WorktreeApiError';
+    }
+}
+/** AbortSignal.timeout when the runtime has it; jsdom and old engines do not. */
+function deadlineSignal(timeoutMs) {
+    const factory = AbortSignal.timeout;
+    if (typeof factory !== 'function')
+        return undefined;
+    try {
+        return factory.call(AbortSignal, timeoutMs);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** fetch with a deadline; a stalled or aborted request becomes a transport error. */
+async function request(path, init, timeoutMs) {
+    try {
+        const signal = deadlineSignal(timeoutMs);
+        return await fetch(path, signal === undefined ? init : { ...init, signal });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const aborted = error instanceof Error && (error.name === 'TimeoutError' || error.name === 'AbortError');
+        throw new WorktreeApiError(aborted ? `the worktree host did not answer within ${String(timeoutMs)}ms` : message, 0, 'transport');
+    }
+}
+/** JSON POST helper shared by every mutation. */
+async function postJson(path, body, timeoutMs) {
+    return request(path, {
+        method: 'POST',
+        credentials: 'same-origin',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+    }, timeoutMs);
+}
+/** The refusal text of a non-envelope body (`{ error }` / `{ error: { message } }`). */
+function refusalMessageOf(body) {
+    if (typeof body !== 'object' || body === null)
+        return undefined;
+    const value = body.error;
+    if (typeof value === 'string' && value !== '')
+        return value;
+    if (typeof value === 'object' && value !== null) {
+        const message = value.message;
+        if (typeof message === 'string' && message !== '')
+            return message;
+    }
+    return undefined;
+}
+/** The error kind implied by a bare HTTP status. */
+function kindForStatus(status) {
+    return status === 401 || status === 403 ? 'permission' : 'transport';
+}
+/** A readable message for a status that arrived without the envelope. */
+function statusMessage(status) {
+    return status === 401 || status === 403
+        ? 'this browser is not admitted to the worktree host surface'
+        : `worktree endpoint failed with HTTP ${String(status)}`;
+}
+/** Parse a JSON response into the worktree envelope, throwing on transport failure. */
+async function envelope(response) {
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        if (!response.ok)
+            throw new WorktreeApiError(statusMessage(response.status), response.status, kindForStatus(response.status));
+        throw new WorktreeApiError(`worktree endpoint returned a non-JSON body (status ${response.status})`, response.status, 'malformed');
+    }
+    if (typeof body !== 'object' || body === null
+        || typeof body.ok !== 'boolean') {
+        // A fence refusal answers `{ error: ... }` without the envelope: report it
+        // as a refusal rather than as a protocol break.
+        if (!response.ok) {
+            throw new WorktreeApiError(refusalMessageOf(body) ?? statusMessage(response.status), response.status, kindForStatus(response.status));
+        }
+        throw new WorktreeApiError('worktree endpoint returned a malformed envelope', response.status, 'malformed');
+    }
+    return body;
+}
+/** The stable domain code of an `ok:false` envelope, when it carries one. */
+function codeOf(envelope) {
+    const code = envelope.code;
+    return typeof code === 'string' ? code : undefined;
+}
+/** Throw a `WorktreeApiError` for any `ok: false` envelope. */
+function unwrap(envelope) {
+    if (envelope.ok)
+        return envelope.value;
+    throw new WorktreeApiError(envelope.message, 0, 'domain', codeOf(envelope));
+}
+/** The browser-side worktree API surface. */
+export class WorktreeApi {
+    /**
+     * GET /worktree/tree — the registered projects and their lanes.
+     * Returns null only for a host half that does not serve the route (404);
+     * a refusal, a failure or a broken envelope throws so the panel can say so
+     * instead of rendering the "no git repository workspaces" empty state.
+     */
+    async tree() {
+        const response = await request(`${API_PREFIX}/tree`, { credentials: 'same-origin' }, READ_TIMEOUT_MS);
+        if (response.status === 404)
+            return null;
+        return unwrap(await envelope(response));
+    }
+    /** POST /worktree/create */
+    async create(input) {
+        return unwrap(await envelope(await postJson(`${API_PREFIX}/create`, input, MUTATION_TIMEOUT_MS)));
+    }
+    /** POST /worktree/remove */
+    async remove(input) {
+        return unwrap(await envelope(await postJson(`${API_PREFIX}/remove`, input, MUTATION_TIMEOUT_MS)));
+    }
+    /** POST /worktree/init */
+    async init(input) {
+        return unwrap(await envelope(await postJson(`${API_PREFIX}/init`, input, MUTATION_TIMEOUT_MS)));
+    }
+    /** POST /worktree/pr-create — push the branch and obtain a PR page. */
+    async prCreate(input) {
+        return unwrap(await envelope(await postJson(`${API_PREFIX}/pr-create`, input, PUSH_TIMEOUT_MS)));
+    }
+    /** POST /worktree/status — per-repo PR/merge status. */
+    async status(input) {
+        return unwrap(await envelope(await postJson(`${API_PREFIX}/status`, input, READ_TIMEOUT_MS)));
+    }
+    /** POST /worktree/cleanup — teardown a merged worktree. */
+    async cleanup(input) {
+        return unwrap(await envelope(await postJson(`${API_PREFIX}/cleanup`, input, MUTATION_TIMEOUT_MS)));
+    }
+    /**
+     * POST /worktree/lane — resolve the lane a session (or a path) belongs to.
+     * Never throws: this feeds the conversation header chip, which must
+     * degrade to "no chip" rather than break the header, so a missing route
+     * (older host half), a fence refusal, an envelope error and a transport
+     * failure all yield `null`.
+     */
+    async lane(input) {
+        try {
+            const response = await postJson(`${API_PREFIX}/lane`, input, READ_TIMEOUT_MS);
+            if (response.status === 404)
+                return null;
+            const env = await envelope(response);
+            return env.ok ? env.value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** POST /worktree/lane/create — create the lane (worktree + workspace).
+     *  The session itself is created by the platform's own create path. */
+    async createLane(input) {
+        return unwrap(await envelope(await postJson(`${API_PREFIX}/lane/create`, input, MUTATION_TIMEOUT_MS)));
+    }
+    /** POST /worktree/lane/bind — attach the created session to its lane and
+     *  apply the lane's permission preset. */
+    async bindLane(input) {
+        return unwrap(await envelope(await postJson(`${API_PREFIX}/lane/bind`, input, MUTATION_TIMEOUT_MS)));
+    }
+    /** POST /worktree/lane/rollback — undo a lane whose session never came up. */
+    async rollbackLane(input) {
+        unwrap(await envelope(await postJson(`${API_PREFIX}/lane/rollback`, input, MUTATION_TIMEOUT_MS)));
+    }
+}
+/** Browser-side workspace-model API surface (for the /workspace-model/* routes). */
+export class WorkspaceModelApi {
+    /** POST /workspace-model/get — the preset for one workspace path. Reads
+     *  never block the UI: a missing route (host half not yet loaded), a
+     *  transport failure, or an errored envelope all yield `preset: undefined`
+     *  so the caller can still open the editor with empty fields. */
+    async get(path) {
+        try {
+            const response = await postJson(`${MODEL_API_PREFIX}/get`, { path }, READ_TIMEOUT_MS);
+            if (response.status === 404)
+                return { path, preset: undefined };
+            const env = await envelope(response);
+            return env.ok ? env.value : { path, preset: undefined };
+        }
+        catch {
+            return { path, preset: undefined };
+        }
+    }
+    /** GET /workspace-model/list — every preset keyed by workspace path. */
+    async list() {
+        try {
+            const response = await request(`${MODEL_API_PREFIX}/list`, { credentials: 'same-origin' }, READ_TIMEOUT_MS);
+            const env = await envelope(response);
+            return env.ok ? env.value : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /** POST /workspace-model/set — store a preset for one workspace path. */
+    async set(path, preset) {
+        return unwrap(await envelope(await postJson(`${MODEL_API_PREFIX}/set`, { path, preset }, MUTATION_TIMEOUT_MS)));
+    }
+    /** POST /workspace-model/clear — remove a workspace's preset. */
+    async clear(path) {
+        return unwrap(await envelope(await postJson(`${MODEL_API_PREFIX}/clear`, { path }, MUTATION_TIMEOUT_MS)));
+    }
+}

package/lib/types/client/conversation/worktree/dialogs/DeleteWorktreeDialog.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Delete dialog: one action replaced the two that users could not tell apart
+ * ("clean up worktree" vs "remove worktree"). The choice they actually make is
+ * whether the local branch goes too, so that is the checkbox:
+ *
+ *   - unchecked -> host `remove`: deletes the directory and its record, keeps
+ *     the local branch, so a directory can be made for it again later;
+ *   - checked   -> host `cleanup`: also deletes the local branch, which the
+ *     host only allows once the branch is merged (or when forced).
+ *
+ * The force checkbox is not a mode the user has to understand up front: it
+ * appears exactly when the host will demand it — uncommitted changes anywhere,
+ * or deleting an unmerged branch — and says what it costs. A merged, clean
+ * directory therefore deletes in one click with no choices at all.
+ * @module @dsh-cove/dsh-client-ui-worktree/client/dialogs/delete
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { WorktreeApi } from '../api.ts';
+export declare function DeleteWorktreeDialog(props: {
+    repoPath: string;
+    name: string;
+    /** Whether the branch is merged: decides the branch checkbox's default. */
+    merged: boolean;
+    /** Uncommitted files in the directory: the host needs force to drop them. */
+    dirty: number;
+    api: WorktreeApi;
+    /** The asking conversation, when this directory is its own: the host accepts
+     *  that conversation's teardown instead of reporting it as a busy session
+     *  (deleting archives a directory's conversation either way). */
+    sessionId?: string;
+    onClose: () => void;
+    onRemoved: () => void;
+    t: PropsLocale<'worktree'>['t'];
+}): JSX.Element;
+//# sourceMappingURL=DeleteWorktreeDialog.d.ts.map

package/lib/types/client/conversation/worktree/dialogs/DeleteWorktreeDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeleteWorktreeDialog.d.ts","sourceRoot":"","sources":["../../../../../../src/client/conversation/worktree/dialogs/DeleteWorktreeDialog.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAEnE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAIvC,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,2EAA2E;IAC3E,MAAM,EAAE,OAAO,CAAA;IACf,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,WAAW,CAAA;IAChB;;qEAEiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAA;CAChC,GAAG,GAAG,CAAC,OAAO,CAuEd"}

package/lib/types/client/conversation/worktree/dialogs/DeleteWorktreeDialog.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Delete dialog: one action replaced the two that users could not tell apart
+ * ("clean up worktree" vs "remove worktree"). The choice they actually make is
+ * whether the local branch goes too, so that is the checkbox:
+ *
+ *   - unchecked -> host `remove`: deletes the directory and its record, keeps
+ *     the local branch, so a directory can be made for it again later;
+ *   - checked   -> host `cleanup`: also deletes the local branch, which the
+ *     host only allows once the branch is merged (or when forced).
+ *
+ * The force checkbox is not a mode the user has to understand up front: it
+ * appears exactly when the host will demand it — uncommitted changes anywhere,
+ * or deleting an unmerged branch — and says what it costs. A merged, clean
+ * directory therefore deletes in one click with no choices at all.
+ * @module @dsh-cove/dsh-client-ui-worktree/client/dialogs/delete
+ */
+import { useState } from 'react';
+import { Button, Modal } from '@deepseek-ai/dsh-client-ui-primitives';
+import { worktreeErrorMessage } from "../lifecycle.js";
+import styles from '../worktree.module.css';
+export function DeleteWorktreeDialog(props) {
+    const { repoPath, name, merged, dirty, api, sessionId, onClose, onRemoved, t } = props;
+    // Default to finishing the branch off when the host already calls it merged;
+    // otherwise keep the branch, because deleting an unmerged branch needs force.
+    const [deleteBranch, setDeleteBranch] = useState(merged);
+    const [force, setForce] = useState(false);
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(null);
+    /** The host refuses these cases without force; ask instead of failing. */
+    const needsForce = dirty > 0 || (deleteBranch && !merged);
+    const effectiveForce = needsForce && force;
+    /** Closing mid-flight would hide a delete that is already running. */
+    const guardClose = () => { if (!busy)
+        onClose(); };
+    const submit = async () => {
+        if (busy)
+            return;
+        setBusy(true);
+        setError(null);
+        try {
+            const input = { repoPath, name, force: effectiveForce, ...(sessionId === undefined ? {} : { sessionId }) };
+            if (deleteBranch)
+                await api.cleanup(input);
+            else
+                await api.remove(input);
+            onRemoved();
+        }
+        catch (err) {
+            setError(err);
+            setBusy(false);
+        }
+    };
+    return (_jsx(Modal, { open: true, onClose: guardClose, closeLabel: t('dialog.close'), title: t('worktree.deleteTitle', { name }), description: t('worktree.deleteDescription'), footer: (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", disabled: busy, onClick: guardClose, children: t('dialog.cancel') }), _jsx(Button, { variant: "primary", disabled: busy, onClick: () => { void submit(); }, children: busy ? t('dialog.confirm') : t('worktree.deleteConfirm') })] })), children: _jsxs("div", { className: styles.dialogBody, children: [_jsxs("label", { className: styles.checkboxRow, children: [_jsx("input", { type: "checkbox", checked: deleteBranch, onChange: (event) => { setDeleteBranch(event.target.checked); setError(null); }, disabled: busy }), _jsx("span", { children: t('worktree.deleteBranch') })] }), _jsx("div", { className: styles.dialogHint, children: t('worktree.deleteBranchHint') }), needsForce && (_jsxs("label", { className: styles.checkboxRow, children: [_jsx("input", { type: "checkbox", checked: force, onChange: (event) => { setForce(event.target.checked); }, disabled: busy }), _jsx("span", { children: t('worktree.deleteForce') })] })), needsForce && force && (_jsx("div", { className: styles.dialogError, role: "alert", children: t('worktree.deleteForceWarning') })), error !== null && _jsx("div", { className: styles.dialogError, role: "alert", children: worktreeErrorMessage(error, t) })] }) }));
+}

package/lib/types/client/conversation/worktree/dialogs/PrCreateDialog.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Create-PR dialog: pick the PR target base branch (dropdown over the
+ * repo's candidate branches, defaulted to the last status probe), push the
+ * worktree branch, and obtain the PR page. Calls `api.prCreate` on confirm;
+ * on success the dialog shows the resulting PR url with an open button
+ * (window.open in a user gesture). The parent reloads the worktree index and
+ * the PR status as soon as the push/PR landed (`onSettled`), so closing the
+ * dialog with Escape while the request is in flight cannot lose the result;
+ * closes are refused while the request is running.
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { WorktreeApi } from '../api.ts';
+export declare function PrCreateDialog(props: {
+    repoPath: string;
+    name: string;
+    /** Candidate base branches (local first, then origin/*). */
+    branches: string[];
+    /** Default PR target base branch (from the last status probe). */
+    defaultBaseRef: string;
+    api: WorktreeApi;
+    onClose: () => void;
+    onCreated: () => void;
+    /** The host state changed: refresh the panel without closing this dialog. */
+    onSettled: () => void;
+    t: PropsLocale<'worktree'>['t'];
+}): JSX.Element;
+//# sourceMappingURL=PrCreateDialog.d.ts.map

package/lib/types/client/conversation/worktree/dialogs/PrCreateDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrCreateDialog.d.ts","sourceRoot":"","sources":["../../../../../../src/client/conversation/worktree/dialogs/PrCreateDialog.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAEnE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAKvC,wBAAgB,cAAc,CAAC,KAAK,EAAE;IACpC,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,kEAAkE;IAClE,cAAc,EAAE,MAAM,CAAA;IACtB,GAAG,EAAE,WAAW,CAAA;IAChB,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,6EAA6E;IAC7E,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAA;CAChC,GAAG,GAAG,CAAC,OAAO,CAiFd"}

package/lib/types/client/conversation/worktree/dialogs/PrCreateDialog.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Create-PR dialog: pick the PR target base branch (dropdown over the
+ * repo's candidate branches, defaulted to the last status probe), push the
+ * worktree branch, and obtain the PR page. Calls `api.prCreate` on confirm;
+ * on success the dialog shows the resulting PR url with an open button
+ * (window.open in a user gesture). The parent reloads the worktree index and
+ * the PR status as soon as the push/PR landed (`onSettled`), so closing the
+ * dialog with Escape while the request is in flight cannot lose the result;
+ * closes are refused while the request is running.
+ */
+import { useState } from 'react';
+import { Button, Modal } from '@deepseek-ai/dsh-client-ui-primitives';
+import { worktreeErrorMessage } from "../lifecycle.js";
+import styles from '../worktree.module.css';
+export function PrCreateDialog(props) {
+    const { repoPath, name, branches, defaultBaseRef, api, onClose, onCreated, onSettled, t } = props;
+    const [baseRef, setBaseRef] = useState(() => (defaultBaseRef !== '' && (branches.length === 0 || branches.includes(defaultBaseRef))
+        ? defaultBaseRef
+        : (branches[0] ?? defaultBaseRef)));
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    /** Closing mid-flight would drop a PR that the host already created. */
+    const guardClose = () => { if (!busy)
+        onClose(); };
+    const submit = async () => {
+        if (busy)
+            return;
+        setBusy(true);
+        setError(null);
+        try {
+            const created = await api.prCreate({
+                repoPath,
+                name,
+                ...(baseRef.trim() !== '' ? { baseRef: baseRef.trim() } : {}),
+            });
+            setResult(created);
+            // Refresh the panel now, not when the user dismisses the result view.
+            onSettled();
+            setBusy(false);
+        }
+        catch (err) {
+            setError(err);
+            setBusy(false);
+        }
+    };
+    return (_jsx(Modal, { open: true, onClose: guardClose, closeLabel: t('dialog.close'), title: t('worktree.prTitle', { name }), description: t('worktree.prDescription'), footer: result === null ? (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", disabled: busy, onClick: guardClose, children: t('dialog.cancel') }), _jsx(Button, { variant: "primary", disabled: busy, onClick: () => { void submit(); }, children: busy ? t('dialog.confirm') : t('worktree.prConfirm') })] })) : (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", onClick: () => { onCreated(); onClose(); }, children: t('dialog.confirm') }), _jsx(Button, { variant: "primary", onClick: () => { window.open(result.prUrl, '_blank', 'noopener,noreferrer'); onCreated(); onClose(); }, children: t('worktree.prOpen') })] })), children: result === null ? (_jsxs("div", { className: styles.dialogBody, children: [_jsxs("label", { className: styles.field, children: [_jsx("span", { className: styles.fieldLabel, children: t('worktree.prBase') }), _jsxs("select", { className: styles.fieldInput, value: baseRef, onChange: (event) => { setBaseRef(event.target.value); setError(null); }, disabled: busy, children: [branches.length === 0 && _jsx("option", { value: baseRef, children: baseRef }), branches.map((name) => _jsx("option", { value: name, children: name }, name))] })] }), error !== null && _jsx("div", { className: styles.dialogError, role: "alert", children: worktreeErrorMessage(error, t) })] })) : (_jsxs("div", { className: styles.dialogBody, children: [_jsx("div", { className: styles.successText, role: "status", children: t('worktree.prSuccess') }), _jsx("div", { className: styles.prUrl, children: result.prUrl })] })) }));
+}

package/lib/types/client/conversation/worktree/lane-binding.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Recording which conversation a lane belongs to.
+ *
+ * A lane is a DSH workspace now, so a conversation can arrive on it from
+ * anywhere: this plugin's branch picker, the shell's own workspace selector, or
+ * a selection restored after a reload. Whenever a conversation's cwd is a lane,
+ * the host has to know the pairing, because two things key off it:
+ *
+ *   - the lane's `danger-full-access` preset. A linked worktree keeps its git
+ *     directory in `<repo>/.git/worktrees/<name>/`, outside the session cwd, so
+ *     a confined sandbox cannot write the index, objects or refs — the agent
+ *     could not commit at all;
+ *   - the teardown guards, which refuse to delete the directory a running
+ *     conversation works in.
+ *
+ * The binding is idempotent and attempted once per session per page load: a
+ * refusal is reported (the chip warns that the lane may not be able to commit)
+ * but never retried in a loop.
+ * @module @dsh-cove/dsh-client-ui-worktree/client/lane-binding
+ */
+import type { BindLaneInput, BindLaneResult, LaneLookupInput, LaneView } from '../../../core/worktree/types.ts';
+/** The outcome of resolving (and, when needed, recording) a session's lane. */
+export interface LaneBinding {
+    /** The lane this session runs in, or null when it runs outside one. */
+    lane: LaneView | null;
+    /** The lane exists but the host refused to record this conversation on it. */
+    bindFailed: boolean;
+}
+/** Resolve the lane a session runs in, recording the pairing on first sight. */
+export interface LaneBinder {
+    /** @param sessionId - the conversation asking; undefined resolves to no lane. */
+    bind(sessionId: string | undefined): Promise<LaneBinding>;
+}
+/**
+ * Build a binder over the two calls it needs.
+ *
+ * They are passed in rather than imported so each surface keeps its own
+ * injected face (the header chip receives its lookup; the composer hands its
+ * own), and so tests can drive the binder without a network.
+ * @param faces - `/worktree/lane` and `/worktree/lane/bind`.
+ */
+export declare function createLaneBinder(faces: {
+    lane: (input: LaneLookupInput) => Promise<LaneView | null>;
+    bindLane: (input: BindLaneInput) => Promise<BindLaneResult>;
+}): LaneBinder;
+//# sourceMappingURL=lane-binding.d.ts.map

package/lib/types/client/conversation/worktree/lane-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane-binding.d.ts","sourceRoot":"","sources":["../../../../../src/client/conversation/worktree/lane-binding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAE/G,+EAA+E;AAC/E,MAAM,WAAW,WAAW;IAC1B,uEAAuE;IACvE,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAA;IACrB,8EAA8E;IAC9E,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,gFAAgF;AAChF,MAAM,WAAW,UAAU;IACzB,iFAAiF;IACjF,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;CAC1D;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,IAAI,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAA;IAC1D,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,cAAc,CAAC,CAAA;CAC5D,GAAG,UAAU,CA4Bb"}

package/lib/types/client/conversation/worktree/lane-binding.js

@@ -0,0 +1,60 @@
+/**
+ * Recording which conversation a lane belongs to.
+ *
+ * A lane is a DSH workspace now, so a conversation can arrive on it from
+ * anywhere: this plugin's branch picker, the shell's own workspace selector, or
+ * a selection restored after a reload. Whenever a conversation's cwd is a lane,
+ * the host has to know the pairing, because two things key off it:
+ *
+ *   - the lane's `danger-full-access` preset. A linked worktree keeps its git
+ *     directory in `<repo>/.git/worktrees/<name>/`, outside the session cwd, so
+ *     a confined sandbox cannot write the index, objects or refs — the agent
+ *     could not commit at all;
+ *   - the teardown guards, which refuse to delete the directory a running
+ *     conversation works in.
+ *
+ * The binding is idempotent and attempted once per session per page load: a
+ * refusal is reported (the chip warns that the lane may not be able to commit)
+ * but never retried in a loop.
+ * @module @dsh-cove/dsh-client-ui-worktree/client/lane-binding
+ */
+/**
+ * Build a binder over the two calls it needs.
+ *
+ * They are passed in rather than imported so each surface keeps its own
+ * injected face (the header chip receives its lookup; the composer hands its
+ * own), and so tests can drive the binder without a network.
+ * @param faces - `/worktree/lane` and `/worktree/lane/bind`.
+ */
+export function createLaneBinder(faces) {
+    const attempted = new Set();
+    return {
+        bind: async (sessionId) => {
+            if (sessionId === undefined)
+                return { lane: null, bindFailed: false };
+            let lane;
+            try {
+                lane = await faces.lane({ sessionId });
+            }
+            catch {
+                return { lane: null, bindFailed: false };
+            }
+            if (lane === null || lane.sessionId === sessionId || attempted.has(sessionId)) {
+                return { lane, bindFailed: false };
+            }
+            attempted.add(sessionId);
+            try {
+                const bound = await faces.bindLane({
+                    repoPath: lane.repoPath,
+                    branch: lane.branch ?? lane.name,
+                    sessionId,
+                });
+                return { lane: bound.lane ?? lane, bindFailed: false };
+            }
+            catch (error) {
+                console.warn('[dsh-worktree] could not record this conversation on its lane:', error);
+                return { lane, bindFailed: true };
+            }
+        },
+    };
+}