@adhdev/daemon-core 0.8.19 → 0.8.21

package/dist/index.mjs

@@ -60,14 +60,6 @@ function asBoolean(value, fallback) {
 }
 function normalizeConfig(raw) {
   const parsed = isPlainObject(raw) ? raw : {};
-  const legacySessionReads = isPlainObject(parsed.recentSessionReads) ? parsed.recentSessionReads : {};
-  const sessionReads = isPlainObject(parsed.sessionReads) ? parsed.sessionReads : {};
-  const mergedSessionReads = Object.fromEntries(
-    Object.entries({ ...legacySessionReads, ...sessionReads }).filter(([, value]) => typeof value === "number" && Number.isFinite(value))
-  );
-  const sessionReadMarkers = Object.fromEntries(
-    Object.entries(isPlainObject(parsed.sessionReadMarkers) ? parsed.sessionReadMarkers : {}).filter(([, value]) => typeof value === "string")
-  );
   return {
     serverUrl: typeof parsed.serverUrl === "string" && parsed.serverUrl.trim() ? parsed.serverUrl : DEFAULT_CONFIG.serverUrl,
     selectedIde: asNullableString(parsed.selectedIde),
@@ -80,10 +72,6 @@ function normalizeConfig(raw) {
     enabledIdes: asStringArray(parsed.enabledIdes),
     workspaces: Array.isArray(parsed.workspaces) ? parsed.workspaces : [],
     defaultWorkspaceId: asNullableString(parsed.defaultWorkspaceId) ?? asNullableString(parsed.activeWorkspaceId),
-    recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity : [],
-    savedProviderSessions: Array.isArray(parsed.savedProviderSessions) ? parsed.savedProviderSessions : [],
-    sessionReads: mergedSessionReads,
-    sessionReadMarkers,
     machineNickname: asNullableString(parsed.machineNickname),
     machineId: asOptionalString(parsed.machineId),
     machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
@@ -124,6 +112,30 @@ function getConfigDir() {
 function getConfigPath() {
   return join(getConfigDir(), "config.json");
 }
+function migrateStateToStateFile(raw) {
+  const statePath = join(getConfigDir(), "state.json");
+  if (existsSync(statePath)) return;
+  const recentActivity = Array.isArray(raw.recentActivity) ? raw.recentActivity : [];
+  const savedProviderSessions = Array.isArray(raw.savedProviderSessions) ? raw.savedProviderSessions : [];
+  const legacySessionReads = isPlainObject(raw.recentSessionReads) ? raw.recentSessionReads : {};
+  const sessionReads = isPlainObject(raw.sessionReads) ? raw.sessionReads : {};
+  const sessionReadMarkers = isPlainObject(raw.sessionReadMarkers) ? raw.sessionReadMarkers : {};
+  const hasData = recentActivity.length > 0 || savedProviderSessions.length > 0 || Object.keys(sessionReads).length > 0 || Object.keys(legacySessionReads).length > 0 || Object.keys(sessionReadMarkers).length > 0;
+  if (!hasData) return;
+  const mergedReads = Object.fromEntries(
+    Object.entries({ ...legacySessionReads, ...sessionReads }).filter(([, v]) => typeof v === "number" && Number.isFinite(v))
+  );
+  const cleanedMarkers = Object.fromEntries(
+    Object.entries(sessionReadMarkers).filter(([, v]) => typeof v === "string")
+  );
+  const state = {
+    recentActivity,
+    savedProviderSessions,
+    sessionReads: mergedReads,
+    sessionReadMarkers: cleanedMarkers
+  };
+  writeFileSync(statePath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
+}
 function loadConfig() {
   const configPath = getConfigPath();
   if (!existsSync(configPath)) {
@@ -137,6 +149,7 @@ function loadConfig() {
   try {
     const raw = readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(raw);
+    migrateStateToStateFile(parsed);
     const normalizedInput = normalizeConfig(parsed);
     const ensured = ensureMachineId(normalizedInput);
     const normalized = ensured.config;
@@ -204,10 +217,6 @@ var init_config = __esm({
       enabledIdes: [],
       workspaces: [],
       defaultWorkspaceId: null,
-      recentActivity: [],
-      savedProviderSessions: [],
-      sessionReads: {},
-      sessionReadMarkers: {},
       machineNickname: null,
       machineId: void 0,
       machineSecret: null,
@@ -2730,35 +2739,35 @@ function buildRecentActivityKeyForEntry(entry) {
   }
   return buildRecentActivityKey(entry);
 }
-function appendRecentActivity(config, entry) {
+function appendRecentActivity(state, entry) {
   const nextEntry = {
     ...entry,
     workspace: entry.workspace ? normalizeWorkspace(entry.workspace) : void 0,
     id: buildRecentActivityKeyForEntry(entry),
     lastUsedAt: entry.lastUsedAt || Date.now()
   };
-  const filtered = (config.recentActivity || []).filter((item) => item.id !== nextEntry.id);
+  const filtered = (state.recentActivity || []).filter((item) => item.id !== nextEntry.id);
   return {
-    ...config,
+    ...state,
     recentActivity: [nextEntry, ...filtered].slice(0, MAX_ACTIVITY)
   };
 }
-function getRecentActivity(config, limit = 20) {
-  return [...config.recentActivity || []].sort((a, b) => b.lastUsedAt - a.lastUsedAt).slice(0, limit);
+function getRecentActivity(state, limit = 20) {
+  return [...state.recentActivity || []].sort((a, b) => b.lastUsedAt - a.lastUsedAt).slice(0, limit);
 }
-function getSessionSeenAt(config, sessionId) {
-  return config.sessionReads?.[sessionId] || 0;
+function getSessionSeenAt(state, sessionId) {
+  return state.sessionReads?.[sessionId] || 0;
 }
-function getSessionSeenMarker(config, sessionId) {
-  return config.sessionReadMarkers?.[sessionId] || "";
+function getSessionSeenMarker(state, sessionId) {
+  return state.sessionReadMarkers?.[sessionId] || "";
 }
-function markSessionSeen(config, sessionId, seenAt = Date.now(), completionMarker) {
-  const prev = config.sessionReads || {};
+function markSessionSeen(state, sessionId, seenAt = Date.now(), completionMarker) {
+  const prev = state.sessionReads || {};
   const nextSeenAt = Math.max(prev[sessionId] || 0, seenAt);
-  const prevMarkers = config.sessionReadMarkers || {};
+  const prevMarkers = state.sessionReadMarkers || {};
   const nextMarker = typeof completionMarker === "string" ? completionMarker : "";
   return {
-    ...config,
+    ...state,
     sessionReads: {
       ...prev,
       [sessionId]: nextSeenAt
@@ -2784,11 +2793,11 @@ function normalizeWorkspace2(workspace) {
 function buildSavedProviderSessionKey(providerSessionId) {
   return `saved:${providerSessionId.trim()}`;
 }
-function upsertSavedProviderSession(config, entry) {
+function upsertSavedProviderSession(state, entry) {
   const providerSessionId = typeof entry.providerSessionId === "string" ? entry.providerSessionId.trim() : "";
-  if (!providerSessionId) return config;
+  if (!providerSessionId) return state;
   const id = buildSavedProviderSessionKey(providerSessionId);
-  const existing = (config.savedProviderSessions || []).find((item) => item.id === id);
+  const existing = (state.savedProviderSessions || []).find((item) => item.id === id);
   const nextEntry = {
     id,
     kind: entry.kind,
@@ -2801,23 +2810,75 @@ function upsertSavedProviderSession(config, entry) {
     createdAt: existing?.createdAt || entry.createdAt || Date.now(),
     lastUsedAt: entry.lastUsedAt || Date.now()
   };
-  const filtered = (config.savedProviderSessions || []).filter((item) => item.id !== id);
+  const filtered = (state.savedProviderSessions || []).filter((item) => item.id !== id);
   return {
-    ...config,
+    ...state,
     savedProviderSessions: [nextEntry, ...filtered].slice(0, MAX_SAVED_SESSIONS)
   };
 }
-function getSavedProviderSessions(config, filters) {
-  return [...config.savedProviderSessions || []].filter((entry) => {
+function getSavedProviderSessions(state, filters) {
+  return [...state.savedProviderSessions || []].filter((entry) => {
     if (filters?.providerType && entry.providerType !== filters.providerType) return false;
     if (filters?.kind && entry.kind !== filters.kind) return false;
     return true;
   }).sort((a, b) => b.lastUsedAt - a.lastUsedAt);
 }
 
+// src/config/state-store.ts
+init_config();
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+var DEFAULT_STATE = {
+  recentActivity: [],
+  savedProviderSessions: [],
+  sessionReads: {},
+  sessionReadMarkers: {}
+};
+function isPlainObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getStatePath() {
+  return join3(getConfigDir(), "state.json");
+}
+function normalizeState(raw) {
+  const parsed = isPlainObject2(raw) ? raw : {};
+  const sessionReads = Object.fromEntries(
+    Object.entries(isPlainObject2(parsed.sessionReads) ? parsed.sessionReads : {}).filter(([, value]) => typeof value === "number" && Number.isFinite(value))
+  );
+  const sessionReadMarkers = Object.fromEntries(
+    Object.entries(isPlainObject2(parsed.sessionReadMarkers) ? parsed.sessionReadMarkers : {}).filter(([, value]) => typeof value === "string")
+  );
+  return {
+    recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity : [],
+    savedProviderSessions: Array.isArray(parsed.savedProviderSessions) ? parsed.savedProviderSessions : [],
+    sessionReads,
+    sessionReadMarkers
+  };
+}
+function loadState() {
+  const statePath = getStatePath();
+  if (!existsSync3(statePath)) {
+    return { ...DEFAULT_STATE };
+  }
+  try {
+    const raw = readFileSync2(statePath, "utf-8");
+    return normalizeState(JSON.parse(raw));
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+function saveState(state) {
+  const statePath = getStatePath();
+  const normalized = normalizeState(state);
+  writeFileSync2(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function resetState() {
+  saveState({ ...DEFAULT_STATE });
+}
+
 // src/detection/ide-detector.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { platform, homedir as homedir3 } from "os";
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
@@ -2863,9 +2924,9 @@ function checkPathExists(paths) {
     if (p.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = p.replace("*", username);
-      if (existsSync3(resolved)) return resolved;
+      if (existsSync4(resolved)) return resolved;
     } else {
-      if (existsSync3(p)) return p;
+      if (existsSync4(p)) return p;
     }
   }
   return null;
@@ -2880,7 +2941,7 @@ async function detectIDEs() {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os18 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if (existsSync3(bundledCli)) resolvedCli = bundledCli;
+      if (existsSync4(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os18 === "win32") {
       const { dirname: dirname6 } = await import("path");
@@ -2893,7 +2954,7 @@ async function detectIDEs() {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if (existsSync3(c)) {
+        if (existsSync4(c)) {
           resolvedCli = c;
           break;
         }
@@ -9532,9 +9593,9 @@ var DaemonCliManager = class {
   }
   persistRecentActivity(entry) {
     try {
-      let nextConfig = appendRecentActivity(loadConfig(), entry);
+      let nextState = appendRecentActivity(loadState(), entry);
       if (entry.providerSessionId && (entry.kind === "cli" || entry.kind === "acp")) {
-        nextConfig = upsertSavedProviderSession(nextConfig, {
+        nextState = upsertSavedProviderSession(nextState, {
           kind: entry.kind,
           providerType: entry.providerType,
           providerName: entry.providerName,
@@ -9544,7 +9605,7 @@ var DaemonCliManager = class {
           title: entry.title
         });
       }
-      saveConfig(nextConfig);
+      saveState(nextState);
     } catch (e) {
       console.error(colorize("red", `  \u2717 Failed to save recent activity: ${e}`));
     }
@@ -10336,14 +10397,14 @@ var ProviderLoader = class _ProviderLoader {
   */
   setIdeExtensionEnabled(ideType, extensionType, enabled) {
     try {
-      const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = (init_config(), __toCommonJS(config_exports));
+      const { loadConfig: loadConfig2, saveConfig: saveConfig3 } = (init_config(), __toCommonJS(config_exports));
       const config = loadConfig2();
       const baseIdeType = ideType.split("_")[0];
       if (!config.ideSettings) config.ideSettings = {};
       if (!config.ideSettings[baseIdeType]) config.ideSettings[baseIdeType] = {};
       if (!config.ideSettings[baseIdeType].extensions) config.ideSettings[baseIdeType].extensions = {};
       config.ideSettings[baseIdeType].extensions[extensionType] = { enabled };
-      saveConfig2(config);
+      saveConfig3(config);
       this.log(`IDE extension setting: ${ideType}.${extensionType}.enabled = ${enabled}`);
       return true;
     } catch (e) {
@@ -10908,12 +10969,12 @@ var ProviderLoader = class _ProviderLoader {
     }
     if (schemaDef.type === "select" && schemaDef.options && !schemaDef.options.includes(value)) return false;
     try {
-      const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = (init_config(), __toCommonJS(config_exports));
+      const { loadConfig: loadConfig2, saveConfig: saveConfig3 } = (init_config(), __toCommonJS(config_exports));
       const config = loadConfig2();
       if (!config.providerSettings) config.providerSettings = {};
       if (!config.providerSettings[type]) config.providerSettings[type] = {};
       config.providerSettings[type][key] = value;
-      saveConfig2(config);
+      saveConfig3(config);
       this.log(`Setting updated: ${type}.${key} = ${JSON.stringify(value)}`);
       return true;
     } catch (e) {
@@ -11691,16 +11752,17 @@ function buildRecentLaunches(recentActivity) {
 }
 function buildStatusSnapshot(options) {
   const cfg = loadConfig();
+  const state = loadState();
   const wsState = getWorkspaceState(cfg);
   const memSnap = getHostMemorySnapshot();
-  const recentActivity = getRecentActivity(cfg, 20);
+  const recentActivity = getRecentActivity(state, 20);
   const sessions = buildSessionEntries(
     options.allStates,
     options.cdpManagers
   );
   for (const session of sessions) {
-    const lastSeenAt = getSessionSeenAt(cfg, session.id);
-    const seenCompletionMarker = getSessionSeenMarker(cfg, session.id);
+    const lastSeenAt = getSessionSeenAt(state, session.id);
+    const seenCompletionMarker = getSessionSeenMarker(state, session.id);
     const lastUsedAt = getSessionLastUsedAt(session);
     const completionMarker = getSessionCompletionMarker(session);
     const { unread, inboxBucket } = session.surfaceHidden ? { unread: false, inboxBucket: "idle" } : getUnreadState(
@@ -12038,9 +12100,9 @@ var DaemonCommandRouter = class {
         const offset = Math.max(0, Number(args?.offset) || 0);
         const limit = Math.max(1, Math.min(100, Number(args?.limit) || 30));
         const { sessions: historySessions, hasMore } = listSavedHistorySessions(providerType, { offset, limit });
-        const config = loadConfig();
-        const savedSessions = getSavedProviderSessions(config, { providerType, kind });
-        const recentSessions = getRecentActivity(config, 200).filter((entry) => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
+        const state = loadState();
+        const savedSessions = getSavedProviderSessions(state, { providerType, kind });
+        const recentSessions = getRecentActivity(state, 200).filter((entry) => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
         const savedSessionById = new Map(savedSessions.map((entry) => [entry.providerSessionId, entry]));
         const recentSessionById = new Map(recentSessions.map((entry) => [entry.providerSessionId, entry]));
         const providerMeta = this.deps.providerLoader.getMeta(providerType);
@@ -12131,19 +12193,19 @@ var DaemonCommandRouter = class {
         this.deps.onIdeConnected?.();
         if (result.success && resolvedWorkspace) {
           try {
-            const next = appendRecentActivity(loadConfig(), {
+            const next = appendRecentActivity(loadState(), {
               kind: "ide",
               providerType: result.ideId || ideKey,
               providerName: result.ideId || ideKey,
               workspace: resolvedWorkspace,
               title: result.ideId || ideKey
             });
-            saveConfig(next);
+            saveState(next);
           } catch {
           }
         } else if (result.success && (result.ideId || ideKey)) {
           try {
-            saveConfig(appendRecentActivity(loadConfig(), {
+            saveState(appendRecentActivity(loadState(), {
               kind: "ide",
               providerType: result.ideId || ideKey,
               providerName: result.ideId || ideKey,
@@ -12172,8 +12234,8 @@ var DaemonCommandRouter = class {
         if (!sessionId || typeof sessionId !== "string") {
           return { success: false, error: "sessionId is required" };
         }
-        const currentConfig = loadConfig();
-        const prevSeenAt = currentConfig.sessionReads?.[sessionId] || 0;
+        const currentState = loadState();
+        const prevSeenAt = currentState.sessionReads?.[sessionId] || 0;
         const sessionEntries = buildSessionEntries(
           this.deps.instanceManager.collectAllStates(),
           this.deps.cdpManagers
@@ -12181,7 +12243,7 @@ var DaemonCommandRouter = class {
         const targetSession = sessionEntries.find((entry) => entry.id === sessionId);
         const completionMarker = targetSession ? getSessionCompletionMarker(targetSession) : "";
         const next = markSessionSeen(
-          currentConfig,
+          currentState,
           sessionId,
           typeof args?.seenAt === "number" ? args.seenAt : Date.now(),
           completionMarker
@@ -12189,7 +12251,7 @@ var DaemonCommandRouter = class {
         if (READ_DEBUG_ENABLED2) {
           LOG.info("RecentRead", `mark_session_seen sessionId=${sessionId} seenAt=${String(args?.seenAt || "")} prevSeenAt=${String(prevSeenAt)} nextSeenAt=${String(next.sessionReads?.[sessionId] || 0)} marker=${completionMarker || "-"}`);
         }
-        saveConfig(next);
+        saveState(next);
         this.deps.onStatusChange?.();
         return {
           success: true,
@@ -19539,6 +19601,7 @@ export {
   launchWithCdp,
   listHostedCliRuntimes,
   loadConfig,
+  loadState,
   logCommand,
   markSetupComplete,
   maybeRunDaemonUpgradeHelperFromEnv,
@@ -19548,7 +19611,9 @@ export {
   readChatHistory,
   registerExtensionProviders,
   resetConfig,
+  resetState,
   saveConfig,
+  saveState,
   setLogLevel,
   setupIdeInstance,
   shutdownDaemonComponents,