mixdog 0.9.67 → 0.9.68

package/src/standalone/channel-daemon-transport.mjs

@@ -15,6 +15,7 @@
 import http from 'node:http';
 import { randomUUID } from 'node:crypto';
 import { rmSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
 import { writeJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
 import { readBody, sendJson, sendError } from '../runtime/memory/lib/http-wire.mjs';
 
@@ -47,9 +48,12 @@ export function createChannelDaemonTransport({
   getStatus = () => ({}),
   dispatchBind = null,
   registrationReplayTtlMs = 60_000,
+  remoteStatePath = null,
 } = {}) {
   if (typeof handleCall !== 'function') throw new Error('handleCall is required');
 
+  const resolvedRemoteStatePath = remoteStatePath
+    || (discoveryPath ? join(dirname(discoveryPath), 'channel-remote-state.json') : null);
   // token -> { token, leadPid, cwd, sse, lastSeen, registeredAt }
   const clients = new Map();
   // leadPid of the last client to claim the bridge / repoint the transcript.
@@ -68,6 +72,8 @@ export function createChannelDaemonTransport({
   // (notifications/claude/channel) stay pointer-targeted, never broadcast.
   const REMOTE_STATE_METHOD = 'notifications/mixdog/remote';
   let stickyRemoteFrame = null;
+  let remoteAcquired = false;
+  let remoteStateSignature = '';
   // Idempotency cache: callId -> { promise }. A retried /call with the SAME
   // callId awaits/returns the ORIGINAL run's result, so a transport-failure
   // retry never double-runs a non-idempotent tool (e.g. reply). Short TTL.
@@ -86,6 +92,44 @@ export function createChannelDaemonTransport({
 
   function nowMs() { return Date.now(); }
 
+  function remoteSessionIdFromBinding(name, args) {
+    if (!POINTER_TOOLS.has(name) || !args || typeof args !== 'object') return null;
+    const explicit = String(args.sessionId || '').trim();
+    if (/^[A-Za-z0-9_-]+$/.test(explicit)) return explicit;
+    const transcriptPath = String(args.transcriptPath || '').trim();
+    if (!transcriptPath) return null;
+    const inferred = basename(transcriptPath).replace(/\.[^.]+$/, '');
+    return /^[A-Za-z0-9_-]+$/.test(inferred) ? inferred : null;
+  }
+
+  function publishRemoteOwnerState() {
+    if (!resolvedRemoteStatePath) return;
+    const owner = pointerToken ? clients.get(pointerToken) : null;
+    const sessionId = String(owner?.remoteSessionId || '');
+    const state = {
+      enabled: remoteAcquired === true && Boolean(owner) && Boolean(sessionId),
+      sessionId: remoteAcquired === true && owner && sessionId ? sessionId : null,
+      ownerLeadPid: owner?.leadPid ?? null,
+      cwd: owner?.cwd ?? null,
+      daemonPid: process.pid,
+      updatedAt: nowMs(),
+    };
+    const signature = JSON.stringify([
+      state.enabled,
+      state.sessionId,
+      state.ownerLeadPid,
+      state.cwd,
+      state.daemonPid,
+    ]);
+    if (signature === remoteStateSignature) return;
+    remoteStateSignature = signature;
+    try {
+      writeJsonAtomicSync(resolvedRemoteStatePath, state, { compact: true });
+    } catch (err) {
+      log(`remote owner state write failed: ${err?.message || err}`);
+    }
+  }
+
   function pruneDeadClients() {
     for (const [token, c] of clients) {
       // A client is dead when its lead pid is gone OR its SSE stream closed and
@@ -117,6 +161,7 @@ export function createChannelDaemonTransport({
     // during stop()/close (grace shutdown owns teardown) and when no live client
     // remains (grace shutdown path).
     if (wasPointer && !closed) failoverPointer(reason);
+    publishRemoteOwnerState();
     maybeArmGrace('client removed');
   }
 
@@ -187,6 +232,7 @@ export function createChannelDaemonTransport({
       if (!best || c.lastSeen > best.lastSeen) best = c;
     }
     if (!best) return; // no live clients — let grace shutdown run
+    remoteAcquired = true;
     movePointer(best.token, 'failover');
     // Persist the acquired badge as the sticky frame so a later attachSse (or a
     // reconnect that follows the pointer) can replay it — matters when the
@@ -296,11 +342,16 @@ export function createChannelDaemonTransport({
   // re-binding to itself — it never "lost").
   function movePointer(newToken, reason) {
     const oldToken = pointerToken;
-    if (oldToken === newToken) { pointerToken = newToken; return; }
+    if (oldToken === newToken) {
+      pointerToken = newToken;
+      publishRemoteOwnerState();
+      return;
+    }
     pointerToken = newToken;
     const oldClient = oldToken ? clients.get(oldToken) : null;
     const newClient = clients.get(newToken);
     log(`routing pointer -> token=${newToken} lead=${newClient?.leadPid ?? '?'} via ${reason}`);
+    publishRemoteOwnerState();
     if (!oldClient || oldClient === newClient) return;
     if (newClient && oldClient.leadPid === newClient.leadPid) return; // same TUI
     if (isPidAlive(oldClient.leadPid)) {
@@ -326,7 +377,9 @@ export function createChannelDaemonTransport({
         // a late attach that IS the pointer can replay it. Under last-wins the
         // owner is exactly the pointer client, so deliver ONLY there — a
         // broadcast would light the badge on displaced/non-owner TUIs.
+        remoteAcquired = true;
         stickyRemoteFrame = frame;
+        publishRemoteOwnerState();
         const target = resolveTarget();
         if (!target?.sse) { log('remote-state acquired not delivered (no live pointer SSE); sticky set'); return false; }
         try { target.sse.write(`data: ${frame}\n\n`); return true; }
@@ -336,7 +389,9 @@ export function createChannelDaemonTransport({
       // other transition CLEAR the sticky and broadcast to every live client —
       // whoever holds the badge must drop it; replaying it to a future attach
       // would wrongly stop a fresh remote client.
+      remoteAcquired = false;
       stickyRemoteFrame = null;
+      publishRemoteOwnerState();
       let delivered = false;
       for (const [, c] of liveClients()) {
         if (!c.sse) continue;
@@ -420,6 +475,7 @@ export function createChannelDaemonTransport({
       // A non-owner can hold a buffered superseded frame or stored bind intent.
       if (replaced.pending?.length) fresh.pending.push(...replaced.pending.splice(0));
       if (replaced.lastBind) fresh.lastBind = replaced.lastBind;
+      if (replaced.remoteSessionId) fresh.remoteSessionId = replaced.remoteSessionId;
       if (replacedWasPointer) pointerToken = token;
       removeClientRecord(replaced.token);
       log(`client reconnect replaced token=${replaced.token} -> ${token} lead=${pid}`);
@@ -434,13 +490,14 @@ export function createChannelDaemonTransport({
     // token, migrate its buffered pending frames + last bind intent, and remove
     // the old entry WITHOUT a failover or a self-'superseded'. A live-stream
     // pointer that happens to share the pid (e.g. co-located clients) is left
-    // alone — last-wins handles a genuine fresh register below.
+    // alone — a genuine fresh attach remains an observer until it binds.
     if (pointerToken && pointerToken !== token) {
       const old = clients.get(pointerToken);
       if (old && old.leadPid === pid && !old.sse) {
         const fresh = clients.get(token);
         if (old.pending?.length) fresh.pending.push(...old.pending.splice(0));
         if (old.lastBind) fresh.lastBind = old.lastBind;
+        if (old.remoteSessionId) fresh.remoteSessionId = old.remoteSessionId;
         removeClientRecord(pointerToken);
         pointerToken = token;
         log(`pointer follows reconnect -> token=${token} lead=${pid} (old entry dropped)`);
@@ -451,15 +508,16 @@ export function createChannelDaemonTransport({
         return rememberReplacement(token);
       }
     }
-    if (reattach) {
-      // SSE-reconnect re-register: a pruned client re-registers with a FRESH
-      // token but it is NOT a new terminal — it must never steal ownership.
-      // Only adopt the pointer when none exists (avoid a notify blackhole).
-      if (!pointerToken) pointerToken = token;
-    } else {
-      // Last-wins: the NEWEST registered TUI (fresh terminal) always steals the
-      // ownership seat, and the displaced owner is told it lost (superseded).
-      movePointer(token, 'register');
+    // Registration establishes transport connectivity only. Desktop engine
+    // prewarm, automation, and remote auto-start may all attach to an existing
+    // daemon without claiming its active terminal's relay seat. Only an
+    // explicit pointer tool (/remote claim or transcript bind) may move an
+    // occupied pointer and supersede its owner. Adopt a vacant pointer so the
+    // first client still receives daemon notifications without a blackhole.
+    if (!pointerToken) {
+      pointerToken = token;
+      publishRemoteOwnerState();
+      log(`routing pointer initialized -> token=${token} lead=${pid}`);
     }
     return rememberReplacement(token);
   }
@@ -563,11 +621,28 @@ export function createChannelDaemonTransport({
         }
         c.lastSeen = nowMs();
         const name = String(body.name || '');
+        const pointerCall = Boolean(c && POINTER_TOOLS.has(name));
+        const pointerOwner = pointerToken ? clients.get(pointerToken) : null;
+        const claimIfVacant = name === 'activate_channel_bridge'
+          && body.args?.active === true
+          && body.args?.claimIfVacant === true;
+        const claimBlocked = claimIfVacant
+          && pointerToken !== clientToken
+          && remoteAcquired === true
+          && Boolean(pointerOwner?.remoteSessionId);
+        const pointerMove = pointerCall && !claimBlocked;
+        const previousRemoteSessionId = c?.remoteSessionId || null;
+        const previousRemoteAcquired = remoteAcquired;
         // Bind-intent calls re-point routing at the caller BEFORE dispatch, so a
         // notify emitted synchronously during the call already targets it.
-        if (c && POINTER_TOOLS.has(name)) {
-          // Last-wins bind claim (/remote or boot). Steals the seat AND tells
-          // the displaced owner it lost (targeted superseded).
+        if (pointerMove) {
+          const bindingSessionId = remoteSessionIdFromBinding(name, body.args);
+          if (bindingSessionId) c.remoteSessionId = bindingSessionId;
+          if (name === 'activate_channel_bridge' && body.args?.active === false) {
+            remoteAcquired = false;
+          }
+          // Explicit bind claims are last-wins. Auto claims reach here only
+          // when no live bound remote owner occupies the pointer.
           movePointer(clientToken, name);
         }
         const callId = body.callId ? String(body.callId) : null;
@@ -577,11 +652,16 @@ export function createChannelDaemonTransport({
           // side-effect) instead of dispatching handleCall a second time.
           dispatch = callCache.get(callId).promise;
         } else {
-          dispatch = Promise.resolve().then(() => handleCall(name, body.args || {}, {
-            clientToken,
-            leadPid: c?.leadPid ?? null,
-            cwd: c?.cwd ?? null,
-          }));
+          dispatch = claimBlocked
+            ? Promise.resolve({
+              content: [{ type: 'text', text: 'channel bridge claim skipped: live remote owner' }],
+              claimSkipped: true,
+            })
+            : Promise.resolve().then(() => handleCall(name, body.args || {}, {
+              clientToken,
+              leadPid: c?.leadPid ?? null,
+              cwd: c?.cwd ?? null,
+            }));
           if (callId) {
             callCache.set(callId, { promise: dispatch, at: nowMs() });
             // Start the TTL only once the call SETTLES: an in-flight call can
@@ -598,9 +678,17 @@ export function createChannelDaemonTransport({
           const result = await dispatch;
           // Record the caller's last bind intent so a failover can rebind the
           // output forwarder to THIS client's transcript when it becomes owner.
-          if (c && POINTER_TOOLS.has(name)) c.lastBind = { name, args: body.args || {} };
+          if (pointerMove) {
+            c.lastBind = { name, args: body.args || {} };
+            publishRemoteOwnerState();
+          }
           sendJson(res, { result });
         } catch (err) {
+          if (pointerMove) {
+            c.remoteSessionId = previousRemoteSessionId;
+            remoteAcquired = previousRemoteAcquired;
+            publishRemoteOwnerState();
+          }
           sendJson(res, { error: err?.message || String(err) }, 200);
         }
         return;
@@ -640,6 +728,7 @@ export function createChannelDaemonTransport({
         boundPort = server.address().port;
         server.on('error', (err) => log(`server error: ${err?.message || err}`));
         writeDiscovery();
+        publishRemoteOwnerState();
         log(`daemon transport listening on 127.0.0.1:${boundPort} pid=${process.pid}`);
         resolve({ port: boundPort, token: serverToken });
       });
@@ -651,6 +740,9 @@ export function createChannelDaemonTransport({
     cancelGrace();
     if (sweepTimer) { try { clearInterval(sweepTimer); } catch {} sweepTimer = null; }
     for (const [token] of clients) dropClient(token, 'transport stop');
+    remoteAcquired = false;
+    pointerToken = null;
+    publishRemoteOwnerState();
     clearRegistrationReplays();
     if (discoveryPath) { try { rmSync(discoveryPath, { force: true }); } catch {} }
     if (server) {

package/src/standalone/channel-daemon.mjs

@@ -187,10 +187,12 @@ async function main() {
   }
   log(`ready port=${port} pid=${process.pid} in ${(performance.now() - startedAt).toFixed(0)}ms`);
 
-  // Boot the owned channels runtime (Discord connect, transcript bind) AFTER
-  // the ready signal. Fire-and-forget — failure is non-fatal (the daemon still
-  // serves tool calls and can reconnect later) and must not delay ready.
-  void Promise.resolve().then(() => channels.start())
+  // Boot messaging only for an explicit/auto remote request. Automation may
+  // spawn the shared daemon with no remote intent; keep schedules/webhooks live
+  // without connecting the channel backend until a Remote claim arrives.
+  const remoteIntent = String(process.env.MIXDOG_REMOTE_INTENT || '');
+  const messaging = remoteIntent === 'explicit' || remoteIntent === 'auto';
+  void Promise.resolve().then(() => channels.start({ messaging }))
     .catch((e) => log(`channels.start failed (non-fatal): ${e?.message || e}`));
 
   // Fold memory startup in: eagerly ensure the memory runtime is up under the

package/src/tui/App.jsx

@@ -1898,38 +1898,8 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
             });
           return true;
         }
-        if (channelPrompt.kind === 'schedule-add') {
-          const [name, time, instructions, channel, model] = parts;
-          // saveSchedule is async (PG-backed). Only close the prompt / open the
-          // list on success; surface a failure notice and keep the prompt open
-          // so the input is not lost and the user can retry.
-          Promise.resolve(store.saveSchedule({ name, time, instructions, channel, model }))
-            .then(() => {
-              setChannelPrompt(null);
-              void openChannelSetupPicker('schedules');
-            })
-            .catch((e) => {
-              store.pushNotice(`schedule save failed: ${e?.message || e}`, 'error');
-            });
-          return true;
-        }
-        if (channelPrompt.kind === 'webhook-add') {
-          const [name, instructions, channel, model, parser] = parts;
-          // saveWebhook is async (PG-backed). Only close the prompt / open the
-          // list on success; surface a failure notice and keep the prompt open.
-          Promise.resolve(store.saveWebhook({ name, instructions, channel, model, parser }))
-            .then((result) => {
-              if (result?.secret) {
-                store.pushNotice(`webhook secret for ${result.name}: ${result.secret}`, 'info');
-              }
-              setChannelPrompt(null);
-              void openChannelSetupPicker('webhooks');
-            })
-            .catch((e) => {
-              store.pushNotice(`webhook save failed: ${e?.message || e}`, 'error');
-            });
-          return true;
-        }
+        // schedule-add / webhook-add prompt kinds retired: schedules and
+        // webhooks are managed in the desktop app (user decision).
       } catch (e) {
         store.pushNotice(`channels update failed: ${e?.message || e}`, 'error');
         return false;

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

@@ -215,149 +215,8 @@ export function createChannelPickers({
       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 = async (item) => {
-        if (item._action !== 'schedule-toggle') return;
-        if (!channelRemoteEnabled) {
-          store.pushNotice('enable channel first', 'warn');
-          return;
-        }
-        try {
-          await 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 publicUrl = setup.webhook?.publicUrl || '';
-      const items = [
-        {
-          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: '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-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');
-          }
-        },
-        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 = async (item) => {
-        if (item._action !== 'webhook-toggle') return;
-        if (!channelRemoteEnabled) {
-          store.pushNotice('enable channel first', 'warn');
-          return;
-        }
-        try {
-          await 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;
-    }
-
+    // Schedules/webhooks management is desktop-only (user decision): the TUI
+    // no longer carries their pickers or the webhook-endpoint info page.
     const worker = store.getChannelWorkerStatus?.();
     const activeBackend = setup.backend === 'telegram' ? 'telegram' : 'discord';
     const backendLabel = activeBackend === 'telegram' ? 'Telegram' : 'Discord';

package/src/tui/app/slash-commands.mjs

@@ -25,10 +25,8 @@ export const SLASH_COMMANDS = [
   { name: 'plugins', usage: '/plugins', description: 'Manage local plugin integrations' },
   { name: 'hooks', usage: '/hooks', description: 'Manage before-tool hook rules and events' },
   { name: 'providers', usage: '/providers', description: 'Manage auth, API keys, OAuth, and local endpoints' },
-  { name: 'channels', usage: '/channels', description: 'Manage Discord, channels, schedules, webhooks' },
+  { name: 'channels', usage: '/channels', description: 'Manage Discord, Telegram, and voice' },
   { name: 'remote', usage: '/remote', description: 'Claim remote for this session (takes over from any other session)' },
-  { name: 'schedules', usage: '/schedules', description: 'Manage schedules' },
-  { name: 'webhooks', usage: '/webhooks', description: 'Manage inbound webhooks' },
   { name: 'settings', usage: '/setting', aliases: ['setting', 'config'], aliasUsage: ['settings', 'config'], showAliasUsage: false, description: 'Open runtime settings' },
   { name: 'profile', usage: '/profile', description: 'Set your title and response language' },
   { name: 'update', usage: '/update', description: 'Check version and update mixdog' },

package/src/tui/app/slash-dispatch.mjs

@@ -265,10 +265,10 @@ export function createSlashDispatch({
         void openChannelSetupPicker('all');
         return true;
       case 'schedules':
-        void openChannelSetupPicker('schedules');
-        return true;
       case 'webhooks':
-        void openChannelSetupPicker('webhooks');
+        // Management surface is desktop-only (user decision): hidden from the
+        // palette, and a typed command answers instead of opening a picker.
+        store.pushNotice('Schedules and webhooks are managed in the Mixdog desktop app', 'info');
         return true;
       case 'auth':
         store.pushNotice('/auth moved to /providers', 'info');