@audiofool/moondog 0.1.0 → 0.2.0-beta.3

package/scripts/moondog.mjs

@@ -2,6 +2,8 @@
 
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { createApplicationUpdater } from "../src/core/application-update.mjs";
+import { runUpdateCommand } from "../src/surfaces/cli/update-command.mjs";
 
 import { MoondogApplication } from "../src/core/moondog-application.mjs";
 import { openLocalMemoryStore } from "../src/memory/local-memory-store.mjs";
@@ -13,6 +15,8 @@ import { readAppleMusicSourceStatus } from "../src/core/apple-library-source-sta
 import { createListeningProfileDomainServices } from "../src/core/listening-profile-domain-services.mjs";
 import { runMemoryReflection } from "../src/memory/reflection-worker.mjs";
 import { createConfiguredRuntime } from "../src/runtime/pi/configured-runtime.mjs";
+import { createModelSettings } from "../src/runtime/pi/model-settings.mjs";
+import { createToolTrace } from "../src/runtime/pi/tool-trace.mjs";
 import { writePiRuntimeSelection } from "../src/runtime/pi/runtime-settings.mjs";
 import {
   formatLocalResult,
@@ -23,10 +27,10 @@ import {
 } from "../src/surfaces/cli/format-output.mjs";
 import { runAuthCommand } from "../src/surfaces/cli/auth-command.mjs";
 import { runDataCommand } from "../src/surfaces/cli/data-command.mjs";
-import { migrateLegacyAppleMusicData } from "../src/core/apple-data-migration.mjs";
 import { runCatalogCommand } from "../src/surfaces/cli/catalog-command.mjs";
 import { runProfileCommand } from "../src/surfaces/cli/profile-command.mjs";
-import { createCodexWebResearch } from "../src/integrations/web/codex-web.mjs";
+import { runListenerProfileCommand, savedProfileActions } from "../src/surfaces/cli/listener-profile-command.mjs";
+import { createWebResearch } from "../src/integrations/web/web-research.mjs";
 import { runWebCommand } from "../src/surfaces/cli/web-command.mjs";
 import { openSpotifyConnection } from "../src/integrations/spotify/connection.mjs";
 import {
@@ -38,12 +42,17 @@ import {
 import { runSpotifyCommand } from "../src/surfaces/cli/spotify-command.mjs";
 import { runListenBrainzCommand } from "../src/surfaces/cli/listenbrainz-command.mjs";
 import { openListeningHistoryStore } from "../src/profile/listening-history-store.mjs";
-import { prepareHistoryImport, prepareSpotifyRecentImport } from "../src/profile/history-import.mjs";
+import { commitSpotifyQuickImport, prepareHistoryImport, prepareSpotifyQuickImport } from "../src/profile/history-import.mjs";
 import { persistAppleLibraryImport, refreshAppleLibraryImport } from "../src/profile/apple-library-import.mjs";
 import { IMPORT_GUIDE_URLS } from "../src/surfaces/cli/import-guides.mjs";
+import { readLastfmConfiguration, writeLastfmConfiguration } from "../src/integrations/lastfm/settings.mjs";
 import { runMoondogTui } from "../src/surfaces/cli/tui.mjs";
 import { createLyricService } from "../src/core/lyric-service.mjs";
+import { startListeningUpkeep } from "../src/core/listening-upkeep.mjs";
 import { createAppleMusicCatalog } from "../src/integrations/apple-music/catalog.mjs";
+import { createTerminalPreviewPlayer } from "../src/integrations/apple-music/terminal-preview-player.mjs";
+import { createNeteasePlayer } from "../src/integrations/netease/ncm-cli-player.mjs";
+import { createMusicAppPlayer } from "../src/integrations/apple-music/music-app.mjs";
 import {
   createOpenMusicSimilarity,
   createWikidataArtistResolver,
@@ -58,7 +67,8 @@ import {
   SPOTIFY_ARCHIVE_SET_MAXIMUM,
 } from "../src/profile/spotify-archive-taste.mjs";
 import { deriveArtistReleaseHintsFromSpotifyArchive } from "../src/profile/spotify-archive-catalog-hints.mjs";
-import { runMoondogStudio } from "../src/surfaces/web/studio.mjs";
+import { resolveListenerLocale, writeLanguagePreference } from "../src/i18n/preferences.mjs";
+import { createPlaybackSelection, resolvePlaybackService, watchPlaybackPreference, writePlaybackPreference } from "../src/core/playback-preferences.mjs";
 
 const localCommands = new Set([
   "status",
@@ -152,7 +162,6 @@ function projectionErrorCode(error) {
 }
 
 async function loadDomainServices() {
-  await migrateLegacyAppleMusicData();
   const listeningHistoryStore = await openListeningHistoryStore();
   let domainServicesError = null;
   let subjectId = null;
@@ -250,7 +259,7 @@ async function loadSpotifyConnection() {
 }
 
 async function spotifyRecentSyncContext(args) {
-  if (!new Set(["sync-recent", "import-history"]).has(args[0])) return {};
+  if (!new Set(["sync-recent", "sync-library", "import-history"]).has(args[0])) return {};
   const recentActivityStore = await openListeningHistoryStore();
   try {
     const appleSubjectId = await optionalAppleMusicSubjectId();
@@ -267,6 +276,22 @@ async function spotifyRecentSyncContext(args) {
   }
 }
 
+// Reads the latest Spotify plays into a listener's existing history. It never starts one:
+// a listener who has imported nothing yet still chooses when to begin.
+async function syncRecentSpotifyListening({ signal } = {}) {
+  const recentActivityStore = await openListeningHistoryStore();
+  try {
+    const appleSubjectId = await optionalAppleMusicSubjectId();
+    const subjectId = recentActivityStore.localSubjectId(appleSubjectId ? { preferredSubjectId: appleSubjectId } : {});
+    if (!subjectId) return null;
+    return await runSpotifyCommand({
+      args: ["sync-recent"], json: true, stdout: { write() {} }, signal, recentActivityStore, subjectId,
+    });
+  } finally {
+    recentActivityStore.close();
+  }
+}
+
 async function runSpotifySurface(options) {
   const syncContext = await spotifyRecentSyncContext(options.args);
   try {
@@ -300,7 +325,7 @@ async function runListenBrainzSurface(options) {
   }
 }
 
-async function prepareTuiHistoryImport(filePath, { recentPage, provider } = {}) {
+async function prepareTuiHistoryImport(filePath, { recentPage, librarySnapshot, libraryUnavailable, provider, onProgress, signal } = {}) {
   const historyStore = await openListeningHistoryStore();
   try {
     const appleSubjectId = await optionalAppleMusicSubjectId();
@@ -308,8 +333,8 @@ async function prepareTuiHistoryImport(filePath, { recentPage, provider } = {})
       ...(appleSubjectId ? { preferredSubjectId: appleSubjectId } : {}),
       create: true,
     });
-    const prepared = recentPage ? prepareSpotifyRecentImport({ page: recentPage, subjectId }) : await prepareHistoryImport({
-      filePath, subjectId, provider, capturedAt: new Date().toISOString(),
+    const prepared = recentPage ? prepareSpotifyQuickImport({ page: recentPage, librarySnapshot, libraryUnavailable, subjectId }) : await prepareHistoryImport({
+      filePath, subjectId, provider, capturedAt: new Date().toISOString(), onProgress, signal,
     });
     let closed = false;
     let committed = false;
@@ -320,8 +345,8 @@ async function prepareTuiHistoryImport(filePath, { recentPage, provider } = {})
         if (closed || committed) throw new Error("That preview is gone. Open it again before importing.");
         const options = { args: ["import-history", filePath], stdout: { write() {} }, subjectId };
         // Commit the exact inspected bundle, even if the source file later changes.
-        const receipt = prepared.provider === "spotify-recent"
-          ? historyStore.ingest(prepared.bundle)
+        const receipt = prepared.provider === "spotify-quick"
+          ? commitSpotifyQuickImport(historyStore, prepared)
           : prepared.provider === "apple-music-library"
           ? await persistAppleLibraryImport(prepared.bundle)
           : prepared.provider === "spotify"
@@ -425,6 +450,28 @@ async function emitTasteprintArtifact(
 }
 
 async function main() {
+  const updater = createApplicationUpdater();
+  const argv = process.argv.slice(2);
+  if (argv.length === 1 && ["--version", "-v"].includes(argv[0])) {
+    process.stdout.write(`${await updater.version()}\n`);
+    return;
+  }
+  const installUpdate = async (args) => {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    process.once("SIGINT", abort);
+    process.once("SIGTERM", abort);
+    try {
+      const result = await runUpdateCommand({ args, updater, signal: controller.signal,
+        onProgress: text => process.stdout.write(`${sanitizeTerminalText(text)}\n`) });
+      process.stdout.write(`${sanitizeTerminalText(result.text)}\n`);
+      if (result.result?.state === "unavailable") process.exitCode = 1;
+    } finally {
+      process.removeListener("SIGINT", abort);
+      process.removeListener("SIGTERM", abort);
+    }
+  };
+  if (argv[0] === "update") { await installUpdate(argv.slice(1)); return; }
   const options = parseArguments(process.argv.slice(2));
 
   if (options.command === "help" || options.command === "--help" || options.command === "-h") {
@@ -432,11 +479,13 @@ async function main() {
     return;
   }
 
+  await updater.assertNotUpdating();
+
   if (options.command === "web") {
     if (options.dryRun || options.offline || options.html || options.card || options.save || options.from || options.output) {
       throw new Error("Usage: moondog web status|search|read [arguments] [--json].");
     }
-    const webResearch = await createCodexWebResearch();
+    const webResearch = await createWebResearch();
     const controller = new AbortController();
     const abort = () => controller.abort();
     process.once("SIGINT", abort);
@@ -451,31 +500,6 @@ async function main() {
     return;
   }
 
-  if (options.command === "studio") {
-    const demoOnly =
-      options.rest.length === 1 && options.rest[0] === "--demo";
-    if (
-      (options.rest.length > 0 && !demoOnly) ||
-      (demoOnly && options.from) ||
-      options.json ||
-      options.dryRun ||
-      options.offline ||
-      options.html ||
-      options.card ||
-      options.save ||
-      options.output
-    ) {
-      throw new Error(
-        "Usage: moondog studio [--demo | --from <spotify-history.zip> [--from <spotify-history.zip>]].",
-      );
-    }
-    await runMoondogStudio({
-      demoOnly,
-      archivePaths: options.fromArchives,
-    });
-    return;
-  }
-
   if (options.command === "demo-history") {
     if (
       options.rest.length > 0 ||
@@ -543,7 +567,6 @@ async function main() {
   }
 
   if (options.command === "data") {
-    await migrateLegacyAppleMusicData();
     if (
       options.dryRun ||
       options.offline ||
@@ -564,7 +587,7 @@ async function main() {
     return;
   }
 
-  if (options.command === "profile" && options.rest.length > 0) {
+  if (options.command === "profile" && options.rest.length > 0 && !savedProfileActions.has(options.rest[0])) {
     if (
       options.dryRun ||
       options.offline ||
@@ -767,6 +790,36 @@ async function main() {
     return;
   }
 
+  if (options.command === "profile" && savedProfileActions.has(options.rest[0])) {
+    if (options.dryRun || options.offline || options.html || options.card || options.save || options.output || options.from) {
+      throw new Error("Usage: moondog profile <build|saved|explain> [--json].");
+    }
+    const application = new MoondogApplication(await loadDomainServices());
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    process.once("SIGINT", abort);
+    try {
+      // Saved reads only need the profile domain. The builder connects its own
+      // model when new analysis is actually required.
+      const stages = { synthesis: "Writing your profile", check: "Checking the draft",
+        revision: "Revising after the check", complete: "Saving your profile" };
+      let stage;
+      await runListenerProfileCommand({ application, args: options.rest, json: options.json,
+        signal: controller.signal, onProgress: options.json ? undefined : progress => {
+          if (progress.model_retry) {
+            process.stderr.write(`Retrying the model, ${progress.model_retry.attempt} of ${progress.model_retry.maxRetries}\n`);
+          } else if (progress.phase !== stage) {
+            stage = progress.phase;
+            process.stderr.write(`${stages[stage] ?? "Building your profile"}\n`);
+          }
+        } });
+    } finally {
+      process.removeListener("SIGINT", abort);
+      application.close();
+    }
+    return;
+  }
+
   const domainState = await loadDomainServices();
   const memoryStore = await openLocalMemoryStore();
   const spotifyConnection = await loadSpotifyConnection();
@@ -775,20 +828,64 @@ async function main() {
   const musicSimilarity = createOpenMusicSimilarity({
     identityResolver: artistIdentityResolver,
   });
-  const webResearch = await createCodexWebResearch();
-  const application = new MoondogApplication({
-    ...domainState,
-    webResearch,
-    memoryStore,
-    spotifyConnection,
-    musicCatalog,
-    musicSimilarity,
-    artistIdentityResolver,
+  const webResearch = await createWebResearch();
+  // The desktop app (app/) stands in for the terminal: it registers its screen and
+  // preview player here before the room starts. Without it, nothing changes.
+  const host = globalThis[Symbol.for("moondog.host")] ?? null;
+  // The listening room plays previews through the system's player when there is one.
+  // One-shot commands get none: they would exit in the middle of the first song.
+  // In the desktop app, the window's own player plays them instead.
+  const previewPlayer = options.command ? null : host ? host.musicPreviewPlayer : await createTerminalPreviewPlayer();
+  // What the listener plays in the Music app on this Mac, read but never opened.
+  const musicApp = createMusicAppPlayer();
+  // NetEase Cloud Music plays through ncm-cli in the terminal and the window alike. Its tools
+  // appear once ncm-cli says it is signed in; only listeners who chose it wait for that check.
+  const neteasePlayer = createNeteasePlayer();
+  const playbackService = await resolvePlaybackService();
+  if (playbackService === "netease") await neteasePlayer.check();
+  const playbackSelection = createPlaybackSelection({ service: playbackService, save: writePlaybackPreference });
+  // The terminal and the window each run this core on one playback.json. A service chosen on the
+  // other side reaches this side's picker and agents, and stops the previews this side plays.
+  const unwatchPlayback = watchPlaybackPreference(playbackSelection, {
+    onChange: (service) => { if (service !== "apple_music") previewPlayer?.stop?.(); },
+  });
+  // The main application and every conversation the window opens beside it are built from
+  // this one list, so they cannot drift apart. Each passes in what may change after launch:
+  // its domain services, the Spotify connection, the language and the music service.
+  // Spotify's four-week top artists, as the listening upkeep last read them.
+  const spotifyTopArtists = { read_at: null, artists: [] };
+  const applicationOptions = ({ domainServices, domainServicesError, spotifyConnection, locale, playbackService }) => ({
+    domainServices, domainServicesError, spotifyConnection, locale, playbackService, playbackSelection,
+    webResearch, memoryStore, musicCatalog, musicPreviewPlayer: previewPlayer, neteasePlayer, musicSimilarity, artistIdentityResolver,
+    spotifyTopArtists, musicApp,
   });
+  const application = new MoondogApplication(applicationOptions({
+    ...domainState, spotifyConnection, locale: await resolveListenerLocale(), playbackService,
+  }));
+  // The conversations the window runs beside the main one, each with its own application and agent.
+  const conversations = new Set();
+  // An import replaces the domain services under the main application and every open
+  // conversation. The old ones close last, once every fork over them has been replaced.
+  const replaceDomainServices = (next) => {
+    const previous = application.domainServices;
+    application.domainServices = next.domainServices;
+    application.domainServicesError = next.domainServicesError;
+    for (const { application: conversation } of conversations) {
+      const fork = conversation.domainServices;
+      conversation.domainServices = next.domainServices?.fork?.() ?? null;
+      conversation.domainServicesError = next.domainServicesError;
+      fork?.close?.();
+    }
+    previous?.close?.();
+  };
 
   let lyrics = null;
+  let listeningUpkeep = null;
+  let exitRequest;
   try {
-    const runtime = await createConfiguredRuntime(application);
+    // The command keeps a local trace of the agent's tool calls in the state directory.
+    const toolTrace = createToolTrace(process.env);
+    const runtime = await createConfiguredRuntime(application, process.env, { toolTrace });
     const runtimeStatus = runtime.publicStatus();
 
     if (localCommands.has(options.command)) {
@@ -861,38 +958,140 @@ async function main() {
       throw new Error(`Unknown command: ${options.command}`);
     }
 
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    if (!host && (!process.stdin.isTTY || !process.stdout.isTTY)) {
       throw new Error(
         "The listening room needs an interactive terminal. For a quick check without one, try moondog status.",
       );
     }
     lyrics = await createLyricService().catch(() => null);
-    await runMoondogTui({
+    // Each step stands alone, so a Spotify outage does not hold back a due rebuild.
+    listeningUpkeep = startListeningUpkeep({
+      run: async ({ signal }) => {
+        const spotify = application.spotifyReady() ? application.spotifyConnection : null;
+        const granted = (scope) => spotify !== null && !spotify.missingScopes?.().includes(scope);
+        if (granted("user-read-recently-played")) {
+          const synced = await syncRecentSpotifyListening({ signal }).catch(() => null);
+          // Open domain services read new plays as they land; only a first history needs opening.
+          if (synced?.inserted_events > 0 && !application.domainServices) replaceDomainServices(await loadDomainServices());
+        }
+        if (granted("user-top-read")) {
+          const top = await spotify.service.topItems({ type: "artists", timeRange: "short_term", limit: 10 }, { signal })
+            .catch(() => null);
+          if (top) {
+            spotifyTopArtists.read_at = new Date().toISOString();
+            spotifyTopArtists.artists = top.items.flatMap((artist) => typeof artist.name === "string" ? [artist.name.slice(0, 256)] : []);
+          }
+        }
+        signal.throwIfAborted();
+        await application.refreshListenerProfile({ signal });
+      },
+    });
+    // The window answers in several sessions at the same time: each busy session gets its own
+    // application on the shared services, with its own fork of the domain services, and its own
+    // agent. The terminal never opens one.
+    const openConversation = async ({ sessionId = null, reason = "user_new" } = {}) => {
+      // Two agents writing one session would mix their turns.
+      const bound = [application, ...[...conversations].map((conversation) => conversation.application)];
+      if (sessionId && bound.some((candidate) => candidate.memorySession?.session_id === sessionId)) {
+        throw new Error("That conversation is already open.");
+      }
+      const conversationApplication = new MoondogApplication({
+        ...applicationOptions({
+          domainServices: application.domainServices?.fork?.() ?? null,
+          domainServicesError: application.domainServicesError,
+          spotifyConnection: application.spotifyConnection,
+          locale: application.locale,
+          playbackService: application.playbackService,
+        }),
+        ownsServices: false,
+      });
+      const conversation = {
+        application: conversationApplication,
+        runtime: null,
+        close() {
+          conversations.delete(conversation);
+          conversationApplication.close();
+        },
+      };
+      // It joins before its agent is built, so an import in the meantime reaches it too.
+      conversations.add(conversation);
+      try {
+        // The agent reads the session's turns when it is built, so the session comes first.
+        if (sessionId) conversationApplication.resumeSession(sessionId);
+        else conversationApplication.startNewSession(reason);
+        conversation.runtime = await createConfiguredRuntime(conversationApplication, process.env, { toolTrace });
+        return conversation;
+      } catch (error) {
+        conversation.close();
+        throw error;
+      }
+    };
+    // The desktop app draws its own window on this same application and agent.
+    exitRequest = await (host?.runRoom ?? runMoondogTui)({
       application,
       runtime,
+      toolTrace,
+      openConversation,
+      terminal: host?.terminal,
+      previewPlayer,
       lyrics,
+      checkUpdates: options => updater.startupCheck(options),
+      runUpdate: (args, options) => runUpdateCommand({ args, updater, deferInstall: true, ...options }),
       prepareImport: prepareTuiHistoryImport,
-      prepareRecentImport: async () => prepareTuiHistoryImport(undefined, {
-        recentPage: await runSpotifySurface({
-          args: ["recent", "--limit", "50"], stdout: { write() {} },
-        }),
-      }),
+      prepareRecentImport: async ({ onProgress } = {}) => {
+        const recentPage = await runSpotifySurface({ args: ["recent", "--limit", "50"], stdout: { write() {} } });
+        let librarySnapshot = null;
+        let libraryUnavailable = null;
+        try {
+          librarySnapshot = await runSpotifySurface({ args: ["library"], stdout: { write() {} }, onProgress });
+        } catch (error) {
+          // An older recent-plays-only sign-in can still import recent plays.
+          if (error?.code !== "spotify_scope_insufficient") throw error;
+          libraryUnavailable = "missing_permission";
+        }
+        return prepareTuiHistoryImport(undefined, { recentPage, librarySnapshot, libraryUnavailable });
+      },
       openImportHelp,
+      // The room asks whether a Last.fm key is set, and saves one the listener pastes.
+      lastfm: {
+        status: async () => {
+          const access = await readLastfmConfiguration().catch(() => undefined);
+          return { configured: Boolean(access?.apiKey), source: access?.source ?? null };
+        },
+        save: async (apiKey) => ({ configured: true, source: (await writeLastfmConfiguration(apiKey)).source }),
+      },
+      saveLanguage: locale => writeLanguagePreference(locale),
+      // The service picker and the agent use the same persisted selection, shared by every conversation.
+      savePlaybackService: async (service) => {
+        const result = await application.selectPlaybackService(service, { strict: false });
+        if (result.refused) throw new Error(result.refused);
+        return result.selected_service;
+      },
       refreshImportedData: async (receipt) => {
         if (receipt?.provider === "apple-music-library") await refreshAppleLibraryImport();
-        const next = await loadDomainServices();
-        const previous = application.domainServices;
-        application.domainServices = next.domainServices;
-        application.domainServicesError = next.domainServicesError;
-        previous?.close?.();
+        replaceDomainServices(await loadDomainServices());
       },
-      rebuildRuntime: async (selection) => {
+      // The window also rebuilds the agent of each conversation it opened.
+      // A choice made while a reply runs is saved here, before that reply ends, so quitting does not drop it.
+      saveRuntimeSelection: (selection) => writePiRuntimeSelection(selection),
+      rebuildRuntime: async (selection, target = application) => {
         if (selection) await writePiRuntimeSelection(selection);
-        return createConfiguredRuntime(application, process.env, { selection });
+        // A key saved with /auth, or a Codex sign-in since, takes effect with the new runtime's tools.
+        await webResearch.refresh();
+        return createConfiguredRuntime(target, process.env, { selection, toolTrace });
       },
+      // The desktop window lists models and signs in here, with no terminal.
+      modelSettings: createModelSettings({ environment: process.env }),
+      // A host with its own terminal streams takes the sign-in prompts. The
+      // desktop window has none and uses modelSettings instead.
       runAuth: (provider) =>
         runAuthCommand({
           args: ["login", provider],
+          ...(host?.terminalStreams && {
+            input: host.terminalStreams.input,
+            output: host.terminalStreams.output,
+            progressOutput: host.terminalStreams.output,
+          }),
         }),
       runWeb: (args, options) => runWebCommand({ args, webResearch, ...options }),
       runProfileAction: (args) => runProfileCommand({
@@ -901,12 +1100,14 @@ async function main() {
         resolvePreferredSubjectId: optionalAppleMusicSubjectId,
         output: { write() {} },
       }),
-      runProfile: async (args) => {
+      runProfile: async (args, controls = {}) => {
         const values = [...args];
         const json = values.at(-1) === "--json";
         if (json) values.pop();
         let output = "";
-        await runProfileCommand({
+        const command = savedProfileActions.has(values[0]) ? runListenerProfileCommand : runProfileCommand;
+        await command({
+          application, ...controls,
           args: values,
           json,
           commandPrefix: "/profile",
@@ -915,7 +1116,7 @@ async function main() {
         });
         return json ? `\`\`\`json\n${output.trim()}\n\`\`\`` : output.trim();
       },
-      runSpotify: async (args, { signal } = {}) => {
+      runSpotify: async (args, { signal, stderr } = {}) => {
         let output = "";
         const capture = {
           write(value) {
@@ -926,24 +1127,30 @@ async function main() {
           args,
           signal,
           stdout: capture,
-          stderr: args[0] === "login" ? process.stderr : capture,
+          stderr: stderr ?? (args[0] === "login" ? host?.terminalStreams?.output ?? process.stderr : capture),
           resolutionCache: await spotifyResolutionCacheIfConfigured(),
         });
         if (["import-history", "sync-recent"].includes(args[0])) {
-          const next = await loadDomainServices();
-          const previous = application.domainServices;
-          application.domainServices = next.domainServices;
-          application.domainServicesError = next.domainServicesError;
-          previous?.close?.();
+          replaceDomainServices(await loadDomainServices());
         }
-        application.setSpotifyConnection(await loadSpotifyConnection());
+        const connection = await loadSpotifyConnection();
+        application.setSpotifyConnection(connection);
+        for (const conversation of conversations) conversation.application.setSpotifyConnection(connection);
         return output.trim();
       },
     });
   } finally {
+    unwatchPlayback();
+    listeningUpkeep?.stop();
     lyrics?.close();
+    // Conversations close first: their domain services are forks of the main application's.
+    for (const conversation of conversations) conversation.close();
     application.close();
   }
+  if (exitRequest?.update) {
+    closeSpotifyResolutionCache();
+    await installUpdate(["--channel", exitRequest.update.channel]);
+  }
 }
 
 main()
@@ -951,4 +1158,8 @@ main()
     process.stderr.write(`moondog: ${sanitizeTerminalText(error.message)}\n`);
     process.exitCode = 1;
   })
-  .finally(() => closeSpotifyResolutionCache());
+  .finally(() => {
+    closeSpotifyResolutionCache();
+    // The desktop app closes when its room does.
+    globalThis[Symbol.for("moondog.host")]?.closed?.();
+  });

package/src/core/apple-library-source-status.mjs

@@ -1,28 +1,12 @@
 import { lstat, readFile, readdir } from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 
 import { resolveMoondogStateDirectory } from "./state-directory.mjs";
 
-const repositoryRoot = path.resolve(
-  path.dirname(fileURLToPath(import.meta.url)),
-  "../..",
-);
-
-// Earlier versions kept Apple Music data inside the source checkout.
-export const legacyAppleMusicImportsRoot = path.join(
-  repositoryRoot,
-  "data",
-  "imports",
-  "apple-music-library",
-);
-
 export function defaultAppleMusicImportsRootFor(environment = process.env) {
   return path.join(resolveMoondogStateDirectory(environment), "apple-music-library", "imports");
 }
 
-export const defaultAppleMusicImportsRoot = defaultAppleMusicImportsRootFor();
-
 export function resolveAppleMusicImportsRoot(environment = process.env) {
   const configured = environment.MOONDOG_APPLE_IMPORTS_ROOT?.trim();
   if (!configured) return defaultAppleMusicImportsRootFor(environment);