mixdog 0.9.66 → 0.9.67

package/src/session-runtime/channel-config-api.mjs

@@ -2,6 +2,7 @@ import {
   channelSetup,
   deleteSchedule,
   deleteWebhook,
+  getWebhookSecret,
   setChannelAsync,
   saveSchedule,
   saveWebhook,
@@ -68,6 +69,10 @@ export function createChannelConfigApi({ flushBackendSave, channels, reloadChann
       reloadChannelsSoon();
       return result;
     },
+    // Read-only secret fetch for the webhook editor; no worker reload.
+    async getWebhookSecret(name) {
+      return getWebhookSecret(name);
+    },
     async runScheduleNow(name) {
       const id = String(name || '').trim();
       const schedule = await getSchedule(id);

package/src/session-runtime/lifecycle-api.mjs

@@ -89,6 +89,11 @@ export function createLifecycleApi(deps) {
     return {
       id: s.id,
       updatedAt: s.updatedAt,
+      // Conversation-activity timestamp for Recent ordering. Without this the
+      // desktop falls back to updatedAt, which detach/resume bookkeeping
+      // bumps — clicking a session reshuffled the sidebar (the row just left
+      // jumped to the top).
+      lastUsedAt: Number(s.lastUsedAt) || 0,
       cwd: s.cwd || '',
       model: s.model,
       provider: s.provider,

package/src/session-runtime/prewarm.mjs

@@ -15,6 +15,7 @@ export function createPrewarmSchedulers({
   getSession,
   isRemoteEnabled,
   channelsEnabled,
+  hasActiveAutomation,
   getCodeGraphModule,
   createCurrentSession,
   channels,
@@ -111,25 +112,30 @@ export function createPrewarmSchedulers({
       bootProfile('channels:start-skipped');
       return;
     }
-    if (!channelsEnabled()) {
-      bootProfile('channels:start-disabled');
-      return;
-    }
     if (timers.channelStartTimer || state.channelStartPromise || isCloseRequested()) return;
     bootProfile('channels:start-scheduled', { delayMs });
-    timers.channelStartTimer = setTimeout(() => {
+    timers.channelStartTimer = setTimeout(() => void (async () => {
       timers.channelStartTimer = null;
       if (isCloseRequested()) return;
+      // Channels-module and remote toggles gate MESSAGING; automation
+      // (enabled schedules/webhooks) keeps the worker boot alive — its
+      // backend runs headless when messaging is off or unconfigured.
+      const automation = await hasActiveAutomation().catch(() => false);
+      if (!channelsEnabled() && !automation) {
+        bootProfile('channels:start-disabled');
+        return;
+      }
       // A deferred start may straddle a stopRemote(); re-check before booting so
       // a turned-off session neither starts channels nor keeps rescheduling.
-      if (!isRemoteEnabled()) return;
+      if (!isRemoteEnabled() && !automation) return;
+      if (isCloseRequested()) return;
       if (getActiveTurnCount() > 0 || getSessionCreatePromise()) {
         bootProfile('channels:start-deferred', { reason: getActiveTurnCount() > 0 ? 'turn-active' : 'session-create' });
         scheduleChannelStart(backgroundBusyRetryMs);
         return;
       }
       void invokeChannelStart();
-    }, delayMs);
+    })(), delayMs);
     timers.channelStartTimer.unref?.();
   }
 

package/src/session-runtime/runtime-core.mjs

@@ -65,13 +65,12 @@ import {
   deleteWebhook,
   forgetDiscordToken,
   forgetTelegramToken,
-  forgetWebhookAuthtoken,
+  hasActiveAutomation,
   setChannel,
   saveDiscordToken,
   saveTelegramToken,
   saveSchedule,
   saveWebhook,
-  saveWebhookAuthtoken,
   setBackend,
   setBackendAsync,
   setScheduleEnabled,
@@ -1694,6 +1693,7 @@ export async function createMixdogSessionRuntime({
     getSession: () => session,
     isRemoteEnabled: () => remoteEnabled,
     channelsEnabled,
+    hasActiveAutomation,
     getCodeGraphModule,
     createCurrentSession,
     channels,
@@ -1884,10 +1884,6 @@ export async function createMixdogSessionRuntime({
       bootProfile('channels:start-skipped');
       return true;
     }
-    if (!channelsEnabled()) {
-      bootProfile('channels:start-disabled');
-      return true;
-    }
     if (closeRequested) return true;
     if (prewarmTimers.channelStartTimer) {
       clearTimeout(prewarmTimers.channelStartTimer);
@@ -1895,6 +1891,14 @@ export async function createMixdogSessionRuntime({
     }
     bootProfile('channels:start-scheduled', { delayMs: 0, immediate: true });
     void (async () => {
+      // Channels-module toggle gates MESSAGING only: automation (schedules/
+      // webhooks) still boots the worker — its backend runs headless when
+      // messaging is off or unconfigured (see channels/lib/config.mjs).
+      if (!channelsEnabled() && !(await hasActiveAutomation().catch(() => false))) {
+        bootProfile('channels:start-disabled');
+        remoteClaimPending = false;
+        return;
+      }
       // A backend switch may still be pending or writing asynchronously. Drain
       // it before the worker reads config; never race it with a sync lock wait.
       try { await flushBackendSave(); } catch {}
@@ -2035,9 +2039,9 @@ export async function createMixdogSessionRuntime({
   // early /remote (startRemote clears it), stopRemote(), and close() all
   // cancel it through the existing clearTimeout paths. Runtime /remote calls
   // still start immediately (user-initiated, UI already painted).
+  const remoteAutoStartDelayMs = envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 });
   if (remoteEnabled || remoteAutoStartRequested) {
     const remoteStartIntent = remoteEnabled ? 'explicit' : 'auto';
-    const remoteAutoStartDelayMs = envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 });
     bootProfile('channels:autostart-deferred', { delayMs: remoteAutoStartDelayMs, intent: remoteStartIntent });
     prewarmTimers.channelStartTimer = setTimeout(() => {
       prewarmTimers.channelStartTimer = null;
@@ -2048,6 +2052,23 @@ export async function createMixdogSessionRuntime({
       startRemote({ intent: remoteStartIntent });
     }, remoteAutoStartDelayMs);
     prewarmTimers.channelStartTimer.unref?.();
+  } else {
+    // Automation decoupling (user decision): enabled schedules/webhooks boot
+    // the worker on their own — no remote flag, no remote.autoStart, no
+    // messaging backend required. Claim-if-vacant auto intent reuses the
+    // exact autoStart semantics (a live owner elsewhere wins silently).
+    prewarmTimers.channelStartTimer = setTimeout(() => {
+      prewarmTimers.channelStartTimer = null;
+      if (closeRequested || remoteEnabled) return;
+      void hasActiveAutomation()
+        .then((active) => {
+          if (!active || closeRequested || remoteEnabled) return;
+          bootProfile('channels:automation-autostart');
+          startRemote({ intent: 'auto' });
+        })
+        .catch(() => { /* automation probe is best-effort */ });
+    }, remoteAutoStartDelayMs);
+    prewarmTimers.channelStartTimer.unref?.();
   }
 
   // Pure settings-delegate methods (onboarding status/skip, autoClear, profile,
@@ -2103,8 +2124,6 @@ export async function createMixdogSessionRuntime({
     forgetDiscordToken,
     saveTelegramToken,
     forgetTelegramToken,
-    saveWebhookAuthtoken,
-    forgetWebhookAuthtoken,
     setBackend,
   });
 

package/src/session-runtime/session-text.mjs

@@ -39,6 +39,12 @@ const SYNTHETIC_SESSION_TEXT_PATTERNS = Object.freeze([
   /^\[mixdog-runtime\]/i,
   /^\[(?:truncated|request interrupted by user)\]$/i,
   /^a previous model worked on this task and produced the compacted handoff summary below\b/i,
+  // Compact/auto-clear re-seed handoff variants: these lead the FIRST user
+  // message of every post-compaction session, so titling from them painted
+  // "Re-attached after compaction…" rows in Recent (user report). Skipping
+  // them titles the session from its first REAL user message instead.
+  /^re-attached after compaction\b/i,
+  /^reference files:\s/i,
   /^the async (?:agent|shell) task\b/i,
 ]);
 

package/src/session-runtime/settings-api.mjs

@@ -56,8 +56,6 @@ export function createSettingsApi({
   forgetDiscordToken,
   saveTelegramToken,
   forgetTelegramToken,
-  saveWebhookAuthtoken,
-  forgetWebhookAuthtoken,
   setBackend,
 }) {
   return {
@@ -378,15 +376,5 @@ export function createSettingsApi({
       scheduleBackendSave(value);
       return { ok: true, backend: value };
     },
-    saveWebhookAuthtoken(token) {
-      const result = saveWebhookAuthtoken(token);
-      reloadChannelsSoon();
-      return result;
-    },
-    forgetWebhookAuthtoken() {
-      const result = forgetWebhookAuthtoken();
-      reloadChannelsSoon();
-      return result;
-    },
   };
 }

package/src/standalone/channel-admin.mjs

@@ -15,7 +15,6 @@ import {
   diagnoseDiscordTokenValue,
   getDiscordToken,
   getTelegramToken,
-  getWebhookAuthtoken,
   hasStoredSecret,
   readSection,
   saveSecret,
@@ -34,10 +33,12 @@ import {
 import {
   listEndpoints as dbListEndpoints,
   loadEndpointConfig as dbLoadEndpoint,
+  readEndpointSecret as dbReadEndpointSecret,
   upsertEndpoint as dbUpsertEndpoint,
   deleteEndpoint as dbDeleteEndpoint,
   setEndpointEnabled as dbSetEndpointEnabled,
 } from '../runtime/shared/webhooks-db.mjs';
+import { readHookPublicBase } from '../runtime/channels/lib/webhook/relay-tunnel.mjs';
 
 const NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const DEFAULT_CHANNELS = Object.freeze({
@@ -197,18 +198,6 @@ export function forgetTelegramToken() {
   return { ok: true };
 }
 
-export function saveWebhookAuthtoken(token) {
-  const value = String(token || '').trim();
-  if (!value) throw new Error('Webhook/ngrok authtoken is required');
-  saveSecret(SECRET_ACCOUNTS.webhookAuth, value);
-  return { ok: true, configured: Boolean(getWebhookAuthtoken()) };
-}
-
-export function forgetWebhookAuthtoken() {
-  deleteSecret(SECRET_ACCOUNTS.webhookAuth);
-  return { ok: true };
-}
-
 // Single-channel write: persists `cfg.channel`, keeping the per-backend id
 // fields (discordChannelId/telegramChatId) so a backend switch retains both
 // ids. `backend` selects which per-backend field the id updates; when omitted
@@ -254,7 +243,6 @@ export function setWebhookConfig(patch = {}) {
       ...(Object.prototype.hasOwnProperty.call(patch, 'enabled') ? { enabled: patch.enabled === true } : {}),
       ...(patch.port ? { port: Number(patch.port) || 3333 } : {}),
       ...(patch.domain ? { domain: String(patch.domain).trim() } : {}),
-      ...(patch.ngrokDomain ? { ngrokDomain: String(patch.ngrokDomain).trim() } : {}),
     },
   }));
 }
@@ -267,7 +255,6 @@ export async function setWebhookConfigAsync(patch = {}) {
       ...(Object.prototype.hasOwnProperty.call(patch, 'enabled') ? { enabled: patch.enabled === true } : {}),
       ...(patch.port ? { port: Number(patch.port) || 3333 } : {}),
       ...(patch.domain ? { domain: String(patch.domain).trim() } : {}),
-      ...(patch.ngrokDomain ? { ngrokDomain: String(patch.ngrokDomain).trim() } : {}),
     },
   }));
 }
@@ -486,7 +473,13 @@ export async function saveWebhook({
   if (overwrite !== true && (await dbLoadEndpoint(id))) {
     throw new Error(`webhook "${id}" already exists`);
   }
-  const secretValue = String(secret || randomBytes(24).toString('hex')).trim();
+  // Secret semantics: an explicit value always wins; an EMPTY value on an
+  // overwrite PRESERVES the stored secret (editing instructions must not
+  // silently rotate the key the external service was configured with); only
+  // a brand-new endpoint mints a random secret.
+  const secretValue = String(secret || '').trim()
+    || (overwrite === true ? String((await dbReadEndpointSecret(id)) || '').trim() : '')
+    || randomBytes(24).toString('hex');
   const saved = await dbUpsertEndpoint({
     name: id,
     description: String(description || '').trim(),
@@ -522,11 +515,32 @@ export async function setWebhookEnabled(name, enabled) {
   return { name: id, enabled: enabled !== false };
 }
 
+// Explicit single-purpose secret read for the editor's copy affordance (the
+// list path only ever exposes a presence flag). Local surfaces only — the
+// desktop blocks this capability over the remote bridge.
+export async function getWebhookSecret(name) {
+  const id = assertName(name, 'webhook name');
+  return { name: id, secret: (await dbReadEndpointSecret(id)) || '' };
+}
+
+// Automation presence: any enabled schedule or webhook endpoint. Drives the
+// worker boot decision independently of the messaging channels — schedules
+// and webhooks run sessions, so they must not require Discord/Telegram
+// tokens or an explicit remote toggle.
+export async function hasActiveAutomation() {
+  try {
+    const [schedules, webhooks] = await Promise.all([listSchedules(), listWebhooks()]);
+    return schedules.some((entry) => entry?.enabled !== false && entry?.status !== 'done')
+      || webhooks.some((entry) => entry?.enabled !== false);
+  } catch {
+    return false;
+  }
+}
+
 export async function channelSetup(config = null) {
   const cfg = normalizeChannelsConfig(config || readSection('channels'));
   const discordToken = getDiscordToken();
   const discordProblem = diagnoseDiscordTokenValue(discordToken, cfg);
-  const webhookAuth = getWebhookAuthtoken();
   const telegramToken = getTelegramToken();
   return {
     backend: cfg.backend || 'discord',
@@ -546,9 +560,9 @@ export async function channelSetup(config = null) {
     },
     webhook: {
       ...(cfg.webhook || {}),
-      authenticated: Boolean(webhookAuth),
-      stored: hasStoredSecret(SECRET_ACCOUNTS.webhookAuth),
-      status: webhookAuth ? 'Set' : 'Off',
+      // Relay-tunnel public base (null until the channel worker first
+      // connects and mints its hook identity).
+      publicUrl: readHookPublicBase(),
     },
     channel: getChannel(cfg),
     schedules: await listSchedules(),
@@ -560,7 +574,7 @@ async function renderChannelStatus(config = null) {
   const setup = await channelSetup(config);
   const lines = [];
   lines.push(`discord  ${setup.discord.status}${setup.discord.problem ? ` (${setup.discord.problem})` : ''}`);
-  lines.push(`webhook  ${setup.webhook.enabled === false ? 'disabled' : 'enabled'} · auth ${setup.webhook.status} · port ${setup.webhook.port || 3333}`);
+  lines.push(`webhook  ${setup.webhook.enabled === false ? 'disabled' : 'enabled'} · port ${setup.webhook.port || 3333}${setup.webhook.publicUrl ? ` · ${setup.webhook.publicUrl}` : ''}`);
   lines.push(`channel  ${setup.channel.channelId || '(unset)'}`);
   lines.push('schedules');
   if (setup.schedules.length === 0) lines.push('  (none)');

package/src/tui/App.jsx

@@ -1881,21 +1881,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
           resumeAfterChannelPrompt(channelPrompt);
           return true;
         }
-        if (channelPrompt.kind === 'webhook-token') {
-          if (!commandText) return false;
-          store.saveWebhookAuthtoken(commandText);
-          resumeAfterChannelPrompt(channelPrompt);
-          return true;
-        }
-        if (channelPrompt.kind === 'webhook-domain') {
-          if (!commandText) return false;
-          Promise.resolve(store.setWebhookConfig?.({ ngrokDomain: commandText }))
-            .then(() => resumeAfterChannelPrompt(channelPrompt))
-            .catch((e) => {
-              store.pushNotice(`webhook config update failed: ${e?.message || e}`, 'error');
-            });
-          return true;
-        }
         const parts = commandText.split('|').map((part) => part.trim());
         if (channelPrompt.kind === 'channel-add') {
           // Single-channel: the UI asks only for the channel id. Legacy

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

@@ -271,46 +271,30 @@ export function createChannelPickers({
       const returnTo = typeof options.returnTo === 'function'
         ? options.returnTo
         : () => setPicker(null);
-      const domain = setup.webhook?.ngrokDomain || setup.webhook?.domain || '';
+      const publicUrl = setup.webhook?.publicUrl || '';
       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',
+          value: 'endpoint-url',
+          label: 'Public URL',
+          description: publicUrl
+            ? `${publicUrl}/webhook/<name>`
+            : 'Assigned when the channel worker connects to the relay',
+          _action: 'endpoint-url',
         },
       ];
       setPicker({
         title: 'Webhook endpoint',
-        description: 'ngrok domain and authtoken. Toggle individual webhooks in /webhooks.',
+        description: 'Served through the Mixdog relay — no tunnel setup needed. 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),
-              });
+            if (item._action === 'endpoint-url') {
+              store.pushNotice(publicUrl
+                ? `Webhook base: ${publicUrl}/webhook/<name>`
+                : 'URL not assigned yet — start channels once and reopen.', 'info');
             }
           } catch (e) {
             store.pushNotice(`webhook endpoint failed: ${e?.message || e}`, 'error');
@@ -465,20 +449,12 @@ export function createChannelPickers({
       {
         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';
-        })(),
+        // Relay tunnel: public exposure is automatic, so the endpoint is
+        // "On" whenever the webhook server itself is enabled.
+        meta: setup.webhook?.enabled === false ? 'Off' : 'On',
+        description: setup.webhook?.publicUrl
+          ? setup.webhook.publicUrl
+          : 'Mixdog relay tunnel — URL assigned on first run',
         _action: 'webhook-endpoint',
       },
     ];

package/src/tui/app/doctor.mjs

@@ -165,7 +165,6 @@ export async function buildDoctorReport(runtime = {}, getState = () => ({})) {
     const tokens = [];
     if (setup.discord?.authenticated) tokens.push('discord');
     if (setup.telegram?.authenticated) tokens.push('telegram');
-    if (setup.webhook?.authenticated) tokens.push('webhook');
     const running = worker.running === true;
     const detail = `enabled · worker ${running ? 'running' : 'stopped'} · tokens: ${tokens.length ? tokens.join(', ') : 'none'}`;
     row(running ? 'ok' : 'warn', detail);