@geraldmaron/construct 1.0.0 → 1.0.1

package/lib/embed/providers/jira.mjs

@@ -0,0 +1,192 @@
+/**
+ * lib/embed/providers/jira.mjs — Jira (Atlassian) provider for embed mode.
+ *
+ * Reads issues from Jira Cloud using the REST API v3.
+ * Zero external deps — uses Node's built-in fetch.
+ *
+ * Supported refs:
+ *   issues     Issues matching a JQL query or project filter
+ *   sprints    Active sprint issues for a board
+ *
+ * Source config fields (embed.yaml):
+ *   provider: jira
+ *   project: PROJ              # project key — drives the default JQL
+ *   projects:                  # OR list of project keys
+ *     - PROJ
+ *     - INFRA
+ *   jql: "project = PROJ AND sprint in openSprints()"   # override JQL
+ *   refs: [issues]
+ *   limit: 50                  # max issues (default: 50)
+ *   fields: [summary,status,assignee,priority]  # optional field subset
+ */
+
+export class JiraProvider {
+  #baseUrl;
+  #auth;
+  #fetchFn;
+
+  constructor({ baseUrl, email, token, fetchFn = globalThis.fetch } = {}) {
+    if (!baseUrl || !email || !token) {
+      throw new Error('JiraProvider requires baseUrl, email, and token');
+    }
+    this.#baseUrl = baseUrl.replace(/\/$/, '');
+    this.#auth = `Basic ${Buffer.from(`${email}:${token}`).toString('base64')}`;
+    this.#fetchFn = fetchFn;
+  }
+
+  /**
+   * Default sources used when no embed.yaml is present.
+   * Queries all non-done issues assigned to the current user.
+   */
+  defaultSources() {
+    return [
+      {
+        provider: 'jira',
+        refs: ['issues'],
+        jql: 'assignee = currentUser() AND statusCategory != Done ORDER BY updated DESC',
+        limit: 50,
+      },
+    ];
+  }
+
+  /**
+   * @param {string} ref      - 'issues' | 'sprints'
+   * @param {object} opts     - source config (project, projects, jql, limit, fields)
+   * @returns {Promise<Item[]>}
+   */
+  async read(ref, opts = {}) {
+    switch (ref) {
+      case 'issues':  return this.#listIssues(opts);
+      case 'sprints': return this.#listSprintIssues(opts);
+      default:        throw new Error(`Jira provider: unknown ref "${ref}"`);
+    }
+  }
+
+  async #listIssues(opts) {
+    const limit = Number(opts.limit ?? 50);
+    const jql = opts.jql ?? buildDefaultJql(opts);
+    const fields = opts.fields ?? ['summary', 'status', 'assignee', 'priority', 'issuetype', 'labels', 'updated', 'created'];
+
+    const data = await this.#post('/rest/api/3/search/jql', {
+      jql,
+      maxResults: limit,
+      fields,
+    });
+
+    return (data.issues ?? []).map((issue) => ({
+      type: 'issue',
+      source: 'jira',
+      key: issue.key,
+      id: issue.id,
+      title: issue.fields?.summary ?? '',
+      status: issue.fields?.status?.name ?? null,
+      statusCategory: issue.fields?.status?.statusCategory?.name ?? null,
+      assignee: issue.fields?.assignee?.displayName ?? null,
+      priority: issue.fields?.priority?.name ?? null,
+      issueType: issue.fields?.issuetype?.name ?? null,
+      labels: issue.fields?.labels ?? [],
+      project: issue.key.split('-')[0],
+      url: `${this.#baseUrl}/browse/${issue.key}`,
+      createdAt: issue.fields?.created,
+      updatedAt: issue.fields?.updated,
+      summary: `[${issue.key}] ${issue.fields?.summary ?? ''}`,
+    }));
+  }
+
+  async #listSprintIssues(opts) {
+    // Fetch all boards, find ones matching the project, get active sprint
+    const projects = resolveProjects(opts);
+    if (!projects.length) throw new Error('Jira sprints source requires "project" or "projects"');
+
+    const results = [];
+    for (const projectKey of projects) {
+      try {
+        const boards = await this.#get(`/rest/agile/1.0/board?projectKeyOrId=${projectKey}&type=scrum`);
+        const board = boards.values?.[0];
+        if (!board) continue;
+
+        const sprints = await this.#get(`/rest/agile/1.0/board/${board.id}/sprint?state=active`);
+        const sprint = sprints.values?.[0];
+        if (!sprint) continue;
+
+        const sprintIssues = await this.#get(
+          `/rest/agile/1.0/sprint/${sprint.id}/issue?maxResults=${opts.limit ?? 50}`,
+        );
+        const items = (sprintIssues.issues ?? []).map((issue) => ({
+          type: 'issue',
+          source: 'jira',
+          sprint: sprint.name,
+          key: issue.key,
+          title: issue.fields?.summary ?? '',
+          status: issue.fields?.status?.name ?? null,
+          assignee: issue.fields?.assignee?.displayName ?? null,
+          priority: issue.fields?.priority?.name ?? null,
+          project: projectKey,
+          url: `${this.#baseUrl}/browse/${issue.key}`,
+          updatedAt: issue.fields?.updated,
+          summary: `[${issue.key}] ${issue.fields?.summary ?? ''}`,
+        }));
+        results.push(...items);
+      } catch (err) {
+        results.push({ type: 'error', source: 'jira', project: projectKey, message: err.message });
+      }
+    }
+    return results;
+  }
+
+  async #get(path) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10_000);
+    try {
+      const res = await this.#fetchFn(`${this.#baseUrl}${path}`, {
+        headers: { Authorization: this.#auth, Accept: 'application/json' },
+        signal: controller.signal,
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`Jira API ${res.status}: ${body.slice(0, 200)}`);
+      }
+      return res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  async #post(path, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10_000);
+    try {
+      const res = await this.#fetchFn(`${this.#baseUrl}${path}`, {
+        method: 'POST',
+        headers: {
+          Authorization: this.#auth,
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`Jira API ${res.status}: ${text.slice(0, 200)}`);
+      }
+      return res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+function resolveProjects(opts) {
+  if (Array.isArray(opts.projects)) return opts.projects.filter(Boolean);
+  if (opts.project) return [opts.project];
+  return [];
+}
+
+function buildDefaultJql(opts) {
+  const projects = resolveProjects(opts);
+  const projectClause = projects.length
+    ? `project in (${projects.map((p) => `"${p}"`).join(', ')}) AND `
+    : '';
+  return `${projectClause}statusCategory != Done ORDER BY updated DESC`;
+}

package/lib/embed/providers/linear.mjs

@@ -0,0 +1,186 @@
+/**
+ * lib/embed/providers/linear.mjs — Linear provider for embed mode.
+ *
+ * Reads issues from Linear using the GraphQL API.
+ * Zero external deps — uses Node's built-in fetch.
+ *
+ * Supported refs:
+ *   issues     Open/in-progress issues
+ *   cycles     Active cycle issues
+ *
+ * Source config fields (embed.yaml):
+ *   provider: linear
+ *   team: ENG                  # team key or ID (optional — all teams if omitted)
+ *   project: My Project        # project name filter (optional)
+ *   refs: [issues]
+ *   states: [Todo, In Progress] # filter by state names (default: excludes Done/Cancelled)
+ *   limit: 50                  # max issues (default: 50)
+ */
+
+const LINEAR_API = 'https://api.linear.app/graphql';
+
+export class LinearProvider {
+  #apiKey;
+  #fetchFn;
+
+  constructor({ apiKey, fetchFn = globalThis.fetch } = {}) {
+    if (!apiKey) throw new Error('LinearProvider requires an apiKey');
+    this.#apiKey = apiKey;
+    this.#fetchFn = fetchFn;
+  }
+
+  /**
+   * Auto-discovery: return assigned non-completed issues when LINEAR_API_KEY is present.
+   */
+  defaultSources() {
+    return [{ provider: 'linear', refs: ['issues'], limit: 50 }];
+  }
+
+  /**
+   * @param {string} ref      - 'issues' | 'cycles'
+   * @param {object} opts     - source config (team, project, states, limit)
+   * @returns {Promise<Item[]>}
+   */
+  async read(ref, opts = {}) {
+    switch (ref) {
+      case 'issues': return this.#listIssues(opts);
+      case 'cycles': return this.#listCycleIssues(opts);
+      default:       throw new Error(`Linear provider: unknown ref "${ref}"`);
+    }
+  }
+
+  async #listIssues(opts) {
+    const limit = Number(opts.limit ?? 50);
+    const stateFilter = Array.isArray(opts.states) ? opts.states : null;
+
+    // Build filter clauses
+    const filters = [];
+    if (opts.team) filters.push(`team: { key: { eq: "${opts.team}" } }`);
+    if (stateFilter) {
+      const stateIn = stateFilter.map((s) => `"${s}"`).join(', ');
+      filters.push(`state: { name: { in: [${stateIn}] } }`);
+    } else {
+      // Default: exclude terminal states
+      filters.push(`state: { type: { nin: ["completed", "cancelled"] } }`);
+    }
+    if (opts.project) filters.push(`project: { name: { eq: "${opts.project}" } }`);
+
+    const filterClause = filters.length ? `filter: { ${filters.join(', ')} }` : '';
+
+    const query = `{
+      issues(first: ${limit} ${filterClause} orderBy: updatedAt) {
+        nodes {
+          id
+          identifier
+          title
+          description
+          priority
+          priorityLabel
+          state { name type }
+          assignee { name }
+          team { name key }
+          project { name }
+          url
+          createdAt
+          updatedAt
+          labels { nodes { name } }
+        }
+      }
+    }`;
+
+    const data = await this.#graphql(query);
+    return (data?.issues?.nodes ?? []).map((issue) => ({
+      type: 'issue',
+      source: 'linear',
+      id: issue.identifier,
+      title: issue.title,
+      description: issue.description?.slice(0, 200) ?? null,
+      state: issue.state?.name,
+      stateType: issue.state?.type,
+      priority: issue.priorityLabel,
+      assignee: issue.assignee?.name ?? null,
+      team: issue.team?.key,
+      teamName: issue.team?.name,
+      project: issue.project?.name ?? null,
+      labels: (issue.labels?.nodes ?? []).map((l) => l.name),
+      url: issue.url,
+      createdAt: issue.createdAt,
+      updatedAt: issue.updatedAt,
+      summary: `[${issue.identifier}] ${issue.title}`,
+    }));
+  }
+
+  async #listCycleIssues(opts) {
+    const limit = Number(opts.limit ?? 50);
+    const teamFilter = opts.team ? `filter: { team: { key: { eq: "${opts.team}" } } }` : '';
+
+    const query = `{
+      cycles(first: 1 ${teamFilter} filter: { isActive: { eq: true } }) {
+        nodes {
+          id
+          name
+          number
+          startsAt
+          endsAt
+          team { name key }
+          issues(first: ${limit}) {
+            nodes {
+              id
+              identifier
+              title
+              state { name type }
+              assignee { name }
+              priority
+              priorityLabel
+              url
+              updatedAt
+            }
+          }
+        }
+      }
+    }`;
+
+    const data = await this.#graphql(query);
+    const cycle = data?.cycles?.nodes?.[0];
+    if (!cycle) return [];
+
+    return (cycle.issues?.nodes ?? []).map((issue) => ({
+      type: 'issue',
+      source: 'linear',
+      cycle: `${cycle.team?.key ?? ''} Cycle ${cycle.number}`,
+      id: issue.identifier,
+      title: issue.title,
+      state: issue.state?.name,
+      stateType: issue.state?.type,
+      priority: issue.priorityLabel,
+      assignee: issue.assignee?.name ?? null,
+      url: issue.url,
+      updatedAt: issue.updatedAt,
+      summary: `[${issue.identifier}] ${issue.title}`,
+    }));
+  }
+
+  async #graphql(query) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15_000);
+    try {
+      const res = await this.#fetchFn(LINEAR_API, {
+        method: 'POST',
+        headers: {
+          Authorization: this.#apiKey,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ query }),
+        signal: controller.signal,
+      });
+      if (!res.ok) throw new Error(`Linear API HTTP ${res.status}`);
+      const json = await res.json();
+      if (json.errors?.length) {
+        throw new Error(`Linear GraphQL: ${json.errors[0].message}`);
+      }
+      return json.data;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}

package/lib/embed/providers/registry.mjs

@@ -0,0 +1,115 @@
+/**
+ * lib/embed/providers/registry.mjs — ProviderRegistry.
+ *
+ * Holds named provider instances and exposes an async factory that builds
+ * the standard set from environment variables. Each provider implements:
+ *
+ *   read(ref, opts)  → Promise<Item[]>
+ *     ref:  source-type string e.g. 'prs', 'issues', 'commits', 'messages'
+ *     opts: source config fields (repo, channel, project, …)
+ *
+ *   write(action)    → Promise<void>   (optional — only mutation providers)
+ *     action: { type, channel?, text?, … }
+ *
+ * Providers are registered by name and can be swapped for test doubles.
+ */
+
+export class ProviderRegistry {
+  #providers = new Map();
+
+  /**
+   * Register a provider under one or more names.
+   * @param {string|string[]} names
+   * @param {object} provider
+   */
+  register(names, provider) {
+    for (const name of [].concat(names)) {
+      this.#providers.set(name, provider);
+    }
+    return this;
+  }
+
+  /**
+   * Retrieve a provider by name. Returns null if not registered.
+   * @param {string} name
+   */
+  get(name) {
+    return this.#providers.get(name) ?? null;
+  }
+
+  /**
+   * Build the union of all registered providers' default sources.
+   * Called when no embed.yaml is present.
+   * @param {object} env  - Merged environment (for providers that need it, e.g. GitHub repos)
+   * @returns {object[]}  - Array of source config objects ready for SnapshotEngine
+   */
+  autoSources(env = {}) {
+    const sources = [];
+    for (const provider of this.#providers.values()) {
+      if (typeof provider.defaultSources === 'function') {
+        sources.push(...provider.defaultSources(env));
+      }
+    }
+    // Deduplicate by provider+refs signature — multiple registry aliases can point to same instance
+    const seen = new Set();
+    return sources.filter((s) => {
+      const key = `${s.provider}:${(s.refs ?? []).join(',')}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  /**
+   * List all registered provider names.
+   */
+  names() {
+    return [...this.#providers.keys()];
+  }
+
+  /**
+   * Build a registry pre-populated with all concrete providers derived
+   * from the supplied environment. Providers whose required credentials
+   * are absent are silently omitted — callers get a warning at runtime
+   * when a source references a missing provider.
+   *
+   * @param {object} env  - Merged environment (loadConstructEnv output)
+   * @returns {Promise<ProviderRegistry>}
+   */
+  static async fromEnv(env = process.env) {
+    const registry = new ProviderRegistry();
+
+    if (env.GITHUB_TOKEN || env.GITHUB_PERSONAL_ACCESS_TOKEN) {
+      const { GitHubProvider } = await import('./github.mjs');
+      registry.register(['github', 'gh'], new GitHubProvider({
+        token: env.GITHUB_TOKEN || env.GITHUB_PERSONAL_ACCESS_TOKEN,
+      }));
+    }
+
+    if (env.SLACK_BOT_TOKEN) {
+      const { SlackProvider } = await import('./slack.mjs');
+      registry.register(['slack'], new SlackProvider({
+        token: env.SLACK_BOT_TOKEN,
+        teamId: env.SLACK_TEAM_ID,
+      }));
+    }
+
+    if (env.LINEAR_API_KEY) {
+      const { LinearProvider } = await import('./linear.mjs');
+      registry.register(['linear'], new LinearProvider({
+        apiKey: env.LINEAR_API_KEY,
+      }));
+    }
+
+    if (env.JIRA_API_TOKEN && env.JIRA_USER_EMAIL && env.JIRA_BASE_URL) {
+      const { JiraProvider } = await import('./jira.mjs');
+      registry.register(['jira', 'atlassian'], new JiraProvider({
+        baseUrl: env.JIRA_BASE_URL,
+        email: env.JIRA_USER_EMAIL,
+        token: env.JIRA_API_TOKEN,
+      }));
+    }
+
+    return registry;
+  }
+}

package/lib/embed/providers/slack.mjs

@@ -0,0 +1,203 @@
+/**
+ * lib/embed/providers/slack.mjs — Slack provider for embed mode.
+ *
+ * Reads recent messages from one or more channels using the Slack Web API.
+ * Zero external deps — uses Node's built-in fetch.
+ *
+ * Supported refs:
+ *   messages   Recent messages in a channel
+ *
+ * Source config fields (embed.yaml):
+ *   provider: slack
+ *   channel: C12345678         # single channel ID or name
+ *   channels:                  # OR list, optionally with intent tags
+ *     - general                # no intent — defaults to 'internal'
+ *     - incidents:risk         # channel:intent — drives observation category
+ *     - customer-feedback:external
+ *   refs: [messages]
+ *   limit: 20                  # max messages per channel (default: 20)
+ *   oldest: 86400              # seconds of history to fetch (default: 86400 = 24h)
+ *
+ * SLACK_CHANNELS env format (config.env):
+ *   SLACK_CHANNELS=#eng-general,#incidents:risk,#decisions:decision,#customer:external
+ *
+ * Intent values and their observation category mapping:
+ *   internal   → insight       (default — team chat, general discussion)
+ *   risk       → anti-pattern  (incidents, alerts, on-call, escalations)
+ *   decision   → decision      (decision-making channels, RFC discussions)
+ *   external   → insight + tag:external  (customer feedback, support, sales)
+ *   how-to     → pattern       (tips, best practices, knowledge sharing)
+ *   (none)     → insight       (fallback)
+ */
+
+const SLACK_API = 'https://slack.com/api';
+
+export class SlackProvider {
+  #token;
+  #teamId;
+  #fetchFn;
+
+  constructor({ token, teamId, fetchFn = globalThis.fetch } = {}) {
+    if (!token) throw new Error('SlackProvider requires a token');
+    this.#token = token;
+    this.#teamId = teamId;
+    this.#fetchFn = fetchFn;
+  }
+
+  /**
+   * Auto-discovery: return one source per intent group from SLACK_CHANNELS.
+   * Format: SLACK_CHANNELS=#eng-general,#incidents:risk,#decisions:decision
+   * Channels without an intent tag default to 'internal'.
+   * Each unique intent becomes its own source so snapshot sections are typed.
+   */
+  defaultSources(env = {}) {
+    const raw = env.SLACK_CHANNELS ?? env.SLACK_CHANNEL ?? '';
+    const entries = raw.split(',').map((c) => c.trim()).filter(Boolean).map(parseChannelEntry);
+    if (!entries.length) return [];
+
+    // Group channels by intent so each source section carries a consistent intent
+    const byIntent = new Map();
+    for (const { channel, intent } of entries) {
+      if (!byIntent.has(intent)) byIntent.set(intent, []);
+      byIntent.get(intent).push(channel);
+    }
+
+    return [...byIntent.entries()].map(([intent, channels]) => ({
+      provider: 'slack',
+      refs: ['messages'],
+      channels,
+      intent,
+      oldest: 86400,
+      limit: 50,
+    }));
+  }
+
+  /**
+   * @param {string} ref      - 'messages'
+   * @param {object} opts     - source config (channel, channels, limit, oldest)
+   * @returns {Promise<Item[]>}
+   */
+  async read(ref, opts = {}) {
+    if (ref !== 'messages') throw new Error(`Slack provider: unknown ref "${ref}"`);
+
+    const channelEntries = resolveChannels(opts);
+    if (!channelEntries.length) {
+      throw new Error(`Slack source requires "channel" or "channels" field`);
+    }
+
+    const intent = opts.intent ?? 'internal';
+    const limit = Number(opts.limit ?? 20);
+    const oldestSec = Number(opts.oldest ?? 86400);
+    const oldest = String(Math.floor(Date.now() / 1000) - oldestSec);
+    const results = [];
+
+    for (const { channel, intent: entryIntent } of channelEntries) {
+      const effectiveIntent = entryIntent ?? intent;
+      try {
+        const channelId = await this.#resolveChannelId(channel);
+        const items = await this.#listMessages(channelId, { limit, oldest });
+        results.push(...items.map((i) => ({ ...i, channelName: channel, intent: effectiveIntent })));
+      } catch (err) {
+        results.push({ type: 'error', source: 'slack', channel, message: err.message });
+      }
+    }
+
+    return results;
+  }
+
+  async #resolveChannelId(channelOrId) {
+    // Already looks like an ID (C... or D... or G...)
+    if (/^[A-Z][A-Z0-9]{8,}$/.test(channelOrId)) return channelOrId;
+
+    // Resolve by name
+    const name = channelOrId.replace(/^#/, '');
+    const data = await this.#apiGet('conversations.list', { limit: 200, exclude_archived: true });
+    const match = (data.channels ?? []).find(
+      (c) => c.name === name || c.name_normalized === name,
+    );
+    if (!match) throw new Error(`Slack channel not found: ${channelOrId}`);
+    return match.id;
+  }
+
+  async #listMessages(channelId, { limit, oldest }) {
+    const data = await this.#apiGet('conversations.history', {
+      channel: channelId,
+      limit,
+      oldest,
+    });
+
+    return (data.messages ?? [])
+      .filter((m) => m.type === 'message' && !m.subtype)
+      .map((m) => ({
+        type: 'message',
+        source: 'slack',
+        channel: channelId,
+        user: m.user ?? m.username ?? 'unknown',
+        text: m.text ?? '',
+        ts: m.ts,
+        threadTs: m.thread_ts ?? null,
+        replyCount: m.reply_count ?? 0,
+        reactions: (m.reactions ?? []).map((r) => `${r.name}:${r.count}`),
+        url: this.#teamId
+          ? `https://app.slack.com/client/${this.#teamId}/${channelId}/p${m.ts.replace('.', '')}`
+          : null,
+        summary: `<${m.user ?? 'unknown'}> ${(m.text ?? '').slice(0, 80)}`,
+      }));
+  }
+
+  async #apiGet(method, params = {}) {
+    const qs = new URLSearchParams(
+      Object.entries(params).map(([k, v]) => [k, String(v)]),
+    ).toString();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10_000);
+    try {
+      const res = await this.#fetchFn(`${SLACK_API}/${method}?${qs}`, {
+        headers: {
+          Authorization: `Bearer ${this.#token}`,
+          'Content-Type': 'application/json',
+        },
+        signal: controller.signal,
+      });
+      if (!res.ok) throw new Error(`Slack HTTP ${res.status}`);
+      const json = await res.json();
+      if (!json.ok) throw new Error(`Slack API error: ${json.error ?? 'unknown'}`);
+      return json;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+/**
+ * Parse a channel entry that may carry an intent tag: "#name:intent" or "name".
+ * Returns { channel: string, intent: string }.
+ */
+function parseChannelEntry(raw) {
+  const s = String(raw).trim().replace(/^#/, '');
+  const colonIdx = s.lastIndexOf(':');
+  // Avoid splitting channel IDs like C12345678 — intents are alpha-only words
+  if (colonIdx > 0 && /^[a-z-]+$/.test(s.slice(colonIdx + 1))) {
+    return { channel: s.slice(0, colonIdx), intent: s.slice(colonIdx + 1) };
+  }
+  return { channel: s, intent: 'internal' };
+}
+
+/**
+ * Map an intent label to an observation category.
+ */
+export function intentToCategory(intent) {
+  switch ((intent ?? '').toLowerCase()) {
+    case 'risk':     return 'anti-pattern';
+    case 'decision': return 'decision';
+    case 'how-to':
+    case 'howto':    return 'pattern';
+    default:         return 'insight';
+  }
+}
+
+function resolveChannels(opts) {
+  if (Array.isArray(opts.channels)) return opts.channels.filter(Boolean).map(parseChannelEntry);
+  if (opts.channel) return [parseChannelEntry(opts.channel)];
+  return [];
+}