feat: [ENG-2466] Add brv vc remote remove subcommand (#542)

* feat: [ENG-2466] Add brv vc remote remove subcommand

* feat: [ENG-2466] fix review

Author: bao-byterover

src/oclif/commands/vc/remote/remove.ts

@@ -0,0 +1,29 @@
+import {Args, Command} from '@oclif/core'
+
+import {type IVcRemoteResponse, VcEvents} from '../../../../shared/transport/events/vc-events.js'
+import {formatConnectionError, withDaemonRetry} from '../../../lib/daemon-client.js'
+
+export default class VcRemoteRemove extends Command {
+  public static args = {
+    name: Args.string({description: 'Remote name', required: true}),
+  }
+  public static description = 'Remove a named remote'
+  public static examples = [`<%= config.bin %> <%= command.id %> origin`]
+
+  public async run(): Promise<void> {
+    const {args} = await this.parse(VcRemoteRemove)
+
+    if (args.name !== 'origin') {
+      this.error(`Only 'origin' remote is currently supported.`)
+    }
+
+    try {
+      await withDaemonRetry(async (client) =>
+        client.requestWithAck<IVcRemoteResponse>(VcEvents.REMOTE, {subcommand: 'remove'}),
+      )
+      this.log(`Remote 'origin' removed.`)
+    } catch (error) {
+      this.error(formatConnectionError(error))
+    }
+  }
+}

src/server/core/domain/entities/brv-config.ts

@@ -222,6 +222,19 @@ export class BrvConfig {
     }
   }
 
+  /**
+   * Creates a new BrvConfig with space fields cleared, preserving all other fields.
+   */
+  public withoutSpace(): BrvConfig {
+    return new BrvConfig({
+      ...this,
+      spaceId: undefined,
+      spaceName: undefined,
+      teamId: undefined,
+      teamName: undefined,
+    })
+  }
+
   /**
    * Creates a new BrvConfig with space fields replaced, preserving all other fields.
    */

src/server/infra/transport/handlers/vc-handler.ts

@@ -1219,6 +1219,30 @@ export class VcHandler {
       return {action: 'show', url: url ? maskCredentialsInUrl(url) : undefined}
     }
 
+    if (data.subcommand === 'remove') {
+      const existingUrl = await this.gitService.getRemoteUrl({directory, remote: 'origin'})
+      if (!existingUrl) {
+        throw new VcError("No remote 'origin' to remove.", VcErrorCode.NO_REMOTE)
+      }
+
+      // Clear config before removing the remote so a mid-way failure leaves a retry-friendly state:
+      // if removeRemote throws, config is already cleared and remote is still present, so
+      // re-running `remove` will retry removeRemote and succeed. The reverse order leaves the
+      // remote gone but config stale, and the next `remove` fails with NO_REMOTE — unrecoverable.
+      const existingConfig = await this.projectConfigStore.read(projectPath)
+      if (existingConfig) {
+        await this.projectConfigStore.write(existingConfig.withoutSpace(), projectPath)
+      }
+
+      await this.gitService.removeRemote({directory, remote: 'origin'})
+
+      return {action: 'remove'}
+    }
+
+    if (data.subcommand !== 'add' && data.subcommand !== 'set-url') {
+      throw new VcError('Unknown remote subcommand.', VcErrorCode.INVALID_ACTION)
+    }
+
     if (!data.url) {
       throw new VcError('URL is required.', VcErrorCode.INVALID_REMOTE_URL)
     }

src/shared/transport/events/vc-events.ts

@@ -166,14 +166,22 @@ export interface IVcLogResponse {
   currentBranch?: string
 }
 
-export type VcRemoteSubcommand = 'add' | 'set-url' | 'show'
+export type VcRemoteSubcommand = 'add' | 'remove' | 'set-url' | 'show'
 
 export const VC_REMOTE_SUBCOMMANDS: readonly string[] = [
   'add',
+  'remove',
   'set-url',
   'show',
 ] satisfies readonly VcRemoteSubcommand[]
 
+export const VC_REMOTE_SUBCOMMAND_REQUIRES_URL: Record<VcRemoteSubcommand, boolean> = {
+  add: true,
+  remove: false,
+  'set-url': true,
+  show: false,
+}
+
 export function isVcRemoteSubcommand(value: string): value is VcRemoteSubcommand {
   return VC_REMOTE_SUBCOMMANDS.includes(value)
 }

src/tui/features/commands/definitions/vc-remote.ts

@@ -2,14 +2,14 @@ import React from 'react'
 
 import type {MessageActionReturn, SlashCommand} from '../../../types/commands.js'
 
-import {isVcRemoteSubcommand} from '../../../../shared/transport/events/vc-events.js'
+import {isVcRemoteSubcommand, VC_REMOTE_SUBCOMMAND_REQUIRES_URL} from '../../../../shared/transport/events/vc-events.js'
 import {getGitRemoteBaseUrl} from '../../../lib/environment.js'
 import {VcRemoteFlow} from '../../vc/remote/components/vc-remote-flow.js'
 import {Args, parseReplArgs} from '../utils/arg-parser.js'
 
 /* eslint-disable perfectionist/sort-objects -- positional order matters: subcommand, name, url */
 const vcRemoteArgs = {
-  subcommand: Args.string({description: 'Subcommand: add | set-url (omit to show current remote)'}),
+  subcommand: Args.string({description: 'Subcommand: add | set-url | remove (omit to show current remote)'}),
   name: Args.string({description: 'Remote name (e.g. origin)'}),
   url: Args.string({description: `Remote URL (e.g. ${getGitRemoteBaseUrl()}/<team>/<space>.git)`}),
 }
@@ -29,16 +29,28 @@ export const vcRemoteSubCommand: SlashCommand = {
 
     if (!isVcRemoteSubcommand(rawSubcommand)) {
       const errorMsg: MessageActionReturn = {
-        content: `Unknown subcommand '${rawSubcommand}'. Usage: /vc remote [add|set-url] <name> <url>`,
+        content: `Unknown subcommand '${rawSubcommand}'. Usage: /vc remote [add|set-url|remove] <name> [url]`,
         messageType: 'error',
         type: 'message',
       }
       return errorMsg
     }
 
-    if (!name || !url) {
+    if (rawSubcommand === 'show') {
+      return {
+        render: ({onCancel, onComplete}) =>
+          React.createElement(VcRemoteFlow, {onCancel, onComplete, subcommand: 'show'}),
+      }
+    }
+
+    const requiresUrl = VC_REMOTE_SUBCOMMAND_REQUIRES_URL[rawSubcommand]
+
+    if (!name || (requiresUrl && !url)) {
+      const usage = requiresUrl
+        ? `Usage: /vc remote ${rawSubcommand} <name> <url>`
+        : `Usage: /vc remote ${rawSubcommand} <name>`
       const errorMsg: MessageActionReturn = {
-        content: `Usage: /vc remote ${rawSubcommand} <name> <url>`,
+        content: usage,
         messageType: 'error',
         type: 'message',
       }
@@ -60,9 +72,9 @@ export const vcRemoteSubCommand: SlashCommand = {
     }
   },
   args: [
-    {description: 'Subcommand: add | set-url (omit to show current remote)', name: 'subcommand'},
+    {description: 'Subcommand: add | set-url | remove (omit to show current remote)', name: 'subcommand'},
     {description: 'Remote name (e.g. origin)', name: 'name'},
-    {description: 'Remote URL', name: 'url'},
+    {description: 'Remote URL (required for add | set-url)', name: 'url'},
   ],
   description: 'Manage remote origin for ByteRover version control',
   name: 'remote',

src/tui/features/vc/remote/components/vc-remote-flow.tsx

@@ -15,6 +15,7 @@ type VcRemoteFlowProps = CustomDialogCallbacks & {
 
 const LABELS: Record<VcRemoteSubcommand, string> = {
   add: 'Adding remote...',
+  remove: 'Removing remote...',
   'set-url': 'Updating remote...',
   show: 'Fetching remote...',
 }
@@ -39,12 +40,32 @@ export function VcRemoteFlow({onCancel, onComplete, subcommand, url}: VcRemoteFl
           onComplete(`Failed: ${formatTransportError(error)}`)
         },
         onSuccess(result) {
-          if (result.action === 'show') {
-            onComplete(result.url ? `origin: ${result.url}` : 'No remote configured.')
-          } else if (result.action === 'add') {
-            onComplete(`Remote 'origin' set to ${result.url}.`)
-          } else {
-            onComplete(`Remote 'origin' updated to ${result.url}.`)
+          switch (result.action) {
+            case 'add': {
+              onComplete(`Remote 'origin' set to ${result.url}.`)
+              break
+            }
+
+            case 'remove': {
+              onComplete(`Remote 'origin' removed.`)
+              break
+            }
+
+            case 'set-url': {
+              onComplete(`Remote 'origin' updated to ${result.url}.`)
+              break
+            }
+
+            case 'show': {
+              onComplete(result.url ? `origin: ${result.url}` : 'No remote configured.')
+              break
+            }
+
+            default: {
+              const exhaustive: never = result.action
+              onComplete(`Unknown action: ${String(exhaustive)}`)
+              break
+            }
           }
         },
       },

test/unit/core/domain/entities/brv-config.test.ts

@@ -185,9 +185,60 @@ describe('BrvConfig', () => {
     })
   })
 
+  describe('withoutSpace', () => {
+    it('should create new config with space fields cleared, preserving all other fields', () => {
+      const original = new BrvConfig(validConstructorArgs)
+      const cleared = original.withoutSpace()
+
+      expect(cleared.spaceId).to.be.undefined
+      expect(cleared.spaceName).to.be.undefined
+      expect(cleared.teamId).to.be.undefined
+      expect(cleared.teamName).to.be.undefined
+      expect(cleared.chatLogPath).to.equal(original.chatLogPath)
+      expect(cleared.cwd).to.equal(original.cwd)
+      expect(cleared.ide).to.equal(original.ide)
+      expect(cleared.createdAt).to.equal(original.createdAt)
+      expect(cleared.version).to.equal(original.version)
+    })
+
+    it('should not mutate the original config', () => {
+      const original = new BrvConfig(validConstructorArgs)
+      original.withoutSpace()
+
+      expect(original.spaceId).to.equal(validConstructorArgs.spaceId)
+      expect(original.teamId).to.equal(validConstructorArgs.teamId)
+    })
+
+    it('should produce a config that is not cloud-connected', () => {
+      const original = new BrvConfig(validConstructorArgs)
+      expect(original.isCloudConnected()).to.be.true
+      expect(original.withoutSpace().isCloudConnected()).to.be.false
+    })
+
+    it('should preserve non-space fields (cipherAgent fields) through withoutSpace', () => {
+      const original = new BrvConfig({
+        ...validConstructorArgs,
+        cipherAgentContext: 'context-payload',
+        cipherAgentModes: ['mode-a', 'mode-b'],
+        cipherAgentSystemPrompt: 'system-prompt-text',
+      })
+      const cleared = original.withoutSpace()
+
+      expect(cleared.cipherAgentContext).to.equal('context-payload')
+      expect(cleared.cipherAgentModes).to.deep.equal(['mode-a', 'mode-b'])
+      expect(cleared.cipherAgentSystemPrompt).to.equal('system-prompt-text')
+    })
+  })
+
   describe('fromSpace', () => {
     it('should create config from Space entity with current version', () => {
-      const space = new Space({id: 'space-789', isDefault: false, name: 'my-space', teamId: 'team-abc', teamName: 'my-team'})
+      const space = new Space({
+        id: 'space-789',
+        isDefault: false,
+        name: 'my-space',
+        teamId: 'team-abc',
+        teamName: 'my-team',
+      })
 
       const config = BrvConfig.fromSpace({
         chatLogPath: '/path/to/logs',
@@ -203,6 +254,5 @@ describe('BrvConfig', () => {
       expect(config.teamName).to.equal('my-team')
       expect(config.createdAt).to.be.a('string')
     })
-
   })
 })