byterover-cli 2.6.0 → 3.0.1

package/dist/tui/features/vc/clone/components/vc-clone-flow.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { VcEvents } from '../../../../../shared/transport/events/vc-events.js';
+import { InlineInput } from '../../../../components/inline-prompts/inline-input.js';
+import { useTheme } from '../../../../hooks/index.js';
+import { getWebAppUrl } from '../../../../lib/environment.js';
+import { useTransportStore } from '../../../../stores/transport-store.js';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcClone } from '../api/execute-vc-clone.js';
+function validateRemoteUrl(value) {
+    if (!value)
+        return 'URL is required';
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== 'https:') {
+            return 'URL must start with https://';
+        }
+        return true;
+    }
+    catch {
+        return 'Invalid URL';
+    }
+}
+export function VcCloneFlow({ onCancel, onComplete, url }) {
+    const { theme: { colors }, } = useTheme();
+    const [step, setStep] = useState(url ? 'cloning' : 'entering_url');
+    const [cloneUrl, setCloneUrl] = useState(url ?? null);
+    const [cloneError, setCloneError] = useState(null);
+    const [progressMessages, setProgressMessages] = useState([]);
+    const mutatedRef = useRef(false);
+    const cloneMutation = useExecuteVcClone();
+    useInput((_, key) => {
+        if (key.escape && !cloneMutation.isPending) {
+            onCancel();
+        }
+    });
+    useEffect(() => {
+        if (step !== 'cloning' || mutatedRef.current || !cloneUrl)
+            return;
+        mutatedRef.current = true;
+        const { apiClient } = useTransportStore.getState();
+        const unsub = apiClient?.on(VcEvents.CLONE_PROGRESS, (evt) => {
+            setProgressMessages((prev) => [...prev, evt.message]);
+        });
+        cloneMutation.mutate({ url: cloneUrl }, {
+            onError(err) {
+                unsub?.();
+                mutatedRef.current = false;
+                if (url) {
+                    onComplete(formatTransportError(err));
+                }
+                else {
+                    setCloneError(formatTransportError(err));
+                    setStep('entering_url');
+                }
+            },
+            onSuccess(result) {
+                unsub?.();
+                const label = result.teamName && result.spaceName ? `${result.teamName}/${result.spaceName}` : 'repository';
+                onComplete(`Cloned ${label} successfully.`);
+            },
+        });
+        return () => {
+            unsub?.();
+        };
+    }, [onComplete, step, cloneUrl, url]);
+    const handleUrlSubmit = useCallback((submittedUrl) => {
+        setCloneError(null);
+        setProgressMessages([]);
+        setCloneUrl(submittedUrl);
+        setStep('cloning');
+    }, []);
+    if (step === 'cloning') {
+        return (_jsxs(_Fragment, { children: [progressMessages.map((msg, idx) => (_jsx(Text, { children: msg }, idx))), _jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Cloning..."] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [cloneError && _jsx(Text, { color: colors.errorText, children: cloneError }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "To clone a space:" }), _jsxs(Text, { children: ['  ', "Go to ", _jsx(Text, { bold: true, children: getWebAppUrl() }), " \u2192 create or open a Space"] }), _jsxs(Text, { children: ['  ', "and copy the remote URL."] })] }), _jsx(InlineInput, { message: "Paste your remote URL:", onSubmit: handleUrlSubmit, validate: validateRemoteUrl })] }));
+}

package/dist/tui/features/vc/commit/api/execute-vc-commit.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcCommitRequest, type IVcCommitResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcCommit: (request: IVcCommitRequest) => Promise<IVcCommitResponse>;
+type UseExecuteVcCommitOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcCommit>;
+};
+export declare const useExecuteVcCommit: ({ mutationConfig }?: UseExecuteVcCommitOptions) => import("@tanstack/react-query").UseMutationResult<IVcCommitResponse, Error, IVcCommitRequest, unknown>;
+export {};

package/dist/tui/features/vc/commit/api/execute-vc-commit.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/react-query';
+import { VcEvents, } from '../../../../../shared/transport/events/vc-events.js';
+import { useTransportStore } from '../../../../stores/transport-store.js';
+export const executeVcCommit = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.COMMIT, request);
+};
+export const useExecuteVcCommit = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcCommit,
+});

package/dist/tui/features/vc/commit/components/vc-commit-flow.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcCommitFlowProps = CustomDialogCallbacks & {
+    message: string;
+};
+export declare function VcCommitFlow({ message, onCancel, onComplete }: VcCommitFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/commit/components/vc-commit-flow.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcCommit } from '../api/execute-vc-commit.js';
+export function VcCommitFlow({ message, onCancel, onComplete }) {
+    const commitMutation = useExecuteVcCommit();
+    useInput((_, key) => {
+        if (key.escape && !commitMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        commitMutation.mutate({ message }, {
+            onError(error) {
+                onComplete(`Failed to commit: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                onComplete(`[${result.sha.slice(0, 7)}] ${result.message}`);
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Committing..."] }));
+}

package/dist/tui/features/vc/config/api/execute-vc-config.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcConfigRequest, type IVcConfigResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcConfig: (request: IVcConfigRequest) => Promise<IVcConfigResponse>;
+type UseExecuteVcConfigOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcConfig>;
+};
+export declare const useExecuteVcConfig: ({ mutationConfig }?: UseExecuteVcConfigOptions) => import("@tanstack/react-query").UseMutationResult<IVcConfigResponse, Error, IVcConfigRequest, unknown>;
+export {};

package/dist/tui/features/vc/config/api/execute-vc-config.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/react-query';
+import { VcEvents, } from '../../../../../shared/transport/events/vc-events.js';
+import { useTransportStore } from '../../../../stores/transport-store.js';
+export const executeVcConfig = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.CONFIG, request);
+};
+export const useExecuteVcConfig = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcConfig,
+});

package/dist/tui/features/vc/config/components/vc-config-flow.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { VcConfigKey } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcConfigFlowProps = CustomDialogCallbacks & {
+    configKey: VcConfigKey;
+    value?: string;
+};
+export declare function VcConfigFlow({ configKey, onCancel, onComplete, value }: VcConfigFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/config/components/vc-config-flow.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcConfig } from '../api/execute-vc-config.js';
+export function VcConfigFlow({ configKey, onCancel, onComplete, value }) {
+    const configMutation = useExecuteVcConfig();
+    useInput((_, key) => {
+        if (key.escape && !configMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        configMutation.mutate({ key: configKey, value }, {
+            onError(error) {
+                onComplete(`Failed: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                onComplete(`${result.key} = ${result.value}`);
+            },
+        });
+    }, []);
+    const action = value === undefined ? 'Getting' : 'Setting';
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", action, " ", configKey, "..."] }));
+}

package/dist/tui/features/vc/fetch/api/execute-vc-fetch.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcFetchRequest, type IVcFetchResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcFetch: (request: IVcFetchRequest) => Promise<IVcFetchResponse>;
+type UseExecuteVcFetchOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcFetch>;
+};
+export declare const useExecuteVcFetch: ({ mutationConfig }?: UseExecuteVcFetchOptions) => import("@tanstack/react-query").UseMutationResult<IVcFetchResponse, Error, IVcFetchRequest, unknown>;
+export {};

package/dist/tui/features/vc/fetch/api/execute-vc-fetch.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/react-query';
+import { VcEvents, } from '../../../../../shared/transport/events/vc-events.js';
+import { useTransportStore } from '../../../../stores/transport-store.js';
+export const executeVcFetch = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.FETCH, request);
+};
+export const useExecuteVcFetch = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcFetch,
+});

package/dist/tui/features/vc/fetch/components/vc-fetch-flow.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcFetchFlowProps = CustomDialogCallbacks & {
+    ref?: string;
+    remote?: string;
+};
+export declare function VcFetchFlow({ onCancel, onComplete, ref: refProp, remote }: VcFetchFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/fetch/components/vc-fetch-flow.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { VcErrorCode } from '../../../../../shared/transport/events/vc-events.js';
+import { InlineInput } from '../../../../components/inline-prompts/inline-input.js';
+import { useTheme } from '../../../../hooks/index.js';
+import { getWebAppUrl } from '../../../../lib/environment.js';
+import { formatTransportError, getTransportErrorCode } from '../../../../utils/error-messages.js';
+import { useExecuteVcRemote } from '../../remote/api/execute-vc-remote.js';
+import { useExecuteVcFetch } from '../api/execute-vc-fetch.js';
+function validateRemoteUrl(value) {
+    if (!value)
+        return 'URL is required';
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== 'https:') {
+            return 'URL must start with https://';
+        }
+        return true;
+    }
+    catch {
+        return 'Invalid URL';
+    }
+}
+export function VcFetchFlow({ onCancel, onComplete, ref: refProp, remote }) {
+    const { theme: { colors }, } = useTheme();
+    const [step, setStep] = useState('fetching');
+    const fetchMutation = useExecuteVcFetch();
+    const remoteMutation = useExecuteVcRemote();
+    useInput((_, key) => {
+        if (key.escape && !fetchMutation.isPending && !remoteMutation.isPending) {
+            onCancel();
+        }
+    });
+    const executeFetch = useCallback(() => {
+        fetchMutation.mutate({ ref: refProp, remote }, {
+            onError(error) {
+                if (getTransportErrorCode(error) === VcErrorCode.NO_REMOTE) {
+                    setStep('configuring_remote');
+                    return;
+                }
+                onComplete(`Failed to fetch: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                onComplete(`Fetched from ${result.remote}.`);
+            },
+        });
+    }, [fetchMutation, onComplete, refProp, remote]);
+    const fired = useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        executeFetch();
+    }, []);
+    const handleUrlSubmit = useCallback((url) => {
+        remoteMutation.mutate({ subcommand: 'add', url }, {
+            onError(error) {
+                onComplete(`Failed to add remote: ${formatTransportError(error)}`);
+            },
+            onSuccess() {
+                setStep('fetching');
+                executeFetch();
+            },
+        });
+    }, [executeFetch, onComplete, remoteMutation]);
+    if (step === 'configuring_remote') {
+        if (remoteMutation.isPending) {
+            return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Adding remote..."] }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.warning, children: "No remote configured." }), _jsx(Text, {}), _jsx(Text, { children: "To connect to cloud:" }), _jsxs(Text, { children: ["  Go to ", _jsx(Text, { bold: true, children: getWebAppUrl() }), " \u2192 create or open a Space"] }), _jsx(Text, { children: "  and copy the remote URL." })] }), _jsx(InlineInput, { message: "Paste your remote URL:", onSubmit: handleUrlSubmit, validate: validateRemoteUrl })] }));
+    }
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Fetching..."] }));
+}

package/dist/tui/features/vc/init/api/execute-vc-init.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcInitResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcInit: () => Promise<IVcInitResponse>;
+type UseExecuteVcInitOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcInit>;
+};
+export declare const useExecuteVcInit: ({ mutationConfig }?: UseExecuteVcInitOptions) => import("@tanstack/react-query").UseMutationResult<IVcInitResponse, Error, undefined, unknown>;
+export {};

package/dist/tui/features/vc/init/api/execute-vc-init.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/react-query';
+import { VcEvents } from '../../../../../shared/transport/events/vc-events.js';
+import { useTransportStore } from '../../../../stores/transport-store.js';
+export const executeVcInit = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.INIT, {});
+};
+export const useExecuteVcInit = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcInit,
+});

package/dist/tui/features/vc/init/components/vc-init-flow.d.ts

@@ -0,0 +1,10 @@
+/**
+ * VcInitFlow Component
+ *
+ * Initializes the git repository in .brv/context-tree/ via VcHandler.
+ */
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcInitFlowProps = CustomDialogCallbacks;
+export declare function VcInitFlow({ onCancel, onComplete }: VcInitFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/init/components/vc-init-flow.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * VcInitFlow Component
+ *
+ * Initializes the git repository in .brv/context-tree/ via VcHandler.
+ */
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcInit } from '../api/execute-vc-init.js';
+export function VcInitFlow({ onCancel, onComplete }) {
+    const initMutation = useExecuteVcInit();
+    useInput((_, key) => {
+        if (key.escape && !initMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        initMutation.mutate(undefined, {
+            onError(error) {
+                onComplete(`Failed to initialize: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                const msg = result.reinitialized
+                    ? `Reinitialized Git repository in ${result.gitDir}`
+                    : `Initialized Git repository in ${result.gitDir}`;
+                onComplete(msg);
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Initializing git repository..."] }));
+}

package/dist/tui/features/vc/merge/api/execute-vc-merge.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcMergeRequest, type IVcMergeResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcMerge: (request: IVcMergeRequest) => Promise<IVcMergeResponse>;
+type UseExecuteVcMergeOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcMerge>;
+};
+export declare const useExecuteVcMerge: ({ mutationConfig }?: UseExecuteVcMergeOptions) => import("@tanstack/react-query").UseMutationResult<IVcMergeResponse, Error, IVcMergeRequest, unknown>;
+export {};

package/dist/tui/features/vc/merge/api/execute-vc-merge.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/react-query';
+import { VcEvents, } from '../../../../../shared/transport/events/vc-events.js';
+import { useTransportStore } from '../../../../stores/transport-store.js';
+export const executeVcMerge = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.MERGE, request);
+};
+export const useExecuteVcMerge = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcMerge,
+});

package/dist/tui/features/vc/merge/components/vc-merge-flow.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { VcMergeAction } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcMergeFlowProps = CustomDialogCallbacks & {
+    action: VcMergeAction;
+    allowUnrelatedHistories?: boolean;
+    branch?: string;
+    message?: string;
+};
+export declare function VcMergeFlow({ action, allowUnrelatedHistories, branch, message, onCancel, onComplete }: VcMergeFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/merge/components/vc-merge-flow.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcMerge } from '../api/execute-vc-merge.js';
+export function VcMergeFlow({ action, allowUnrelatedHistories, branch, message, onCancel, onComplete }) {
+    const mergeMutation = useExecuteVcMerge();
+    useInput((_, key) => {
+        if (key.escape && !mergeMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        const request = { action, allowUnrelatedHistories, branch, message };
+        // For TUI --continue without message: send first to get defaultMessage, then commit with it
+        if (action === 'continue' && !message) {
+            mergeMutation.mutate(request, {
+                onError(error) {
+                    onComplete(`Failed to continue merge: ${formatTransportError(error)}`);
+                },
+                onSuccess(result) {
+                    // Got defaultMessage — now commit with it silently (TUI can't spawn editor)
+                    const commitMessage = result.defaultMessage ?? 'Merge commit';
+                    mergeMutation.mutate({ action: 'continue', message: commitMessage }, {
+                        onError(error) {
+                            onComplete(`Failed to continue merge: ${formatTransportError(error)}`);
+                        },
+                        onSuccess() {
+                            onComplete('Merge commit created.');
+                        },
+                    });
+                },
+            });
+            return;
+        }
+        mergeMutation.mutate(request, {
+            onError(error) {
+                onComplete(`Failed to ${action} merge: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.action === 'abort') {
+                    onComplete('Merge aborted.');
+                    return;
+                }
+                if (result.action === 'continue') {
+                    onComplete('Merge commit created.');
+                    return;
+                }
+                // action: 'merge'
+                if (result.alreadyUpToDate) {
+                    onComplete('Already up to date.');
+                }
+                else if (result.conflicts && result.conflicts.length > 0) {
+                    const conflictLines = result.conflicts
+                        .map((c) => `CONFLICT (${c.type}): ${c.path}`)
+                        .join('\n');
+                    onComplete(`${conflictLines}\nAutomatic merge failed; fix conflicts and then commit the result.`);
+                }
+                else {
+                    onComplete(`Merged branch '${branch}'.`);
+                }
+            },
+        });
+    }, []);
+    const statusText = action === 'abort' ? 'Aborting merge...' : action === 'continue' ? 'Continuing merge...' : `Merging ${branch}...`;
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", statusText] }));
+}

package/dist/tui/features/vc/pull/api/execute-vc-pull.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcPullRequest, type IVcPullResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcPull: (request?: IVcPullRequest) => Promise<IVcPullResponse>;
+type UseExecuteVcPullOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcPull>;
+};
+export declare const useExecuteVcPull: ({ mutationConfig }?: UseExecuteVcPullOptions) => import("@tanstack/react-query").UseMutationResult<IVcPullResponse, Error, IVcPullRequest | undefined, unknown>;
+export {};

package/dist/tui/features/vc/pull/api/execute-vc-pull.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/react-query';
+import { VcEvents } from '../../../../../shared/transport/events/vc-events.js';
+import { useTransportStore } from '../../../../stores/transport-store.js';
+export const executeVcPull = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.PULL, request);
+};
+export const useExecuteVcPull = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcPull,
+});

package/dist/tui/features/vc/pull/components/vc-pull-flow.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcPullFlowProps = CustomDialogCallbacks & {
+    allowUnrelatedHistories?: boolean;
+    branch?: string;
+    remote?: string;
+};
+export declare function VcPullFlow({ allowUnrelatedHistories, branch, onCancel, onComplete, remote }: VcPullFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/pull/components/vc-pull-flow.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { VcErrorCode } from '../../../../../shared/transport/events/vc-events.js';
+import { InlineInput } from '../../../../components/inline-prompts/inline-input.js';
+import { useTheme } from '../../../../hooks/index.js';
+import { getWebAppUrl } from '../../../../lib/environment.js';
+import { formatTransportError, getTransportErrorCode } from '../../../../utils/error-messages.js';
+import { useExecuteVcRemote } from '../../remote/api/execute-vc-remote.js';
+import { useExecuteVcPull } from '../api/execute-vc-pull.js';
+function validateRemoteUrl(value) {
+    if (!value)
+        return 'URL is required';
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== 'https:') {
+            return 'URL must start with https://';
+        }
+        return true;
+    }
+    catch {
+        return 'Invalid URL';
+    }
+}
+export function VcPullFlow({ allowUnrelatedHistories, branch, onCancel, onComplete, remote }) {
+    const { theme: { colors }, } = useTheme();
+    const [step, setStep] = useState('pulling');
+    const pullMutation = useExecuteVcPull();
+    const remoteMutation = useExecuteVcRemote();
+    useInput((_, key) => {
+        if (key.escape && !pullMutation.isPending && !remoteMutation.isPending) {
+            onCancel();
+        }
+    });
+    const executePull = useCallback(() => {
+        pullMutation.mutate({ allowUnrelatedHistories, branch, remote }, {
+            onError(error) {
+                if (getTransportErrorCode(error) === VcErrorCode.NO_REMOTE) {
+                    setStep('configuring_remote');
+                    return;
+                }
+                onComplete(`Failed to pull: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.conflicts && result.conflicts.length > 0) {
+                    const conflictLines = result.conflicts
+                        .map((c) => `CONFLICT (${c.type}): ${c.path}`)
+                        .join('\n');
+                    onComplete(`${conflictLines}\nAutomatic merge failed; fix conflicts and then commit the result.`);
+                }
+                else {
+                    onComplete(result.alreadyUpToDate ? 'Already up to date.' : `Pulled from origin/${result.branch}.`);
+                }
+            },
+        });
+    }, [allowUnrelatedHistories, branch, onComplete, pullMutation, remote]);
+    const fired = useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        executePull();
+    }, []);
+    const handleUrlSubmit = useCallback((url) => {
+        remoteMutation.mutate({ subcommand: 'add', url }, {
+            onError(error) {
+                onComplete(`Failed to add remote: ${formatTransportError(error)}`);
+            },
+            onSuccess() {
+                setStep('pulling');
+                executePull();
+            },
+        });
+    }, [executePull, onComplete, remoteMutation]);
+    if (step === 'configuring_remote') {
+        if (remoteMutation.isPending) {
+            return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Adding remote..."] }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.warning, children: "No remote configured." }), _jsx(Text, {}), _jsx(Text, { children: "To connect to cloud:" }), _jsxs(Text, { children: ["  Go to ", _jsx(Text, { bold: true, children: getWebAppUrl() }), " \u2192 create or open a Space"] }), _jsx(Text, { children: "  and copy the remote URL." })] }), _jsx(InlineInput, { message: "Paste your remote URL:", onSubmit: handleUrlSubmit, validate: validateRemoteUrl })] }));
+    }
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Pulling..."] }));
+}

package/dist/tui/features/vc/push/api/execute-vc-push.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcPushRequest, type IVcPushResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcPush: (request: IVcPushRequest) => Promise<IVcPushResponse>;
+type UseExecuteVcPushOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcPush>;
+};
+export declare const useExecuteVcPush: ({ mutationConfig }?: UseExecuteVcPushOptions) => import("@tanstack/react-query").UseMutationResult<IVcPushResponse, Error, IVcPushRequest, unknown>;
+export {};