mixdog 1.3.4 → 1.4.0

package/src/standalone/daemon-channels-loader.mjs

@@ -26,16 +26,16 @@ export function createChannelsRuntimeLoader({ log, onLoaded = () => {}, setOwner
     return channelsReady;
   }
 
-  // Channels bring automation with them (schedules, webhook listener + tunnel,
-  // optional messaging service). A daemon spawned by a TUI starts them exactly
-  // as before; a daemon spawned for session views stays dormant until a channels
-  // client actually registers, so an app-only service runs no tunnels.
+  // Channels bring automation with them (schedules, webhook listener + tunnel).
+  // A daemon spawned by a TUI starts them exactly as before; a daemon spawned
+  // for session views stays dormant until a channels client actually registers,
+  // so an app-only service runs no tunnels. The channel bridge is activated
+  // separately, by the activate_channel_bridge call.
   let channelsStartPromise = null;
-  function start(options = {}) {
+  function start() {
     if (channelsStartPromise) return channelsStartPromise;
-    const messaging = options.messaging === true;
     channelsStartPromise = ensure()
-      .then((module) => module.start({ messaging }))
+      .then((module) => module.start({ bridge: false }))
       .catch((e) => {
         channelsStartPromise = null;
         log(`channels.start failed (non-fatal): ${e?.message || e}`);
@@ -50,7 +50,9 @@ export function createChannelsRuntimeLoader({ log, onLoaded = () => {}, setOwner
     if (ctx && BINDING_TOOLS.has(name)) {
       try {
         setOwnerContext({ leadPid: ctx.leadPid, cwd: ctx.cwd });
-      } catch {}
+      } catch {
+        // Binding context is advisory; the tool call still runs without it.
+      }
     }
     return module.handleToolCall(name, args || {});
   }

package/src/standalone/daemon-session-control/list-page.mjs

@@ -0,0 +1,72 @@
+import { sessionBotOf } from '../../session-runtime/bot-status.mjs';
+import { isAgentOnlySession } from '../../runtime/agent/orchestrator/session/store-summary-visibility.mjs';
+import { activityOf, encodeCatalogCursor } from '../../runtime/agent/orchestrator/session/catalog-db/schema.mjs';
+
+// The keyset position before every catalog row: a page continuing from a
+// pinned live row starts over at the top of the catalog order.
+export const TOP_CURSOR = encodeCatalogCursor({ id: '', lastUsedAt: Number.MAX_SAFE_INTEGER });
+
+/** Throws unless the list's opt-in flags are booleans when given. */
+export function assertListFlags(args) {
+  for (const flag of ['include_agents', 'include_archived']) {
+    if (args[flag] !== undefined && typeof args[flag] !== 'boolean') {
+      throw new Error(`session: ${flag} must be a boolean`);
+    }
+  }
+}
+
+/** Whether the listing keeps a catalog row: sub-agent sessions and archived
+ *  ones (`archived`, the desktop's flags) only on request. */
+export function listRowFilter(args, archived) {
+  return (row) =>
+    (args.include_agents === true || !isAgentOnlySession(row)) &&
+    (args.include_archived === true || !Object.hasOwn(archived, row.id));
+}
+
+/** A row with the live work of `live` (storedLiveWork) overlaid. */
+export function liveRowOverlay(live) {
+  return (row) => {
+    const working = row.working === true || live.own.has(row.id);
+    const agentWorking = row.agentWorking === true || live.agents.has(row.id);
+    if (!working && !agentWorking) return row;
+    return {
+      ...row,
+      ...(working ? { working: true, liveAt: live.own.get(row.id) || 0 } : {}),
+      ...(agentWorking ? { agentWorking: true } : {}),
+    };
+  };
+}
+
+const liveActivity = (row) => Math.max(row.liveAt || 0, activityOf(row), Number(row.updatedAt) || 0);
+
+/** Every session with live work in `live`, each once. */
+export function liveCandidates(live) {
+  return [...new Set([...live.own.keys(), ...live.agents])];
+}
+
+/** The live rows a first page leads with: kept like the listing, overlaid,
+ *  newest sign of work first, at most `limit`. */
+export function pinnedLiveRows(rows, keep, withLive, limit) {
+  return rows
+    .filter((row) => row && keep(row))
+    .map(withLive)
+    .sort((left, right) => liveActivity(right) - liveActivity(left) || (left.id < right.id ? -1 : 1))
+    .slice(0, limit);
+}
+
+/** The page's sessions: the pinned live rows, then the scanned ones overlaid,
+ *  archived ones marked. */
+export function listedSessions(pinned, scanned, withLive, archived) {
+  return [...pinned, ...scanned.map(withLive)].map((row) =>
+    Object.hasOwn(archived, row.id) ? { ...row, archived: true } : row
+  );
+}
+
+/** sessionListOutput options: rich rows for the human, or only the caller
+ *  bot's own (`own`, scopedBot); a pinned row continues from the top. */
+export function listOutputOptions(own, pinnedIds) {
+  return {
+    rich: own ? (row) => sessionBotOf(row) === own : own !== null,
+    cursorOf: (row) => (pinnedIds.has(row.id) ? TOP_CURSOR : encodeCatalogCursor(row)),
+  };
+}

package/src/standalone/daemon-session-control/request.mjs

@@ -0,0 +1,51 @@
+import { SESSION_ID_PATTERN } from '../../runtime/agent/orchestrator/runtime-core/session-id.mjs';
+
+const TARGET_ACTIONS = new Set(['status', 'read', 'send', 'cancel', 'delete']);
+const MUTATING_ACTIONS = new Set(['send', 'cancel', 'delete']);
+
+/** The calling session of a `session` request; throws on an action the tool
+ *  does not run or a request without a valid caller session. */
+export function requestCaller(action, context) {
+  if (
+    action !== 'list' &&
+    action !== 'create' &&
+    action !== 'bots' &&
+    action !== 'worktree' &&
+    action !== 'route' &&
+    !TARGET_ACTIONS.has(action)
+  ) {
+    throw new Error(`session: unsupported remote action "${action}"`);
+  }
+  const caller = context.callerSessionId;
+  if (typeof caller !== 'string' || !SESSION_ID_PATTERN.test(caller)) {
+    throw new Error('session: caller session is required');
+  }
+  return caller;
+}
+
+/** The addressed session and transcript paging of a `list` or target action:
+ *  `{ sessionId, limit, offset, textOffset }`; throws on a missing target, a
+ *  self mutation or paging out of range. */
+export function targetRequest(args, action, caller) {
+  const sessionId = typeof args.session_id === 'string' ? args.session_id.trim() : '';
+  if (TARGET_ACTIONS.has(action) && !SESSION_ID_PATTERN.test(sessionId)) {
+    throw new Error(`session: session_id is required for action=${action}`);
+  }
+  if (MUTATING_ACTIONS.has(action) && sessionId === caller) {
+    throw new Error(`session: ${action} must target another session`);
+  }
+  const limit = args.limit ?? 25;
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+    throw new Error('session: limit must be an integer from 1 to 100');
+  }
+  const offset = args.offset ?? 0;
+  const textOffset = args.text_offset ?? 0;
+  if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(offset + limit)) {
+    throw new Error('session: offset must be a nonnegative safe integer');
+  }
+  if (!Number.isSafeInteger(textOffset) || textOffset < 0) throw new Error('session: invalid text_offset');
+  if (args.text_offset !== undefined && (args.offset === undefined || limit !== 1 || !args.item_id)) {
+    throw new Error('session: text_offset requires offset, limit:1 and item_id from read');
+  }
+  return { sessionId, limit, offset, textOffset };
+}

package/src/standalone/daemon-session-control/room-host.mjs

@@ -0,0 +1,57 @@
+import { rememberSubmissionBotChain } from '../../runtime/shared/bot-hops.mjs';
+import { agentRoomHost } from '../../runtime/shared/agent-room-host.mjs';
+
+/** The member a send to room log `sessionId` addresses, through the desktop
+ *  room host: `{ host, agentId, sessionId, text }`; throws when no desktop is
+ *  attached or no member resolves. */
+export async function roomAddressee(sessionId, args) {
+  let host;
+  try {
+    host = agentRoomHost();
+  } catch (error) {
+    throw new Error(`session: cannot send to ${sessionId}: ${error.message}`);
+  }
+  const member = await host.member(sessionId, { to: args.to, prompt: args.prompt }).catch((error) => {
+    throw new Error(`session: ${error?.message || error}`);
+  });
+  return { host, ...member };
+}
+
+/** The submit of a send to `room` (roomAddressee) at room log `sessionId`:
+ *  the member's turn carries the send's hop (`transcriptMeta.hop`), so a
+ *  chain through the room counts on toward MAX_BOT_HOPS; its bot chain is
+ *  recorded under every submission id that turn may take. */
+export function roomSubmitter(room, sessionId, prompt, from) {
+  return async ({ id, onSettled, follow, transcriptMeta } = {}) => {
+    rememberSubmissionBotChain(id, transcriptMeta?.botChain);
+    const followed = follow
+      ? (submissionId) => {
+          rememberSubmissionBotChain(submissionId, transcriptMeta?.botChain);
+          return follow(submissionId);
+        }
+      : null;
+    return {
+      accepted:
+        (await room.host.ask(sessionId, {
+          agentId: room.agentId,
+          prompt,
+          from,
+          ...(id ? { id } : {}),
+          ...(transcriptMeta?.hop > 0 ? { hop: transcriptMeta.hop } : {}),
+          ...(onSettled ? { onSettled } : {}),
+          ...(followed ? { follow: followed } : {}),
+        })) === true,
+    };
+  };
+}
+
+/** Stops the exchange of room log `sessionId` through the desktop room host. */
+export function stopRoomExchange(sessionId) {
+  let host;
+  try {
+    host = agentRoomHost();
+  } catch (error) {
+    throw new Error(`session: cannot cancel ${sessionId}: ${error.message}`);
+  }
+  return { sessionId, aborted: host.stop(sessionId) === true };
+}

package/src/standalone/daemon-session-control/route-control.mjs

@@ -0,0 +1,48 @@
+import { SESSION_ID_PATTERN } from '../../runtime/agent/orchestrator/runtime-core/session-id.mjs';
+
+// The route methods the setup tool reaches on another session (all on the
+// session protocol's configure allowlist), through the same configure lane
+// the desktop's model picker and quota card use.
+const ROUTE_METHODS = new Set(['setRoute', 'continueSessionInModel', 'scheduleQuotaResume', 'cancelQuotaResume']);
+const ROUTE_FIELDS = [
+  'provider',
+  'model',
+  'effort',
+  'fast',
+  'autoEffort',
+  'modelParameters',
+  'contextPercent',
+  'contextTokens',
+];
+
+// Only route fields cross: no option of the picker's write (keepMainModel,
+// applyToCurrentSession) can ride along and change the Lead route.
+function routeFields(input) {
+  const route = {};
+  for (const key of ROUTE_FIELDS) if (input?.[key] !== undefined && input[key] !== null) route[key] = input[key];
+  if (!route.provider || !route.model) throw new Error('session: route provider and model are required');
+  return route;
+}
+
+/**
+ * One route method on another session, for the setup tool
+ * (setup-tool/session-route-actions.mjs): `setRoute` is the session's own
+ * model pick (session-only, from its next turn: a running turn finishes on
+ * its model), the others its quota card's buttons. The caller's own session
+ * is changed by its runtime directly, never through here.
+ */
+export function createRouteControl(getSessionService) {
+  return async function routeControl(args, caller) {
+    const sessionId = typeof args.session_id === 'string' ? args.session_id.trim() : '';
+    if (!SESSION_ID_PATTERN.test(sessionId)) throw new Error('session: session_id is required for action=route');
+    if (sessionId === caller) throw new Error('session: route control must target another session');
+    if (!ROUTE_METHODS.has(args.method)) throw new Error(`session: unsupported route method "${args.method}"`);
+    const service = getSessionService();
+    if (!service) throw new Error('session: session service is unavailable');
+    let input = [sessionId];
+    if (args.method === 'setRoute') input = [{ ...routeFields(args.input), sessionOnly: true }];
+    else if (args.method === 'continueSessionInModel') input = [sessionId, routeFields(args.input)];
+    const result = await service.configureSession({ sessionId, action: args.method, args: input }, { revision: 1 });
+    return result.value;
+  };
+}

package/src/standalone/daemon-session-control/send-turn.mjs

@@ -0,0 +1,60 @@
+import { BOT_HOP_LIMIT_ERROR, MAX_BOT_HOPS } from '../../runtime/shared/bot-hops.mjs';
+import { roomMemberOfSession, roomSessionId } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
+
+// Why a send from a conversation that is no bot's reports nothing back.
+const NOT_BOT_REASON = 'only a bot conversation gets session results reported back; check that session for the result';
+
+/** Throws unless a send to `sessionId` carries a prompt and addresses no
+ *  room member's session directly. */
+export function assertSendRequest(args, sessionId) {
+  if (typeof args.prompt !== 'string' || !args.prompt.trim()) {
+    throw new Error('session: prompt is required for action=send');
+  }
+  // A room member's session is the room's to drive: a message goes to the
+  // room, naming the member.
+  if (roomMemberOfSession(sessionId)) {
+    throw new Error(
+      `session: ${sessionId} is a group-room member's session; send to its room (session_id ${roomSessionId(roomMemberOfSession(sessionId).roomId)}) with to: <member>`
+    );
+  }
+}
+
+/** Applies effort `level` (checked) to `sessionId`, just before the prompt is queued. */
+export function effortApplier(service, sessionId, level) {
+  // sessionOnly: the session's route changes, never the user's saved model settings.
+  return async () => {
+    const applied = await service.configureSession(
+      { sessionId, action: 'setEffort', args: [level, { sessionOnly: true }] },
+      { revision: 1 }
+    );
+    if (applied?.value === false) {
+      throw new Error(`session: ${sessionId} is busy with another command; effort not changed`);
+    }
+  };
+}
+
+/** `hop`, refused past MAX_BOT_HOPS. */
+export function chainedHop(hop) {
+  if (hop > MAX_BOT_HOPS) throw new Error(BOT_HOP_LIMIT_ERROR);
+  return hop;
+}
+
+/** The report origin with the send's hop and bot chain carried on. */
+export function chainedOrigin(origin, hop, botChain) {
+  let chained = origin;
+  if (hop > 0) chained = { ...chained, hop };
+  if (botChain.length) chained = { ...chained, botChain };
+  return chained;
+}
+
+/** The result of a send that reports nothing back (no report origin). */
+export function unreportedSendResult(sessionId, addressed, accepted, hop) {
+  return {
+    sessionId,
+    ...addressed,
+    accepted,
+    reportsBack: false,
+    ...(accepted ? { reportsBackReason: NOT_BOT_REASON } : {}),
+    ...(hop > 0 ? { hop } : {}),
+  };
+}

package/src/standalone/daemon-session-control/worktree-control.mjs

@@ -0,0 +1,40 @@
+import { SESSION_ID_PATTERN } from '../../runtime/agent/orchestrator/runtime-core/session-id.mjs';
+import { assertWorktreeMutationAllowed } from '../../session-runtime/services/worktree-access.mjs';
+
+// The workspace methods `worktree` reaches on another session (all on the
+// session protocol's read/configure allowlists).
+const WORKTREE_METHODS = new Set([
+  'getBranchMenu',
+  'requestWorktree',
+  'selectBranch',
+  'mergeWorkspace',
+  'removeWorktree',
+]);
+
+/**
+ * Another session's workspace for the git tool's worktree operations
+ * (session-runtime/workspace/worktree-tool.mjs): one workspace method with
+ * one input, through the same configure / read lanes the desktop uses. No
+ * `ownTurn` ever crosses: the target must be idle. A change (anything but
+ * the menu read) needs the caller's trusted scope (`callerScope`, from
+ * worktree-access.mjs worktreeCallerScope) to be an attended conversation.
+ */
+export function createWorktreeControl(getSessionService) {
+  return async function worktreeControl(args, caller, callerScope) {
+    const sessionId = typeof args.session_id === 'string' ? args.session_id.trim() : '';
+    if (!SESSION_ID_PATTERN.test(sessionId)) throw new Error('session: session_id is required for action=worktree');
+    if (sessionId === caller) throw new Error('session: worktree control must target another session');
+    if (!WORKTREE_METHODS.has(args.method)) throw new Error(`session: unsupported worktree method "${args.method}"`);
+    if (args.method !== 'getBranchMenu') assertWorktreeMutationAllowed(callerScope, `session: worktree ${args.method}`);
+    const service = getSessionService();
+    if (!service) throw new Error('session: session service is unavailable');
+    if (args.method === 'getBranchMenu') {
+      return (await service.readSession({ sessionId, action: 'getBranchMenu', args: [] })).value;
+    }
+    const result = await service.configureSession(
+      { sessionId, action: args.method, args: [args.input ?? {}] },
+      { revision: 1 }
+    );
+    return result.value;
+  };
+}