@joshski/dust 0.1.84 → 0.1.85

package/biome/no-vitest-mocking.grit

@@ -0,0 +1,25 @@
+language js
+
+or {
+  `vi.mock($...)` where {
+    register_diagnostic(span=$match, message="Avoid vi.mock(). Use dependency injection or a test helper instead.")
+  },
+  `vi.spyOn($...)` where {
+    register_diagnostic(span=$match, message="Avoid vi.spyOn(). Use dependency injection or a test helper instead.")
+  },
+  `vi.useFakeTimers($...)` where {
+    register_diagnostic(span=$match, message="Avoid vi.useFakeTimers(). Use a test helper instead.")
+  },
+  `vi.useRealTimers($...)` where {
+    register_diagnostic(span=$match, message="Avoid vi.useRealTimers(). Use a test helper instead.")
+  },
+  `vi.runAllTimers($...)` where {
+    register_diagnostic(span=$match, message="Avoid vi.runAllTimers(). Use a test helper instead.")
+  },
+  `vi.advanceTimersByTime($...)` where {
+    register_diagnostic(span=$match, message="Avoid vi.advanceTimersByTime(). Use a test helper instead.")
+  },
+  `vi.fn($...)` where {
+    register_diagnostic(span=$match, message="Avoid vi.fn(). Use a typed test double or test helper instead.")
+  }
+}

package/dist/agent-events.d.ts

@@ -22,7 +22,8 @@ export type AgentSessionEvent = {
 } | {
     type: 'agent-session-activity';
 } | {
-    type: 'claude-event';
+    type: 'agent-event';
+    provider: string;
     rawEvent: Record<string, unknown>;
 };
 export interface EventMessage {
@@ -35,19 +36,19 @@ export interface EventMessage {
     event: AgentSessionEvent;
 }
 /**
- * Convert a raw Claude streaming event to an AgentSessionEvent.
+ * Convert a raw agent streaming event to an AgentSessionEvent.
  * stream_event types become activity heartbeats; everything else
- * is forwarded as a claude-event.
+ * is forwarded as an agent-event with provider info.
  */
-export declare function rawEventToAgentEvent(rawEvent: Record<string, unknown>): AgentSessionEvent;
+export declare function rawEventToAgentEvent(rawEvent: Record<string, unknown>, provider: string): AgentSessionEvent;
 /**
  * Create a heartbeat throttler that limits agent-session-activity events
  * to at most once per interval (default: 5 seconds).
  *
- * The returned callback converts raw Claude events to AgentSessionEvents,
+ * The returned callback converts raw agent events to AgentSessionEvents,
  * throttling stream_event heartbeats while forwarding all other events.
  */
-export declare function createHeartbeatThrottler(onAgentEvent: (event: AgentSessionEvent) => void, options?: {
+export declare function createHeartbeatThrottler(onAgentEvent: (event: AgentSessionEvent) => void, provider: string, options?: {
     intervalMs?: number;
     now?: () => number;
 }): (rawEvent: Record<string, unknown>) => void;

package/dist/dust.js

@@ -319,7 +319,7 @@ async function loadSettings(cwd, fileSystem) {
 }
 
 // lib/version.ts
-var DUST_VERSION = "0.1.84";
+var DUST_VERSION = "0.1.85";
 
 // lib/session.ts
 var DUST_UNATTENDED = "DUST_UNATTENDED";
@@ -1840,6 +1840,264 @@ function openBrowser(url) {
   nodeSpawn(cmd, [url], { stdio: "ignore", detached: true }).unref();
 }
 
+// lib/bucket/bucket-state.ts
+function handleServerMessage(state, message) {
+  const effects = [];
+  effects.push({
+    type: "debugLog",
+    message: `ws message: ${message.type}`
+  });
+  switch (message.type) {
+    case "repository-list": {
+      const repos = message.repositories;
+      effects.push({
+        type: "log",
+        message: `Received repository list (${repos.length} repositories):`,
+        stream: "stdout"
+      });
+      if (repos.length === 0) {
+        effects.push({
+          type: "log",
+          message: "  (empty)",
+          stream: "stdout"
+        });
+      } else {
+        for (const r of repos) {
+          effects.push({
+            type: "log",
+            message: `  - name=${r.name}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    id=${r.id}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    gitUrl=${r.gitUrl}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    gitSshUrl=${r.gitSshUrl ?? "(none)"}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    url=${r.url}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    hasTask=${r.hasTask}`,
+            stream: "stdout"
+          });
+          if (r.agentProvider) {
+            effects.push({
+              type: "log",
+              message: `    agentProvider=${r.agentProvider}`,
+              stream: "stdout"
+            });
+          }
+        }
+      }
+      effects.push({
+        type: "syncUI",
+        repositories: repos
+      });
+      effects.push({
+        type: "handleRepositoryList",
+        repositories: repos
+      });
+      break;
+    }
+    case "task-available": {
+      const repoName = message.repository;
+      effects.push({
+        type: "log",
+        message: `Received task-available for ${repoName}`,
+        stream: "stdout"
+      });
+      if (state.repositoryNames.includes(repoName)) {
+        effects.push({
+          type: "signalTaskAvailable",
+          repositoryName: repoName
+        });
+      } else {
+        effects.push({
+          type: "log",
+          message: `No repository state found for ${repoName}`,
+          stream: "stderr"
+        });
+      }
+      break;
+    }
+  }
+  return { effects };
+}
+function handleMessageParseError(rawData) {
+  return {
+    effects: [
+      {
+        type: "log",
+        message: `Failed to parse WebSocket message: ${rawData}`,
+        stream: "stderr"
+      }
+    ]
+  };
+}
+function handleInvalidMessageFormat(rawData) {
+  return {
+    effects: [
+      {
+        type: "log",
+        message: `Invalid WebSocket message format: ${rawData}`,
+        stream: "stderr"
+      }
+    ]
+  };
+}
+var KEYS = {
+  UP: "\x1B[A",
+  DOWN: "\x1B[B",
+  RIGHT: "\x1B[C",
+  LEFT: "\x1B[D",
+  PAGE_UP: "\x1B[5~",
+  PAGE_DOWN: "\x1B[6~",
+  HOME: "\x1B[H",
+  END: "\x1B[F",
+  CTRL_C: "\x03"
+};
+var SGR_MOUSE_RE = new RegExp(String.raw`^\x1b\[<(\d+);\d+;\d+[Mm]$`);
+function parseSGRMouse(key) {
+  const match = key.match(SGR_MOUSE_RE);
+  if (!match)
+    return null;
+  return Number.parseInt(match[1], 10);
+}
+function handleKeypress(state, key) {
+  const effects = [];
+  const mouseButton = parseSGRMouse(key);
+  if (mouseButton !== null) {
+    if (mouseButton === 64) {
+      effects.push({ type: "scroll", direction: "up" });
+      effects.push({ type: "scroll", direction: "up" });
+      effects.push({ type: "scroll", direction: "up" });
+    } else if (mouseButton === 65) {
+      effects.push({ type: "scroll", direction: "down" });
+      effects.push({ type: "scroll", direction: "down" });
+      effects.push({ type: "scroll", direction: "down" });
+    }
+    return { effects };
+  }
+  switch (key) {
+    case "q":
+    case KEYS.CTRL_C:
+      effects.push({ type: "quit" });
+      break;
+    case KEYS.LEFT:
+      effects.push({ type: "selectPrevious" });
+      break;
+    case KEYS.RIGHT:
+      effects.push({ type: "selectNext" });
+      break;
+    case KEYS.UP:
+      effects.push({ type: "scroll", direction: "up" });
+      break;
+    case KEYS.DOWN:
+      effects.push({ type: "scroll", direction: "down" });
+      break;
+    case KEYS.PAGE_UP:
+      effects.push({ type: "scroll", direction: "pageUp" });
+      break;
+    case KEYS.PAGE_DOWN:
+      effects.push({ type: "scroll", direction: "pageDown" });
+      break;
+    case "g":
+    case KEYS.HOME:
+      effects.push({ type: "scroll", direction: "top" });
+      break;
+    case "G":
+    case KEYS.END:
+      effects.push({ type: "scroll", direction: "bottom" });
+      break;
+    case "o": {
+      if (state.selectedIndex === -1) {
+        break;
+      }
+      const repoName = state.repositories[state.selectedIndex];
+      if (!repoName)
+        break;
+      const url = state.repositoryUrls[repoName];
+      if (url) {
+        effects.push({ type: "openBrowser", url });
+      }
+      break;
+    }
+  }
+  return { effects };
+}
+var INITIAL_RECONNECT_DELAY_MS = 1000;
+var MAX_RECONNECT_DELAY_MS = 30000;
+function handleClose(state, code, reason) {
+  const effects = [];
+  effects.push({
+    type: "log",
+    message: `bucket.disconnected code=${code} reason=${reason || "none"}`,
+    stream: "stdout"
+  });
+  if (code === 4000) {
+    effects.push({
+      type: "log",
+      message: "Another connection replaced this one. Not reconnecting.",
+      stream: "stdout"
+    });
+    return { state, effects };
+  }
+  if (!state.shuttingDown) {
+    effects.push({
+      type: "log",
+      message: `Reconnecting in ${state.reconnectDelay / 1000} seconds...`,
+      stream: "stdout"
+    });
+    effects.push({
+      type: "scheduleReconnect",
+      delayMs: state.reconnectDelay
+    });
+    const nextDelay = Math.min(state.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+    return {
+      state: { ...state, reconnectDelay: nextDelay },
+      effects
+    };
+  }
+  return { state, effects };
+}
+function handleError(state, errorMessage) {
+  return {
+    state,
+    effects: [
+      {
+        type: "log",
+        message: `WebSocket error: ${errorMessage}`,
+        stream: "stderr"
+      }
+    ]
+  };
+}
+function handleOpen(state) {
+  return {
+    state: { ...state, reconnectDelay: INITIAL_RECONNECT_DELAY_MS },
+    effects: [
+      {
+        type: "log",
+        message: "bucket.connected",
+        stream: "stdout"
+      }
+    ]
+  };
+}
+
 // lib/bucket/events.ts
 var WS_OPEN = 1;
 function formatBucketEvent(event) {
@@ -1965,7 +2223,8 @@ class FileSink {
 
 // lib/logging/index.ts
 var DUST_LOG_FILE = "DUST_LOG_FILE";
-function createLoggingService() {
+function createLoggingService(options) {
+  const writeStdout = options?.stdout ?? process.stdout.write.bind(process.stdout);
   let patterns = null;
   let initialized = false;
   let activeFileSink = null;
@@ -1995,12 +2254,12 @@ function createLoggingService() {
       }
       activeFileSink = sinkForTesting ?? new FileSink(path);
     },
-    createLogger(name, options) {
+    createLogger(name, options2) {
       let perLoggerSink;
-      if (options?.file === false) {
+      if (options2?.file === false) {
         perLoggerSink = null;
-      } else if (typeof options?.file === "string") {
-        perLoggerSink = getOrCreateFileSink(options.file);
+      } else if (typeof options2?.file === "string") {
+        perLoggerSink = getOrCreateFileSink(options2.file);
       }
       return (...messages) => {
         init();
@@ -2013,7 +2272,7 @@ function createLoggingService() {
           activeFileSink.write(line);
         }
         if (patterns && matchesAny(name, patterns)) {
-          process.stdout.write(line);
+          writeStdout(line);
         }
       };
     },
@@ -2551,19 +2810,19 @@ import os2 from "node:os";
 import path3 from "node:path";
 
 // lib/agent-events.ts
-function rawEventToAgentEvent(rawEvent) {
+function rawEventToAgentEvent(rawEvent, provider) {
   if (typeof rawEvent.type === "string" && rawEvent.type === "stream_event") {
     return { type: "agent-session-activity" };
   }
-  return { type: "claude-event", rawEvent };
+  return { type: "agent-event", provider, rawEvent };
 }
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 5000;
-function createHeartbeatThrottler(onAgentEvent, options) {
+function createHeartbeatThrottler(onAgentEvent, provider, options) {
   const intervalMs = options?.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
   const now = options?.now ?? Date.now;
   let lastHeartbeatTime;
   return (rawEvent) => {
-    const event = rawEventToAgentEvent(rawEvent);
+    const event = rawEventToAgentEvent(rawEvent, provider);
     if (event.type === "agent-session-activity") {
       const currentTime = now();
       if (lastHeartbeatTime !== undefined && currentTime - lastHeartbeatTime < intervalMs) {
@@ -2588,7 +2847,7 @@ function formatAgentEvent(event) {
     case "agent-session-ended":
       return event.success ? "\uD83E\uDD16 Agent session ended (success)" : `\uD83E\uDD16 Agent session ended (error: ${event.error})`;
     case "agent-session-activity":
-    case "claude-event":
+    case "agent-event":
       return null;
   }
 }
@@ -3227,7 +3486,7 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
     docker: dockerConfig
   };
   if (eventsUrl) {
-    iterationOptions.onRawEvent = createHeartbeatThrottler(onAgentEvent);
+    iterationOptions.onRawEvent = createHeartbeatThrottler(onAgentEvent, loopDependencies.agentType ?? "claude");
   }
   while (completedIterations < maxIterations) {
     agentSessionId = crypto.randomUUID();
@@ -3510,6 +3769,7 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
   };
   const isCodex = repoState.repository.agentProvider === "codex";
   const agentType = isCodex ? "codex" : "claude";
+  log3(`${repoName}: agentProvider=${repoState.repository.agentProvider ?? "(unset)"}, using ${agentType}`);
   const createStdoutSink2 = () => createBufferStdoutSink(loopState, repoState.logBuffer);
   let bufferRun;
   if (isCodex) {
@@ -3593,7 +3853,7 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
         hooksInstalled,
         signal: abortController.signal,
         repositoryId: repoState.repository.id.toString(),
-        onRawEvent: createHeartbeatThrottler(onAgentEvent),
+        onRawEvent: createHeartbeatThrottler(onAgentEvent, agentType),
         docker: dockerConfig
       });
     } catch (error) {
@@ -3653,7 +3913,8 @@ function parseRepository(data) {
         gitUrl: repositoryData.gitUrl,
         gitSshUrl: typeof repositoryData.gitSshUrl === "string" ? repositoryData.gitSshUrl : undefined,
         url: repositoryData.url,
-        id: repositoryData.id
+        id: repositoryData.id,
+        agentProvider: typeof repositoryData.agentProvider === "string" ? repositoryData.agentProvider : undefined
       };
     }
   }
@@ -3731,6 +3992,16 @@ async function handleRepositoryList(repositories, manager, repoDeps, context) {
   for (const [name, repo] of incomingRepos) {
     if (!manager.repositories.has(name)) {
       await addRepository(repo, manager, repoDeps, context);
+    } else {
+      const existing = manager.repositories.get(name);
+      if (!existing)
+        continue;
+      if (existing.repository.agentProvider !== repo.agentProvider) {
+        const from = existing.repository.agentProvider ?? "(unset)";
+        const to = repo.agentProvider ?? "(unset)";
+        log4(`${name}: agentProvider changed from ${from} to ${to}`);
+        existing.repository.agentProvider = repo.agentProvider;
+      }
     }
   }
   for (const name of manager.repositories.keys()) {
@@ -4136,90 +4407,37 @@ function enterAlternateScreen() {
 function exitAlternateScreen() {
   return `\x1B[?1006l\x1B[?1000l${ANSI.EXIT_ALT_SCREEN}${ANSI.SHOW_CURSOR}`;
 }
-var KEYS = {
-  UP: "\x1B[A",
-  DOWN: "\x1B[B",
-  RIGHT: "\x1B[C",
-  LEFT: "\x1B[D",
-  PAGE_UP: "\x1B[5~",
-  PAGE_DOWN: "\x1B[6~",
-  HOME: "\x1B[H",
-  END: "\x1B[F",
-  CTRL_C: "\x03"
-};
-var SGR_MOUSE_RE = new RegExp(String.raw`^\x1b\[<(\d+);\d+;\d+[Mm]$`);
-function parseSGRMouse(key) {
-  const match = key.match(SGR_MOUSE_RE);
-  if (!match)
-    return null;
-  return Number.parseInt(match[1], 10);
-}
-function handleKeyInput(state, key, options) {
-  const mouseButton = parseSGRMouse(key);
-  if (mouseButton !== null) {
-    if (mouseButton === 64) {
-      scrollUp(state, 3);
-    } else if (mouseButton === 65) {
-      scrollDown(state, 3);
-    }
-    return false;
-  }
-  switch (key) {
-    case "q":
-    case KEYS.CTRL_C:
-      return true;
-    case KEYS.LEFT:
-      selectPrevious(state);
-      state.scrollOffset = 0;
-      state.autoScroll = true;
-      break;
-    case KEYS.RIGHT:
-      selectNext(state);
-      state.scrollOffset = 0;
-      state.autoScroll = true;
-      break;
-    case KEYS.UP:
-      scrollUp(state, 1);
-      break;
-    case KEYS.DOWN:
-      scrollDown(state, 1);
-      break;
-    case KEYS.PAGE_UP:
-      scrollUp(state, getLogAreaHeight(state));
-      break;
-    case KEYS.PAGE_DOWN:
-      scrollDown(state, getLogAreaHeight(state));
-      break;
-    case "g":
-    case KEYS.HOME:
-      scrollToTop(state);
-      break;
-    case "G":
-    case KEYS.END:
-      scrollToBottom(state);
-      break;
-    case "o": {
-      if (state.selectedIndex === -1) {
-        break;
-      }
-      const repoName = state.repositories[state.selectedIndex];
-      if (!repoName)
-        break;
-      const url = state.repositoryUrls.get(repoName);
-      if (url && options?.openBrowser) {
-        options.openBrowser(url);
-      }
-      break;
-    }
-  }
-  return false;
-}
+var SGR_MOUSE_RE2 = new RegExp(String.raw`^\x1b\[<(\d+);\d+;\d+[Mm]$`);
 
 // lib/cli/commands/bucket.ts
 var log5 = createLogger("dust:cli:commands:bucket");
 var DEFAULT_DUSTBUCKET_WS_URL = "wss://dustbucket.com/agent/connect";
-var INITIAL_RECONNECT_DELAY_MS = 1000;
-var MAX_RECONNECT_DELAY_MS = 30000;
+function createAuthFileSystem(dependencies) {
+  return {
+    exists: (path4) => {
+      try {
+        dependencies.accessSync(path4);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    isDirectory: (path4) => {
+      try {
+        return dependencies.statSync(path4).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    getFileCreationTime: (path4) => dependencies.statSync(path4).birthtimeMs,
+    readFile: (path4) => dependencies.readFile(path4, "utf8"),
+    writeFile: (path4, content) => dependencies.writeFile(path4, content, "utf8"),
+    mkdir: (path4, options) => dependencies.mkdir(path4, options).then(() => {}),
+    readdir: (path4) => dependencies.readdir(path4),
+    chmod: (path4, mode) => dependencies.chmod(path4, mode),
+    rename: (oldPath, newPath) => dependencies.rename(oldPath, newPath)
+  };
+}
 function defaultCreateWebSocket(url, token) {
   const ws = new WebSocket(url, {
     headers: {
@@ -4274,32 +4492,6 @@ function defaultGetTerminalSize() {
 function defaultWriteStdout(data) {
   process.stdout.write(data);
 }
-function createAuthFileSystem(dependencies) {
-  return {
-    exists: (path4) => {
-      try {
-        dependencies.accessSync(path4);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    isDirectory: (path4) => {
-      try {
-        return dependencies.statSync(path4).isDirectory();
-      } catch {
-        return false;
-      }
-    },
-    getFileCreationTime: (path4) => dependencies.statSync(path4).birthtimeMs,
-    readFile: (path4) => dependencies.readFile(path4, "utf8"),
-    writeFile: (path4, content) => dependencies.writeFile(path4, content, "utf8"),
-    mkdir: (path4, options) => dependencies.mkdir(path4, options).then(() => {}),
-    readdir: (path4) => dependencies.readdir(path4),
-    chmod: (path4, mode) => dependencies.chmod(path4, mode),
-    rename: (oldPath, newPath) => dependencies.rename(oldPath, newPath)
-  };
-}
 function createDefaultBucketDependencies() {
   const authFileSystem = createAuthFileSystem({
     accessSync,
@@ -4470,8 +4662,13 @@ function connectWebSocket(token, state, bucketDependencies, context, fileSystem,
     state.ws = ws;
     ws.onopen = () => {
       state.emit({ type: "bucket.connected" });
-      logMessage(state, context, useTUI, formatBucketEvent({ type: "bucket.connected" }));
-      state.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+      const lifecycleState = {
+        reconnectDelay: state.reconnectDelay,
+        shuttingDown: state.shuttingDown
+      };
+      const result = handleOpen(lifecycleState);
+      state.reconnectDelay = result.state.reconnectDelay;
+      executeLifecycleEffects(result.effects, { state, context, useTUI, bucketDependencies, fileSystem }, token);
     };
   }
   ws.onclose = (event) => {
@@ -4481,80 +4678,122 @@ function connectWebSocket(token, state, bucketDependencies, context, fileSystem,
       reason: event.reason || "none"
     };
     state.emit(disconnectEvent);
-    logMessage(state, context, useTUI, formatBucketEvent(disconnectEvent));
     state.ws = null;
-    if (event.code === 4000) {
-      logMessage(state, context, useTUI, "Another connection replaced this one. Not reconnecting.");
-      return;
-    }
-    if (!state.shuttingDown) {
-      logMessage(state, context, useTUI, `Reconnecting in ${state.reconnectDelay / 1000} seconds...`);
-      state.reconnectTimer = setTimeout(() => {
-        connectWebSocket(token, state, bucketDependencies, context, fileSystem, useTUI);
-      }, state.reconnectDelay);
-      state.reconnectDelay = Math.min(state.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
-    }
+    const lifecycleState = {
+      reconnectDelay: state.reconnectDelay,
+      shuttingDown: state.shuttingDown
+    };
+    const result = handleClose(lifecycleState, event.code, event.reason || "");
+    state.reconnectDelay = result.state.reconnectDelay;
+    executeLifecycleEffects(result.effects, { state, context, useTUI, bucketDependencies, fileSystem }, token);
   };
   ws.onerror = (error) => {
-    logMessage(state, context, useTUI, `WebSocket error: ${error.message}`, "stderr");
+    const lifecycleState = {
+      reconnectDelay: state.reconnectDelay,
+      shuttingDown: state.shuttingDown
+    };
+    const result = handleError(lifecycleState, error.message);
+    executeLifecycleEffects(result.effects, { state, context, useTUI, bucketDependencies, fileSystem }, token);
   };
   ws.onmessage = (event) => {
     let rawData;
     try {
       rawData = JSON.parse(event.data);
     } catch {
-      logMessage(state, context, useTUI, `Failed to parse WebSocket message: ${event.data}`, "stderr");
+      const result2 = handleMessageParseError(event.data);
+      executeEffects(result2.effects, {
+        state,
+        context,
+        useTUI,
+        bucketDependencies,
+        fileSystem
+      });
       return;
     }
     const message = parseServerMessage(rawData);
     if (!message) {
-      logMessage(state, context, useTUI, `Invalid WebSocket message format: ${event.data}`, "stderr");
+      const result2 = handleInvalidMessageFormat(event.data);
+      executeEffects(result2.effects, {
+        state,
+        context,
+        useTUI,
+        bucketDependencies,
+        fileSystem
+      });
       return;
     }
-    log5(`ws message: ${message.type}`);
-    if (message.type === "repository-list") {
-      const repos = message.repositories;
-      logMessage(state, context, useTUI, `Received repository list (${repos.length} repositories):`);
-      if (repos.length === 0) {
-        logMessage(state, context, useTUI, "  (empty)");
-      } else {
-        for (const r of repos) {
-          logMessage(state, context, useTUI, `  - name=${r.name}`);
-          logMessage(state, context, useTUI, `    id=${r.id}`);
-          logMessage(state, context, useTUI, `    gitUrl=${r.gitUrl}`);
-          logMessage(state, context, useTUI, `    gitSshUrl=${r.gitSshUrl ?? "(none)"}`);
-          logMessage(state, context, useTUI, `    url=${r.url}`);
-          logMessage(state, context, useTUI, `    hasTask=${r.hasTask}`);
-        }
-      }
-      syncUIWithRepoList(state, repos);
-      const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
-      const repoContext = createTUIContext(state, context, useTUI);
-      handleRepositoryList(repos, state, repoDeps, repoContext).then(() => {
-        syncTUI(state);
-        for (const repoData of repos) {
-          if (repoData.hasTask) {
-            const repoState = state.repositories.get(repoData.name);
-            if (repoState) {
-              signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
+    const handlerState = {
+      repositoryNames: Array.from(state.repositories.keys())
+    };
+    const result = handleServerMessage(handlerState, message);
+    executeEffects(result.effects, {
+      state,
+      context,
+      useTUI,
+      bucketDependencies,
+      fileSystem
+    });
+  };
+}
+function executeEffects(effects, dependencies) {
+  const { state, context, useTUI, bucketDependencies, fileSystem } = dependencies;
+  for (const effect of effects) {
+    switch (effect.type) {
+      case "log":
+        logMessage(state, context, useTUI, effect.message, effect.stream);
+        break;
+      case "debugLog":
+        log5(effect.message);
+        break;
+      case "syncUI":
+        syncUIWithRepoList(state, effect.repositories);
+        break;
+      case "handleRepositoryList": {
+        const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
+        const repoContext = createTUIContext(state, context, useTUI);
+        const repos = effect.repositories;
+        handleRepositoryList(repos, state, repoDeps, repoContext).then(() => {
+          syncTUI(state);
+          for (const repoData of repos) {
+            if (repoData.hasTask) {
+              const repoState = state.repositories.get(repoData.name);
+              if (repoState) {
+                signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
+              }
             }
           }
+        }).catch((error) => {
+          logMessage(state, context, useTUI, `Failed to handle repository list: ${error.message}`, "stderr");
+        });
+        break;
+      }
+      case "signalTaskAvailable": {
+        const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
+        const repoState = state.repositories.get(effect.repositoryName);
+        if (repoState) {
+          signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
         }
-      }).catch((error) => {
-        logMessage(state, context, useTUI, `Failed to handle repository list: ${error.message}`, "stderr");
-      });
-    } else if (message.type === "task-available") {
-      const repoName = message.repository;
-      const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
-      logMessage(state, context, useTUI, `Received task-available for ${repoName}`);
-      const repoState = state.repositories.get(repoName);
-      if (repoState) {
-        signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
-      } else {
-        logMessage(state, context, useTUI, `No repository state found for ${repoName}`, "stderr");
+        break;
       }
+      case "scheduleReconnect":
+        break;
     }
-  };
+  }
+}
+function executeLifecycleEffects(effects, dependencies, token) {
+  const { state, context, useTUI, bucketDependencies, fileSystem } = dependencies;
+  for (const effect of effects) {
+    switch (effect.type) {
+      case "log":
+        logMessage(state, context, useTUI, effect.message, effect.stream);
+        break;
+      case "scheduleReconnect":
+        state.reconnectTimer = setTimeout(() => {
+          connectWebSocket(token, state, bucketDependencies, context, fileSystem, useTUI);
+        }, effect.delayMs);
+        break;
+    }
+  }
 }
 async function shutdown(state, bucketDeps, context) {
   if (state.shuttingDown)
@@ -4608,17 +4847,80 @@ function setupTUI(state, bucketDeps) {
     }
   };
 }
+function createKeypressHandlerState(ui) {
+  const repositoryUrls = {};
+  for (const [name, url] of ui.repositoryUrls) {
+    repositoryUrls[name] = url;
+  }
+  return {
+    selectedIndex: ui.selectedIndex,
+    repositories: ui.repositories,
+    repositoryUrls
+  };
+}
+function executeKeypressEffects(ui, effects, onQuit, options) {
+  for (const effect of effects) {
+    switch (effect.type) {
+      case "quit":
+        onQuit();
+        break;
+      case "openBrowser":
+        if (options?.openBrowser) {
+          options.openBrowser(effect.url);
+        }
+        break;
+      case "selectNext":
+        selectNext(ui);
+        ui.scrollOffset = 0;
+        ui.autoScroll = true;
+        break;
+      case "selectPrevious":
+        selectPrevious(ui);
+        ui.scrollOffset = 0;
+        ui.autoScroll = true;
+        break;
+      case "scroll":
+        switch (effect.direction) {
+          case "up":
+            scrollUp(ui, 1);
+            break;
+          case "down":
+            scrollDown(ui, 1);
+            break;
+          case "pageUp":
+            scrollUp(ui, getLogAreaHeight(ui));
+            break;
+          case "pageDown":
+            scrollDown(ui, getLogAreaHeight(ui));
+            break;
+          case "top":
+            scrollToTop(ui);
+            break;
+          case "bottom":
+            scrollToBottom(ui);
+            break;
+        }
+        break;
+    }
+  }
+}
 function createKeypressHandler(useTUI, state, onQuit, options) {
   if (useTUI) {
     return (key) => {
-      const shouldQuit = handleKeyInput(state.ui, key, options);
-      if (shouldQuit)
-        onQuit();
+      const keypressState = createKeypressHandlerState(state.ui);
+      const { effects } = handleKeypress(keypressState, key);
+      executeKeypressEffects(state.ui, effects, onQuit, options);
     };
   }
   return (key) => {
-    if (key === "q" || key === "\x03")
-      onQuit();
+    const keypressState = createKeypressHandlerState(state.ui);
+    const { effects } = handleKeypress(keypressState, key);
+    for (const effect of effects) {
+      if (effect.type === "quit") {
+        onQuit();
+        break;
+      }
+    }
   };
 }
 async function resolveToken(authDeps, context) {
@@ -4868,7 +5170,8 @@ async function bucketAssetUpload(dependencies, uploadDeps = createDefaultUploadD
   }
   const fileBytes = await uploadDeps.readFileBytes(filePath);
   const contentType = getContentType(filePath);
-  const fileName = filePath.split("/").pop();
+  const parts = filePath.split("/");
+  const fileName = parts[parts.length - 1];
   const uploadUrl = `${getDustbucketHost()}/api/assets?repositoryId=${encodeURIComponent(repositoryId)}`;
   try {
     const result = await uploadDeps.uploadFile(uploadUrl, token, fileBytes, contentType, fileName);
@@ -5801,13 +6104,13 @@ function truncateOutput(output) {
   ].join(`
 `);
 }
-async function runSingleCheck(check, cwd, runner, emitEvent) {
+async function runSingleCheck(check, cwd, runner, emitEvent, clock = Date.now) {
   const timeoutMs = check.timeoutMilliseconds ?? DEFAULT_CHECK_TIMEOUT_MS;
   log6(`running check ${check.name}: ${check.command}`);
   emitEvent?.({ type: "check-started", name: check.name });
-  const startTime = Date.now();
+  const startTime = clock();
   const result = await runner.run(check.command, cwd, timeoutMs);
-  const durationMs = Date.now() - startTime;
+  const durationMs = clock() - startTime;
   const status = result.timedOut ? "timed out" : result.exitCode === 0 ? "passed" : "failed";
   log6(`check ${check.name} ${status} (${durationMs}ms)`);
   if (result.exitCode === 0) {
@@ -5833,18 +6136,18 @@ async function runSingleCheck(check, cwd, runner, emitEvent) {
     timeoutSeconds: timeoutMs / 1000
   };
 }
-async function runConfiguredChecks(checks, cwd, runner, emitEvent) {
-  const promises = checks.map((check) => runSingleCheck(check, cwd, runner, emitEvent));
+async function runConfiguredChecks(checks, cwd, runner, emitEvent, clock = Date.now) {
+  const promises = checks.map((check) => runSingleCheck(check, cwd, runner, emitEvent, clock));
   return Promise.all(promises);
 }
-async function runConfiguredChecksSerially(checks, cwd, runner, emitEvent) {
+async function runConfiguredChecksSerially(checks, cwd, runner, emitEvent, clock = Date.now) {
   const results = [];
   for (const check of checks) {
-    results.push(await runSingleCheck(check, cwd, runner, emitEvent));
+    results.push(await runSingleCheck(check, cwd, runner, emitEvent, clock));
   }
   return results;
 }
-async function runValidationCheck(dependencies, emitEvent) {
+async function runValidationCheck(dependencies, emitEvent, clock = Date.now) {
   const outputLines = [];
   const bufferedContext = {
     cwd: dependencies.context.cwd,
@@ -5853,13 +6156,13 @@ async function runValidationCheck(dependencies, emitEvent) {
   };
   log6("running built-in check: dust lint");
   emitEvent?.({ type: "check-started", name: "lint" });
-  const startTime = Date.now();
+  const startTime = clock();
   const result = await lintMarkdown({
     ...dependencies,
     context: bufferedContext,
     arguments: []
   });
-  const durationMs = Date.now() - startTime;
+  const durationMs = clock() - startTime;
   const lintStatus = result.exitCode === 0 ? "passed" : "failed";
   log6(`built-in check dust lint ${lintStatus} (${durationMs}ms)`);
   const output = outputLines.join(`
@@ -5923,7 +6226,7 @@ function displayResults(results, context) {
   context.stdout(`${indicator} ${passed.length}/${results.length} checks passed`);
   return failed.length > 0 ? 1 : 0;
 }
-async function check(dependencies, shellRunner = defaultShellRunner) {
+async function check(dependencies, shellRunner = defaultShellRunner, clock = Date.now) {
   const {
     arguments: commandArguments,
     context,
@@ -5949,18 +6252,18 @@ async function check(dependencies, shellRunner = defaultShellRunner) {
   if (serial) {
     const results2 = [];
     if (hasDustDir) {
-      results2.push(await runValidationCheck(dependencies, context.emitEvent));
+      results2.push(await runValidationCheck(dependencies, context.emitEvent, clock));
     }
-    const configuredResults = await runConfiguredChecksSerially(settings.checks, context.cwd, shellRunner, context.emitEvent);
+    const configuredResults = await runConfiguredChecksSerially(settings.checks, context.cwd, shellRunner, context.emitEvent, clock);
     results2.push(...configuredResults);
     const exitCode2 = displayResults(results2, context);
     return { exitCode: exitCode2 };
   }
   const checkPromises = [];
   if (hasDustDir) {
-    checkPromises.push(runValidationCheck(dependencies, context.emitEvent));
+    checkPromises.push(runValidationCheck(dependencies, context.emitEvent, clock));
   }
-  checkPromises.push(runConfiguredChecks(settings.checks, context.cwd, shellRunner, context.emitEvent));
+  checkPromises.push(runConfiguredChecks(settings.checks, context.cwd, shellRunner, context.emitEvent, clock));
   const promiseResults = await Promise.all(checkPromises);
   const results = [];
   for (const result of promiseResults) {

package/dist/logging/index.d.ts

@@ -65,7 +65,10 @@ export interface LoggingService {
  * Create an isolated logging service instance. All mutable state is
  * encapsulated inside the returned object.
  */
-export declare function createLoggingService(): LoggingService;
+export interface LoggingServiceOptions {
+    stdout?: (line: string) => boolean;
+}
+export declare function createLoggingService(options?: LoggingServiceOptions): LoggingService;
 /**
  * Activate file logging for this command. See {@link LoggingService.enableFileLogs}.
  */

package/dist/logging.js

@@ -60,7 +60,8 @@ class FileSink {
 
 // lib/logging/index.ts
 var DUST_LOG_FILE = "DUST_LOG_FILE";
-function createLoggingService() {
+function createLoggingService(options) {
+  const writeStdout = options?.stdout ?? process.stdout.write.bind(process.stdout);
   let patterns = null;
   let initialized = false;
   let activeFileSink = null;
@@ -90,12 +91,12 @@ function createLoggingService() {
       }
       activeFileSink = sinkForTesting ?? new FileSink(path);
     },
-    createLogger(name, options) {
+    createLogger(name, options2) {
       let perLoggerSink;
-      if (options?.file === false) {
+      if (options2?.file === false) {
         perLoggerSink = null;
-      } else if (typeof options?.file === "string") {
-        perLoggerSink = getOrCreateFileSink(options.file);
+      } else if (typeof options2?.file === "string") {
+        perLoggerSink = getOrCreateFileSink(options2.file);
       }
       return (...messages) => {
         init();
@@ -108,7 +109,7 @@ function createLoggingService() {
           activeFileSink.write(line);
         }
         if (patterns && matchesAny(name, patterns)) {
-          process.stdout.write(line);
+          writeStdout(line);
         }
       };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.84",
+  "version": "0.1.85",
   "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {