@dexto/tui 1.15.0-beta.0 → 1.15.0-beta.1

package/dist/hooks/useDeckState.cjs

@@ -0,0 +1,140 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useDeckState_exports = {};
+__export(useDeckState_exports, {
+  useDeckState: () => useDeckState
+});
+module.exports = __toCommonJS(useDeckState_exports);
+var import_react = require("react");
+var import_chatgpt_rate_limit = require("../utils/chatgpt-rate-limit.js");
+var import_reasoning_variant = require("../utils/reasoning-variant.js");
+var import_deck_state = require("../utils/deck-state.js");
+var import_useContextStats = require("./useContextStats.js");
+var import_useDextoCredits = require("./useDextoCredits.js");
+var import_useElapsedTime = require("./useElapsedTime.js");
+var import_useGitDirtyFiles = require("./useGitDirtyFiles.js");
+var import_useHeldValue = require("./useHeldValue.js");
+var import_useTokenCounter = require("./useTokenCounter.js");
+function useLastRunFailed(agent, sessionId, isProcessing) {
+  const [failed, setFailed] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    if (isProcessing) setFailed(false);
+  }, [isProcessing]);
+  (0, import_react.useEffect)(() => {
+    setFailed(false);
+  }, [sessionId]);
+  (0, import_react.useEffect)(() => {
+    const controller = new AbortController();
+    agent.on(
+      "run:complete",
+      (payload) => {
+        if (payload.sessionId && payload.sessionId !== sessionId) return;
+        setFailed(payload.finishReason === "error");
+      },
+      { signal: controller.signal }
+    );
+    return () => controller.abort();
+  }, [agent, sessionId]);
+  return failed;
+}
+function useDeckState(input) {
+  const { agent, sessionId, ui, approval } = input;
+  const [, setLlmTick] = (0, import_react.useState)(0);
+  const llmConfig = sessionId ? agent.getCurrentLLMConfig(sessionId) : null;
+  const lastRunFailed = useLastRunFailed(agent, sessionId, ui.isProcessing);
+  const mode = (0, import_deck_state.deckMode)({
+    isProcessing: ui.isProcessing,
+    isCancelling: ui.isCancelling,
+    isThinking: ui.isThinking,
+    isCompacting: ui.isCompacting,
+    awaitingUser: approval !== null,
+    toolRunning: input.pendingMessages.some(
+      (m) => m.role === "tool" && m.toolStatus === "running"
+    ),
+    steerCount: input.steerCount,
+    lastRunFailed
+  });
+  const working = ui.isProcessing && approval === null;
+  const paused = ui.copyModeEnabled;
+  const run = (0, import_useElapsedTime.useElapsedTime)({ isActive: working, intervalMs: 1e3, paused });
+  const wait = (0, import_useElapsedTime.useElapsedTime)({ isActive: approval !== null, intervalMs: 1e3, paused });
+  const { formatted: tokens } = (0, import_useTokenCounter.useTokenCounter)({ agent, isActive: working });
+  const shownTokens = (0, import_useHeldValue.useHeldValue)(tokens, paused);
+  const readout = (0, import_deck_state.deckReadout)(mode, {
+    elapsed: mode === "wait" ? wait.formatted : run.formatted,
+    tokens: shownTokens,
+    compacting: ui.isCompacting,
+    steerCount: input.steerCount,
+    permission: (0, import_deck_state.permissionLabel)({
+      isShellMode: input.isShellMode,
+      planModeActive: ui.planModeActive,
+      autoApproveEdits: ui.autoApproveEdits,
+      bypassPermissions: ui.bypassPermissions,
+      configuredMode: agent.getEffectiveConfig(sessionId ?? void 0).permissions.mode
+    }),
+    reasoning: (0, import_reasoning_variant.displayedReasoningVariant)(llmConfig),
+    rateLimitHint: (0, import_chatgpt_rate_limit.resolveChatGPTRateLimitHint)(
+      llmConfig,
+      input.chatgptRateLimitStatus,
+      "short"
+    )
+  });
+  const context = (0, import_useContextStats.useContextStats)(agent, sessionId, () => setLlmTick((prev) => prev + 1));
+  const account = (0, import_useDextoCredits.useDextoAccount)(agent, ui.activeOverlay);
+  const balance = (0, import_useDextoCredits.useDextoCreditBalance)(
+    agent,
+    sessionId,
+    account,
+    ui.activeOverlay === "insufficient-credits"
+  );
+  const turnBaseline = (0, import_react.useRef)({
+    sessionId,
+    account,
+    isProcessing: false,
+    balance: null
+  });
+  turnBaseline.current = (0, import_deck_state.nextTurnBaseline)(turnBaseline.current, {
+    sessionId,
+    account,
+    isProcessing: ui.isProcessing,
+    balance
+  });
+  const dirtyFiles = (0, import_useGitDirtyFiles.useGitDirtyFiles)(agent, input.cwd);
+  return {
+    mode,
+    readout,
+    status: {
+      model: (0, import_deck_state.deckModelId)(llmConfig?.provider ?? null, llmConfig?.model ?? input.modelName),
+      contextUsedTokens: context?.usedTokens ?? null,
+      contextMaxTokens: context?.maxTokens ?? null,
+      where: { kind: "local" },
+      branch: input.branch,
+      dirtyFiles,
+      credits: (0, import_deck_state.deckCredits)({
+        signedIn: account !== null,
+        balance,
+        turnStartBalance: turnBaseline.current.balance
+      })
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDeckState
+});

package/dist/hooks/useDeckState.d.ts

@@ -0,0 +1,20 @@
+import type { CodexRateLimitSnapshot } from '@dexto/core';
+import type { TuiAgentBackend } from '../agent-backend.js';
+import type { ApprovalRequest } from '../components/ApprovalPrompt.js';
+import type { DeckState } from '../signal/index.js';
+import type { Message, UIState } from '../state/types.js';
+export interface DeckStateInput {
+    agent: TuiAgentBackend;
+    sessionId: string | null;
+    modelName: string;
+    ui: UIState;
+    approval: ApprovalRequest | null;
+    pendingMessages: readonly Message[];
+    steerCount: number;
+    branch: string | null;
+    cwd: string;
+    isShellMode: boolean;
+    chatgptRateLimitStatus: CodexRateLimitSnapshot | null;
+}
+export declare function useDeckState(input: DeckStateInput): DeckState;
+//# sourceMappingURL=useDeckState.d.ts.map

package/dist/hooks/useDeckState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeckState.d.ts","sourceRoot":"","sources":["../../src/hooks/useDeckState.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAmB1D,MAAM,WAAW,cAAc;IAC3B,KAAK,EAAE,eAAe,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IACjC,eAAe,EAAE,SAAS,OAAO,EAAE,CAAC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,OAAO,CAAC;IACrB,sBAAsB,EAAE,sBAAsB,GAAG,IAAI,CAAC;CACzD;AA+BD,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,CAuF7D"}

package/dist/hooks/useDeckState.js

@@ -0,0 +1,123 @@
+import { useEffect, useRef, useState } from "react";
+import { resolveChatGPTRateLimitHint } from "../utils/chatgpt-rate-limit.js";
+import { displayedReasoningVariant } from "../utils/reasoning-variant.js";
+import {
+  deckCredits,
+  deckMode,
+  deckModelId,
+  deckReadout,
+  nextTurnBaseline,
+  permissionLabel
+} from "../utils/deck-state.js";
+import { useContextStats } from "./useContextStats.js";
+import { useDextoAccount, useDextoCreditBalance } from "./useDextoCredits.js";
+import { useElapsedTime } from "./useElapsedTime.js";
+import { useGitDirtyFiles } from "./useGitDirtyFiles.js";
+import { useHeldValue } from "./useHeldValue.js";
+import { useTokenCounter } from "./useTokenCounter.js";
+function useLastRunFailed(agent, sessionId, isProcessing) {
+  const [failed, setFailed] = useState(false);
+  useEffect(() => {
+    if (isProcessing) setFailed(false);
+  }, [isProcessing]);
+  useEffect(() => {
+    setFailed(false);
+  }, [sessionId]);
+  useEffect(() => {
+    const controller = new AbortController();
+    agent.on(
+      "run:complete",
+      (payload) => {
+        if (payload.sessionId && payload.sessionId !== sessionId) return;
+        setFailed(payload.finishReason === "error");
+      },
+      { signal: controller.signal }
+    );
+    return () => controller.abort();
+  }, [agent, sessionId]);
+  return failed;
+}
+function useDeckState(input) {
+  const { agent, sessionId, ui, approval } = input;
+  const [, setLlmTick] = useState(0);
+  const llmConfig = sessionId ? agent.getCurrentLLMConfig(sessionId) : null;
+  const lastRunFailed = useLastRunFailed(agent, sessionId, ui.isProcessing);
+  const mode = deckMode({
+    isProcessing: ui.isProcessing,
+    isCancelling: ui.isCancelling,
+    isThinking: ui.isThinking,
+    isCompacting: ui.isCompacting,
+    awaitingUser: approval !== null,
+    toolRunning: input.pendingMessages.some(
+      (m) => m.role === "tool" && m.toolStatus === "running"
+    ),
+    steerCount: input.steerCount,
+    lastRunFailed
+  });
+  const working = ui.isProcessing && approval === null;
+  const paused = ui.copyModeEnabled;
+  const run = useElapsedTime({ isActive: working, intervalMs: 1e3, paused });
+  const wait = useElapsedTime({ isActive: approval !== null, intervalMs: 1e3, paused });
+  const { formatted: tokens } = useTokenCounter({ agent, isActive: working });
+  const shownTokens = useHeldValue(tokens, paused);
+  const readout = deckReadout(mode, {
+    elapsed: mode === "wait" ? wait.formatted : run.formatted,
+    tokens: shownTokens,
+    compacting: ui.isCompacting,
+    steerCount: input.steerCount,
+    permission: permissionLabel({
+      isShellMode: input.isShellMode,
+      planModeActive: ui.planModeActive,
+      autoApproveEdits: ui.autoApproveEdits,
+      bypassPermissions: ui.bypassPermissions,
+      configuredMode: agent.getEffectiveConfig(sessionId ?? void 0).permissions.mode
+    }),
+    reasoning: displayedReasoningVariant(llmConfig),
+    rateLimitHint: resolveChatGPTRateLimitHint(
+      llmConfig,
+      input.chatgptRateLimitStatus,
+      "short"
+    )
+  });
+  const context = useContextStats(agent, sessionId, () => setLlmTick((prev) => prev + 1));
+  const account = useDextoAccount(agent, ui.activeOverlay);
+  const balance = useDextoCreditBalance(
+    agent,
+    sessionId,
+    account,
+    ui.activeOverlay === "insufficient-credits"
+  );
+  const turnBaseline = useRef({
+    sessionId,
+    account,
+    isProcessing: false,
+    balance: null
+  });
+  turnBaseline.current = nextTurnBaseline(turnBaseline.current, {
+    sessionId,
+    account,
+    isProcessing: ui.isProcessing,
+    balance
+  });
+  const dirtyFiles = useGitDirtyFiles(agent, input.cwd);
+  return {
+    mode,
+    readout,
+    status: {
+      model: deckModelId(llmConfig?.provider ?? null, llmConfig?.model ?? input.modelName),
+      contextUsedTokens: context?.usedTokens ?? null,
+      contextMaxTokens: context?.maxTokens ?? null,
+      where: { kind: "local" },
+      branch: input.branch,
+      dirtyFiles,
+      credits: deckCredits({
+        signedIn: account !== null,
+        balance,
+        turnStartBalance: turnBaseline.current.balance
+      })
+    }
+  };
+}
+export {
+  useDeckState
+};

package/dist/hooks/useDextoCredits.cjs

@@ -0,0 +1,81 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useDextoCredits_exports = {};
+__export(useDextoCredits_exports, {
+  useDextoAccount: () => useDextoAccount,
+  useDextoCreditBalance: () => useDextoCreditBalance
+});
+module.exports = __toCommonJS(useDextoCredits_exports);
+var import_react = require("react");
+var import_host = require("../host/index.js");
+function useDextoCreditBalance(agent, sessionId, account, billingOverlayOpen) {
+  const [balance, setBalance] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    setBalance(null);
+  }, [agent, sessionId, account]);
+  (0, import_react.useEffect)(() => {
+    if (account === null) return;
+    let cancelled = false;
+    const refresh = () => {
+      (0, import_host.dextoCreditBalance)().then((next) => {
+        if (!cancelled) setBalance(next);
+      }).catch(() => void 0);
+    };
+    refresh();
+    const controller = new AbortController();
+    agent.on(
+      "llm:response",
+      (payload) => {
+        if (!payload.sessionId || payload.sessionId === sessionId) refresh();
+      },
+      { signal: controller.signal }
+    );
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [agent, sessionId, account, billingOverlayOpen]);
+  return balance;
+}
+function useDextoAccount(agent, recheckKey) {
+  const [account, setAccount] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    let cancelled = false;
+    const check = () => {
+      (0, import_host.currentSignIn)().then((who) => {
+        if (!cancelled) setAccount(who);
+      }).catch(() => {
+        if (!cancelled) setAccount(null);
+      });
+    };
+    check();
+    const controller = new AbortController();
+    agent.on("run:complete", check, { signal: controller.signal });
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [agent, recheckKey]);
+  return account;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDextoAccount,
+  useDextoCreditBalance
+});

package/dist/hooks/useDextoCredits.d.ts

@@ -0,0 +1,14 @@
+import type { TuiAgentBackend } from '../agent-backend.js';
+/**
+ * The credit balance in USD of `account`; null when `account` is null or the balance is not
+ * known. Refetches when `billingOverlayOpen` changes, since a top-up in the browser emits no
+ * agent event.
+ */
+export declare function useDextoCreditBalance(agent: TuiAgentBackend, sessionId: string | null, account: string | null, billingOverlayOpen: boolean): number | null;
+/**
+ * Who is signed in to Dexto, or null. Compared by label, so replacing one account with another
+ * shows up even though the user stays signed in. Checked at start, after each run, and whenever
+ * `recheckKey` changes (the deck passes the active overlay, since /login and /logout are overlays).
+ */
+export declare function useDextoAccount(agent: TuiAgentBackend, recheckKey: string): string | null;
+//# sourceMappingURL=useDextoCredits.d.ts.map

package/dist/hooks/useDextoCredits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDextoCredits.d.ts","sourceRoot":"","sources":["../../src/hooks/useDextoCredits.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG3D;;;;GAIG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,kBAAkB,EAAE,OAAO,GAC5B,MAAM,GAAG,IAAI,CA8Bf;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAsBzF"}

package/dist/hooks/useDextoCredits.js

@@ -0,0 +1,56 @@
+import { useEffect, useState } from "react";
+import { currentSignIn, dextoCreditBalance } from "../host/index.js";
+function useDextoCreditBalance(agent, sessionId, account, billingOverlayOpen) {
+  const [balance, setBalance] = useState(null);
+  useEffect(() => {
+    setBalance(null);
+  }, [agent, sessionId, account]);
+  useEffect(() => {
+    if (account === null) return;
+    let cancelled = false;
+    const refresh = () => {
+      dextoCreditBalance().then((next) => {
+        if (!cancelled) setBalance(next);
+      }).catch(() => void 0);
+    };
+    refresh();
+    const controller = new AbortController();
+    agent.on(
+      "llm:response",
+      (payload) => {
+        if (!payload.sessionId || payload.sessionId === sessionId) refresh();
+      },
+      { signal: controller.signal }
+    );
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [agent, sessionId, account, billingOverlayOpen]);
+  return balance;
+}
+function useDextoAccount(agent, recheckKey) {
+  const [account, setAccount] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    const check = () => {
+      currentSignIn().then((who) => {
+        if (!cancelled) setAccount(who);
+      }).catch(() => {
+        if (!cancelled) setAccount(null);
+      });
+    };
+    check();
+    const controller = new AbortController();
+    agent.on("run:complete", check, { signal: controller.signal });
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [agent, recheckKey]);
+  return account;
+}
+export {
+  useDextoAccount,
+  useDextoCreditBalance
+};

package/dist/hooks/useDextoCredits.test.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var import_react = require("react");
+var import_node_stream = require("node:stream");
+var import_ink = require("ink");
+var import_vitest = require("vitest");
+var import_host = require("../host/index.js");
+var import_useDextoCredits = require("./useDextoCredits.js");
+import_vitest.vi.mock("../host/index.js", () => ({
+  currentSignIn: import_vitest.vi.fn(),
+  dextoCreditBalance: import_vitest.vi.fn()
+}));
+const balanceMock = import_vitest.vi.mocked(import_host.dextoCreditBalance);
+const agent = { on: import_vitest.vi.fn() };
+const tick = () => new Promise((resolve) => setTimeout(resolve, 10));
+(0, import_vitest.describe)("useDextoCreditBalance", () => {
+  (0, import_vitest.beforeEach)(() => balanceMock.mockReset());
+  (0, import_vitest.it)("refetches when billing recovery closes, keeping the old balance until it arrives", async () => {
+    const seen = [];
+    const Probe = ({ billingOpen }) => {
+      seen.push((0, import_useDextoCredits.useDextoCreditBalance)(agent, "s1", "ada", billingOpen));
+      return (0, import_react.createElement)(import_ink.Text, null, "x");
+    };
+    const stdout = Object.assign(new import_node_stream.PassThrough(), { columns: 40, rows: 10, isTTY: false });
+    const options = {
+      stdout,
+      debug: true,
+      patchConsole: false,
+      exitOnCtrlC: false
+    };
+    balanceMock.mockResolvedValue(0);
+    const view = (0, import_ink.render)((0, import_react.createElement)(Probe, { billingOpen: true }), options);
+    await tick();
+    (0, import_vitest.expect)(seen.at(-1)).toBe(0);
+    balanceMock.mockResolvedValue(25);
+    const before = seen.length;
+    view.rerender((0, import_react.createElement)(Probe, { billingOpen: false }));
+    await tick();
+    view.unmount();
+    (0, import_vitest.expect)(seen.slice(before)).not.toContain(null);
+    (0, import_vitest.expect)(seen.at(-1)).toBe(25);
+  });
+  (0, import_vitest.it)("drops the old balance and refetches when another account signs in", async () => {
+    const seen = [];
+    const Probe = ({ account }) => {
+      seen.push((0, import_useDextoCredits.useDextoCreditBalance)(agent, "s1", account, false));
+      return (0, import_react.createElement)(import_ink.Text, null, "x");
+    };
+    const stdout = Object.assign(new import_node_stream.PassThrough(), { columns: 40, rows: 10, isTTY: false });
+    const options = {
+      stdout,
+      debug: true,
+      patchConsole: false,
+      exitOnCtrlC: false
+    };
+    balanceMock.mockResolvedValue(12);
+    const view = (0, import_ink.render)((0, import_react.createElement)(Probe, { account: "ada" }), options);
+    await tick();
+    (0, import_vitest.expect)(seen.at(-1)).toBe(12);
+    let resolveBalance = () => void 0;
+    balanceMock.mockReturnValue(
+      new Promise((resolve) => {
+        resolveBalance = resolve;
+      })
+    );
+    view.rerender((0, import_react.createElement)(Probe, { account: "grace" }));
+    await tick();
+    (0, import_vitest.expect)(seen.at(-1)).toBeNull();
+    resolveBalance(5);
+    await tick();
+    view.unmount();
+    (0, import_vitest.expect)(seen.at(-1)).toBe(5);
+  });
+});

package/dist/hooks/useDextoCredits.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useDextoCredits.test.d.ts.map

package/dist/hooks/useDextoCredits.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDextoCredits.test.d.ts","sourceRoot":"","sources":["../../src/hooks/useDextoCredits.test.ts"],"names":[],"mappings":""}

package/dist/hooks/useDextoCredits.test.js

@@ -0,0 +1,72 @@
+import { createElement } from "react";
+import { PassThrough } from "node:stream";
+import { render, Text } from "ink";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { dextoCreditBalance } from "../host/index.js";
+import { useDextoCreditBalance } from "./useDextoCredits.js";
+vi.mock("../host/index.js", () => ({
+  currentSignIn: vi.fn(),
+  dextoCreditBalance: vi.fn()
+}));
+const balanceMock = vi.mocked(dextoCreditBalance);
+const agent = { on: vi.fn() };
+const tick = () => new Promise((resolve) => setTimeout(resolve, 10));
+describe("useDextoCreditBalance", () => {
+  beforeEach(() => balanceMock.mockReset());
+  it("refetches when billing recovery closes, keeping the old balance until it arrives", async () => {
+    const seen = [];
+    const Probe = ({ billingOpen }) => {
+      seen.push(useDextoCreditBalance(agent, "s1", "ada", billingOpen));
+      return createElement(Text, null, "x");
+    };
+    const stdout = Object.assign(new PassThrough(), { columns: 40, rows: 10, isTTY: false });
+    const options = {
+      stdout,
+      debug: true,
+      patchConsole: false,
+      exitOnCtrlC: false
+    };
+    balanceMock.mockResolvedValue(0);
+    const view = render(createElement(Probe, { billingOpen: true }), options);
+    await tick();
+    expect(seen.at(-1)).toBe(0);
+    balanceMock.mockResolvedValue(25);
+    const before = seen.length;
+    view.rerender(createElement(Probe, { billingOpen: false }));
+    await tick();
+    view.unmount();
+    expect(seen.slice(before)).not.toContain(null);
+    expect(seen.at(-1)).toBe(25);
+  });
+  it("drops the old balance and refetches when another account signs in", async () => {
+    const seen = [];
+    const Probe = ({ account }) => {
+      seen.push(useDextoCreditBalance(agent, "s1", account, false));
+      return createElement(Text, null, "x");
+    };
+    const stdout = Object.assign(new PassThrough(), { columns: 40, rows: 10, isTTY: false });
+    const options = {
+      stdout,
+      debug: true,
+      patchConsole: false,
+      exitOnCtrlC: false
+    };
+    balanceMock.mockResolvedValue(12);
+    const view = render(createElement(Probe, { account: "ada" }), options);
+    await tick();
+    expect(seen.at(-1)).toBe(12);
+    let resolveBalance = () => void 0;
+    balanceMock.mockReturnValue(
+      new Promise((resolve) => {
+        resolveBalance = resolve;
+      })
+    );
+    view.rerender(createElement(Probe, { account: "grace" }));
+    await tick();
+    expect(seen.at(-1)).toBeNull();
+    resolveBalance(5);
+    await tick();
+    view.unmount();
+    expect(seen.at(-1)).toBe(5);
+  });
+});

package/dist/hooks/useElapsedTime.cjs

@@ -39,35 +39,24 @@ function formatElapsedTime(ms) {
 }
 function useElapsedTime({
   isActive,
-  intervalMs = 100
+  intervalMs = 100,
+  paused = false
 }) {
   const [elapsedMs, setElapsedMs] = (0, import_react.useState)(0);
   const startTimeRef = (0, import_react.useRef)(null);
-  const intervalRef = (0, import_react.useRef)(null);
   (0, import_react.useEffect)(() => {
-    if (isActive) {
-      startTimeRef.current = Date.now();
-      setElapsedMs(0);
-      intervalRef.current = setInterval(() => {
-        if (startTimeRef.current !== null) {
-          setElapsedMs(Date.now() - startTimeRef.current);
-        }
-      }, intervalMs);
-    } else {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
-      }
-      startTimeRef.current = null;
-      setElapsedMs(0);
-    }
-    return () => {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
+    startTimeRef.current = isActive ? Date.now() : null;
+    setElapsedMs(0);
+  }, [isActive]);
+  (0, import_react.useEffect)(() => {
+    if (!isActive || paused) return;
+    const interval = setInterval(() => {
+      if (startTimeRef.current !== null) {
+        setElapsedMs(Date.now() - startTimeRef.current);
       }
-    };
-  }, [isActive, intervalMs]);
+    }, intervalMs);
+    return () => clearInterval(interval);
+  }, [isActive, paused, intervalMs]);
   return {
     elapsedMs,
     formatted: formatElapsedTime(elapsedMs)

package/dist/hooks/useElapsedTime.d.ts

@@ -7,6 +7,8 @@ export interface ElapsedTimeOptions {
     isActive: boolean;
     /** Update interval in milliseconds (default: 100ms) */
     intervalMs?: number;
+    /** Hold the shown value without redrawing; time still counts (default: false) */
+    paused?: boolean;
 }
 export interface ElapsedTimeResult {
     /** Elapsed time in milliseconds */
@@ -20,5 +22,5 @@ export interface ElapsedTimeResult {
  * @param options - Configuration options
  * @returns Elapsed time in ms and formatted string
  */
-export declare function useElapsedTime({ isActive, intervalMs, }: ElapsedTimeOptions): ElapsedTimeResult;
+export declare function useElapsedTime({ isActive, intervalMs, paused, }: ElapsedTimeOptions): ElapsedTimeResult;
 //# sourceMappingURL=useElapsedTime.d.ts.map

package/dist/hooks/useElapsedTime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useElapsedTime.d.ts","sourceRoot":"","sources":["../../src/hooks/useElapsedTime.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,kBAAkB;IAC/B,mEAAmE;IACnE,QAAQ,EAAE,OAAO,CAAC;IAClB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAC9B,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;CACrB;AA4BD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAC3B,QAAQ,EACR,UAAgB,GACnB,EAAE,kBAAkB,GAAG,iBAAiB,CAuCxC"}
+{"version":3,"file":"useElapsedTime.d.ts","sourceRoot":"","sources":["../../src/hooks/useElapsedTime.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,kBAAkB;IAC/B,mEAAmE;IACnE,QAAQ,EAAE,OAAO,CAAC;IAClB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAC9B,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;CACrB;AA4BD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAC3B,QAAQ,EACR,UAAgB,EAChB,MAAc,GACjB,EAAE,kBAAkB,GAAG,iBAAiB,CAuBxC"}