deepline 0.3.293 → 0.3.295

package/dist/cli/settings-UVLOQZRH.mjs

@@ -0,0 +1,846 @@
+import {
+  DeeplineClient,
+  PRODUCT_NOTIFICATION_EVENT_CATALOG,
+  resolveLegacySlackNotification
+} from "./chunk-XL2FO6CW.mjs";
+import "./chunk-CBVIJSHF.mjs";
+import {
+  readCliUpdatePreferences,
+  runUpdateCommand,
+  setCliAutoUpdateEnabled
+} from "./chunk-YJYPL5OK.mjs";
+import "./chunk-OQYEC4GL.mjs";
+import "./chunk-GHRQQPW2.mjs";
+import "./chunk-GAMFK2ZP.mjs";
+import {
+  openInBrowser,
+  printCommandEnvelope
+} from "./chunk-6O5YZOVN.mjs";
+import "./chunk-EACVZI6N.mjs";
+import "./chunk-DLIRSHV6.mjs";
+import "./chunk-LDWT7RJK.mjs";
+import "./chunk-GVUJJJ5G.mjs";
+import "./chunk-NXGCO4JB.mjs";
+import "./chunk-WZYKRD7T.mjs";
+import "./chunk-KRD6H754.mjs";
+
+// src/cli/commands/settings.ts
+import { readFileSync } from "fs";
+var eventHelp = PRODUCT_NOTIFICATION_EVENT_CATALOG.map(
+  (event) => `  ${event.id.padEnd(28)} ${event.description}`
+).join("\n");
+function slackDestination(settings) {
+  const destinations = settings.destinations.map(
+    (entry) => ({
+      ...entry,
+      kind: typeof entry.kind === "string" ? entry.kind : "",
+      name: typeof entry.name === "string" ? entry.name : "",
+      archivedAt: typeof entry.archivedAt === "number" ? entry.archivedAt : void 0
+    })
+  );
+  return resolveLegacySlackNotification(destinations);
+}
+function eventLines(settings, destinationId) {
+  const enabled = new Map(
+    settings.subscriptions.filter(
+      (entry) => !destinationId || entry.destinationId === destinationId
+    ).map((entry) => [entry.eventType, entry.enabled])
+  );
+  return settings.catalog.map(
+    (event) => `${event.id}: ${enabled.get(event.id) === true ? "enabled" : "disabled"} \u2014 ${event.description}`
+  );
+}
+function requireCatalogEvent(settings, eventType) {
+  const event = settings.catalog.find((entry) => entry.id === eventType);
+  if (!event) {
+    throw new Error(
+      `Unknown notification event "${eventType}". Run deepline settings notifications subscriptions list.`
+    );
+  }
+  return event;
+}
+async function printSettings(options) {
+  const settings = await new DeeplineClient().getNotificationSettings();
+  const slack = slackDestination(settings);
+  const destinationId = typeof slack?._id === "string" ? slack._id : void 0;
+  printCommandEnvelope(
+    {
+      settings,
+      render: {
+        sections: [
+          {
+            title: "Slack destination",
+            lines: slack ? [
+              `status: ${String(slack.status ?? "unknown")}`,
+              `${slack.targetKind === "member" ? "member" : "channel"}: ${slack.targetKind === "member" ? "@" : "#"}${String(slack.channelName ?? slack.channelId ?? "unknown")}`,
+              ...slack.lastErrorMessage ? [`issue: ${String(slack.lastErrorMessage)}`] : []
+            ] : ["Not configured."]
+          },
+          {
+            title: "subscriptions",
+            lines: eventLines(settings, destinationId)
+          },
+          {
+            title: "dead letter queue",
+            lines: [
+              `${settings.dlq.count}${settings.dlq.capped ? "+" : ""} deliveries require review`
+            ]
+          }
+        ],
+        actions: slack ? [
+          {
+            label: "Validate Slack",
+            command: "deepline settings notifications test slack"
+          }
+        ] : [
+          {
+            label: "Connect Slack",
+            command: "deepline settings notifications connect slack --open"
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+function registerSettingsCommands(program) {
+  const settings = program.command("settings").description("Manage Deepline settings.");
+  const autoupdate = settings.command("autoupdate").description("Configure automatic CLI updates on this machine.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline settings autoupdate
+  deepline settings autoupdate on
+  deepline settings autoupdate off
+  deepline settings autoupdate pin <version>
+
+Automatic updates are enabled by default. Turning them on clears an existing
+version pin. Pinning installs and holds one exact pin-aware CLI version.
+`
+  ).option("--json", "Emit JSON output").action((options) => {
+    const preferences = readCliUpdatePreferences();
+    printCommandEnvelope(
+      {
+        autoUpdateEnabled: preferences.autoUpdateEnabled,
+        pinnedVersion: preferences.pinnedVersion,
+        render: {
+          sections: [
+            {
+              title: "automatic CLI updates",
+              lines: [
+                `status: ${preferences.autoUpdateEnabled && !preferences.pinnedVersion ? "on" : "off"}`,
+                `pinned version: ${preferences.pinnedVersion ?? "none"}`
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  for (const enabled of [true, false]) {
+    autoupdate.command(enabled ? "on" : "off").description(
+      enabled ? "Enable automatic CLI updates and clear any version pin." : "Disable automatic CLI updates."
+    ).option("--json", "Emit JSON output").action((options) => {
+      const preferences = setCliAutoUpdateEnabled(enabled);
+      printCommandEnvelope(
+        {
+          ok: true,
+          autoUpdateEnabled: preferences.autoUpdateEnabled,
+          pinnedVersion: preferences.pinnedVersion,
+          render: {
+            sections: [
+              {
+                title: "automatic CLI updates",
+                lines: [
+                  enabled ? "enabled; any version pin was cleared" : "disabled"
+                ]
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    });
+  }
+  autoupdate.command("pin").description("Install and hold an exact pin-aware CLI version.").argument("<version>", "Exact semantic version from a pin-aware release").option("--json", "Emit JSON output").action(async (version, options) => {
+    process.exitCode = await runUpdateCommand({
+      pin: version,
+      json: options.json,
+      executeWithJson: true
+    });
+  });
+  const notifications = settings.command("notifications").description(
+    "Configure Deepline product notifications and delivery safety."
+  ).addHelpText(
+    "after",
+    `
+Workflow:
+  1. deepline settings notifications connect slack --open
+  2. deepline settings notifications channels --query pipeline
+  3. deepline settings notifications set slack --channel '#pipeline-alerts'
+  4. deepline settings notifications test slack
+  5. deepline settings notifications subscriptions list
+
+Slack is the delivery integration. This command group only manages product
+notifications; there is no general integrations CLI.
+`
+  );
+  notifications.command("get").description("Show destination, subscriptions, and DLQ health.").option("--json", "Emit JSON output").action(printSettings);
+  notifications.command("connect").description("Start the OAuth connection required by a destination.").argument("<destination>", "Destination kind (currently slack)").option("--open", "Open the Slack authorization URL in a browser").option("--dry-run", "Describe the mutation without starting OAuth").option("--json", "Emit JSON output").action(
+    async (destination, options) => {
+      if (destination !== "slack")
+        throw new Error("Only slack is supported.");
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, destination, action: "start_oauth" },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await new DeeplineClient().connectNotificationSlack();
+      const browser = options.open ? openInBrowser(result.redirect_url, { deduplicate: false }) : "not_requested";
+      printCommandEnvelope(
+        {
+          ...result,
+          browser,
+          render: {
+            sections: [
+              {
+                title: "Slack authorization",
+                lines: [result.redirect_url, `browser: ${browser}`]
+              }
+            ],
+            actions: [
+              {
+                label: "After authorization",
+                command: "deepline settings notifications set slack --channel '#channel'"
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    }
+  );
+  notifications.command("channels").description("List Slack channels visible to the connected Deepline app.").option("--query <text>", "Filter channels by name").option("--json", "Emit JSON output").action(async (options) => {
+    const result = await new DeeplineClient().listNotificationSlackChannels(
+      options.query
+    );
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "Slack channels",
+              lines: result.channels.length ? result.channels.map(
+                (channel) => `#${channel.name} (${channel.id})${channel.isPrivate ? " private" : ""}`
+              ) : ["No visible channels matched."]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  notifications.command("set").description("Set a product-notification destination.").argument("<destination>", "Destination kind (currently slack)").option("--channel <channel>", "Slack channel name or ID").option("--member-id <id>", "Slack member ID, for example U0123456789").option("--dry-run", "Validate intent without changing settings").option("--json", "Emit JSON output").action(
+    async (destination, options) => {
+      if (destination !== "slack")
+        throw new Error("Only slack is supported.");
+      if (Boolean(options.channel) === Boolean(options.memberId)) {
+        throw new Error("Provide exactly one of --channel or --member-id.");
+      }
+      const target = options.memberId ? { memberId: options.memberId } : options.channel;
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, destination, target },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await new DeeplineClient().setNotificationSlack(target);
+      printCommandEnvelope(
+        {
+          ok: true,
+          result,
+          render: {
+            sections: [
+              {
+                title: "Slack destination saved",
+                lines: [options.memberId ?? options.channel]
+              }
+            ],
+            actions: [
+              {
+                label: "Validate delivery",
+                command: "deepline settings notifications test slack"
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    }
+  );
+  notifications.command("test").description("Send a validation ping to a destination.").argument("<destination>", "Destination kind (currently slack)").option("--dry-run", "Describe the external send without sending").option("--json", "Emit JSON output").action(async (destination, options) => {
+    if (destination !== "slack") throw new Error("Only slack is supported.");
+    if (options.dryRun) {
+      printCommandEnvelope(
+        { dryRun: true, destination, action: "send_test_ping" },
+        { json: options.json }
+      );
+      return;
+    }
+    const result = await new DeeplineClient().testNotificationSlack();
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [{ title: "Slack validation", lines: [result.message] }]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  notifications.command("disable").description("Disable a product-notification destination.").argument("<destination>", "Destination kind (currently slack)").option("--dry-run", "Describe the mutation without changing settings").option("--json", "Emit JSON output").action(async (destination, options) => {
+    if (destination !== "slack") throw new Error("Only slack is supported.");
+    if (options.dryRun) {
+      printCommandEnvelope(
+        { dryRun: true, destination, action: "disable" },
+        { json: options.json }
+      );
+      return;
+    }
+    const result = await new DeeplineClient().disableNotificationSlack();
+    printCommandEnvelope(
+      {
+        ok: true,
+        result,
+        render: {
+          sections: [{ title: "Slack destination", lines: ["disabled"] }]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  const subscriptions = notifications.command("subscriptions").description("List and configure supported notification events.").addHelpText(
+    "after",
+    `
+Supported events (shared product catalog):
+${eventHelp}
+`
+  );
+  subscriptions.command("list").description("List every supported event and its current state.").option("--json", "Emit JSON output").action(async (options) => {
+    const current = await new DeeplineClient().getNotificationSettings();
+    const destination = slackDestination(current);
+    const destinationId = typeof destination?._id === "string" ? destination._id : void 0;
+    printCommandEnvelope(
+      {
+        catalog: current.catalog,
+        subscriptions: current.subscriptions,
+        render: {
+          sections: [
+            {
+              title: "subscriptions",
+              lines: eventLines(current, destinationId)
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  subscriptions.command("describe").description("Describe one event from the shared product catalog.").argument("<event>", "Event ID; run subscriptions list to enumerate").option("--json", "Emit JSON output").action(async (eventType, options) => {
+    const current = await new DeeplineClient().getNotificationSettings();
+    const event = requireCatalogEvent(current, eventType);
+    const destination = slackDestination(current);
+    const destinationId = typeof destination?._id === "string" ? destination._id : void 0;
+    const subscription = current.subscriptions.find(
+      (entry) => entry.eventType === event.id && (!destinationId || entry.destinationId === destinationId)
+    );
+    printCommandEnvelope(
+      {
+        event,
+        enabled: subscription?.enabled === true,
+        render: {
+          sections: [
+            {
+              title: event.id,
+              lines: [
+                event.description,
+                `enabled: ${subscription?.enabled === true}`
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  for (const enabled of [true, false]) {
+    subscriptions.command(enabled ? "enable" : "disable").description(`${enabled ? "Enable" : "Disable"} one supported event.`).argument("<event>", "Event ID; run subscriptions list to enumerate").option("--dry-run", "Validate intent without changing settings").option("--json", "Emit JSON output").action(async (eventType, options) => {
+      const client = new DeeplineClient();
+      const current = await client.getNotificationSettings();
+      const event = requireCatalogEvent(current, eventType);
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, event, enabled },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await client.setNotificationSubscriptions(
+        [event.id],
+        enabled
+      );
+      printCommandEnvelope(
+        {
+          ok: true,
+          event: event.id,
+          enabled,
+          result,
+          render: {
+            sections: [
+              {
+                title: "subscription updated",
+                lines: [`${event.id}: ${enabled ? "enabled" : "disabled"}`]
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    });
+  }
+  const dlq = notifications.command("dlq").description("Inspect and explicitly resolve inert failed deliveries.");
+  dlq.command("list").option("--limit <count>", "Maximum deliveries", "25").option("--json", "Emit JSON output").action(async (options) => {
+    const result = await new DeeplineClient().listNotificationDlq(
+      Number(options.limit)
+    );
+    const deliveries = result.deliveries ?? [];
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "dead letter queue",
+              lines: deliveries.length ? deliveries.map(
+                (entry) => `${String(entry._id)}: ${String(entry.lastErrorCode ?? "delivery_failed")}`
+              ) : ["empty"]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  dlq.command("get").argument("<delivery-id>").option("--json", "Emit JSON output").action(async (deliveryId, options) => {
+    const result = await new DeeplineClient().getNotificationDlqDelivery(
+      deliveryId
+    );
+    printCommandEnvelope(result, {
+      json: options.json
+    });
+  });
+  for (const action of ["retry", "archive"]) {
+    dlq.command(action).description(
+      `${action === "retry" ? "Replay once from attempt zero" : "Archive"} one delivery.`
+    ).argument("<delivery-id>").option("--dry-run", "Describe the mutation without changing state").option("--json", "Emit JSON output").action(async (deliveryId, options) => {
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, action, deliveryId },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await new DeeplineClient().updateNotificationDlqDelivery(
+        deliveryId,
+        action
+      );
+      printCommandEnvelope(
+        { ok: true, action, deliveryId, result },
+        { json: options.json }
+      );
+    });
+  }
+}
+function notificationByName(settings, reference) {
+  const notification = (settings.notifications ?? []).find(
+    (entry) => entry.id === reference || entry.name === reference
+  );
+  if (!notification) {
+    throw new Error(
+      `No notification named "${reference}". Run deepline notifications list.`
+    );
+  }
+  return notification;
+}
+function parseSlackTarget(value) {
+  const match = /^slack:(.+)$/i.exec(value.trim());
+  if (!match?.[1]) {
+    throw new Error(
+      "Use --to slack:#channel or --to slack:member:U0123456789."
+    );
+  }
+  const target = match[1].trim();
+  const member = /^member:([UW][A-Z0-9]{8,})$/i.exec(target);
+  if (member?.[1]) return { memberId: member[1].toUpperCase() };
+  if (target.toLowerCase().startsWith("member:")) {
+    throw new Error(
+      "Slack member IDs must look like slack:member:U0123456789."
+    );
+  }
+  return { channel: target };
+}
+function displaySlackTarget(target) {
+  return `${target.kind === "member" ? "@" : "#"}${target.name}`;
+}
+function collectEvent(value, previous = []) {
+  return [...previous, value];
+}
+function collectNotificationTarget(value, previous = []) {
+  return [...previous, value];
+}
+async function readNotificationConfigurationChange(source, read = (path, encoding) => readFileSync(path, encoding)) {
+  const label = source === "-" ? "stdin" : source;
+  let text;
+  try {
+    text = await read(source === "-" ? 0 : source, "utf8");
+  } catch (error) {
+    throw new Error(
+      `Could not read notification configuration from ${label}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error(
+      `Notification configuration from ${label} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (typeof parsed.expectedWorkspaceVersion !== "number" || !Number.isInteger(parsed.expectedWorkspaceVersion) || !parsed.change || typeof parsed.change !== "object") {
+    throw new Error(
+      `Notification configuration from ${label} must contain an integer expectedWorkspaceVersion and a change object.`
+    );
+  }
+  return {
+    expectedWorkspaceVersion: parsed.expectedWorkspaceVersion,
+    change: parsed.change
+  };
+}
+function registerNotificationCommands(program) {
+  const notifications = program.command("notifications").description("Configure notification groups, destinations, and rules.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline notifications add oncall --to email:oncall@example.com --to slack:#oncall
+  deepline notifications events
+  deepline notifications slack channels --search pipeline
+  deepline notifications add pipeline-watchdog --to slack:#pipeline-alerts --for play.cron.failed
+  deepline notifications add owner-alerts --to slack:member:U0123456789 --for play.cron.failed
+  deepline notifications test pipeline-watchdog
+
+Each named notification is a group. Repeat --to to give it email and Slack
+destinations. Add rules from the dashboard or notification configuration. The
+existing one-Slack-target form with --for remains supported and creates the
+equivalent compatibility group and rules. Slack connections are managed in
+Dashboard \u2192 Integrations.
+`
+  );
+  const configuration = notifications.command("configuration").description("Read or atomically update notification groups and rules.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline notifications configuration get --json
+  deepline notifications configuration apply change.json --dry-run --json
+  jq '{expectedWorkspaceVersion: .configuration.workspaceVersion, change: {kind: "delete_group", groupKey: "oncall"}}' current.json | deepline notifications configuration apply - --json
+`
+  );
+  configuration.command("get").description("Show the effective group-based notification configuration.").option("--json", "Emit JSON output").action(async (options) => {
+    const result = await new DeeplineClient().getNotificationConfiguration();
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "notification groups",
+              lines: result.configuration.groups.length ? result.configuration.groups.map(
+                (group) => `${group.name}: ${group.enabled ? "active" : "paused"}`
+              ) : ["No notification groups are configured."]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  configuration.command("apply").argument(
+    "<file>",
+    "JSON file, or - for stdin, containing expectedWorkspaceVersion and one desired change"
+  ).description(
+    "Atomically apply a configuration draft exported by an agent or UI."
+  ).option("--dry-run", "Validate and display the file without saving it").option("--json", "Emit JSON output").action(async (file, options) => {
+    const input = await readNotificationConfigurationChange(file);
+    if (options.dryRun) {
+      printCommandEnvelope(
+        { dryRun: true, ...input },
+        { json: options.json }
+      );
+      return;
+    }
+    const result = await new DeeplineClient().changeNotificationConfiguration(
+      input.expectedWorkspaceVersion,
+      input.change
+    );
+    printCommandEnvelope(result, { json: options.json });
+  });
+  notifications.command("events").description("List the Play events available to a notification.").option("--json", "Emit JSON output").action(async (options) => {
+    const settings = await new DeeplineClient().getNotifications();
+    printCommandEnvelope(
+      {
+        events: settings.catalog,
+        render: {
+          sections: [
+            {
+              title: "available events",
+              lines: settings.catalog.length ? settings.catalog.map(
+                (event) => `${event.id}: ${event.description}`
+              ) : ["No notification events are available."]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  notifications.command("list").description("List named notifications and their selected Play events.").option("--json", "Emit JSON output").option("--compact", "Emit only names, state, target, and event IDs").action(async (options) => {
+    const settings = await new DeeplineClient().getNotifications();
+    const rules = settings.notifications ?? [];
+    printCommandEnvelope(
+      {
+        notifications: options.compact ? rules.map((rule) => ({
+          id: rule.id,
+          name: rule.name,
+          enabled: rule.enabled,
+          target: displaySlackTarget(rule.target),
+          eventTypes: rule.eventTypes
+        })) : rules,
+        count: rules.length,
+        render: {
+          sections: [
+            {
+              title: "notifications",
+              lines: rules.length ? rules.map(
+                (rule) => `${rule.name}: ${rule.enabled ? "on" : "paused"} \u2192 ${displaySlackTarget(rule.target)} (${rule.eventTypes.join(", ") || "no events"})`
+              ) : [
+                "None yet. Add one with deepline notifications add <name> --to slack:#channel --for play.cron.failed."
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  notifications.command("get").argument("<name>", "Notification name or ID").description("Show one named notification.").option("--json", "Emit JSON output").action(async (name, options) => {
+    const rule = notificationByName(
+      await new DeeplineClient().getNotifications(),
+      name
+    );
+    printCommandEnvelope({ notification: rule }, { json: options.json });
+  });
+  notifications.command("add").argument("<name>", "Group name, for example oncall").requiredOption(
+    "--to <target>",
+    "Target; repeat email:name@example.com, slack:#channel, or slack:member:U0123456789",
+    collectNotificationTarget,
+    []
+  ).option(
+    "--for <event>",
+    "Legacy one-Slack-target event ID; repeat for more events",
+    collectEvent,
+    []
+  ).option("--dry-run", "Describe the notification without saving it").option("--json", "Emit JSON output").action(
+    async (name, options) => {
+      const result = await new DeeplineClient().createNotificationGroup({
+        name,
+        targets: options.to,
+        legacyEvents: options.for,
+        dryRun: options.dryRun
+      });
+      if (result.mode === "dry_run") {
+        printCommandEnvelope(
+          result.compatibilityMode ? {
+            dryRun: true,
+            name: result.name,
+            target: options.to[0],
+            eventTypes: result.legacyEvents
+          } : {
+            dryRun: true,
+            group: result.name,
+            targets: result.targets,
+            compatibilityMode: false
+          },
+          { json: options.json }
+        );
+        return;
+      }
+      if (result.mode === "legacy") {
+        printCommandEnvelope(
+          {
+            notification: result.notification,
+            render: {
+              sections: [
+                {
+                  title: "notification saved",
+                  lines: [name]
+                }
+              ],
+              actions: [
+                {
+                  label: "Send a test",
+                  command: `deepline notifications test ${name}`
+                }
+              ]
+            }
+          },
+          { json: options.json }
+        );
+        return;
+      }
+      printCommandEnvelope(
+        {
+          ...result,
+          render: {
+            sections: [
+              {
+                title: "notification group saved",
+                lines: [
+                  result.group.name,
+                  `${result.destinations.length} destination${result.destinations.length === 1 ? "" : "s"}`,
+                  "0 rules"
+                ]
+              }
+            ],
+            actions: [
+              {
+                label: "View configuration",
+                command: "deepline notifications configuration get"
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    }
+  );
+  notifications.command("edit").argument("<name>", "Notification name or ID").option(
+    "--to <target>",
+    "New target, for example slack:#pipeline-alerts or slack:member:U0123456789"
+  ).option(
+    "--for <event>",
+    "Replace selected events; repeat for more events. Run notifications events to list them",
+    collectEvent,
+    []
+  ).option("--dry-run", "Describe the change without saving it").option("--json", "Emit JSON output").action(
+    async (name, options) => {
+      const client = new DeeplineClient();
+      const rule = notificationByName(await client.getNotifications(), name);
+      const target = options.to ? parseSlackTarget(options.to) : rule.target.kind === "member" ? { memberId: rule.target.id } : { channel: rule.target.name };
+      const eventTypes = options.for.length ? options.for : rule.eventTypes;
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, notification: rule.id, target, eventTypes },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await client.updateNotification(rule.id, {
+        name: rule.name,
+        ...target,
+        eventTypes
+      });
+      printCommandEnvelope({ notification: result }, { json: options.json });
+    }
+  );
+  const slack = notifications.command("slack").description("Select a channel from the connected Slack integration.");
+  slack.command("channels").option("--search <text>", "Filter channel names").option("--json", "Emit JSON output").action(async (options) => {
+    const result = await new DeeplineClient().listNotificationChannels(
+      options.search
+    );
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "Slack channels",
+              lines: result.channels.length ? result.channels.map((channel) => `#${channel.name}`) : ["No visible channels matched."]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  for (const [command, enabled] of [
+    ["pause", false],
+    ["resume", true]
+  ]) {
+    notifications.command(command).argument("<name>", "Notification name or ID").option("--dry-run", "Describe the change without saving it").option("--json", "Emit JSON output").action(async (name, options) => {
+      const client = new DeeplineClient();
+      const rule = notificationByName(await client.getNotifications(), name);
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, notification: rule.id, enabled },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await client.updateNotification(rule.id, { enabled });
+      printCommandEnvelope({ notification: result }, { json: options.json });
+    });
+  }
+  notifications.command("test").argument("<name>", "Notification name or ID").option("--dry-run", "Describe the external send without sending").option("--json", "Emit JSON output").action(async (name, options) => {
+    const client = new DeeplineClient();
+    const rule = notificationByName(await client.getNotifications(), name);
+    if (options.dryRun) {
+      printCommandEnvelope(
+        { dryRun: true, notification: rule.id, action: "send_test" },
+        { json: options.json }
+      );
+      return;
+    }
+    const result = await client.testNotification(rule.id);
+    printCommandEnvelope(
+      { ...result, notification: rule.name },
+      { json: options.json }
+    );
+  });
+  notifications.command("delete").argument("<name>", "Notification name or ID").description(
+    "Archive one notification without touching its provider integration."
+  ).option("--dry-run", "Describe the deletion without changing state").option("--json", "Emit JSON output").action(async (name, options) => {
+    const client = new DeeplineClient();
+    const rule = notificationByName(await client.getNotifications(), name);
+    if (options.dryRun) {
+      printCommandEnvelope(
+        { dryRun: true, notification: rule.id, action: "archive" },
+        { json: options.json }
+      );
+      return;
+    }
+    const result = await client.deleteNotification(rule.id);
+    printCommandEnvelope(
+      { ...result, notification: rule.name },
+      { json: options.json }
+    );
+  });
+}
+export {
+  readNotificationConfigurationChange,
+  registerNotificationCommands,
+  registerSettingsCommands
+};