mixdog 1.3.4 → 1.4.0

package/src/runtime/channels/lib/owned-runtime/owned-stop.mjs

@@ -3,7 +3,6 @@ import { releaseOwnedChannelLocks, clearActiveInstance } from '../runtime-paths.
 
 export function createOwnedStopper({
   state,
-  getProvider,
   getBridgeRuntimeConnected,
   setBridgeRuntimeConnected,
   instanceId,
@@ -11,19 +10,9 @@ export function createOwnedStopper({
   logOwnership,
   services,
 }) {
-  // Only disconnect when connect() actually completed; disconnecting
-  // mid-connect races the connect promise. In-flight outbound sends are
-  // drained first (bounded inside drainPendingSends) so a handoff never cuts
-  // off a reply mid-delivery.
-  async function disconnectConnectedProvider() {
-    try {
-      await getProvider().drainPendingSends?.();
-    } catch {}
-    await getProvider().disconnect();
-  }
   return async function stopOwnedRuntime(reason) {
     // A start advertises owner metadata and claims channel locks before
-    // awaiting connect(); a stop landing in that window (starting=true,
+    // it finishes; a stop landing in that window (starting=true,
     // connected=false) still has partial state to tear down.
     if (
       !getBridgeRuntimeConnected() &&
@@ -33,27 +22,21 @@ export function createOwnedStopper({
     ) {
       return;
     }
-    // Signal an in-flight start to abort right after its connect() resolves;
-    // otherwise it would re-mark connected and re-launch scheduler/webhook
-    // after the teardown below.
+    // Signal an in-flight start to abort at its next checkpoint; otherwise it
+    // would re-launch scheduler/webhook after the teardown below.
     if (state.bridgeRuntimeStarting || state.automationStartPromise) state.stopRequested = true;
     if (state.automationStartPromise) {
       try {
         await state.automationStartPromise;
       } catch {}
     }
-    const wasConnected = getBridgeRuntimeConnected();
     scheduler.stop();
     stopSnapshotWriter();
     await services.stopWebhookAndEventRuntime();
     state.automationRunning = false;
     releaseOwnedChannelLocks(instanceId);
     clearActiveInstance(instanceId);
-    try {
-      if (wasConnected) await disconnectConnectedProvider();
-    } finally {
-      setBridgeRuntimeConnected(false);
-      logOwnership(`standby: ${reason}`);
-    }
+    setBridgeRuntimeConnected(false);
+    logOwnership(`standby: ${reason}`);
   };
 }

package/src/runtime/channels/lib/owned-runtime/state.mjs

@@ -8,15 +8,9 @@ export function createOwnedRuntimeState() {
     // stopOwnedRuntime() landed while an owned or automation start was in
     // flight; the in-flight run bails at its next checkpoint.
     stopRequested: false,
-    // Resolves when the current startOwnedRuntime() run fully settles, so a
-    // reload can wait before issuing a restart (lost-restart race).
-    inFlightStart: null,
-    // Automation (scheduler + webhook server + relay tunnel) can outlive a
-    // failed/absent messaging provider; tracked apart from the connect flag.
+    // Automation (scheduler + webhook server + relay tunnel) can run without
+    // the bridge being active; tracked apart from the bridge-connected flag.
     automationRunning: false,
     automationStartPromise: null,
-    // Coalesces concurrent refreshBridgeOwnership() callers.
-    refreshInFlight: null,
-    selfHealing: false,
   };
 }

package/src/runtime/channels/lib/owned-runtime.mjs

@@ -1,15 +1,13 @@
-// Owned-runtime lifecycle: provider connect/disconnect, automation runtime
-// (scheduler + webhook/event runtime), ownership refresh and config
-// hot-reload. The phases live under owned-runtime/ and share one explicit
-// state object; config / provider / bridgeRuntimeConnected / webhookServer /
-// eventPipeline stay on the worker (get/set) so file-level reference
-// semantics are preserved.
+// Owned-runtime lifecycle: bridge activation, automation runtime (scheduler +
+// webhook/event runtime) and config hot-reload. The phases live under
+// owned-runtime/ and share one explicit state object; config /
+// bridgeRuntimeConnected / webhookServer / eventPipeline stay on the worker
+// (get/set) so file-level reference semantics are preserved.
 import { createOwnedRuntimeState } from './owned-runtime/state.mjs';
 import { createAutomationServices } from './owned-runtime/automation-services.mjs';
 import { createAutomationStarter } from './owned-runtime/automation-start.mjs';
 import { createOwnedStarter } from './owned-runtime/owned-start.mjs';
 import { createOwnedStopper } from './owned-runtime/owned-stop.mjs';
-import { createOwnershipRefresh } from './owned-runtime/ownership-refresh.mjs';
 import { createConfigReloader } from './owned-runtime/config-reload.mjs';
 
 export function createOwnedRuntime(deps) {
@@ -26,29 +24,14 @@ export function createOwnedRuntime(deps) {
     ...deps,
     state,
     services,
-    startAutomationRuntime,
     notifyRemoteAcquired,
   });
   const stopOwnedRuntime = createOwnedStopper({ ...deps, state, services });
-  const { refreshBridgeOwnership, refreshBridgeOwnershipSafe } = createOwnershipRefresh({
-    ...deps,
-    state,
-    startOwnedRuntime,
-    stopOwnedRuntime,
-  });
-  const reloadRuntimeConfig = createConfigReloader({
-    ...deps,
-    state,
-    services,
-    stopOwnedRuntime,
-    refreshBridgeOwnershipSafe,
-  });
+  const reloadRuntimeConfig = createConfigReloader({ ...deps, state, services });
   return {
     startAutomationRuntime,
     startOwnedRuntime,
     stopOwnedRuntime,
-    refreshBridgeOwnership,
-    refreshBridgeOwnershipSafe,
     reloadRuntimeConfig,
     notifyRemoteAcquired,
   };

package/src/runtime/channels/lib/parent-bridge.mjs

@@ -28,8 +28,8 @@ function setChannelNotifySink(fn) {
 function createParentBridge({ getInstanceId, ipcProcess = process }) {
   function sendNotifyToParent(method, params) {
     // The channel schema requires meta: Record<string,string>.
-    // Coerce every meta value to string so a non-string (e.g. a Discord
-    // interaction.type number) can't fail zod and silently drop the notify.
+    // Coerce every meta value to string so a non-string (e.g. a numeric
+    // meta field) can't fail zod and silently drop the notify.
     // silent_to_agent stays boolean — an internal routing flag the daemon
     // router / agentNotify consume (=== true) before the zod boundary.
     const outParams = normalizeChannelNotifyParams(method, params);

package/src/runtime/channels/lib/runtime-paths.mjs

@@ -81,9 +81,9 @@ function activeInstanceStaleReason(state) {
   // NOTE: ownership is no longer decided here — the machine-global channels
   // daemon (singleton-owner lock in src/standalone) is the authority. This
   // PID-death check only marks a metadata advert whose owning process is gone so
-  // refreshActiveInstance can avoid preserving its owner fields. The former
-  // ui_heartbeat_at staleness branch was removed: its false-stale eviction was
-  // the Discord-flapping root cause.
+  // refreshActiveInstance can avoid preserving its owner fields. There is no
+  // ui_heartbeat_at staleness branch: its false-stale eviction wrongly dropped
+  // live owners.
   return null;
 }
 function buildRuntimeIdentity() {
@@ -126,11 +126,8 @@ function readActiveInstance() {
 /** Caller-supplied advert fields, in the order every writer publishes them. */
 function metaFields(meta) {
   return {
-    ...(meta?.channelId ? { channelId: meta.channelId } : {}),
     ...(meta?.transcriptPath ? { transcriptPath: meta.transcriptPath } : {}),
     ...(meta?.httpPort ? { httpPort: meta.httpPort } : {}),
-    ...Object.fromEntries(Object.entries(meta || {}).filter(([k]) => k.startsWith('gateway_'))),
-    ...(typeof meta?.providerReady === 'boolean' ? { providerReady: meta.providerReady } : {}),
   };
 }
 function buildActiveInstanceState(instanceId, meta) {
@@ -143,41 +140,6 @@ function buildActiveInstanceState(instanceId, meta) {
     ...metaFields(meta),
   };
 }
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (e) {
-    return !(e && e.code === 'ESRCH');
-  }
-}
-// gateway_* fields are preserved while the gateway owner is alive: the gateway
-// child advertises itself independently, and active-owner heartbeats must not
-// erase that discovery record while its owning server-main process is still
-// alive. Writes into `preservedExtra` (and clears from `next`).
-function preserveGatewayFields(prev, meta, identity, preservedExtra, next) {
-  const prevGatewayServerPid = parsePositivePid(prev?.gateway_server_pid);
-  const prevGatewayOwnerAlive = prevGatewayServerPid !== null && isProcessAlive(prevGatewayServerPid);
-  const sameGatewayAdvertiser =
-    prevGatewayServerPid !== null && identity.server_pid !== null && prevGatewayServerPid === identity.server_pid;
-  if (!(sameGatewayAdvertiser || prevGatewayOwnerAlive)) return;
-  if (!prev || !Object.hasOwn(prev, 'gateway_port')) return;
-  for (const [key, value] of Object.entries(prev)) {
-    if (key.startsWith('gateway_')) preservedExtra[key] = value;
-  }
-  preservedExtra.gateway_server_pid = prevGatewayServerPid;
-  // Clear session-scoped gateway metrics when the transcript changes — a new
-  // session must not inherit the previous session's context usage before the
-  // gateway re-advertises.
-  const nonEmptyString = (value) => (typeof value === 'string' && value ? value : null);
-  const metricTranscript = nonEmptyString(prev.gateway_transcript_path) ?? nonEmptyString(prev.transcriptPath);
-  if (typeof meta?.transcriptPath === 'string' && meta.transcriptPath && metricTranscript !== meta.transcriptPath) {
-    delete preservedExtra.gateway_context_used_pct;
-    delete preservedExtra.gateway_last_usage;
-    delete next.gateway_context_used_pct;
-    delete next.gateway_last_usage;
-  }
-}
 function refreshActiveInstance(instanceId, meta, options) {
   ensureRuntimeDirs();
   // Periodic refresh/heartbeat callers pass options.timeoutMs:0 (try-once) so
@@ -237,7 +199,6 @@ function refreshActiveInstance(instanceId, meta, options) {
       const preservedExtra = Object.fromEntries(
         Object.entries(prevForPreserve ?? {}).filter(([k]) => k.startsWith('pg_'))
       );
-      preserveGatewayFields(prevForPreserve, meta, identity, preservedExtra, next);
       return { ...preservedExtra, ...next };
     },
     writeOpts
@@ -354,7 +315,7 @@ function cleanupInstanceRuntimeFiles(instanceId) {
   for (const target of targets) {
     removeFileIfExists(target);
   }
-  // Remove artifacts left by pre-standalone Discord approval builds.
+  // Remove per-instance permission artifacts left by pre-standalone builds.
   forEachFile(RUNTIME_ROOT, (fullPath, file) => {
     if (file.startsWith(`perm-${sanitize(instanceId)}-`)) {
       removeFileIfExists(fullPath);

package/src/runtime/channels/lib/schedule-errors.mjs

@@ -0,0 +1,51 @@
+// Structured reasons a schedule rename is refused or ends unsure. The app
+// decides on the `code` and the `name` detail (the desktop's
+// shared/schedule-error-codes.ts mirrors these codes), never on the English
+// message, which is for the model and the logs.
+
+/** Another schedule already has the name (detail: `name`, the name asked for). */
+export const SCHEDULE_NAME_TAKEN = 'SCHEDULE_NAME_TAKEN';
+/** A run of the schedule is in flight, or another rename of it (detail: `name`). */
+export const SCHEDULE_RENAME_RUNNING = 'SCHEDULE_RENAME_RUNNING';
+/** The row moved but the scheduler did not reload (detail: `name`, the new name). */
+export const SCHEDULE_RENAME_RELOAD_FAILED = 'SCHEDULE_RENAME_RELOAD_FAILED';
+/** The scheduler never answered, so the rename may or may not have applied. */
+export const SCHEDULE_RENAME_UNCERTAIN = 'SCHEDULE_RENAME_UNCERTAIN';
+
+const NAMED_CODES = new Set([SCHEDULE_NAME_TAKEN, SCHEDULE_RENAME_RUNNING, SCHEDULE_RENAME_RELOAD_FAILED]);
+const CODES = new Set([...NAMED_CODES, SCHEDULE_RENAME_UNCERTAIN]);
+
+/** The fields of `error` a reply may carry across the worker boundary: a
+ *  schedule code and, for the codes that name a schedule, that public `name`.
+ *  Any other code or detail stays on this side. */
+export function scheduleErrorFields(error) {
+  const code = error?.code;
+  if (typeof code !== 'string' || !CODES.has(code)) return {};
+  const name = error.details?.name;
+  return {
+    code,
+    ...(NAMED_CODES.has(code) && typeof name === 'string' && name ? { details: { name } } : {}),
+  };
+}
+
+const coded = (message, code, details = null) =>
+  Object.assign(new Error(message), { code }, details ? { details } : {});
+
+export const scheduleNameTakenError = (name) =>
+  coded(`A schedule named "${name}" already exists.`, SCHEDULE_NAME_TAKEN, { name });
+
+export const scheduleRenameRunningError = (name) =>
+  coded(`Schedule "${name}" is running. Rename it after the run finishes.`, SCHEDULE_RENAME_RUNNING, { name });
+
+export const scheduleRenameReloadError = (name, cause) =>
+  coded(
+    `Renamed to "${name}", but reloading the scheduler failed (${cause}); it is armed on the next reload.`,
+    SCHEDULE_RENAME_RELOAD_FAILED,
+    { name }
+  );
+
+export const scheduleRenameUncertainError = (cause) =>
+  coded(
+    `The rename may or may not have applied (the scheduler did not answer: ${cause}). Check the schedule list.`,
+    SCHEDULE_RENAME_UNCERTAIN
+  );