mixdog 0.9.2 → 0.9.4

package/src/tui/app/channel-pickers.mjs

@@ -0,0 +1,510 @@
+/**
+ * channel-pickers.mjs — the Channel setup picker cluster.
+ *
+ * Extracted from App.jsx behavior-preservingly as a dependency-injection
+ * factory. Every function body is the original App logic verbatim, with closure
+ * identifiers threaded through the factory argument. Cross-references between
+ * the three openers stay inside this factory; the onboarding-only dep
+ * (onboardingWarnReopen) threads as a lazy getter wrapper so it resolves the
+ * live opener at call time.
+ */
+import { theme } from '../theme.mjs';
+
+export function createChannelPickers({
+  store,
+  setPicker,
+  setProviderPrompt,
+  setChannelPrompt,
+  setHookPrompt,
+  setSettingsPrompt,
+  setContextPanel,
+  onboardingWarnReopen,
+}) {
+  const openChannelTypeActionsPicker = (backend, options = {}) => {
+    const parentReturn = typeof options.returnTo === 'function'
+      ? options.returnTo
+      : () => openChannelSettingTypePicker();
+    setProviderPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    setContextPanel(null);
+    let setup;
+    try {
+      setup = store.getChannelSetup();
+    } catch (e) {
+      store.pushNotice(`channels failed: ${e?.message || e}`, 'error');
+      return;
+    }
+    const isTelegram = backend === 'telegram';
+    const activeBackend = setup.backend || 'discord';
+    const tokenDescription = isTelegram
+      ? `${setup.telegram?.status ?? 'Off'}${setup.telegram?.problem ? ' · Invalid' : ''}`
+      : `${setup.discord.status}${setup.discord.problem ? ' · Invalid' : ''}`;
+    const mainEntry = (setup.channels || []).find((ch) => ch.main)
+      || (setup.channels || []).find((ch) => ch.name === 'main');
+    const mainTarget = isTelegram
+      ? (mainEntry?.telegramChatId || (activeBackend === 'telegram' ? mainEntry?.channelId : ''))
+      : (mainEntry?.discordChannelId || (activeBackend === 'discord' ? mainEntry?.channelId : ''));
+    const mainDescription = isTelegram
+      ? (mainTarget ? `Chat ID ${mainTarget}` : 'Not set · Enter Telegram chat ID')
+      : (mainTarget ? `Channel ID ${mainTarget}` : 'Not set · Enter Discord channel ID');
+
+    const openChannelPrompt = (prompt) => {
+      setPicker(null);
+      setContextPanel(null);
+      setChannelPrompt({
+        ...prompt,
+        afterSave: () => openChannelTypeActionsPicker(backend, options),
+      });
+    };
+
+    setPicker({
+      title: isTelegram ? 'Telegram' : 'Discord',
+      description: activeBackend === backend
+        ? 'Active channel type · token and main target'
+        : 'Token and main target settings',
+      help: '↑/↓ Select · Enter Edit · Esc Back',
+      indexMode: 'always',
+      labelWidth: 18,
+      items: [
+        {
+          value: 'token',
+          label: 'Bot token',
+          description: tokenDescription,
+          _action: isTelegram ? 'telegram-token' : 'discord-token',
+        },
+        {
+          value: 'main',
+          label: isTelegram ? 'Main chat' : 'Main channel',
+          description: mainDescription,
+          _action: 'main-target',
+        },
+      ],
+      onSelect: (_value, item) => {
+        try {
+          if (item._action === 'discord-token') {
+            openChannelPrompt({
+              kind: 'discord-token',
+              label: 'Discord bot token',
+              hint: 'Paste the Discord bot token. It is stored in the OS keychain.',
+            });
+            return;
+          }
+          if (item._action === 'telegram-token') {
+            openChannelPrompt({
+              kind: 'telegram-token',
+              label: 'Telegram bot token',
+              hint: 'Paste the Telegram bot token from @BotFather. Stored in the OS keychain.',
+            });
+            return;
+          }
+          if (item._action === 'main-target') {
+            openChannelPrompt({
+              kind: 'channel-add',
+              backend,
+              label: isTelegram ? 'Main chat' : 'Main channel',
+              hint: isTelegram
+                ? 'Paste the Telegram chat ID.'
+                : 'Paste the Discord channel ID.',
+            });
+          }
+        } catch (e) {
+          store.pushNotice(`channels update failed: ${e?.message || e}`, 'error');
+        }
+      },
+      onCancel: () => {
+        parentReturn();
+      },
+    });
+  };
+
+  const openChannelSettingTypePicker = (options = {}) => {
+    const returnTo = typeof options.returnTo === 'function' ? options.returnTo : () => {};
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    setContextPanel(null);
+    let setup;
+    try {
+      setup = store.getChannelSetup();
+    } catch (e) {
+      store.pushNotice(`channels failed: ${e?.message || e}`, 'error');
+      return;
+    }
+    const activeBackend = setup.backend || 'discord';
+    const mainEntry = (setup.channels || []).find((ch) => ch.main)
+      || (setup.channels || []).find((ch) => ch.name === 'main');
+    const typeDescription = (backend) => {
+      const selected = activeBackend === backend;
+      const hasToken = backend === 'telegram'
+        ? setup.telegram?.authenticated === true
+        : setup.discord?.authenticated === true;
+      const hasTarget = backend === 'telegram'
+        ? Boolean(mainEntry?.telegramChatId || (activeBackend === 'telegram' && mainEntry?.channelId))
+        : Boolean(mainEntry?.discordChannelId || (activeBackend === 'discord' && mainEntry?.channelId));
+      const needs = [
+        ...(hasToken ? [] : ['token']),
+        ...(hasTarget ? [] : [backend === 'telegram' ? 'chat ID' : 'channel ID']),
+      ];
+      return [
+        ...(selected ? ['Selected'] : []),
+        needs.length ? `Needs ${needs.join(' + ')}` : 'Ready',
+      ].join(' · ');
+    };
+    setPicker({
+      title: 'Channel Type Settings',
+      description: 'Choose a type. Selected is the active backend; Ready means token and main target are set.',
+      help: '↑/↓ Select · Enter Open · Esc Back',
+      indexMode: 'always',
+      labelWidth: 18,
+      items: [
+        {
+          value: 'discord',
+          label: 'Discord',
+          description: typeDescription('discord'),
+          _backend: 'discord',
+        },
+        {
+          value: 'telegram',
+          label: 'Telegram',
+          description: typeDescription('telegram'),
+          _backend: 'telegram',
+        },
+      ],
+      onSelect: (value, item) => {
+        const backend = item?._backend || (value === 'telegram' ? 'telegram' : value === 'discord' ? 'discord' : null);
+        if (!backend) return;
+        setPicker(null);
+        openChannelTypeActionsPicker(backend, {
+          returnTo: () => openChannelSettingTypePicker(options),
+        });
+      },
+      onCancel: () => {
+        setPicker(null);
+        returnTo();
+      },
+    });
+  };
+
+  const openChannelSetupPicker = async (focus = 'all', options = {}) => {
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    setContextPanel(null);
+    let setup;
+    try {
+      setup = store.getChannelSetup();
+    } catch (e) {
+      store.pushNotice(`channels failed: ${e?.message || e}`, 'error');
+      return;
+    }
+
+    const openChannelPrompt = (prompt) => {
+      setPicker(null);
+      setContextPanel(null);
+      setChannelPrompt(prompt);
+    };
+
+    const channelRemoteEnabled = store.isRemoteEnabled?.() === true;
+
+    if (focus === 'schedules') {
+      const schedules = setup.schedules || [];
+      const items = [
+        ...(schedules.length ? schedules.map((schedule) => {
+        const enabled = schedule.enabled !== false;
+        return {
+          value: `schedule:${schedule.name}`,
+          label: schedule.name,
+          marker: enabled ? '●' : '○',
+          markerColor: channelRemoteEnabled ? (enabled ? theme.success : theme.inactive) : theme.inactive,
+          description: `${schedule.time || '(no cron)'} · ${schedule.route}${schedule.model ? ` · ${schedule.model}` : ''}${channelRemoteEnabled ? '' : ' · channel off'}`,
+          _action: 'schedule-toggle',
+          _name: schedule.name,
+          _enabled: enabled,
+        };
+      }) : [{
+          value: 'empty',
+          label: 'No schedules',
+          description: 'no schedules configured',
+          _action: 'noop',
+        }]),
+      ];
+      const toggleSchedule = (item) => {
+        if (item._action !== 'schedule-toggle') return;
+        if (!channelRemoteEnabled) {
+          store.pushNotice('enable channel first', 'warn');
+          return;
+        }
+        try {
+          store.setScheduleEnabled?.(item._name, !item._enabled);
+          void openChannelSetupPicker('schedules', { highlightValue: `schedule:${item._name}` });
+        } catch (e) {
+          store.pushNotice(`schedule toggle failed: ${e?.message || e}`, 'error');
+        }
+      };
+      setPicker({
+        title: 'Schedules',
+        description: channelRemoteEnabled ? 'Enable or disable cron schedules.' : 'Enable channel to toggle schedules.',
+        initialIndex: Math.max(0, items.findIndex((entry) => entry.value === options.highlightValue)),
+        items,
+        onSelect: (_value, item) => toggleSchedule(item),
+        onLeft: (item) => toggleSchedule(item),
+        onRight: (item) => toggleSchedule(item),
+        onCancel: () => {
+          setPicker(null);
+        },
+      });
+      return;
+    }
+
+    if (focus === 'webhook-endpoint') {
+      const returnTo = typeof options.returnTo === 'function'
+        ? options.returnTo
+        : () => setPicker(null);
+      const domain = setup.webhook?.ngrokDomain || setup.webhook?.domain || '';
+      const items = [
+        {
+          value: 'endpoint-domain',
+          label: 'ngrok domain',
+          description: domain ? domain : 'Not set · Enter ngrok domain',
+          _action: 'endpoint-domain',
+        },
+        {
+          value: 'endpoint-authtoken',
+          label: 'authtoken',
+          description: setup.webhook?.authenticated === true ? 'Set' : 'Not set · Enter authtoken',
+          _action: 'endpoint-authtoken',
+        },
+      ];
+      setPicker({
+        title: 'Webhook endpoint',
+        description: 'ngrok domain and authtoken. Toggle individual webhooks in /webhooks.',
+        help: '↑/↓ Select · Enter Edit · Esc Back',
+        indexMode: 'always',
+        labelWidth: 18,
+        items,
+        onSelect: (_value, item) => {
+          try {
+            if (item._action === 'endpoint-domain') {
+              openChannelPrompt({
+                kind: 'webhook-domain',
+                label: 'ngrok domain',
+                hint: 'Paste the reserved ngrok domain (e.g. my-app.ngrok-free.app).',
+                afterSave: () => void openChannelSetupPicker('webhook-endpoint', options),
+              });
+              return;
+            }
+            if (item._action === 'endpoint-authtoken') {
+              openChannelPrompt({
+                kind: 'webhook-token',
+                label: 'Webhook/ngrok authtoken',
+                hint: 'Paste the webhook/ngrok authtoken. It is stored in the OS keychain.',
+                afterSave: () => void openChannelSetupPicker('webhook-endpoint', options),
+              });
+            }
+          } catch (e) {
+            store.pushNotice(`webhook endpoint failed: ${e?.message || e}`, 'error');
+          }
+        },
+        onCancel: () => {
+          setPicker(null);
+          returnTo();
+        },
+      });
+      return;
+    }
+
+    if (focus === 'webhooks') {
+      const hooks = setup.webhooks || [];
+      const items = [
+        ...(hooks.length ? hooks.map((hook) => {
+          const enabled = hook.enabled !== false;
+          return {
+            value: `webhook:${hook.name}`,
+            label: hook.name,
+            marker: enabled ? '●' : '○',
+            markerColor: channelRemoteEnabled ? (enabled ? theme.success : theme.inactive) : theme.inactive,
+            description: `${hook.parser || 'github'} · ${hook.route} · secret:${hook.secretSet ? 'set' : 'missing'}${channelRemoteEnabled ? '' : ' · channel off'}`,
+            _action: 'webhook-toggle',
+            _name: hook.name,
+            _enabled: enabled,
+          };
+        }) : [{
+          value: 'empty',
+          label: 'No webhooks',
+          description: 'no webhook endpoints configured',
+          _action: 'noop',
+        }]),
+      ];
+      const toggleWebhook = (item) => {
+        if (item._action !== 'webhook-toggle') return;
+        if (!channelRemoteEnabled) {
+          store.pushNotice('enable channel first', 'warn');
+          return;
+        }
+        try {
+          store.setWebhookEnabled?.(item._name, !item._enabled);
+          void openChannelSetupPicker('webhooks', { highlightValue: `webhook:${item._name}` });
+        } catch (e) {
+          store.pushNotice(`webhook toggle failed: ${e?.message || e}`, 'error');
+        }
+      };
+      setPicker({
+        title: 'Webhooks',
+        description: channelRemoteEnabled ? 'Enable or disable inbound webhook endpoints.' : 'Enable channel to toggle webhooks.',
+        initialIndex: Math.max(0, items.findIndex((entry) => entry.value === options.highlightValue)),
+        items,
+        onSelect: (_value, item) => toggleWebhook(item),
+        onLeft: (item) => toggleWebhook(item),
+        onRight: (item) => toggleWebhook(item),
+        onCancel: () => {
+          setPicker(null);
+        },
+      });
+      return;
+    }
+
+    const worker = store.getChannelWorkerStatus?.();
+    const activeBackend = setup.backend === 'telegram' ? 'telegram' : 'discord';
+    const backendLabel = activeBackend === 'telegram' ? 'Telegram' : 'Discord';
+    const remoteEnabled = store.isRemoteEnabled?.() === true;
+    const boolLabel = (enabled) => enabled ? 'On' : 'Off';
+    // Onboarding Step 5 reuses this root picker with a ConfirmBar. Reopens after
+    // a toggle must carry the onboarding context (confirmBar + flag) forward so
+    // Back/Finish stay wired and the general /channels path keeps its own opts.
+    const reopenRoot = (extra = {}) => {
+      const preserved = options.onboarding
+        ? { onboarding: true, confirmBar: options.confirmBar || null }
+        : {};
+      void openChannelSetupPicker('all', { ...preserved, ...extra });
+    };
+    const applyRemoteRuntime = (highlightValue = 'remote-runtime') => {
+      const enabled = store.toggleRemote?.() === true;
+      store.pushNotice(enabled ? 'Remote mode ON' : 'Remote mode OFF', 'info');
+      reopenRoot({ highlightValue });
+    };
+    const cycleChannelBackend = (direction = 1, highlightValue = 'channel-backend') => {
+      const backends = ['discord', 'telegram'];
+      const currentIndex = Math.max(0, backends.indexOf(activeBackend));
+      const chosen = backends[(currentIndex + direction + backends.length) % backends.length];
+      if (chosen === activeBackend) {
+        reopenRoot({ highlightValue, backendOverride: activeBackend });
+        return;
+      }
+      try {
+        store.setBackend(chosen);
+        const label = chosen === 'telegram' ? 'Telegram' : 'Discord';
+        const restartHint = (store.isRemoteEnabled?.() === true || worker?.running)
+          ? `Channel set to ${label}. Restart remote to apply.`
+          : `Channel set to ${label}.`;
+        store.pushNotice(restartHint, 'info');
+      } catch (e) {
+        store.pushNotice(`channel backend failed: ${e?.message || e}`, 'error');
+      }
+      reopenRoot({ highlightValue, backendOverride: chosen });
+    };
+    const items = [
+      {
+        value: 'remote-runtime',
+        label: 'Remote Runtime',
+        meta: boolLabel(remoteEnabled),
+        description: worker?.running ? `Running · pid ${worker.pid}` : 'Stopped',
+        _action: 'remote-runtime',
+      },
+      {
+        value: 'channel-backend',
+        label: 'Channel',
+        meta: backendLabel,
+        description: 'Select Discord or Telegram',
+        _action: 'channel-backend',
+      },
+      {
+        value: 'channel-setting',
+        label: 'Setting',
+        description: 'Token and main target',
+        _action: 'channel-setting',
+      },
+      {
+        value: 'webhook-endpoint',
+        label: 'Webhook endpoint',
+        meta: (() => {
+          const hasDomain = Boolean(setup.webhook?.ngrokDomain || setup.webhook?.domain);
+          const hasAuth = setup.webhook?.authenticated === true;
+          return (hasDomain && hasAuth) ? 'On' : 'Off';
+        })(),
+        description: (() => {
+          const hasDomain = Boolean(setup.webhook?.ngrokDomain || setup.webhook?.domain);
+          const hasAuth = setup.webhook?.authenticated === true;
+          const needs = [
+            ...(hasDomain ? [] : ['domain']),
+            ...(hasAuth ? [] : ['authtoken']),
+          ];
+          return needs.length ? `Needs ${needs.join(' + ')}` : 'ngrok domain and authtoken set';
+        })(),
+        _action: 'webhook-endpoint',
+      },
+    ];
+
+    setPicker({
+      title: 'Channels',
+      description: 'Remote access and channel setup.',
+      // Onboarding overlays a ConfirmBar (←/→ drive Back/Finish, not toggles),
+      // so drop the ←/→ Change hint there and use the Picker's ConfirmBar help.
+      help: options.confirmBar ? undefined : '↑/↓ Select · ←/→ Change · Enter Choose/Toggle · Esc Back',
+      indexMode: 'always',
+      labelWidth: 18,
+      metaWidth: 12,
+      pickerKey: `channels:${activeBackend}:${remoteEnabled ? 'on' : 'off'}:${options.highlightValue || 'root'}`,
+      initialIndex: Math.max(0, items.findIndex((entry) => entry.value === options.highlightValue)),
+      items,
+      confirmBar: options.confirmBar || null,
+      onLeft: options.confirmBar ? undefined : (item) => {
+        if (item?._action === 'remote-runtime') applyRemoteRuntime(item.value);
+        else if (item?._action === 'channel-backend') cycleChannelBackend(-1, item.value);
+      },
+      onRight: options.confirmBar ? undefined : (item) => {
+        if (item?._action === 'remote-runtime') applyRemoteRuntime(item.value);
+        else if (item?._action === 'channel-backend') cycleChannelBackend(1, item.value);
+      },
+      onSelect: (_value, item) => {
+        try {
+          if (item._action === 'remote-runtime') {
+            applyRemoteRuntime(item.value);
+            return;
+          }
+          if (item._action === 'channel-backend') {
+            cycleChannelBackend(1, item.value);
+            return;
+          }
+          if (item._action === 'channel-setting') {
+            openChannelSettingTypePicker({
+              returnTo: () => reopenRoot({ highlightValue: 'channel-setting' }),
+            });
+            return;
+          }
+          if (item._action === 'webhook-endpoint') {
+            void openChannelSetupPicker('webhook-endpoint', {
+              ...(options.onboarding ? { onboarding: true, confirmBar: options.confirmBar || null } : {}),
+              returnTo: () => reopenRoot({ highlightValue: 'webhook-endpoint' }),
+            });
+          }
+        } catch (e) {
+          store.pushNotice(`channels update failed: ${e?.message || e}`, 'error');
+        }
+      },
+      onCancel: () => {
+        setPicker(null);
+        // Onboarding Step 5 Esc mirrors the other steps' reopen-next-launch warning.
+        if (options.onboarding) onboardingWarnReopen();
+      },
+    });
+  };
+
+  return {
+    openChannelTypeActionsPicker,
+    openChannelSettingTypePicker,
+    openChannelSetupPicker,
+  };
+}

package/src/tui/app/clipboard.mjs

@@ -0,0 +1,67 @@
+/**
+ * clipboard.mjs — OS-clipboard write helpers extracted verbatim from App.jsx.
+ * Pure module functions (spawn/process/Buffer only); no React, no App state.
+ */
+import { Buffer } from 'node:buffer';
+import { spawn } from 'node:child_process';
+
+export function osc52ClipboardSequence(text) {
+  const b64 = Buffer.from(String(text ?? ''), 'utf8').toString('base64');
+  const raw = `\x1b]52;c;${b64}\x07`;
+  if (!process.env.TMUX) return raw;
+  return `\x1bPtmux;${raw.replaceAll('\x1b', '\x1b\x1b')}\x1b\\`;
+}
+
+export function writeOsc52Clipboard(text) {
+  try {
+    process.stdout.write(osc52ClipboardSequence(text));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function nativeClipboardCommand(text) {
+  if (process.platform === 'win32') {
+    return {
+      cmd: 'powershell.exe',
+      args: [
+        '-NoLogo',
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        '$b=[Console]::In.ReadToEnd();$t=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($b));Set-Clipboard -Value $t',
+      ],
+      input: Buffer.from(String(text ?? ''), 'utf8').toString('base64'),
+    };
+  }
+  if (process.platform === 'darwin') return { cmd: 'pbcopy', args: [], input: text };
+  if (process.env.WAYLAND_DISPLAY) return { cmd: 'wl-copy', args: [], input: text };
+  return { cmd: 'xclip', args: ['-selection', 'clipboard'], input: text };
+}
+
+export function copyToClipboard(text) {
+  const value = String(text ?? '');
+  const wroteOsc52 = writeOsc52Clipboard(value);
+  return new Promise((resolve, reject) => {
+    const { cmd, args, input } = nativeClipboardCommand(value);
+    let child;
+    try {
+      child = spawn(cmd, args, { stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true });
+    } catch (e) {
+      if (wroteOsc52) resolve();
+      else reject(e);
+      return;
+    }
+    child.on('error', (e) => {
+      if (wroteOsc52) resolve();
+      else reject(e);
+    });
+    child.on('close', (code) => {
+      if (code === 0 || wroteOsc52) resolve();
+      else reject(new Error(`${cmd} exited with code ${code}`));
+    });
+    child.stdin.on('error', () => { /* ignore EPIPE if the helper closed early */ });
+    child.stdin.end(input);
+  });
+}