@inforge/migrations-tools-cli 1.0.0

package/README.md

@@ -0,0 +1,171 @@
+# Inforge Migrations CLI (`imigrate`)
+
+Inforge's interactive CLI tool that enables side-effect-free Salesforce data operations by managing validation rules, flows, and triggers.
+
+## Features
+
+- **Deactivate automation** (validation rules, flows, triggers) for clean data operations
+- **Smart restore** with automatic state detection
+- **Atomic operations** with automatic rollback on failure
+- **Local backups** organized by org/object/type
+- **Managed package awareness** - skip managed components gracefully
+- **Full audit logging** for compliance
+- **Beautiful interactive UI** powered by @clack/prompts
+
+## Installation
+
+```bash
+# Install globally
+npm install -g @inforge/migrations-tools-cli
+
+# Or use npx (no installation required)
+npx @inforge/migrations-tools-cli
+```
+
+## Prerequisites
+
+- Node.js 18+
+- Salesforce CLI (`sf` or `sfdx`) with at least one authenticated org
+- Authenticated org: `sf org login web -a my-org`
+
+## Usage
+
+Run the CLI:
+
+```bash
+imigrate
+```
+
+Or with npx:
+
+```bash
+npx @inforge/migrations-tools-cli
+```
+
+### Deactivate Automation
+
+1. Select "Deactivate automation"
+2. Choose org, object, and automation type
+3. Preview what will be affected
+4. Confirm and execute
+5. Backup saved automatically
+
+### Restore from Backup
+
+1. Select "Restore from backup"
+2. Choose org, object, and automation type
+3. Select backup from list (with metadata)
+4. Preview smart detection (only restore what's needed)
+5. Confirm and execute
+
+### Manage Backups
+
+View all backups organized by org/object/type.
+
+### View Logs
+
+See recent operations with status, timestamps, and details.
+
+## Architecture
+
+### Backup Structure
+
+```
+.backups/
+├── my-org/
+│   ├── Account/
+│   │   ├── validation-rules/
+│   │   │   ├── 2026-02-15_14-30-00-123.json
+│   │   │   └── 2026-02-15_16-45-30-456.json
+│   │   ├── flows/
+│   │   │   └── 2026-02-15_15-00-00-789.json
+│   │   └── triggers/
+│   │       └── 2026-02-15_15-30-00-012.json
+│   └── Contact/
+│       └── validation-rules/
+│           └── 2026-02-15_14-35-00-345.json
+```
+
+### Operation Logs
+
+All operations are logged to `.logs/operations.log` (JSON format, one per line).
+
+## Safety Features
+
+### Atomic Operations
+
+All deactivation and restore operations are **all-or-nothing**:
+- If any error occurs, changes are automatically rolled back
+- You'll never be left in a partial state
+
+### Smart Restore
+
+Before restoring, the tool checks the current org state:
+- Only restores items that actually need it
+- Skips items that are already in the desired state
+- Shows a preview of exactly what will change
+
+### Managed Package Awareness
+
+The tool identifies managed package components:
+- Shows managed items in preview with counts
+- Skips them during deactivation (can't be modified)
+- Clearly explains why they're skipped
+
+### Preview Before Action
+
+Every operation shows a detailed preview:
+- What will be affected
+- What will be skipped (managed packages)
+- Exact counts
+
+You must confirm before any changes are made.
+
+## Development
+
+### Setup
+
+```bash
+git clone <repo>
+cd migrations-cli
+npm install
+```
+
+### Run in dev mode
+
+```bash
+npm run dev
+```
+
+### Build
+
+```bash
+npm run build
+```
+
+### Test
+
+```bash
+npm test
+```
+
+## Supported Automation Types
+
+### V1 (Current)
+- Validation Rules
+- Flows
+- Triggers
+
+### Future
+- Process Builder
+- Workflow Rules
+- Duplicate Rules
+- Matching Rules
+
+## Contributing
+
+Contributions welcome! Please open an issue or PR.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,1158 @@
+#!/usr/bin/env node
+
+// src/ui/prompts.ts
+import * as clack from "@clack/prompts";
+var Prompts = class {
+  intro(title) {
+    clack.intro(title);
+  }
+  outro(message) {
+    clack.outro(message);
+  }
+  async selectOrg(orgs) {
+    const options = orgs.map((org) => ({
+      value: org.alias,
+      label: org.alias,
+      hint: `${org.username} (${org.isSandbox ? "Sandbox" : "Production"})`
+    }));
+    const selected = await clack.select({
+      message: "Select an org:",
+      options
+    });
+    if (clack.isCancel(selected)) {
+      this.cancel();
+    }
+    return selected;
+  }
+  async selectObject(objects) {
+    const selected = await clack.select({
+      message: "Select an object:",
+      options: objects.map((obj) => ({ value: obj, label: obj }))
+    });
+    if (clack.isCancel(selected)) {
+      this.cancel();
+    }
+    return selected;
+  }
+  async selectAutomationType() {
+    const selected = await clack.select({
+      message: "Select automation type:",
+      options: [
+        { value: "validation-rules", label: "Validation Rules" },
+        { value: "flows", label: "Flows" },
+        { value: "triggers", label: "Triggers" }
+      ]
+    });
+    if (clack.isCancel(selected)) {
+      this.cancel();
+    }
+    return selected;
+  }
+  async selectMainAction() {
+    const selected = await clack.select({
+      message: "What would you like to do?",
+      options: [
+        { value: "deactivate", label: "Deactivate automation" },
+        { value: "restore", label: "Restore from backup" },
+        { value: "manage", label: "Manage backups" },
+        { value: "logs", label: "View operation logs" },
+        { value: "exit", label: "Exit" }
+      ]
+    });
+    if (clack.isCancel(selected)) {
+      this.cancel();
+    }
+    return selected;
+  }
+  async selectFromOptions(message, options) {
+    const selected = await clack.select({
+      message,
+      options
+    });
+    if (clack.isCancel(selected)) {
+      this.cancel();
+    }
+    return selected;
+  }
+  async confirm(message) {
+    const result = await clack.confirm({
+      message
+    });
+    if (clack.isCancel(result)) {
+      this.cancel();
+    }
+    return result;
+  }
+  spinner() {
+    return clack.spinner();
+  }
+  note(message, title) {
+    clack.note(message, title);
+  }
+  log(message) {
+    clack.log.message(message);
+  }
+  success(message) {
+    clack.log.success(message);
+  }
+  error(message) {
+    clack.log.error(message);
+  }
+  warning(message) {
+    clack.log.warning(message);
+  }
+  cancel(message = "Operation cancelled") {
+    clack.cancel(message);
+    process.exit(0);
+  }
+};
+
+// src/core/sf-client.ts
+import { AuthInfo, Org } from "@salesforce/core";
+var SfClient = class {
+  async listOrgs() {
+    const authorizations = await AuthInfo.listAllAuthorizations();
+    return authorizations.map((auth) => ({
+      alias: auth.aliases?.[0] || auth.username,
+      username: auth.username,
+      instanceUrl: auth.instanceUrl || "",
+      isDevHub: auth.isDevHub,
+      isSandbox: auth.isSandbox
+    }));
+  }
+  async getConnection(orgAlias) {
+    const org = await Org.create({ aliasOrUsername: orgAlias });
+    return org.getConnection();
+  }
+  async queryObjects(connection) {
+    const query = `
+      SELECT QualifiedApiName
+      FROM EntityDefinition
+      WHERE IsCustomizable = true
+      ORDER BY QualifiedApiName
+    `;
+    const result = await connection.query(query);
+    return result.records.map((r) => r.QualifiedApiName);
+  }
+};
+
+// src/core/backup.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var BackupManager = class {
+  backupDir;
+  constructor(backupDir = ".backups") {
+    this.backupDir = backupDir;
+  }
+  async save(org, object, type, items, managedItems) {
+    const timestamp = this.generateTimestamp();
+    const backupPath = this.getBackupPath(org.alias, object, type, timestamp);
+    const backup = {
+      version: "1.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      org,
+      object,
+      type,
+      items,
+      managedItems,
+      restoredAt: null,
+      restoredBy: null
+    };
+    await this.ensureDir(path.dirname(backupPath));
+    await fs.writeFile(backupPath, JSON.stringify(backup, null, 2), "utf-8");
+    return backupPath;
+  }
+  async list(orgAlias, object, type) {
+    const dir = path.join(this.backupDir, orgAlias, object, type);
+    try {
+      const files = await fs.readdir(dir);
+      return files.filter((f) => f.endsWith(".json")).map((f) => path.join(dir, f)).sort().reverse();
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+  }
+  async load(backupPath) {
+    const content = await fs.readFile(backupPath, "utf-8");
+    return JSON.parse(content);
+  }
+  async markAsRestored(backupPath, operationId) {
+    const backup = await this.load(backupPath);
+    backup.restoredAt = (/* @__PURE__ */ new Date()).toISOString();
+    backup.restoredBy = operationId;
+    await fs.writeFile(backupPath, JSON.stringify(backup, null, 2), "utf-8");
+  }
+  async delete(backupPath) {
+    await fs.unlink(backupPath);
+  }
+  getBackupPath(orgAlias, object, type, timestamp) {
+    return path.join(this.backupDir, orgAlias, object, type, `${timestamp}.json`);
+  }
+  generateTimestamp() {
+    const now = /* @__PURE__ */ new Date();
+    const date = now.toISOString().split("T")[0];
+    const time = now.toTimeString().split(" ")[0].replace(/:/g, "-");
+    const ms = now.getMilliseconds().toString().padStart(3, "0");
+    return `${date}_${time}-${ms}`;
+  }
+  async ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+  }
+};
+
+// src/core/logger.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+var Logger = class {
+  logDir;
+  logFile;
+  constructor(logDir = ".logs") {
+    this.logDir = logDir;
+    this.logFile = path2.join(logDir, "operations.log");
+  }
+  async log(operation) {
+    await this.ensureLogDir();
+    const logLine = JSON.stringify(operation) + "\n";
+    await fs2.appendFile(this.logFile, logLine, "utf-8");
+  }
+  async getLogs() {
+    try {
+      const content = await fs2.readFile(this.logFile, "utf-8");
+      const lines = content.trim().split("\n").filter((line) => line.length > 0);
+      return lines.map((line) => JSON.parse(line));
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+  }
+  generateOperationId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 9);
+    return `op_${timestamp}${random}`;
+  }
+  async ensureLogDir() {
+    try {
+      await fs2.mkdir(this.logDir, { recursive: true });
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+};
+
+// src/core/metadata/validation-rules.ts
+var ValidationRulesHandler = class {
+  async fetch(connection, objectName) {
+    const metadata = await connection.metadata.read("CustomObject", [objectName]);
+    if (!metadata || metadata.length === 0 || !metadata[0].validationRules) {
+      return [];
+    }
+    return metadata[0].validationRules.map((rule) => ({
+      fullName: `${objectName}.${rule.fullName}`,
+      active: rule.active,
+      metadata: rule
+    }));
+  }
+  async fetchSeparated(connection, objectName) {
+    const allRules = await this.fetch(connection, objectName);
+    const custom = [];
+    const managed = [];
+    for (const rule of allRules) {
+      const ruleMetadata = rule.metadata;
+      if (ruleMetadata.namespacePrefix) {
+        managed.push({
+          fullName: rule.fullName,
+          namespace: ruleMetadata.namespacePrefix,
+          reason: "Cannot deactivate managed package component"
+        });
+      } else {
+        custom.push(rule);
+      }
+    }
+    return { custom, managed };
+  }
+  async deactivate(connection, objectName, ruleNames) {
+    await this.updateRules(connection, objectName, ruleNames, false);
+  }
+  async activate(connection, objectName, ruleNames) {
+    await this.updateRules(connection, objectName, ruleNames, true);
+  }
+  async rollback(connection, objectName, originalRules) {
+    const ruleNamesToActivate = originalRules.filter((r) => r.active).map((r) => r.fullName.split(".")[1]);
+    const ruleNamesToDeactivate = originalRules.filter((r) => !r.active).map((r) => r.fullName.split(".")[1]);
+    if (ruleNamesToActivate.length > 0) {
+      await this.activate(connection, objectName, ruleNamesToActivate);
+    }
+    if (ruleNamesToDeactivate.length > 0) {
+      await this.deactivate(connection, objectName, ruleNamesToDeactivate);
+    }
+  }
+  async updateRules(connection, objectName, ruleNames, active) {
+    const metadata = await connection.metadata.read("CustomObject", [objectName]);
+    if (!metadata || metadata.length === 0 || !metadata[0].validationRules) {
+      throw new Error(`No validation rules found for ${objectName}`);
+    }
+    const objectMetadata = metadata[0];
+    const rules = objectMetadata.validationRules;
+    objectMetadata.validationRules = rules.map((rule) => {
+      if (ruleNames.includes(rule.fullName)) {
+        return { ...rule, active };
+      }
+      return rule;
+    });
+    const result = await connection.metadata.update("CustomObject", objectMetadata);
+    if (!result || Array.isArray(result) && !result[0]?.success) {
+      throw new Error(`Failed to update validation rules for ${objectName}`);
+    }
+  }
+};
+
+// src/core/metadata/flows.ts
+var FlowsHandler = class {
+  async fetch(connection, objectName) {
+    const query = `
+      SELECT Id, DeveloperName, ActiveVersion.VersionNumber, LatestVersion.VersionNumber,
+             ProcessType, NamespacePrefix
+      FROM FlowDefinition
+      WHERE ActiveVersion.VersionNumber != null
+         OR LatestVersion.VersionNumber != null
+    `;
+    const result = await connection.tooling.query(query);
+    const objectFlows = result.records.filter(
+      (flow) => flow.DeveloperName.includes(objectName)
+    );
+    return objectFlows.map((flow) => ({
+      fullName: flow.DeveloperName,
+      active: flow.ActiveVersion !== null && flow.ActiveVersion.VersionNumber > 0,
+      metadata: flow
+    }));
+  }
+  async fetchSeparated(connection, objectName) {
+    const allFlows = await this.fetch(connection, objectName);
+    const custom = [];
+    const managed = [];
+    for (const flow of allFlows) {
+      const flowMetadata = flow.metadata;
+      if (flowMetadata.NamespacePrefix) {
+        managed.push({
+          fullName: flow.fullName,
+          namespace: flowMetadata.NamespacePrefix,
+          reason: "Cannot deactivate managed package component"
+        });
+      } else {
+        custom.push(flow);
+      }
+    }
+    return { custom, managed };
+  }
+  async deactivate(connection, flowIds) {
+    const updates = flowIds.map((id) => ({
+      Id: id,
+      Metadata: {
+        activeVersionNumber: 0
+      }
+    }));
+    const results = await connection.tooling.update("FlowDefinition", updates);
+    if (Array.isArray(results)) {
+      const failures = results.filter((r) => !r.success);
+      if (failures.length > 0) {
+        throw new Error(`Failed to deactivate ${failures.length} flow(s)`);
+      }
+    }
+  }
+  async activate(connection, flowsWithVersions) {
+    const updates = flowsWithVersions.map((flow) => ({
+      Id: flow.id,
+      Metadata: {
+        activeVersionNumber: flow.version
+      }
+    }));
+    const results = await connection.tooling.update("FlowDefinition", updates);
+    if (Array.isArray(results)) {
+      const failures = results.filter((r) => !r.success);
+      if (failures.length > 0) {
+        throw new Error(`Failed to activate ${failures.length} flow(s)`);
+      }
+    }
+  }
+};
+
+// src/core/metadata/triggers.ts
+var TriggersHandler = class {
+  async fetch(connection, objectName) {
+    const query = `
+      SELECT Id, Name, TableEnumOrId, Status, NamespacePrefix
+      FROM ApexTrigger
+      WHERE TableEnumOrId = '${objectName}'
+    `;
+    const result = await connection.tooling.query(query);
+    return result.records.map((trigger) => ({
+      fullName: trigger.Name,
+      active: trigger.Status === "Active",
+      metadata: trigger
+    }));
+  }
+  async fetchSeparated(connection, objectName) {
+    const allTriggers = await this.fetch(connection, objectName);
+    const custom = [];
+    const managed = [];
+    for (const trigger of allTriggers) {
+      const triggerMetadata = trigger.metadata;
+      if (triggerMetadata.NamespacePrefix) {
+        managed.push({
+          fullName: trigger.fullName,
+          namespace: triggerMetadata.NamespacePrefix,
+          reason: "Cannot deactivate managed package component"
+        });
+      } else {
+        custom.push(trigger);
+      }
+    }
+    return { custom, managed };
+  }
+  async deactivate(connection, triggerNames) {
+    await this.updateStatus(connection, triggerNames, "Inactive");
+  }
+  async activate(connection, triggerNames) {
+    await this.updateStatus(connection, triggerNames, "Active");
+  }
+  async updateStatus(connection, triggerNames, status) {
+    const metadata = await connection.metadata.read("ApexTrigger", triggerNames);
+    const updates = metadata.map((trigger) => ({
+      ...trigger,
+      status
+    }));
+    const results = await connection.metadata.update("ApexTrigger", updates);
+    if (Array.isArray(results)) {
+      const failures = results.filter((r) => !r.success);
+      if (failures.length > 0) {
+        throw new Error(`Failed to update ${failures.length} trigger(s)`);
+      }
+    }
+  }
+};
+
+// src/commands/deactivate.ts
+var DeactivateCommand = class {
+  sfClient;
+  backupManager;
+  logger;
+  prompts;
+  constructor() {
+    this.sfClient = new SfClient();
+    this.backupManager = new BackupManager();
+    this.logger = new Logger();
+    this.prompts = new Prompts();
+  }
+  async execute() {
+    const orgs = await this.sfClient.listOrgs();
+    if (orgs.length === 0) {
+      this.prompts.error("No authenticated orgs found. Please authenticate with SF CLI first.");
+      return;
+    }
+    const selectedOrg = await this.prompts.selectOrg(orgs);
+    const org = orgs.find((o) => o.alias === selectedOrg);
+    const connection = await this.sfClient.getConnection(selectedOrg);
+    const objects = await this.sfClient.queryObjects(connection);
+    const selectedObject = await this.prompts.selectObject(objects);
+    const automationType = await this.prompts.selectAutomationType();
+    if (automationType === "validation-rules") {
+      await this.deactivateValidationRules(org, selectedObject, connection);
+    } else if (automationType === "flows") {
+      await this.deactivateFlows(org, selectedObject, connection);
+    } else if (automationType === "triggers") {
+      await this.deactivateTriggers(org, selectedObject, connection);
+    }
+  }
+  async deactivateValidationRules(org, objectName, connection) {
+    const handler = new ValidationRulesHandler();
+    const spinner2 = this.prompts.spinner();
+    spinner2.start("Fetching validation rules...");
+    const { custom, managed } = await handler.fetchSeparated(connection, objectName);
+    const originalRules = [...custom];
+    spinner2.stop("Validation rules fetched");
+    if (custom.length === 0 && managed.length === 0) {
+      this.prompts.warning("No validation rules found for this object.");
+      return;
+    }
+    const previewMessage = this.buildPreviewMessage(custom, managed, "validation rules");
+    this.prompts.note(previewMessage, `Preview: ${objectName} Validation Rules`);
+    const confirmed = await this.prompts.confirm("Proceed with deactivation?");
+    if (!confirmed) {
+      this.prompts.cancel("Deactivation cancelled");
+      return;
+    }
+    const operationId = this.logger.generateOperationId();
+    const deactivateSpinner = this.prompts.spinner();
+    deactivateSpinner.start("Deactivating validation rules...");
+    try {
+      const ruleNames = custom.map((r) => r.fullName.split(".")[1]);
+      await handler.deactivate(connection, objectName, ruleNames);
+      const backupPath = await this.backupManager.save(
+        org,
+        objectName,
+        "validation-rules",
+        custom,
+        managed
+      );
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "deactivate",
+        org: org.alias,
+        object: objectName,
+        type: "validation-rules",
+        status: "success",
+        itemsAffected: custom.length,
+        itemsSkipped: managed.length,
+        backupPath,
+        error: null
+      });
+      deactivateSpinner.stop("Validation rules deactivated");
+      this.prompts.success(
+        `Successfully deactivated ${custom.length} validation rule(s). Backup saved to:
+${backupPath}`
+      );
+    } catch (error) {
+      deactivateSpinner.stop("Deactivation failed - rolling back");
+      try {
+        const rollbackSpinner = this.prompts.spinner();
+        rollbackSpinner.start("Rolling back changes...");
+        await handler.rollback(connection, objectName, originalRules);
+        rollbackSpinner.stop("Rollback complete");
+        await this.logger.log({
+          id: operationId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          operation: "deactivate",
+          org: org.alias,
+          object: objectName,
+          type: "validation-rules",
+          status: "rollback",
+          itemsAffected: 0,
+          itemsSkipped: 0,
+          backupPath: null,
+          error: error.message
+        });
+        this.prompts.warning("Changes rolled back. No changes were made.");
+      } catch (rollbackError) {
+        this.prompts.error(`Rollback failed: ${rollbackError.message}`);
+        this.prompts.error("Manual intervention may be required.");
+      }
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "deactivate",
+        org: org.alias,
+        object: objectName,
+        type: "validation-rules",
+        status: "failure",
+        itemsAffected: 0,
+        itemsSkipped: 0,
+        backupPath: null,
+        error: error.message
+      });
+      this.prompts.error(`Failed to deactivate validation rules: ${error.message}`);
+      throw error;
+    }
+  }
+  async deactivateFlows(org, objectName, connection) {
+    const handler = new FlowsHandler();
+    const spinner2 = this.prompts.spinner();
+    spinner2.start("Fetching flows...");
+    const { custom, managed } = await handler.fetchSeparated(connection, objectName);
+    spinner2.stop("Flows fetched");
+    if (custom.length === 0 && managed.length === 0) {
+      this.prompts.warning("No flows found for this object.");
+      return;
+    }
+    const previewMessage = this.buildPreviewMessage(custom, managed, "flows");
+    this.prompts.note(previewMessage, `Preview: ${objectName} Flows`);
+    const confirmed = await this.prompts.confirm("Proceed with deactivation?");
+    if (!confirmed) {
+      this.prompts.cancel("Deactivation cancelled");
+      return;
+    }
+    const operationId = this.logger.generateOperationId();
+    const deactivateSpinner = this.prompts.spinner();
+    deactivateSpinner.start("Deactivating flows...");
+    try {
+      const flowIds = custom.map((f) => f.metadata.Id);
+      await handler.deactivate(connection, flowIds);
+      const backupPath = await this.backupManager.save(
+        org,
+        objectName,
+        "flows",
+        custom,
+        managed
+      );
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "deactivate",
+        org: org.alias,
+        object: objectName,
+        type: "flows",
+        status: "success",
+        itemsAffected: custom.length,
+        itemsSkipped: managed.length,
+        backupPath,
+        error: null
+      });
+      deactivateSpinner.stop("Flows deactivated");
+      this.prompts.success(
+        `Successfully deactivated ${custom.length} flow(s). Backup saved to:
+${backupPath}`
+      );
+    } catch (error) {
+      deactivateSpinner.stop("Deactivation failed");
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "deactivate",
+        org: org.alias,
+        object: objectName,
+        type: "flows",
+        status: "failure",
+        itemsAffected: 0,
+        itemsSkipped: 0,
+        backupPath: null,
+        error: error.message
+      });
+      this.prompts.error(`Failed to deactivate flows: ${error.message}`);
+      throw error;
+    }
+  }
+  async deactivateTriggers(org, objectName, connection) {
+    const handler = new TriggersHandler();
+    const spinner2 = this.prompts.spinner();
+    spinner2.start("Fetching triggers...");
+    const { custom, managed } = await handler.fetchSeparated(connection, objectName);
+    spinner2.stop("Triggers fetched");
+    if (custom.length === 0 && managed.length === 0) {
+      this.prompts.warning("No triggers found for this object.");
+      return;
+    }
+    const previewMessage = this.buildPreviewMessage(custom, managed, "triggers");
+    this.prompts.note(previewMessage, `Preview: ${objectName} Triggers`);
+    const confirmed = await this.prompts.confirm("Proceed with deactivation?");
+    if (!confirmed) {
+      this.prompts.cancel("Deactivation cancelled");
+      return;
+    }
+    const operationId = this.logger.generateOperationId();
+    const deactivateSpinner = this.prompts.spinner();
+    deactivateSpinner.start("Deactivating triggers...");
+    try {
+      const triggerNames = custom.map((t) => t.fullName);
+      await handler.deactivate(connection, triggerNames);
+      const backupPath = await this.backupManager.save(
+        org,
+        objectName,
+        "triggers",
+        custom,
+        managed
+      );
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "deactivate",
+        org: org.alias,
+        object: objectName,
+        type: "triggers",
+        status: "success",
+        itemsAffected: custom.length,
+        itemsSkipped: managed.length,
+        backupPath,
+        error: null
+      });
+      deactivateSpinner.stop("Triggers deactivated");
+      this.prompts.success(
+        `Successfully deactivated ${custom.length} trigger(s). Backup saved to:
+${backupPath}`
+      );
+    } catch (error) {
+      deactivateSpinner.stop("Deactivation failed");
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "deactivate",
+        org: org.alias,
+        object: objectName,
+        type: "triggers",
+        status: "failure",
+        itemsAffected: 0,
+        itemsSkipped: 0,
+        backupPath: null,
+        error: error.message
+      });
+      this.prompts.error(`Failed to deactivate triggers: ${error.message}`);
+      throw error;
+    }
+  }
+  buildPreviewMessage(custom, managed, itemType) {
+    let message = "";
+    if (custom.length > 0) {
+      message += `${custom.length} custom ${itemType} will be deactivated
+
+`;
+      message += "Custom items (will deactivate):\n";
+      custom.forEach((item) => {
+        message += `  - ${item.fullName}
+`;
+      });
+    }
+    if (managed.length > 0) {
+      message += `
+${managed.length} managed package ${itemType} cannot be deactivated
+
+`;
+      message += "Managed items (will skip):\n";
+      managed.forEach((item) => {
+        message += `  - ${item.fullName} (${item.namespace})
+`;
+      });
+    }
+    return message;
+  }
+};
+
+// src/commands/restore.ts
+import * as path3 from "path";
+var RestoreCommand = class {
+  sfClient;
+  backupManager;
+  logger;
+  prompts;
+  constructor() {
+    this.sfClient = new SfClient();
+    this.backupManager = new BackupManager();
+    this.logger = new Logger();
+    this.prompts = new Prompts();
+  }
+  async execute() {
+    const orgs = await this.sfClient.listOrgs();
+    if (orgs.length === 0) {
+      this.prompts.error("No authenticated orgs found.");
+      return;
+    }
+    const selectedOrg = await this.prompts.selectOrg(orgs);
+    const org = orgs.find((o) => o.alias === selectedOrg);
+    const connection = await this.sfClient.getConnection(selectedOrg);
+    const objects = await this.sfClient.queryObjects(connection);
+    const selectedObject = await this.prompts.selectObject(objects);
+    const automationType = await this.prompts.selectAutomationType();
+    const backups = await this.backupManager.list(selectedOrg, selectedObject, automationType);
+    if (backups.length === 0) {
+      this.prompts.warning("No backups found for this org/object/type.");
+      return;
+    }
+    const backupOptions = await Promise.all(
+      backups.map(async (backupPath) => {
+        const backup2 = await this.backupManager.load(backupPath);
+        const filename = path3.basename(backupPath, ".json");
+        const status = backup2.restoredAt ? `restored on ${backup2.restoredAt.split("T")[0]}` : "not restored";
+        return {
+          value: backupPath,
+          label: filename,
+          hint: `${backup2.items.length} items, ${status}`
+        };
+      })
+    );
+    const selectedBackupPath = await this.prompts.selectFromOptions(
+      "Select a backup to restore:",
+      backupOptions
+    );
+    const backup = await this.backupManager.load(selectedBackupPath);
+    if (automationType === "validation-rules") {
+      await this.restoreValidationRules(org, selectedObject, connection, backup, selectedBackupPath);
+    } else if (automationType === "flows") {
+      await this.restoreFlows(org, selectedObject, connection, backup, selectedBackupPath);
+    } else if (automationType === "triggers") {
+      await this.restoreTriggers(org, selectedObject, connection, backup, selectedBackupPath);
+    }
+  }
+  async restoreValidationRules(org, objectName, connection, backup, backupPath) {
+    const handler = new ValidationRulesHandler();
+    const spinner2 = this.prompts.spinner();
+    spinner2.start("Analyzing current state...");
+    const currentRules = await handler.fetch(connection, objectName);
+    const currentRulesMap = new Map(
+      currentRules.map((r) => [r.fullName, r])
+    );
+    const preview = this.analyzeRestoreNeeds(backup.items, currentRulesMap);
+    spinner2.stop("Analysis complete");
+    const previewMessage = this.buildRestorePreviewMessage(preview);
+    this.prompts.note(previewMessage, "Restore Preview");
+    if (preview.needsRestore.length === 0) {
+      this.prompts.success("All items are already active. Nothing to restore.");
+      return;
+    }
+    const confirmed = await this.prompts.confirm("Proceed with restore?");
+    if (!confirmed) {
+      this.prompts.cancel("Restore cancelled");
+      return;
+    }
+    const operationId = this.logger.generateOperationId();
+    const restoreSpinner = this.prompts.spinner();
+    restoreSpinner.start("Restoring validation rules...");
+    try {
+      const ruleNames = preview.needsRestore.map((r) => r.fullName.split(".")[1]);
+      await handler.activate(connection, objectName, ruleNames);
+      await this.backupManager.markAsRestored(backupPath, operationId);
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "restore",
+        org: org.alias,
+        object: objectName,
+        type: "validation-rules",
+        status: "success",
+        itemsAffected: preview.needsRestore.length,
+        itemsSkipped: preview.alreadyActive.length,
+        backupPath,
+        error: null
+      });
+      restoreSpinner.stop("Validation rules restored");
+      this.prompts.success(
+        `Successfully restored ${preview.needsRestore.length} validation rule(s).`
+      );
+    } catch (error) {
+      restoreSpinner.stop("Restore failed");
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "restore",
+        org: org.alias,
+        object: objectName,
+        type: "validation-rules",
+        status: "failure",
+        itemsAffected: 0,
+        itemsSkipped: 0,
+        backupPath,
+        error: error.message
+      });
+      this.prompts.error(`Failed to restore validation rules: ${error.message}`);
+      throw error;
+    }
+  }
+  async restoreFlows(org, objectName, connection, backup, backupPath) {
+    const handler = new FlowsHandler();
+    const spinner2 = this.prompts.spinner();
+    spinner2.start("Analyzing current state...");
+    const currentFlows = await handler.fetch(connection, objectName);
+    const currentFlowsMap = new Map(currentFlows.map((f) => [f.fullName, f]));
+    const preview = this.analyzeRestoreNeeds(backup.items, currentFlowsMap);
+    spinner2.stop("Analysis complete");
+    const previewMessage = this.buildRestorePreviewMessage(preview);
+    this.prompts.note(previewMessage, "Restore Preview");
+    if (preview.needsRestore.length === 0) {
+      this.prompts.success("All flows are already active. Nothing to restore.");
+      return;
+    }
+    const confirmed = await this.prompts.confirm("Proceed with restore?");
+    if (!confirmed) {
+      this.prompts.cancel("Restore cancelled");
+      return;
+    }
+    const operationId = this.logger.generateOperationId();
+    const restoreSpinner = this.prompts.spinner();
+    restoreSpinner.start("Restoring flows...");
+    try {
+      const flowsWithVersions = preview.needsRestore.map((f) => ({
+        id: f.metadata.Id,
+        version: f.metadata.LatestVersion.VersionNumber
+      }));
+      await handler.activate(connection, flowsWithVersions);
+      await this.backupManager.markAsRestored(backupPath, operationId);
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "restore",
+        org: org.alias,
+        object: objectName,
+        type: "flows",
+        status: "success",
+        itemsAffected: preview.needsRestore.length,
+        itemsSkipped: preview.alreadyActive.length,
+        backupPath,
+        error: null
+      });
+      restoreSpinner.stop("Flows restored");
+      this.prompts.success(`Successfully restored ${preview.needsRestore.length} flow(s).`);
+    } catch (error) {
+      restoreSpinner.stop("Restore failed");
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "restore",
+        org: org.alias,
+        object: objectName,
+        type: "flows",
+        status: "failure",
+        itemsAffected: 0,
+        itemsSkipped: 0,
+        backupPath,
+        error: error.message
+      });
+      this.prompts.error(`Failed to restore flows: ${error.message}`);
+      throw error;
+    }
+  }
+  async restoreTriggers(org, objectName, connection, backup, backupPath) {
+    const handler = new TriggersHandler();
+    const spinner2 = this.prompts.spinner();
+    spinner2.start("Analyzing current state...");
+    const currentTriggers = await handler.fetch(connection, objectName);
+    const currentTriggersMap = new Map(currentTriggers.map((t) => [t.fullName, t]));
+    const preview = this.analyzeRestoreNeeds(backup.items, currentTriggersMap);
+    spinner2.stop("Analysis complete");
+    const previewMessage = this.buildRestorePreviewMessage(preview);
+    this.prompts.note(previewMessage, "Restore Preview");
+    if (preview.needsRestore.length === 0) {
+      this.prompts.success("All triggers are already active. Nothing to restore.");
+      return;
+    }
+    const confirmed = await this.prompts.confirm("Proceed with restore?");
+    if (!confirmed) {
+      this.prompts.cancel("Restore cancelled");
+      return;
+    }
+    const operationId = this.logger.generateOperationId();
+    const restoreSpinner = this.prompts.spinner();
+    restoreSpinner.start("Restoring triggers...");
+    try {
+      const triggerNames = preview.needsRestore.map((t) => t.fullName);
+      await handler.activate(connection, triggerNames);
+      await this.backupManager.markAsRestored(backupPath, operationId);
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "restore",
+        org: org.alias,
+        object: objectName,
+        type: "triggers",
+        status: "success",
+        itemsAffected: preview.needsRestore.length,
+        itemsSkipped: preview.alreadyActive.length,
+        backupPath,
+        error: null
+      });
+      restoreSpinner.stop("Triggers restored");
+      this.prompts.success(`Successfully restored ${preview.needsRestore.length} trigger(s).`);
+    } catch (error) {
+      restoreSpinner.stop("Restore failed");
+      await this.logger.log({
+        id: operationId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation: "restore",
+        org: org.alias,
+        object: objectName,
+        type: "triggers",
+        status: "failure",
+        itemsAffected: 0,
+        itemsSkipped: 0,
+        backupPath,
+        error: error.message
+      });
+      this.prompts.error(`Failed to restore triggers: ${error.message}`);
+      throw error;
+    }
+  }
+  analyzeRestoreNeeds(backupItems, currentRulesMap) {
+    const needsRestore = [];
+    const alreadyActive = [];
+    for (const item of backupItems) {
+      const currentRule = currentRulesMap.get(item.fullName);
+      if (!currentRule || !currentRule.active) {
+        needsRestore.push(item);
+      } else {
+        alreadyActive.push(item);
+      }
+    }
+    return {
+      totalItems: backupItems.length,
+      needsRestore,
+      alreadyActive
+    };
+  }
+  buildRestorePreviewMessage(preview) {
+    let message = "Analysis:\n";
+    message += `  - ${preview.totalItems} rules in backup
+`;
+    message += `  - ${preview.needsRestore.length} currently inactive (need restoration)
+`;
+    message += `  - ${preview.alreadyActive.length} already active (will skip)
+
+`;
+    if (preview.needsRestore.length > 0) {
+      message += "Will restore:\n";
+      preview.needsRestore.forEach((item) => {
+        message += `  - ${item.fullName}
+`;
+      });
+    }
+    if (preview.alreadyActive.length > 0) {
+      message += "\nAlready active (skipping):\n";
+      preview.alreadyActive.forEach((item) => {
+        message += `  - ${item.fullName}
+`;
+      });
+    }
+    return message;
+  }
+};
+
+// src/commands/manage.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+var ManageCommand = class {
+  backupManager;
+  prompts;
+  constructor() {
+    this.backupManager = new BackupManager();
+    this.prompts = new Prompts();
+  }
+  async execute() {
+    const action = await this.prompts.selectFromOptions(
+      "What would you like to do?",
+      [
+        { value: "view", label: "View all backups" },
+        { value: "cleanup", label: "Clean up old backups" },
+        { value: "back", label: "Back to main menu" }
+      ]
+    );
+    switch (action) {
+      case "view":
+        await this.viewBackups();
+        break;
+      case "cleanup":
+        await this.cleanupBackups();
+        break;
+      case "back":
+        return;
+    }
+  }
+  async viewBackups() {
+    const backupDir = ".backups";
+    try {
+      const orgs = await fs3.readdir(backupDir);
+      if (orgs.length === 0) {
+        this.prompts.warning("No backups found.");
+        return;
+      }
+      let message = "Backups:\n\n";
+      for (const org of orgs) {
+        message += `${org}
+`;
+        const orgPath = path4.join(backupDir, org);
+        const objects = await fs3.readdir(orgPath);
+        for (const object of objects) {
+          const objectPath = path4.join(orgPath, object);
+          const types = await fs3.readdir(objectPath);
+          for (const type of types) {
+            const typePath = path4.join(objectPath, type);
+            const files = await fs3.readdir(typePath);
+            message += `  ${object} > ${type} (${files.length} backup(s))
+`;
+          }
+        }
+        message += "\n";
+      }
+      this.prompts.note(message, "All Backups");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        this.prompts.warning("No backups directory found.");
+      } else {
+        throw error;
+      }
+    }
+  }
+  async cleanupBackups() {
+    this.prompts.warning("Interactive cleanup coming soon!");
+    this.prompts.note(
+      "For now, you can manually delete backup files from the .backups/ directory.",
+      "Manual Cleanup"
+    );
+  }
+};
+
+// src/commands/logs.ts
+var LogsCommand = class {
+  logger;
+  prompts;
+  constructor() {
+    this.logger = new Logger();
+    this.prompts = new Prompts();
+  }
+  async execute() {
+    const logs = await this.logger.getLogs();
+    if (logs.length === 0) {
+      this.prompts.warning("No operation logs found.");
+      return;
+    }
+    const recentLogs = logs.slice(-20).reverse();
+    let message = "Recent Operations:\n\n";
+    for (const log2 of recentLogs) {
+      const statusEmoji = log2.status === "success" ? "\u2713" : "\u2717";
+      const timestamp = new Date(log2.timestamp).toLocaleString();
+      message += `${statusEmoji} ${log2.operation.toUpperCase()} - ${log2.org}/${log2.object}/${log2.type}
+`;
+      message += `   ${timestamp}
+`;
+      message += `   Items affected: ${log2.itemsAffected}, skipped: ${log2.itemsSkipped}
+`;
+      if (log2.error) {
+        message += `   Error: ${log2.error}
+`;
+      }
+      message += "\n";
+    }
+    this.prompts.note(message, `Operation Logs (showing ${recentLogs.length} of ${logs.length})`);
+  }
+};
+
+// src/index.ts
+async function main() {
+  const prompts = new Prompts();
+  prompts.intro("Salesforce Migration Tools CLI");
+  try {
+    while (true) {
+      const action = await prompts.selectMainAction();
+      switch (action) {
+        case "deactivate":
+          const deactivateCmd = new DeactivateCommand();
+          await deactivateCmd.execute();
+          break;
+        case "restore":
+          const restoreCmd = new RestoreCommand();
+          await restoreCmd.execute();
+          break;
+        case "manage":
+          const manageCmd = new ManageCommand();
+          await manageCmd.execute();
+          break;
+        case "logs":
+          const logsCmd = new LogsCommand();
+          await logsCmd.execute();
+          break;
+        case "exit":
+          prompts.outro("Goodbye!");
+          process.exit(0);
+      }
+      const continuePrompt = await prompts.confirm("Perform another operation?");
+      if (!continuePrompt) {
+        prompts.outro("Goodbye!");
+        process.exit(0);
+      }
+    }
+  } catch (error) {
+    prompts.error(`An error occurred: ${error.message}`);
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@inforge/migrations-tools-cli",
+  "version": "1.0.0",
+  "description": "Inforge's interactive CLI for side-effect-free Salesforce data operations by managing automation",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "imigrate": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:ui": "vitest --ui"
+  },
+  "keywords": [
+    "inforge",
+    "salesforce",
+    "cli",
+    "migration",
+    "automation",
+    "validation-rules",
+    "flows",
+    "triggers",
+    "data-loading"
+  ],
+  "author": "Inforge",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "@salesforce/core": "^8.26.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "@vitest/ui": "^3.2.4",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}