The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 22:15 UTC
fix(server): usage no longer waits on Muse home discovery (#30859)
Julius Marminge committed
Nov 11, 2026 at 15:22 UTC
8e89fe191808d3595c3d047f63fe63c9598a2e22
6 files changed
+233
-65
apps/server/src/usage/UsageService.test.ts
+63
-1
@@ -12,6 +12,7 @@ import { vi } from "vite-plus/test";
12
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
13
import * as NodeServices from "@effect/platform-node/NodeServices";
14
import * as HostProcess from "@t3tools/shared/HostProcess";
15
+import { SpawnExecutableResolution } from "@t3tools/shared/shell";
16
import { mergeUsage } from "@t3tools/shared/usageMerge";
17
import {
18
EnvironmentId,
@@ -1120,7 +1121,7 @@ describe("UsageService", () => {
1121
};
1122
const muse = (summary: UsageSummary) =>
1123
summary.buckets.filter((bucket) => bucket.provider === "muse");
1123
- const first = yield* service.readSummary(window);
1124
+ const first = yield* service.readSummary({ ...window, awaitRefresh: true });
1125
const buckets = muse(first);
1126
assert.strictEqual(
1127
buckets.reduce((sum, b) => sum + b.records, 0),
@@ -1202,6 +1203,7 @@ describe("UsageService", () => {
1203
assert.closeTo(repriced?.costUsd ?? NaN, 0.000486, 1e-12);
1204
}).pipe(
1205
Effect.scoped,
1206
+ Effect.provideService(SpawnExecutableResolution, (command: string) => command),
1207
Effect.provide(
1208
layerService({
1209
prefix: "usage-muse",
@@ -1235,6 +1237,66 @@ describe("UsageService", () => {
1237
}).pipe(Effect.scoped),
1238
);
1239
1240
+ it.live("returns other providers' usage while Muse home discovery is still pending", () =>
1241
+ Effect.gen(function* () {
1242
+ const { transcript, settings, home } = yield* setup;
1243
+ yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
1244
+ const museStarted = yield* Deferred.make<void>();
1245
+ const museReady = yield* Deferred.make<MuseSdk.MuseSdkHost>();
1246
+ const museHome = NodePath.join(home, "muse");
1247
+ yield* Effect.promise(() =>
1248
+ NodeFSP.mkdir(NodePath.join(museHome, "sessions"), { recursive: true }),
1249
+ );
1250
+ using _create = vi
1251
+ .spyOn(MuseSdk, "createMuseSdkHostEffect")
1252
+ .mockImplementation(() =>
1253
+ Deferred.succeed(museStarted, undefined).pipe(Effect.andThen(Deferred.await(museReady))),
1254
+ );
1255
+ const museSources = (summary: UsageSummary) =>
1256
+ summary.sources
1257
+ .filter((source) => source.fingerprint.provider === "muse")
1258
+ .map((source) => [source.fingerprint.resolvedHomePath, source.status, source.refreshing]);
1259
+ const [pending, refreshed] = yield* Effect.gen(function* () {
1260
+ const service = yield* UsageService.make;
1261
+ const read = yield* Effect.forkChild(service.readSummary(WINDOW));
1262
+ yield* Deferred.await(museStarted);
1263
+ const pending = yield* Fiber.join(read);
1264
+ const refresh = yield* Effect.forkChild(
1265
+ service.readSummary({ ...WINDOW, awaitRefresh: true }),
1266
+ );
1267
+ yield* Deferred.succeed(museReady, {
1268
+ initializeResult: { grantedCapabilities: [], museHome },
1269
+ close: async () => {},
1270
+ } as unknown as MuseSdk.MuseSdkHost);
1271
+ return [pending, yield* Fiber.join(refresh)] as const;
1272
+ }).pipe(
1273
+ Effect.scoped,
1274
+ Effect.provideService(SpawnExecutableResolution, (command: string) => command),
1275
+ Effect.provide(
1276
+ layerService({
1277
+ prefix: "usage-muse-pending",
1278
+ home,
1279
+ settings: {
1280
+ ...settings,
1281
+ providerInstances: {
1282
+ ...settings.providerInstances,
1283
+ [ProviderInstanceId.make("muse")]: {
1284
+ driver: ProviderDriverKind.make("muse"),
1285
+ enabled: false,
1286
+ },
1287
+ },
1288
+ },
1289
+ }),
1290
+ ),
1291
+ );
1292
+ assert.strictEqual(totalOutputTokens(pending), 5);
1293
+ assert.deepStrictEqual(museSources(pending), [["muse", "ok", true]]);
1294
+ assert.deepStrictEqual(museSources(refreshed), [
1295
+ [NodePath.join(museHome, "sessions"), "ok", undefined],
1296
+ ]);
1297
+ }).pipe(Effect.scoped),
1298
+ );
1299
+
1300
it.live("reports missing Pi history and skips malformed records without losing valid usage", () =>
1301
Effect.gen(function* () {
1302
const { home, settings } = yield* setup;
apps/server/src/usage/UsageService.ts
+18
-7
@@ -330,16 +330,25 @@ export const make = Effect.gen(function* () {
330
const resolveTranscriptDirs = Effect.fn("UsageService.resolveTranscriptDirs")(function* (
331
settings: ServerSettingsValue,
332
retentionCutoffMs: number,
333
+ awaitRefresh: boolean,
334
) {
335
const dirs: Array<TranscriptSource> = [];
336
+ const pending: Array<ScannedDir> = [];
337
const seen = new Set<string>();
338
for (const { driver, reader } of transcriptReaders) {
339
const { provider, format } = reader;
340
const directories = yield* Effect.forEach(
341
yield* usageInstances(driver, settings),
340
- (instance) => reader.directories(instance),
342
+ (instance) => reader.directories(instance, { awaitRefresh }),
343
);
342
- for (const { dir: directory, fileName } of directories.flat()) {
344
+ for (const { dir: directory, fileName, refreshing } of directories.flat()) {
345
+ if (refreshing) {
346
+ const key = `${provider}\0${directory}`;
347
+ if (seen.has(key)) continue;
348
+ seen.add(key);
349
+ pending.push({ provider, dir: directory, volumeId: "", files: [], refreshing });
350
+ continue;
351
+ }
352
const sourceKey = provider + "\0" + directory;
353
const previous = sourceCache.get(sourceKey);
354
const dir = yield* fileSystem
@@ -375,7 +384,7 @@ export const make = Effect.gen(function* () {
384
});
385
}
386
}
378
- return dirs;
387
+ return { dirs, pending };
388
});
389
390
// Share first loads so concurrent readers cannot scan against a still-empty cache.
@@ -654,9 +663,11 @@ export const make = Effect.gen(function* () {
663
retentionCutoffMs: number,
664
awaitRefresh: boolean,
665
) {
657
- const dirs = yield* resolveTranscriptDirs(settings, retentionCutoffMs).pipe(
658
- Effect.provideContext(readerContext),
659
- );
666
+ const { dirs, pending } = yield* resolveTranscriptDirs(
667
+ settings,
668
+ retentionCutoffMs,
669
+ awaitRefresh,
670
+ ).pipe(Effect.provideContext(readerContext));
671
672
const scans = Effect.forEach(
673
scanReaders,
@@ -690,7 +701,7 @@ export const make = Effect.gen(function* () {
701
[Effect.forEach(dirs, (dir) => scanTranscriptDir(dir, windowStartMs)), scans],
702
{ concurrency: "unbounded" },
703
);
693
- const scanned: readonly ScannedDir[] = [...transcripts, ...scanDirs.flat()];
704
+ const scanned: readonly ScannedDir[] = [...transcripts, ...pending, ...scanDirs.flat()];
705
return scanned;
706
});
707
packages/provider-core/src/server/usage.ts
+7
-1
@@ -111,10 +111,16 @@ export type ProviderUsageReader<Config, R> =
111
readonly resolveServiceTiers?: (
112
records: readonly UsageRecord[],
113
) => Effect.Effect<ReadonlyMap<UsageRecord, UsageSpeed>, never, R>;
114
+ /** A `refreshing` entry is not scanned; it reports its source as still being located. */
115
readonly directories: (
116
instance: ProviderUsageInstance<Config>,
117
+ options: { readonly awaitRefresh: boolean },
118
) => Effect.Effect<
117
- ReadonlyArray<{ readonly dir: string; readonly fileName?: string }>,
119
+ ReadonlyArray<{
120
+ readonly dir: string;
121
+ readonly fileName?: string;
122
+ readonly refreshing?: true;
123
+ }>,
124
never,
125
R
126
>;
packages/provider-muse/src/server/MuseUsageHome.ts
+28
-8
@@ -4,24 +4,32 @@ import * as Duration from "effect/Duration";
4
import * as Effect from "effect/Effect";
5
import * as Exit from "effect/Exit";
6
import * as Layer from "effect/Layer";
7
+import * as Option from "effect/Option";
8
+
9
+import * as HostProcess from "@t3tools/shared/HostProcess";
10
+import { SpawnExecutableResolution } from "@t3tools/shared/shell";
11
12
import { createMuseSdkHostEffect, MuseSdkError } from "./sdk.ts";
13
14
export class MuseUsageHome extends Context.Service<
15
MuseUsageHome,
16
{
17
+ /** None while discovery is still running and `awaitRefresh` is false. */
18
readonly resolve: (input: {
19
readonly binaryPath: string;
20
readonly environment: NodeJS.ProcessEnv;
16
- }) => Effect.Effect<string | undefined>;
21
+ readonly awaitRefresh: boolean;
22
+ }) => Effect.Effect<Option.Option<string | undefined>>;
23
}
24
>()("@t3tools/provider-muse/server/MuseUsageHome") {}
25
26
const make = Effect.gen(function* () {
27
+ const scope = yield* Effect.scope;
28
const cache = yield* Cache.makeWith(
22
- Effect.fn("MuseUsageHome.initialize")(function* (
23
- input: Parameters<MuseUsageHome["Service"]["resolve"]>[0],
24
- ) {
29
+ Effect.fn("MuseUsageHome.initialize")(function* (input: {
30
+ readonly binaryPath: string;
31
+ readonly environment: NodeJS.ProcessEnv;
32
+ }) {
33
return yield* Effect.scoped(
34
Effect.gen(function* () {
35
const host = yield* Effect.acquireRelease(
@@ -35,7 +43,7 @@ const make = Effect.gen(function* () {
43
);
44
return host.initializeResult.museHome;
45
}),
38
- );
46
+ ).pipe(Effect.orElseSucceed(() => undefined));
47
}),
48
{
49
capacity: 32,
@@ -45,15 +53,27 @@ const make = Effect.gen(function* () {
53
},
54
);
55
const resolve: MuseUsageHome["Service"]["resolve"] = Effect.fn("MuseUsageHome.resolve")(
48
- function* ({ binaryPath, environment }) {
56
+ function* ({ binaryPath, environment, awaitRefresh }) {
57
// Cache keys compare structurally. Omitted and undefined variables both
58
// disappear from the child process environment and must share an entry.
51
- return yield* Cache.get(cache, {
59
+ const key = {
60
binaryPath,
61
environment: Object.fromEntries(
62
Object.entries(environment).filter(([, value]) => value !== undefined),
63
),
56
- }).pipe(Effect.orElseSucceed(() => undefined));
64
+ };
65
+ const settled = yield* Cache.getSuccess(cache, key);
66
+ if (Option.isSome(settled)) return settled;
67
+ // Spawn failures surface asynchronously; without this a missing CLI would report as pending.
68
+ const resolveExecutable = yield* SpawnExecutableResolution;
69
+ if (resolveExecutable(binaryPath, yield* HostProcess.Platform, environment) === undefined) {
70
+ return Option.some(undefined);
71
+ }
72
+ if (awaitRefresh) return Option.some(yield* Cache.get(cache, key));
73
+ // Awaited in the layer scope so a departing caller cannot cancel discovery.
74
+ yield* Effect.forkIn(Cache.get(cache, key), scope, { startImmediately: true });
75
+ // A lookup that settled synchronously needs no refresh.
76
+ return yield* Cache.getSuccess(cache, key);
77
},
78
);
79
return MuseUsageHome.of({ resolve });
packages/provider-muse/src/server/usage.test.ts
+106
-45
@@ -2,6 +2,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
2
import { ProviderInstanceId } from "@t3tools/contracts";
3
import { totalTokens } from "@t3tools/provider-core/server/usage";
4
import * as HostProcess from "@t3tools/shared/HostProcess";
5
+import { SpawnExecutableResolution } from "@t3tools/shared/shell";
6
import * as Effect from "effect/Effect";
7
import * as Deferred from "effect/Deferred";
8
import * as Fiber from "effect/Fiber";
@@ -190,6 +191,9 @@ it("handles malformed and partial data and rejects unsupported timestamps or sch
191
).toEqual([]);
192
});
193
194
+const AWAIT_REFRESH = { awaitRefresh: true };
195
+const onPath = Effect.provideService(SpawnExecutableResolution, (command: string) => command);
196
+
197
describe("Muse history discovery", () => {
198
it.effect.each([undefined, "/custom/xdg-data"])(
199
"uses the initialized home with XDG_DATA_HOME=%s and closes without starting a session",
@@ -204,12 +208,15 @@ describe("Muse history discovery", () => {
208
} as unknown as MuseSdk.MuseSdkHost),
209
);
210
if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
207
- const directories = yield* museUsageReader.directories({
208
- instanceId: ProviderInstanceId.make("muse-other"),
209
- configured: true,
210
- config: decodeSettings({ binaryPath: "~/bin/custom-muse" }),
211
- environment: { XDG_DATA_HOME: xdg, MUSE_NO_AUTO_UPDATE: "0" },
212
- });
211
+ const directories = yield* museUsageReader.directories(
212
+ {
213
+ instanceId: ProviderInstanceId.make("muse-other"),
214
+ configured: true,
215
+ config: decodeSettings({ binaryPath: "~/bin/custom-muse" }),
216
+ environment: { XDG_DATA_HOME: xdg, MUSE_NO_AUTO_UPDATE: "0" },
217
+ },
218
+ AWAIT_REFRESH,
219
+ );
220
expect(directories).toEqual([
221
{ dir: path.join("/native/configured-home", "sessions"), fileName: "session.jsonl" },
222
]);
@@ -226,6 +233,7 @@ describe("Muse history discovery", () => {
233
expect(close).toHaveBeenCalledOnce();
234
}).pipe(
235
Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
236
+ onPath,
237
Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
238
Effect.provideService(HostProcess.Environment, {
239
PATH: "/host/bin",
@@ -234,6 +242,27 @@ describe("Muse history discovery", () => {
242
),
243
);
244
245
+ it.effect("reports no history without starting Muse when its CLI is not installed", () =>
246
+ Effect.gen(function* () {
247
+ using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect");
248
+ if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
249
+ const directories = yield* museUsageReader.directories(
250
+ {
251
+ instanceId: ProviderInstanceId.make("muse"),
252
+ configured: false,
253
+ config: undefined,
254
+ environment: {},
255
+ },
256
+ { awaitRefresh: false },
257
+ );
258
+ expect(directories).toEqual([]);
259
+ expect(create).not.toHaveBeenCalled();
260
+ }).pipe(
261
+ Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
262
+ Effect.provideService(SpawnExecutableResolution, () => undefined),
263
+ ),
264
+ );
265
+
266
it.effect("does not guess a directory when initialization fails", () =>
267
Effect.gen(function* () {
268
using _create = vi
@@ -244,14 +273,17 @@ describe("Muse history discovery", () => {
273
),
274
);
275
if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader");
247
- const directories = yield* museUsageReader.directories({
248
- instanceId: ProviderInstanceId.make("muse"),
249
- configured: false,
250
- config: undefined,
251
- environment: {},
252
- });
276
+ const directories = yield* museUsageReader.directories(
277
+ {
278
+ instanceId: ProviderInstanceId.make("muse"),
279
+ configured: false,
280
+ config: undefined,
281
+ environment: {},
282
+ },
283
+ AWAIT_REFRESH,
284
+ );
285
expect(directories).toEqual([]);
254
- }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
286
+ }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath),
287
);
288
289
it.effect(
@@ -273,21 +305,24 @@ describe("Muse history discovery", () => {
305
config: decodeSettings({ binaryPath: "~/bin/muse", enabled: false }),
306
environment: { PATH: "/bin", XDG_DATA_HOME: "/data" },
307
};
276
- const first = yield* museUsageReader.directories(instance);
277
- const second = yield* museUsageReader.directories({
278
- ...instance,
279
- instanceId: ProviderInstanceId.make("another-account"),
280
- config: decodeSettings({
281
- binaryPath: path.join("/test-home", "bin/muse"),
282
- enabled: true,
283
- }),
284
- environment: {
285
- XDG_DATA_HOME: "/data",
286
- PATH: "/bin",
287
- UNUSED: undefined,
288
- META_API_KEY: "ignored",
308
+ const first = yield* museUsageReader.directories(instance, AWAIT_REFRESH);
309
+ const second = yield* museUsageReader.directories(
310
+ {
311
+ ...instance,
312
+ instanceId: ProviderInstanceId.make("another-account"),
313
+ config: decodeSettings({
314
+ binaryPath: path.join("/test-home", "bin/muse"),
315
+ enabled: true,
316
+ }),
317
+ environment: {
318
+ XDG_DATA_HOME: "/data",
319
+ PATH: "/bin",
320
+ UNUSED: undefined,
321
+ META_API_KEY: "ignored",
322
+ },
323
},
290
- });
324
+ AWAIT_REFRESH,
325
+ );
326
expect(second).toEqual(first);
327
expect(first).toEqual([
328
{ dir: path.join("/native/home", "sessions"), fileName: "session.jsonl" },
@@ -296,6 +331,7 @@ describe("Muse history discovery", () => {
331
expect(close).toHaveBeenCalledOnce();
332
}).pipe(
333
Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
334
+ onPath,
335
Effect.provideService(HostProcess.HomeDirectory, "/test-home"),
336
Effect.provideService(HostProcess.Environment, {}),
337
),
@@ -318,20 +354,26 @@ describe("Muse history discovery", () => {
354
config: undefined,
355
environment: {},
356
};
321
- const first = yield* museUsageReader.directories(instance);
357
+ const first = yield* museUsageReader.directories(instance, AWAIT_REFRESH);
358
expect(
323
- yield* museUsageReader.directories({
324
- ...instance,
325
- config: decodeSettings({ binaryPath: "custom-muse" }),
326
- }),
359
+ yield* museUsageReader.directories(
360
+ {
361
+ ...instance,
362
+ config: decodeSettings({ binaryPath: "custom-muse" }),
363
+ },
364
+ AWAIT_REFRESH,
365
+ ),
366
).toEqual(first);
328
- const changed = yield* museUsageReader.directories({
329
- ...instance,
330
- environment: { XDG_DATA_HOME: "/other-data" },
331
- });
367
+ const changed = yield* museUsageReader.directories(
368
+ {
369
+ ...instance,
370
+ environment: { XDG_DATA_HOME: "/other-data" },
371
+ },
372
+ AWAIT_REFRESH,
373
+ );
374
expect(changed).not.toEqual(first);
375
const inherited = yield* museUsageReader
334
- .directories(instance)
376
+ .directories(instance, AWAIT_REFRESH)
377
.pipe(
378
Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/new-host-data" }),
379
);
@@ -340,11 +382,12 @@ describe("Muse history discovery", () => {
382
expect(create).toHaveBeenCalledTimes(4);
383
}).pipe(
384
Effect.provide([NodeServices.layer, MuseUsageHome.layer]),
385
+ onPath,
386
Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/host-data" }),
387
),
388
);
389
347
- it.effect("shares pending initialization across concurrent directory reads", () =>
390
+ it.effect("reports pending discovery without waiting and shares it with awaiting reads", () =>
391
Effect.gen(function* () {
392
const started = yield* Deferred.make<void>();
393
const ready = yield* Deferred.make<MuseSdk.MuseSdkHost>();
@@ -361,11 +404,21 @@ describe("Muse history discovery", () => {
404
config: undefined,
405
environment: {},
406
};
407
+ const pending = [{ dir: "muse", refreshing: true }];
408
+ expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(
409
+ pending,
410
+ );
411
+ yield* Deferred.await(started);
412
const reads = yield* Effect.all(
365
- [museUsageReader.directories(instance), museUsageReader.directories(instance)],
413
+ [
414
+ museUsageReader.directories(instance, AWAIT_REFRESH),
415
+ museUsageReader.directories(instance, AWAIT_REFRESH),
416
+ ],
417
{ concurrency: "unbounded" },
418
).pipe(Effect.forkChild);
368
- yield* Deferred.await(started);
419
+ expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(
420
+ pending,
421
+ );
422
yield* Deferred.succeed(ready, {
423
initializeResult: { museHome: "/native/home" },
424
close,
@@ -373,9 +426,17 @@ describe("Muse history discovery", () => {
426
const [first, second] = yield* Fiber.join(reads);
427
expect(first).toEqual(second);
428
expect(first).toHaveLength(1);
429
+ expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(first);
430
+ const uninstalled = Effect.provideService(SpawnExecutableResolution, () => undefined);
431
+ expect(
432
+ yield* museUsageReader.directories(instance, { awaitRefresh: false }).pipe(uninstalled),
433
+ ).toEqual(first);
434
+ expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH).pipe(uninstalled)).toEqual(
435
+ first,
436
+ );
437
expect(create).toHaveBeenCalledOnce();
438
expect(close).toHaveBeenCalledOnce();
378
- }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
439
+ }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath),
440
);
441
442
it.effect("briefly caches failed discovery and retries after installation recovers", () =>
@@ -400,12 +461,12 @@ describe("Muse history discovery", () => {
461
config: undefined,
462
environment: {},
463
};
403
- expect(yield* museUsageReader.directories(instance)).toEqual([]);
404
- expect(yield* museUsageReader.directories(instance)).toEqual([]);
464
+ expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH)).toEqual([]);
465
+ expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual([]);
466
expect(create).toHaveBeenCalledOnce();
467
yield* TestClock.adjust("30 seconds");
407
- expect(yield* museUsageReader.directories(instance)).toHaveLength(1);
468
+ expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH)).toHaveLength(1);
469
expect(create).toHaveBeenCalledTimes(2);
409
- }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer])),
470
+ }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath),
471
);
472
});
packages/provider-muse/src/server/usage.ts
+11
-3
@@ -121,7 +121,10 @@ export const museUsageReader: ProviderUsageReader<
121
kind: "transcripts",
122
provider: "muse",
123
format: museUsageFormat,
124
- directories: Effect.fn("museUsageReader.directories")(function* ({ config, environment }) {
124
+ directories: Effect.fn("museUsageReader.directories")(function* (
125
+ { config, environment },
126
+ { awaitRefresh },
127
+ ) {
128
const path = yield* Path.Path;
129
const home = yield* HostProcess.HomeDirectory;
130
const usageHome = yield* MuseUsageHome.MuseUsageHome;
@@ -131,10 +134,15 @@ export const museUsageReader: ProviderUsageReader<
134
),
135
yield* HostProcess.Environment,
136
);
137
+ const binaryPath = expandHomePath(config?.binaryPath ?? "muse", home);
138
const museHome = yield* usageHome.resolve({
135
- binaryPath: expandHomePath(config?.binaryPath ?? "muse", home),
139
+ binaryPath,
140
environment: makeMuseEnvironment(processEnvironment),
141
+ awaitRefresh,
142
});
138
- return museHome ? [{ dir: path.join(museHome, "sessions"), fileName: "session.jsonl" }] : [];
143
+ if (Option.isNone(museHome)) return [{ dir: binaryPath, refreshing: true }];
144
+ return museHome.value
145
+ ? [{ dir: path.join(museHome.value, "sessions"), fileName: "session.jsonl" }]
146
+ : [];
147
}),
148
};