agor-live 0.9.1 → 0.9.3

package/dist/cli/commands/admin/add-to-worktree-group.d.ts

@@ -0,0 +1,16 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class AddToWorktreeGroup extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        group: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+
+export { AddToWorktreeGroup as default };

package/dist/cli/commands/admin/add-to-worktree-group.js

@@ -0,0 +1,55 @@
+// src/commands/admin/add-to-worktree-group.ts
+import { createAdminExecutor, UnixGroupCommands } from "@agor/core/unix";
+import { Command, Flags } from "@oclif/core";
+var AddToWorktreeGroup = class _AddToWorktreeGroup extends Command {
+  static description = "Add a user to a worktree Unix group (admin only)";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447",
+    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447 --dry-run"
+  ];
+  static flags = {
+    username: Flags.string({
+      char: "u",
+      description: "Unix username to add",
+      required: true
+    }),
+    group: Flags.string({
+      char: "g",
+      description: "Unix group name (e.g., agor_wt_03b62447)",
+      required: true
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_AddToWorktreeGroup);
+    const { username, group, verbose } = flags;
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    const isInGroup = await executor.check(UnixGroupCommands.isUserInGroup(username, group));
+    if (isInGroup) {
+      this.log(`\u2705 User ${username} is already in group ${group}`);
+      return;
+    }
+    try {
+      await executor.exec(UnixGroupCommands.addUserToGroup(username, group));
+      this.log(`\u2705 Added user ${username} to group ${group}`);
+    } catch (error) {
+      this.error(`Failed to add user ${username} to group ${group}: ${error}`);
+    }
+  }
+};
+export {
+  AddToWorktreeGroup as default
+};

package/dist/cli/commands/admin/create-symlink.d.ts

@@ -0,0 +1,18 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class CreateSymlink extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'worktree-name': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'worktree-path': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'home-base': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+
+export { CreateSymlink as default };

package/dist/cli/commands/admin/create-symlink.js

@@ -0,0 +1,87 @@
+// src/commands/admin/create-symlink.ts
+import {
+  AGOR_HOME_BASE,
+  createAdminExecutor,
+  getWorktreeSymlinkPath,
+  isValidUnixUsername,
+  SymlinkCommands
+} from "@agor/core/unix";
+import { Command, Flags } from "@oclif/core";
+var CreateSymlink = class _CreateSymlink extends Command {
+  static description = "Create a worktree symlink in user home directory (admin only)";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature --worktree-path /var/agor/worktrees/abc123",
+    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature --worktree-path /var/agor/worktrees/abc123 --dry-run"
+  ];
+  static flags = {
+    username: Flags.string({
+      char: "u",
+      description: "Unix username (owner of symlink)",
+      required: true
+    }),
+    "worktree-name": Flags.string({
+      char: "w",
+      description: "Worktree name/slug (symlink name)",
+      required: true
+    }),
+    "worktree-path": Flags.string({
+      char: "p",
+      description: "Absolute path to worktree directory (symlink target)",
+      required: true
+    }),
+    "home-base": Flags.string({
+      description: "Base directory for home directories",
+      default: AGOR_HOME_BASE
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_CreateSymlink);
+    const { username, verbose } = flags;
+    const worktreeName = flags["worktree-name"];
+    const worktreePath = flags["worktree-path"];
+    const homeBase = flags["home-base"];
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    if (!isValidUnixUsername(username)) {
+      this.error(`Invalid Unix username format: ${username}`);
+    }
+    if (!worktreePath.startsWith("/")) {
+      this.error(`Worktree path must be absolute: ${worktreePath}`);
+    }
+    const linkPath = getWorktreeSymlinkPath(username, worktreeName, homeBase);
+    try {
+      const result = await executor.exec(SymlinkCommands.readSymlink(linkPath));
+      const existingTarget = result.stdout.trim();
+      if (existingTarget === worktreePath) {
+        this.log(`\u2705 Symlink already exists: ${linkPath} -> ${worktreePath}`);
+        return;
+      }
+      this.log(`\u2139\uFE0F  Updating symlink (was: ${existingTarget})`);
+    } catch {
+    }
+    try {
+      await executor.execAll(
+        SymlinkCommands.createSymlinkWithOwnership(worktreePath, linkPath, username)
+      );
+      this.log(`\u2705 Created symlink: ${linkPath} -> ${worktreePath}`);
+    } catch (error) {
+      this.error(`Failed to create symlink: ${error}`);
+    }
+  }
+};
+export {
+  CreateSymlink as default
+};

package/dist/cli/commands/admin/create-worktree-group.d.ts

@@ -0,0 +1,15 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class CreateWorktreeGroup extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'worktree-id': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+
+export { CreateWorktreeGroup as default };

package/dist/cli/commands/admin/create-worktree-group.js

@@ -0,0 +1,60 @@
+// src/commands/admin/create-worktree-group.ts
+import {
+  createAdminExecutor,
+  generateWorktreeGroupName,
+  isValidWorktreeGroupName,
+  UnixGroupCommands
+} from "@agor/core/unix";
+import { Command, Flags } from "@oclif/core";
+var CreateWorktreeGroup = class _CreateWorktreeGroup extends Command {
+  static description = "Create a Unix group for a worktree (admin only)";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --worktree-id 03b62447-f2c6-4259-997b-d38ed1ddafed",
+    "<%= config.bin %> <%= command.id %> --worktree-id 03b62447-f2c6-4259-997b-d38ed1ddafed --dry-run"
+  ];
+  static flags = {
+    "worktree-id": Flags.string({
+      char: "w",
+      description: "Worktree ID (full UUID)",
+      required: true
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_CreateWorktreeGroup);
+    const worktreeId = flags["worktree-id"];
+    const dryRun = flags["dry-run"];
+    const verbose = flags.verbose;
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    const groupName = generateWorktreeGroupName(worktreeId);
+    if (!isValidWorktreeGroupName(groupName)) {
+      this.error(`Invalid group name format: ${groupName}`);
+    }
+    const groupExists = await executor.check(UnixGroupCommands.groupExists(groupName));
+    if (groupExists) {
+      this.log(`\u2705 Group ${groupName} already exists`);
+      return;
+    }
+    try {
+      await executor.exec(UnixGroupCommands.createGroup(groupName));
+      this.log(`\u2705 Created Unix group: ${groupName}`);
+    } catch (error) {
+      this.error(`Failed to create group ${groupName}: ${error}`);
+    }
+  }
+};
+export {
+  CreateWorktreeGroup as default
+};

package/dist/cli/commands/admin/delete-user.d.ts

@@ -0,0 +1,16 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class DeleteUser extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'delete-home': _oclif_core_interfaces.BooleanFlag<boolean>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+
+export { DeleteUser as default };

package/dist/cli/commands/admin/delete-user.js

@@ -0,0 +1,64 @@
+// src/commands/admin/delete-user.ts
+import { createAdminExecutor, isValidUnixUsername, UnixUserCommands } from "@agor/core/unix";
+import { Command, Flags } from "@oclif/core";
+var DeleteUser = class _DeleteUser extends Command {
+  static description = "Delete a Unix user (admin only)";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --username agor_03b62447",
+    "<%= config.bin %> <%= command.id %> --username agor_03b62447 --delete-home",
+    "<%= config.bin %> <%= command.id %> --username agor_03b62447 --dry-run"
+  ];
+  static flags = {
+    username: Flags.string({
+      char: "u",
+      description: "Unix username to delete",
+      required: true
+    }),
+    "delete-home": Flags.boolean({
+      description: "Also delete the user home directory",
+      default: false
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_DeleteUser);
+    const { username, verbose } = flags;
+    const deleteHome = flags["delete-home"];
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    if (!isValidUnixUsername(username)) {
+      this.error(`Invalid Unix username format: ${username}`);
+    }
+    const userExists = await executor.check(UnixUserCommands.userExists(username));
+    if (!userExists) {
+      this.log(`\u2705 Unix user ${username} does not exist (nothing to do)`);
+      return;
+    }
+    try {
+      if (deleteHome) {
+        await executor.exec(UnixUserCommands.deleteUserWithHome(username));
+        this.log(`\u2705 Deleted Unix user ${username} and home directory`);
+      } else {
+        await executor.exec(UnixUserCommands.deleteUser(username));
+        this.log(`\u2705 Deleted Unix user ${username} (home directory preserved)`);
+      }
+    } catch (error) {
+      this.error(`Failed to delete user ${username}: ${error}`);
+    }
+  }
+};
+export {
+  DeleteUser as default
+};

package/dist/cli/commands/admin/delete-worktree-group.d.ts

@@ -0,0 +1,15 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class DeleteWorktreeGroup extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        group: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+
+export { DeleteWorktreeGroup as default };

package/dist/cli/commands/admin/delete-worktree-group.js

@@ -0,0 +1,50 @@
+// src/commands/admin/delete-worktree-group.ts
+import { createAdminExecutor, UnixGroupCommands } from "@agor/core/unix";
+import { Command, Flags } from "@oclif/core";
+var DeleteWorktreeGroup = class _DeleteWorktreeGroup extends Command {
+  static description = "Delete a worktree Unix group (admin only)";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --group agor_wt_03b62447",
+    "<%= config.bin %> <%= command.id %> --group agor_wt_03b62447 --dry-run"
+  ];
+  static flags = {
+    group: Flags.string({
+      char: "g",
+      description: "Unix group name to delete (e.g., agor_wt_03b62447)",
+      required: true
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_DeleteWorktreeGroup);
+    const { group, verbose } = flags;
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    const groupExists = await executor.check(UnixGroupCommands.groupExists(group));
+    if (!groupExists) {
+      this.log(`\u2705 Group ${group} doesn't exist (nothing to do)`);
+      return;
+    }
+    try {
+      await executor.exec(UnixGroupCommands.deleteGroup(group));
+      this.log(`\u2705 Deleted Unix group: ${group}`);
+    } catch (error) {
+      this.error(`Failed to delete group ${group}: ${error}`);
+    }
+  }
+};
+export {
+  DeleteWorktreeGroup as default
+};

package/dist/cli/commands/admin/ensure-user.d.ts

@@ -0,0 +1,16 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class EnsureUser extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'home-base': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+
+export { EnsureUser as default };

package/dist/cli/commands/admin/ensure-user.js

@@ -0,0 +1,73 @@
+// src/commands/admin/ensure-user.ts
+import {
+  AGOR_HOME_BASE,
+  createAdminExecutor,
+  isValidUnixUsername,
+  UnixUserCommands
+} from "@agor/core/unix";
+import { Command, Flags } from "@oclif/core";
+var EnsureUser = class _EnsureUser extends Command {
+  static description = "Ensure a Unix user exists with proper Agor setup (admin only)";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --username agor_03b62447",
+    "<%= config.bin %> <%= command.id %> --username alice --home-base /home",
+    "<%= config.bin %> <%= command.id %> --username alice --dry-run"
+  ];
+  static flags = {
+    username: Flags.string({
+      char: "u",
+      description: "Unix username to create/ensure",
+      required: true
+    }),
+    "home-base": Flags.string({
+      description: "Base directory for home directories",
+      default: AGOR_HOME_BASE
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_EnsureUser);
+    const { username, verbose } = flags;
+    const homeBase = flags["home-base"];
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    if (!isValidUnixUsername(username)) {
+      this.error(`Invalid Unix username format: ${username}`);
+    }
+    const userExists = await executor.check(UnixUserCommands.userExists(username));
+    if (userExists) {
+      this.log(`\u2705 Unix user ${username} already exists`);
+      try {
+        await executor.execAll(UnixUserCommands.setupWorktreesDir(username, homeBase));
+        this.log(`\u2705 Ensured ~/agor/worktrees directory for ${username}`);
+      } catch (error) {
+        this.warn(`Failed to setup worktrees directory: ${error}`);
+      }
+      return;
+    }
+    try {
+      this.log(`Creating Unix user: ${username}`);
+      await executor.exec(UnixUserCommands.createUser(username, "/bin/bash", homeBase));
+      this.log(`\u2705 Created Unix user: ${username}`);
+      await executor.execAll(UnixUserCommands.setupWorktreesDir(username, homeBase));
+      this.log(`\u2705 Created ~/agor/worktrees directory for ${username}`);
+    } catch (error) {
+      this.error(`Failed to create user ${username}: ${error}`);
+    }
+  }
+};
+export {
+  EnsureUser as default
+};

package/dist/cli/commands/admin/remove-from-worktree-group.d.ts

@@ -0,0 +1,16 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class RemoveFromWorktreeGroup extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        group: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+
+export { RemoveFromWorktreeGroup as default };

package/dist/cli/commands/admin/remove-from-worktree-group.js

@@ -0,0 +1,55 @@
+// src/commands/admin/remove-from-worktree-group.ts
+import { createAdminExecutor, UnixGroupCommands } from "@agor/core/unix";
+import { Command, Flags } from "@oclif/core";
+var RemoveFromWorktreeGroup = class _RemoveFromWorktreeGroup extends Command {
+  static description = "Remove a user from a worktree Unix group (admin only)";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447",
+    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447 --dry-run"
+  ];
+  static flags = {
+    username: Flags.string({
+      char: "u",
+      description: "Unix username to remove",
+      required: true
+    }),
+    group: Flags.string({
+      char: "g",
+      description: "Unix group name (e.g., agor_wt_03b62447)",
+      required: true
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_RemoveFromWorktreeGroup);
+    const { username, group, verbose } = flags;
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    const isInGroup = await executor.check(UnixGroupCommands.isUserInGroup(username, group));
+    if (!isInGroup) {
+      this.log(`\u2705 User ${username} is not in group ${group} (nothing to do)`);
+      return;
+    }
+    try {
+      await executor.exec(UnixGroupCommands.removeUserFromGroup(username, group));
+      this.log(`\u2705 Removed user ${username} from group ${group}`);
+    } catch (error) {
+      this.error(`Failed to remove user ${username} from group ${group}: ${error}`);
+    }
+  }
+};
+export {
+  RemoveFromWorktreeGroup as default
+};

package/dist/cli/commands/admin/remove-symlink.d.ts

@@ -0,0 +1,17 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class RemoveSymlink extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'worktree-name': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'home-base': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+
+export { RemoveSymlink as default };

package/dist/cli/commands/admin/remove-symlink.js

@@ -0,0 +1,71 @@
+// src/commands/admin/remove-symlink.ts
+import {
+  AGOR_HOME_BASE,
+  createAdminExecutor,
+  getWorktreeSymlinkPath,
+  isValidUnixUsername,
+  SymlinkCommands
+} from "@agor/core/unix";
+import { Command, Flags } from "@oclif/core";
+var RemoveSymlink = class _RemoveSymlink extends Command {
+  static description = "Remove a worktree symlink from user home directory (admin only)";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature",
+    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature --dry-run"
+  ];
+  static flags = {
+    username: Flags.string({
+      char: "u",
+      description: "Unix username (owner of symlink)",
+      required: true
+    }),
+    "worktree-name": Flags.string({
+      char: "w",
+      description: "Worktree name/slug (symlink name)",
+      required: true
+    }),
+    "home-base": Flags.string({
+      description: "Base directory for home directories",
+      default: AGOR_HOME_BASE
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_RemoveSymlink);
+    const { username, verbose } = flags;
+    const worktreeName = flags["worktree-name"];
+    const homeBase = flags["home-base"];
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    if (!isValidUnixUsername(username)) {
+      this.error(`Invalid Unix username format: ${username}`);
+    }
+    const linkPath = getWorktreeSymlinkPath(username, worktreeName, homeBase);
+    const symlinkExists = await executor.check(SymlinkCommands.symlinkExists(linkPath));
+    if (!symlinkExists) {
+      this.log(`\u2705 Symlink does not exist: ${linkPath} (nothing to do)`);
+      return;
+    }
+    try {
+      await executor.exec(SymlinkCommands.removeSymlink(linkPath));
+      this.log(`\u2705 Removed symlink: ${linkPath}`);
+    } catch (error) {
+      this.error(`Failed to remove symlink: ${error}`);
+    }
+  }
+};
+export {
+  RemoveSymlink as default
+};