byterover-cli 2.5.2 → 3.0.0

package/dist/oclif/commands/vc/clone.js

@@ -0,0 +1,61 @@
+import { Args, Command } from '@oclif/core';
+import { getGitRemoteBaseUrl } from '../../../server/config/environment.js';
+import { InitEvents } from '../../../shared/transport/events/init-events.js';
+import { VcEvents, } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+function subscribeToProgress(client) {
+    let lastWasProgress = false;
+    const unsub = client.on(VcEvents.CLONE_PROGRESS, (evt) => {
+        const isGitProgress = evt.step === 'cloning' && /^\w[\w\s]*: \d/.test(evt.message);
+        if (isGitProgress) {
+            process.stderr.write(`\r\u001B[K${evt.message}`);
+            lastWasProgress = true;
+        }
+        else {
+            if (lastWasProgress)
+                process.stderr.write('\n');
+            process.stderr.write(`${evt.message}\n`);
+            lastWasProgress = false;
+        }
+    });
+    return {
+        cleanup() {
+            if (lastWasProgress)
+                process.stderr.write('\n');
+            unsub();
+        },
+    };
+}
+export default class VcClone extends Command {
+    static args = {
+        url: Args.string({ description: `Clone URL (e.g. ${getGitRemoteBaseUrl()}/<team>/<space>.git)` }),
+    };
+    static description = 'Clone a ByteRover space repository';
+    static examples = [`<%= config.bin %> vc clone ${getGitRemoteBaseUrl()}/acme/project.git`];
+    async run() {
+        const { args } = await this.parse(VcClone);
+        const { url } = args;
+        if (!url) {
+            this.error(`URL is required.\nUsage: brv vc clone ${getGitRemoteBaseUrl()}/<team>/<space>.git`);
+        }
+        const daemonOptions = { projectPath: process.cwd() };
+        try {
+            // Ensure .brv/config.json exists so the daemon registers this cwd as the project root
+            await withDaemonRetry(async (client) => client.requestWithAck(InitEvents.LOCAL, {}), daemonOptions);
+            const result = await withDaemonRetry(async (client) => {
+                const { cleanup } = subscribeToProgress(client);
+                try {
+                    return await client.requestWithAck(VcEvents.CLONE, { url }, { timeout: 120_000 });
+                }
+                finally {
+                    cleanup();
+                }
+            }, daemonOptions);
+            const label = result.teamName && result.spaceName ? `${result.teamName}/${result.spaceName}` : 'repository';
+            this.log(`Cloned ${label} successfully.`);
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/commit.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class VcCommit extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/commit.js

@@ -0,0 +1,32 @@
+import { Command, Flags } from '@oclif/core';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcCommit extends Command {
+    static description = 'Save staged changes as a commit';
+    static examples = ['<%= config.bin %> <%= command.id %> -m "Add project architecture notes"'];
+    static flags = {
+        message: Flags.string({
+            char: 'm',
+            description: 'Commit message',
+        }),
+    };
+    static strict = false;
+    async run() {
+        const { argv, flags } = await this.parse(VcCommit);
+        // Support unquoted multi-word messages: brv vc commit -m hello world
+        const extra = argv.join(' ');
+        const message = flags.message
+            ? (extra ? `${flags.message} ${extra}` : flags.message)
+            : (extra || undefined);
+        if (!message) {
+            this.error('Usage: brv vc commit -m "<message>"');
+        }
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.COMMIT, { message }));
+            this.log(`[${result.sha.slice(0, 7)}] ${result.message}`);
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/config.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class VcConfig extends Command {
+    static args: {
+        key: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/config.js

@@ -0,0 +1,30 @@
+import { Args, Command } from '@oclif/core';
+import { isVcConfigKey, VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcConfig extends Command {
+    static args = {
+        key: Args.string({ description: 'Config key (user.name or user.email)', required: true }),
+        value: Args.string({ description: 'Value to set (omit to read current value)' }),
+    };
+    static description = 'Get or set commit author for ByteRover version control';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> user.name "Your Name"',
+        '<%= config.bin %> <%= command.id %> user.email "you@example.com"',
+        '<%= config.bin %> <%= command.id %> user.name',
+        '<%= config.bin %> <%= command.id %> user.email',
+    ];
+    async run() {
+        const { args } = await this.parse(VcConfig);
+        const { key, value } = args;
+        if (!isVcConfigKey(key)) {
+            this.error(`Unknown key '${key}'. Allowed: user.name, user.email.`);
+        }
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.CONFIG, { key, value }));
+            this.log(`${result.value}`);
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/fetch.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class VcFetch extends Command {
+    static args: {
+        remote: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        branch: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/fetch.js

@@ -0,0 +1,42 @@
+import { Args, Command } from '@oclif/core';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcFetch extends Command {
+    /* eslint-disable perfectionist/sort-objects -- positional order matters: remote before branch */
+    static args = {
+        remote: Args.string({ description: 'Remote name (only origin supported)', required: false }),
+        branch: Args.string({ description: 'Branch to fetch', required: false }),
+    };
+    /* eslint-enable perfectionist/sort-objects */
+    static description = 'Fetch refs from ByteRover cloud';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> origin',
+        '<%= config.bin %> <%= command.id %> origin main',
+    ];
+    async run() {
+        const { args } = await this.parse(VcFetch);
+        let remote;
+        let ref;
+        if (args.remote && args.branch) {
+            if (args.remote !== 'origin') {
+                this.error(`Only 'origin' remote is currently supported.`);
+            }
+            remote = args.remote;
+            ref = args.branch;
+        }
+        else if (args.remote) {
+            if (args.remote !== 'origin') {
+                this.error(`Only 'origin' remote is currently supported.`);
+            }
+            remote = args.remote;
+        }
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.FETCH, { ref, remote }, { timeout: 120_000 }));
+            this.log(`Fetched from ${result.remote}.`);
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Vc extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/index.js

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class Vc extends Command {
+    static description = 'Version control commands for the context tree';
+    static examples = ['<%= config.bin %> <%= command.id %> --help'];
+    async run() {
+        await this.config.runCommand('help', ['vc']);
+    }
+}

package/dist/oclif/commands/vc/init.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class VcInit extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/init.js

@@ -0,0 +1,25 @@
+import { Command } from '@oclif/core';
+import { InitEvents } from '../../../shared/transport/events/init-events.js';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcInit extends Command {
+    static description = 'Initialize ByteRover version control for context tree';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const daemonOptions = { projectPath: process.cwd() };
+        try {
+            // Ensure .brv/config.json exists so the daemon can register this project
+            await withDaemonRetry(async (client) => client.requestWithAck(InitEvents.LOCAL, {}), daemonOptions);
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.INIT, {}), daemonOptions);
+            if (result.reinitialized) {
+                this.log(`Reinitialized existing ByteRover version control in ${result.gitDir}`);
+            }
+            else {
+                this.log(`Initialized ByteRover version control in ${result.gitDir}`);
+            }
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/log.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class VcLog extends Command {
+    static args: {
+        branch: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/log.js

@@ -0,0 +1,48 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatCommitLog } from '../../../tui/features/log/utils/format-log.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcLog extends Command {
+    static args = {
+        branch: Args.string({ description: 'Branch name to show history for' }),
+    };
+    static description = 'Show commit history for the context-tree';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --limit 20',
+        '<%= config.bin %> <%= command.id %> main',
+        '<%= config.bin %> <%= command.id %> --all',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'Show commits from all branches',
+        }),
+        limit: Flags.integer({
+            default: 10,
+            description: 'Number of commits to show',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(VcLog);
+        try {
+            const response = await withDaemonRetry((client) => {
+                const req = {
+                    all: flags.all,
+                    limit: flags.limit,
+                    ref: args.branch,
+                };
+                return client.requestWithAck(VcEvents.LOG, req);
+            });
+            if (response.commits.length === 0) {
+                this.log('No commits found.');
+                return;
+            }
+            this.log(formatCommitLog(response.commits, response.currentBranch));
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/merge.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class VcMerge extends Command {
+    static args: {
+        branch: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        abort: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'allow-unrelated-histories': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        continue: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private handleAbort;
+    private handleContinue;
+    private handleMerge;
+    private openEditor;
+}

package/dist/oclif/commands/vc/merge.js

@@ -0,0 +1,130 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcMerge extends Command {
+    static args = {
+        branch: Args.string({ description: 'Branch to merge into the current branch', required: false }),
+    };
+    static description = 'Merge a branch into the current branch';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> feature/my-branch',
+        '<%= config.bin %> <%= command.id %> --abort',
+        '<%= config.bin %> <%= command.id %> --continue',
+        '<%= config.bin %> <%= command.id %> -m "Custom merge message" feature/my-branch',
+    ];
+    static flags = {
+        abort: Flags.boolean({
+            default: false,
+            description: 'Abort the current merge',
+            exclusive: ['continue'],
+        }),
+        'allow-unrelated-histories': Flags.boolean({
+            default: false,
+            description: 'Allow merging unrelated histories',
+        }),
+        continue: Flags.boolean({
+            default: false,
+            description: 'Continue the current merge after resolving conflicts',
+            exclusive: ['abort'],
+        }),
+        message: Flags.string({
+            char: 'm',
+            description: 'Merge commit message',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(VcMerge);
+        if (flags.abort) {
+            return this.handleAbort();
+        }
+        if (flags.continue) {
+            return this.handleContinue(flags.message);
+        }
+        if (!args.branch) {
+            this.error('Usage: brv vc merge <branch> | --abort | --continue');
+        }
+        return this.handleMerge(args.branch, flags.message, flags['allow-unrelated-histories']);
+    }
+    async handleAbort() {
+        try {
+            await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.MERGE, { action: 'abort' }));
+            // Native git produces no output on successful abort
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+    async handleContinue(message) {
+        try {
+            if (message) {
+                // Message provided via -m — commit directly
+                await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.MERGE, { action: 'continue', message }));
+                return;
+            }
+            // No message — get default from server, open editor
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.MERGE, { action: 'continue' }));
+            const editedMessage = this.openEditor(result.defaultMessage ?? 'Merge commit');
+            if (!editedMessage) {
+                this.error('Aborting commit due to empty commit message.');
+            }
+            await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.MERGE, { action: 'continue', message: editedMessage }));
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+    async handleMerge(branch, message, allowUnrelatedHistories) {
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.MERGE, {
+                action: 'merge',
+                allowUnrelatedHistories,
+                branch,
+                message,
+            }));
+            if (result.alreadyUpToDate) {
+                this.log('Already up to date.');
+            }
+            else if (result.conflicts && result.conflicts.length > 0) {
+                for (const conflict of result.conflicts) {
+                    this.log(`CONFLICT (${conflict.type}): ${conflict.path}`);
+                }
+                this.log('Automatic merge failed; fix conflicts and then commit the result.');
+            }
+            else {
+                this.log(`Merged branch '${branch}'.`);
+            }
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+    openEditor(defaultMessage) {
+        const editor = process.env.GIT_EDITOR ?? process.env.EDITOR ?? 'vim';
+        const tmpDir = mkdtempSync(join(tmpdir(), 'brv-merge-'));
+        const tmpFile = join(tmpDir, 'MERGE_MSG');
+        writeFileSync(tmpFile, defaultMessage);
+        try {
+            execSync(`${editor} "${tmpFile}"`, { stdio: 'inherit' });
+            const content = readFileSync(tmpFile, 'utf8');
+            // Strip comment lines and trim
+            const cleaned = content
+                .split('\n')
+                .filter((line) => !line.startsWith('#'))
+                .join('\n')
+                .trim();
+            return cleaned;
+        }
+        finally {
+            try {
+                rmSync(tmpDir, { force: true, recursive: true });
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+    }
+}

package/dist/oclif/commands/vc/pull.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class VcPull extends Command {
+    static args: {
+        remote: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        branch: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'allow-unrelated-histories': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/pull.js

@@ -0,0 +1,60 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcPull extends Command {
+    /* eslint-disable perfectionist/sort-objects -- positional order matters: remote before branch */
+    static args = {
+        remote: Args.string({ description: 'Remote name (only origin supported)', required: false }),
+        branch: Args.string({ description: 'Branch to pull', required: false }),
+    };
+    /* eslint-enable perfectionist/sort-objects */
+    static description = 'Pull commits from ByteRover cloud';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> origin main',
+        '<%= config.bin %> <%= command.id %> origin main --allow-unrelated-histories',
+    ];
+    static flags = {
+        'allow-unrelated-histories': Flags.boolean({
+            default: false,
+            description: 'Allow merging unrelated histories',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(VcPull);
+        let remote;
+        let branch;
+        if (args.remote && args.branch) {
+            if (args.remote !== 'origin') {
+                this.error(`Only 'origin' remote is currently supported.`);
+            }
+            remote = args.remote;
+            branch = args.branch;
+        }
+        else if (args.remote) {
+            if (args.remote !== 'origin') {
+                this.error(`Only 'origin' remote is currently supported.`);
+            }
+            remote = args.remote;
+        }
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.PULL, {
+                allowUnrelatedHistories: flags['allow-unrelated-histories'],
+                branch,
+                remote,
+            }, { timeout: 120_000 }));
+            if (result.conflicts && result.conflicts.length > 0) {
+                for (const conflict of result.conflicts) {
+                    this.log(`CONFLICT (${conflict.type}): ${conflict.path}`);
+                }
+                this.log('Automatic merge failed; fix conflicts and then commit the result.');
+            }
+            else {
+                this.log(result.alreadyUpToDate ? 'Already up to date.' : `Pulled from origin/${result.branch}.`);
+            }
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/push.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class VcPush extends Command {
+    static args: {
+        remote: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        branch: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'set-upstream': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/push.js

@@ -0,0 +1,60 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcPush extends Command {
+    /* eslint-disable perfectionist/sort-objects -- positional order matters: remote before branch */
+    static args = {
+        remote: Args.string({ description: 'Remote name (only origin supported)', required: false }),
+        branch: Args.string({ description: 'Branch to push', required: false }),
+    };
+    /* eslint-enable perfectionist/sort-objects */
+    static description = 'Push commits to ByteRover cloud';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> -u',
+        '<%= config.bin %> <%= command.id %> origin feat/my-branch',
+    ];
+    static flags = {
+        'set-upstream': Flags.boolean({
+            char: 'u',
+            default: false,
+            description: 'Set upstream tracking branch',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(VcPush);
+        // Git push semantics: push [<remote> [<branch>]]
+        //   brv vc push                → current branch
+        //   brv vc push origin         → current branch (explicit remote)
+        //   brv vc push origin feat/x  → feat/x
+        //   brv vc push feat/x         → error (unknown remote)
+        let branch;
+        if (args.remote && args.branch) {
+            if (args.remote !== 'origin') {
+                this.error(`Only 'origin' remote is currently supported.`);
+            }
+            branch = args.branch;
+        }
+        else if (args.remote && args.remote !== 'origin') {
+            this.error(`Only 'origin' remote is currently supported. Use 'brv vc push origin ${args.remote}' to push a specific branch.`);
+        }
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.PUSH, {
+                branch,
+                setUpstream: flags['set-upstream'],
+            }, { timeout: 120_000 }));
+            if (result.alreadyUpToDate) {
+                this.log('Everything up-to-date.');
+            }
+            else if (result.upstreamSet) {
+                this.log(`Pushed to origin/${result.branch} and set upstream.`);
+            }
+            else {
+                this.log(`Pushed to origin/${result.branch}.`);
+            }
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/remote/add.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class VcRemoteAdd extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        url: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/remote/add.js

@@ -0,0 +1,30 @@
+import { Args, Command } from '@oclif/core';
+import { getGitRemoteBaseUrl } from '../../../../server/config/environment.js';
+import { VcEvents } from '../../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../../lib/daemon-client.js';
+export default class VcRemoteAdd extends Command {
+    static args = {
+        name: Args.string({ description: 'Remote name', required: true }),
+        url: Args.string({
+            description: `Remote URL (e.g. ${getGitRemoteBaseUrl()}/<team>/<space>.git)`,
+            required: true,
+        }),
+    };
+    static description = 'Add a named remote';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> origin ${getGitRemoteBaseUrl()}/acme/project.git`,
+    ];
+    async run() {
+        const { args } = await this.parse(VcRemoteAdd);
+        if (args.name !== 'origin') {
+            this.error(`Only 'origin' remote is currently supported.`);
+        }
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.REMOTE, { subcommand: 'add', url: args.url }));
+            this.log(`Remote 'origin' set to ${result.url}.`);
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}