mixdog 1.2.0 → 1.2.2

package/src/session-runtime/conversation-import/service.mjs

@@ -0,0 +1,369 @@
+/**
+ * "Import conversations from other apps": the runtime API (list / register /
+ * start / status / cancel) and the background import jobs behind it.
+ *
+ * Jobs are process-wide, so a job keeps running and stays observable after the
+ * dialog closes or the user switches conversations (each session runtime of
+ * the daemon reads the same registry). Every file passes one serialized
+ * admission lane shared by all jobs, where the "already imported" check is
+ * repeated right before the session is created, against the session catalog
+ * read once per batch and every commit of this process since.
+ * An import key only counts as imported while its session still exists in
+ * storage, so a deleted import can be imported again.
+ * Cancel stops admitting further files; committed imports stay.
+ */
+import { randomUUID } from 'node:crypto';
+import { access, stat } from 'node:fs/promises';
+import {
+  buildImportOrigin,
+  createImportedSession,
+  importOriginKey,
+} from '../../runtime/agent/orchestrator/session/conversation-import/imported-session.mjs';
+import { IMPORT_WARNING_CWD_MISSING } from '../../runtime/agent/orchestrator/session/conversation-import/turns.mjs';
+import { sessionPath } from '../../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
+import {
+  cachedMeta,
+  convertCandidateFile,
+  getCandidate,
+  importError,
+  importedKeyMap,
+  listConversations,
+  recordConversion,
+  registerFile,
+  resolveSourceCwd,
+  resolveViewSelection,
+} from './discovery.mjs';
+
+const MAX_FINISHED_JOBS = 20;
+const MAX_REQUEST_ID_LENGTH = 200;
+
+const jobs = new Map(); // jobId → job (insertion order = start order)
+const jobsByRequest = new Map(); // requestId → jobId
+const pendingStarts = new Map(); // requestId → Promise<job> while a selection resolves
+// import key → session id, imports of this process (summaries can lag a save).
+const committedKeys = new Map();
+let admissionTail = Promise.resolve();
+
+/** Test seam: forget every job and committed key. */
+export function resetConversationImportJobs() {
+  jobs.clear();
+  jobsByRequest.clear();
+  pendingStarts.clear();
+  committedKeys.clear();
+  admissionTail = Promise.resolve();
+}
+
+const EXISTS_CONCURRENCY = 16;
+
+const sessionFileExists = (id) =>
+  access(sessionPath(id)).then(
+    () => true,
+    () => false
+  );
+
+/**
+ * `get(key)` → the id of an existing session imported under `key`, else null.
+ * Candidates come from this process's commits, then summaries; every candidate
+ * id's existence is checked (asynchronously) once, up front. Committed ids
+ * whose session no longer exists are dropped from the commit map.
+ */
+async function importedLookup(summaries, sessionExists) {
+  const fromSummaries = importedKeyMap(summaries);
+  const committedAtStart = new Map(committedKeys);
+  const ids = [...new Set([...committedAtStart.values(), ...[...fromSummaries.values()].flat()])];
+  const existing = new Set();
+  let next = 0;
+  const worker = async () => {
+    while (next < ids.length) {
+      const id = ids[next++];
+      if (await sessionExists(id)) existing.add(id);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(EXISTS_CONCURRENCY, ids.length) }, worker));
+  for (const [key, id] of committedAtStart) {
+    if (!existing.has(id) && committedKeys.get(key) === id) committedKeys.delete(key);
+  }
+  const get = (key) => {
+    const committed = committedAtStart.get(key);
+    if (committed && existing.has(committed)) return committed;
+    return (fromSummaries.get(key) || []).find((id) => existing.has(id)) || null;
+  };
+  return { get, has: (key) => get(key) !== null };
+}
+
+class FatalImportError extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+}
+
+function admit(task) {
+  const run = admissionTail.then(task, task);
+  admissionTail = run.then(
+    () => {},
+    () => {}
+  );
+  return run;
+}
+
+function snapshot(job) {
+  return {
+    jobId: job.jobId,
+    seq: job.seq,
+    state: job.state,
+    total: job.total,
+    processed: job.imported + job.skippedAlreadyImported + job.failed,
+    imported: job.imported,
+    skippedAlreadyImported: job.skippedAlreadyImported,
+    failed: job.failed,
+    byProject: [...job.byProject.entries()].map(([projectPath, counts]) => ({ projectPath, ...counts })),
+    results: job.results.map((result) => ({ ...result, warnings: [...result.warnings] })),
+    current: job.current ? { ...job.current } : null,
+    ...(job.errorCode ? { errorCode: job.errorCode } : {}),
+  };
+}
+
+function touch(job, patch = {}) {
+  Object.assign(job, patch);
+  job.seq += 1;
+}
+
+const COUNTER = { imported: 'imported', alreadyImported: 'skippedAlreadyImported', failed: 'failed' };
+
+function record(job, { projectPath = null, ...result }) {
+  const counter = COUNTER[result.status];
+  job[counter] += 1;
+  const counts = job.byProject.get(projectPath) || { imported: 0, skippedAlreadyImported: 0, failed: 0 };
+  counts[counter] += 1;
+  job.byProject.set(projectPath, counts);
+  job.results.push(result);
+  touch(job);
+}
+
+function pruneFinishedJobs() {
+  const finished = [...jobs.values()].filter((job) => job.state !== 'running' && job.state !== 'stopping');
+  for (const job of finished.slice(0, Math.max(0, finished.length - MAX_FINISHED_JOBS))) {
+    jobs.delete(job.jobId);
+    if (jobsByRequest.get(job.requestId) === job.jobId) jobsByRequest.delete(job.requestId);
+  }
+}
+
+const failed = (candidateId, errorCode, projectPath = null, warnings = []) => ({
+  candidateId,
+  status: 'failed',
+  errorCode,
+  warnings,
+  projectPath,
+});
+
+async function importOne(candidateId, context) {
+  const candidate = getCandidate(candidateId);
+  if (!candidate) return failed(candidateId, 'unknownCandidate');
+  // The chat keeps the title the user picked it by: a long file's listing
+  // title comes from its prefix and can differ from the converted branch.
+  const listedTitle = cachedMeta(candidate)?.title ?? null;
+  let conversion;
+  try {
+    const info = await stat(candidate.path);
+    if (!info.isFile()) return failed(candidateId, 'unreadable');
+    candidate.size = info.size;
+    candidate.mtimeMs = info.mtimeMs;
+    conversion = await convertCandidateFile(candidate, context.limits);
+  } catch {
+    return failed(candidateId, 'unreadable');
+  }
+  if (listedTitle) conversion = { ...conversion, title: listedTitle };
+  recordConversion(candidate, conversion);
+  const cwdInfo = await resolveSourceCwd(conversion.cwd);
+  const projectPath = cwdInfo.exists ? cwdInfo.path : null;
+  if (conversion.errorCode) return failed(candidateId, conversion.errorCode, projectPath, conversion.warnings);
+  const warnings = [...conversion.warnings, ...(projectPath ? [] : [IMPORT_WARNING_CWD_MISSING])];
+  const key = importOriginKey(candidate.source, conversion.foreignSessionId, candidate.path);
+  // The batch's catalog snapshot, then commits made since (by any job; the
+  // admission lane serializes them).
+  let existing = context.imported.get(key);
+  const committed = committedKeys.get(key);
+  if (!existing && committed && (await context.sessionExists(committed))) existing = committed;
+  if (existing) return { candidateId, status: 'alreadyImported', sessionId: existing, warnings, projectPath };
+  if (!context.leadOptions) {
+    try {
+      context.leadOptions = await context.prepareLeadOptions();
+    } catch (error) {
+      throw new FatalImportError(error?.code || 'noModelRoute');
+    }
+  }
+  let session;
+  try {
+    session = await context.createImportedSession({
+      leadOptions: context.leadOptions,
+      conversation: conversion,
+      origin: buildImportOrigin({
+        source: candidate.source,
+        sourcePath: candidate.path,
+        foreignSessionId: conversion.foreignSessionId,
+        sourceCwd: conversion.cwd,
+        importedAt: Date.now(),
+      }),
+      cwd: projectPath,
+      desktopSession: projectPath
+        ? { classification: 'project', projectPath }
+        : { classification: 'task', projectPath: null },
+    });
+  } catch (error) {
+    return failed(candidateId, typeof error?.code === 'string' ? error.code : 'importFailed', projectPath, warnings);
+  }
+  committedKeys.set(key, session.id);
+  return { candidateId, status: 'imported', sessionId: session.id, warnings, projectPath };
+}
+
+async function runJob(job, candidateIds, context) {
+  try {
+    // One catalog read per batch; later commits are seen through committedKeys.
+    context.imported = await context.importedLookup();
+    for (const candidateId of candidateIds) {
+      if (job.cancelRequested) break;
+      let result;
+      try {
+        result = await admit(async () => {
+          // A cancel that arrived while queued behind other jobs wins here.
+          if (job.cancelRequested) return null;
+          const candidate = getCandidate(candidateId);
+          touch(job, { current: { candidateId, title: (candidate && cachedMeta(candidate)?.title) ?? null } });
+          try {
+            return await importOne(candidateId, context);
+          } finally {
+            job.current = null;
+          }
+        });
+      } catch (error) {
+        if (error instanceof FatalImportError) throw error;
+        result = failed(candidateId, 'importFailed');
+      }
+      if (result === null) break;
+      record(job, result);
+    }
+    touch(job, { state: job.cancelRequested ? 'stopped' : 'completed' });
+  } catch (error) {
+    touch(job, { state: 'failed', current: null, errorCode: error?.code || 'importFailed' });
+  }
+  pruneFinishedJobs();
+}
+
+/** Candidate ids of a selection; a `viewId` resolves the view's complete membership. */
+async function selectionIds(selection, imported) {
+  if (!selection || typeof selection !== 'object') throw new TypeError('selection is required.');
+  if (Array.isArray(selection.ids)) {
+    if (!selection.ids.every((id) => typeof id === 'string' && id)) throw new TypeError('selection.ids must be ids.');
+    return [...new Set(selection.ids)];
+  }
+  if (typeof selection.viewId === 'string') {
+    if (selection.excludeIds !== undefined && !Array.isArray(selection.excludeIds)) {
+      throw new TypeError('selection.excludeIds must be ids.');
+    }
+    return resolveViewSelection(selection.viewId, selection.excludeIds, await imported());
+  }
+  throw new TypeError('selection must carry ids or a viewId.');
+}
+
+function requireParams(params) {
+  if (!params || typeof params !== 'object' || Array.isArray(params)) throw new TypeError('expected one object.');
+  return params;
+}
+
+/**
+ * Runtime API slice. deps:
+ *   listSessionSummaries()  async session summary rows (carrying `importKey`), read once per listing/batch
+ *   prepareLeadOptions()    async createSession options of a Lead session on the current route
+ *   createSession(opts)     the session manager's createSession
+ *   sessionExists(id)       async: whether a session is still in storage (default: its file exists)
+ *   ingestSession(session)  content-search ingestion of an imported session (default: ingestSessionTurn)
+ *   limits                  convertCandidateFile limits (maxFileBytes, maxLineBytes, maxTranscriptChars, …)
+ */
+export function createConversationImportApi({
+  listSessionSummaries,
+  prepareLeadOptions,
+  createSession,
+  env,
+  sessionExists = sessionFileExists,
+  ingestSession,
+  limits,
+}) {
+  const summaries = async () => (await listSessionSummaries?.()) || [];
+  const imported = async () => importedLookup(await summaries(), sessionExists);
+  return {
+    async listImportableConversations(params) {
+      return listConversations(requireParams(params), { imported: await imported(), env });
+    },
+    async registerConversationImportFile(params) {
+      return registerFile(requireParams(params), { imported: await imported(), limits });
+    },
+    getConversationImportJobs(params = {}) {
+      const { jobId } = requireParams(params ?? {});
+      const list = [...jobs.values()].filter((job) => jobId === undefined || jobId === null || job.jobId === jobId);
+      return { jobs: list.map(snapshot) };
+    },
+    async startConversationImport(params) {
+      const { requestId, selection } = requireParams(params);
+      if (typeof requestId !== 'string' || !requestId.trim() || requestId.length > MAX_REQUEST_ID_LENGTH) {
+        throw new TypeError('requestId is required.');
+      }
+      const existing = jobs.get(jobsByRequest.get(requestId));
+      if (existing) return snapshot(existing);
+      let pending = pendingStarts.get(requestId);
+      if (!pending) {
+        pending = (async () => {
+          const candidateIds = await selectionIds(selection, imported);
+          const job = {
+            jobId: randomUUID(),
+            requestId,
+            seq: 0,
+            state: 'running',
+            total: candidateIds.length,
+            imported: 0,
+            skippedAlreadyImported: 0,
+            failed: 0,
+            byProject: new Map(),
+            results: [],
+            current: null,
+            errorCode: null,
+            cancelRequested: false,
+          };
+          jobs.set(job.jobId, job);
+          jobsByRequest.set(requestId, job.jobId);
+          void runJob(job, candidateIds, {
+            importedLookup: imported,
+            imported: null,
+            sessionExists,
+            limits,
+            prepareLeadOptions,
+            leadOptions: null,
+            createImportedSession: (args) =>
+              createImportedSession({
+                ...args,
+                ...(createSession ? { createSessionFn: createSession } : {}),
+                ...(ingestSession ? { ingestFn: ingestSession } : {}),
+              }),
+          });
+          return job;
+        })();
+        pendingStarts.set(requestId, pending);
+        pending.then(
+          () => pendingStarts.delete(requestId),
+          () => pendingStarts.delete(requestId)
+        );
+      }
+      return snapshot(await pending);
+    },
+    cancelConversationImport(params) {
+      const { jobId } = requireParams(params);
+      const job = typeof jobId === 'string' ? jobs.get(jobId) : null;
+      if (!job) throw importError('jobNotFound');
+      if (job.state === 'running') {
+        job.cancelRequested = true;
+        touch(job, { state: 'stopping' });
+      }
+      return snapshot(job);
+    },
+  };
+}

package/src/session-runtime/cwd-plugins/cwd-apply.mjs

@@ -20,6 +20,7 @@ export function createCwdApply({
   writeLastSessionCwd,
   updateCurrentCwdOverride,
   persistSession,
+  onCwdChanged,
   clean,
   resolve,
   statSync,
@@ -53,10 +54,11 @@ export function createCwdApply({
     }
   }
 
-  // cwd changes NEVER recreate the session and never reload MCP or Skills
-  // (extension settings are global): a mid-conversation cwd switch must
-  // preserve the full message history. The live execution cwd is retargeted in
-  // place; the BP3 session snapshot remains the session-start environment.
+  // cwd changes NEVER recreate the session and never reload Skills (extension
+  // settings are global): a mid-conversation cwd switch must preserve the full
+  // message history. The live execution cwd is retargeted in place; the BP3
+  // session snapshot remains the session-start environment. `onCwdChanged`
+  // lets MCP reconnect only the plugin servers that run in the session cwd.
   function applyResolvedCwd(nextCwd, { persistProjectSelection: persist = false } = {}) {
     const resolved = resolve(nextCwd);
     const stat = statSync(resolved);
@@ -84,7 +86,10 @@ export function createCwdApply({
     if (changed) {
       try {
         void hooks.dispatch('CwdChanged', hookCommonPayload({ cwd: currentCwd }));
-      } catch {}
+      } catch {
+        // Hook dispatch is fire-and-forget; a synchronous throw must not block the cwd switch.
+      }
+      onCwdChanged?.(currentCwd);
     }
     return currentCwd;
   }

package/src/session-runtime/cwd-plugins/plugin-status.mjs

@@ -1,16 +1,15 @@
 // cwd-plugins/plugin-status.mjs — the registered-plugin status list with its
-// per-root caches (manifest keyed on mtime, MCP discovery and skill-file count
-// on a short TTL).
+// manifest cache (keyed on mtime); skill count and MCP discovery are live.
 import { readFileSync } from 'node:fs';
 import { discoverPluginMcp } from '../../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { PLUGIN_MANIFEST_FILES, pluginSkillsRoots } from '../../runtime/shared/plugin-manifest.mjs';
 import { pluginMetadata } from '../../runtime/shared/plugin-metadata.mjs';
 
 export function createPluginStatus({
-  getConfig,
   listRegisteredPlugins,
   pluginAdminStatus,
   pluginManifest,
-  pluginMcpServerName,
+  pluginMcpSummary = () => new Map(),
   countSkillFiles,
   clean,
   resolve,
@@ -18,16 +17,13 @@ export function createPluginStatus({
   existsSync,
   cfgMod,
 }) {
-  // Per-plugin-root caches for pluginsStatus(): manifest + MCP discovery keyed
-  // by root path + manifest mtime (invalidated on manifest edit); recursive
-  // skill-file count keyed by root with a ~5s TTL fallback (the walk has no
-  // single mtime to key on).
+  // Per-plugin-root manifest cache keyed by root path + manifest mtimes
+  // (invalidated on manifest edit). Skill count and MCP discovery are
+  // recomputed on every call so file add/remove shows up immediately.
   const pluginRootCache = new Map();
-  const skillCountCache = new Map();
-  const mcpDiscoveryCache = new Map();
   function manifestMtimeKey(root) {
     let key = '';
-    for (const rel of ['.codex-plugin/plugin.json', 'plugin.json']) {
+    for (const rel of PLUGIN_MANIFEST_FILES) {
       try {
         key += `${statSync(resolve(root, rel)).mtimeMs}:`;
       } catch {
@@ -38,7 +34,7 @@ export function createPluginStatus({
   }
   // A manifest file that exists but is not a JSON object is breakage.
   function manifestInvalid(root) {
-    for (const rel of ['.codex-plugin/plugin.json', 'plugin.json']) {
+    for (const rel of PLUGIN_MANIFEST_FILES) {
       const file = resolve(root, rel);
       if (!existsSync(file)) continue;
       try {
@@ -58,33 +54,20 @@ export function createPluginStatus({
     pluginRootCache.set(root, entry);
     return entry;
   }
-  // MCP discovery probes candidate script files (.mcp.json, scripts/run-mcp.mjs,
-  // ...) whose add/remove is NOT reflected in the manifest mtime, so key it on a
-  // short TTL instead (~5s, like the skill-file count).
-  function cachedMcpDiscovery(root) {
-    const now = Date.now();
-    const hit = mcpDiscoveryCache.get(root);
-    if (hit && now - hit.at < 5000) return hit.mcp;
-    const mcp = discoverPluginMcp(root);
-    mcpDiscoveryCache.set(root, { at: now, mcp });
-    return mcp;
-  }
-  function cachedSkillCount(root) {
-    const now = Date.now();
-    const hit = skillCountCache.get(root);
-    if (hit && now - hit.at < 5000) return hit.count;
-    const count = countSkillFiles(root);
-    skillCountCache.set(root, { at: now, count });
-    return count;
-  }
 
-  function registeredPlugin(entry, configuredMcp) {
+  function registeredPlugin(entry, mcpByPlugin) {
     const root = clean(entry.root);
     if (!root) return null;
-    if (!existsSync(root)) return { missing: true, id: clean(entry.id) || clean(entry.name) || root, name: clean(entry.name) || clean(entry.id) || root.split(/[\\/]/).pop() || root };
+    if (!existsSync(root))
+      return {
+        missing: true,
+        id: clean(entry.id) || clean(entry.name) || root,
+        name: clean(entry.name) || clean(entry.id) || root.split(/[\\/]/).pop() || root,
+      };
     const { manifest, invalid } = cachedPluginData(root);
     const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || root.split(/[\\/]/).pop() || root;
-    const { mcpScript, mcpInline } = cachedMcpDiscovery(root);
+    const { mcpScript, mcpInline } = discoverPluginMcp(root);
+    const skillCount = countSkillFiles(root);
     const plugin = {
       id: clean(entry.id) || name,
       name,
@@ -101,26 +84,48 @@ export function createPluginStatus({
       root,
       installedAt: entry.installedAt || null,
       updatedAt: entry.updatedAt || null,
-      skillCount: cachedSkillCount(root),
+      skillCount,
       mcpScript,
       mcpInline,
     };
     if (invalid) plugin.invalid = true;
-    plugin.mcpServerName = pluginMcpServerName(plugin);
-    plugin.mcpEnabled =
-      Object.hasOwn(configuredMcp, plugin.mcpServerName) ||
-      Object.keys(configuredMcp).some((k) => k.startsWith(`${plugin.mcpServerName}--`));
+    if (plugin.enabled && skillCount === 0 && !mcpScript && !mcpInline) {
+      plugin.searchedSkillRoots = pluginSkillsRoots(root);
+      plugin.warning = `No skills or MCP server found. Searched skill roots: ${plugin.searchedSkillRoots.join(', ')}`;
+    }
+    // Servers the plugin declares, live: name, declared key, intent/effective
+    // state, connection, and declaration problems.
+    const mcp = mcpByPlugin.get(plugin.id) || { format: 'none', errors: [], servers: [] };
+    plugin.mcpFormat = mcp.format;
+    plugin.mcpErrors = mcp.errors;
+    plugin.mcpServers = mcp.servers.filter(Boolean).map((row) => ({
+      name: row.name,
+      key: row.owner?.key || '',
+      enabled: row.enabled !== false,
+      serverEnabled: row.serverEnabled !== false,
+      connected: row.connected === true,
+      status: row.status,
+      error: row.error || null,
+      warnings: row.warnings || [],
+      cwdDependent: row.owner?.cwdDependent === true,
+    }));
+    plugin.mcpServerName = plugin.mcpServers[0]?.name || '';
+    plugin.mcpEnabled = plugin.mcpServers.some((server) => server.serverEnabled);
     return plugin;
   }
 
   function pluginsStatus() {
-    const config = getConfig();
     const dataDir = cfgMod.getPluginData?.();
-    const configuredMcp = config?.mcpServers && typeof config.mcpServers === 'object' ? config.mcpServers : {};
+    let mcpByPlugin = new Map();
+    try {
+      mcpByPlugin = pluginMcpSummary();
+    } catch {
+      /* status still lists plugins without their MCP rows */
+    }
     const plugins = [];
     const missing = [];
     for (const entry of listRegisteredPlugins({ dataDir })) {
-      const plugin = registeredPlugin(entry, configuredMcp);
+      const plugin = registeredPlugin(entry, mcpByPlugin);
       if (plugin?.missing) missing.push({ id: plugin.id, name: plugin.name, enabled: entry.enabled !== false });
       else if (plugin) plugins.push(plugin);
     }

package/src/session-runtime/lifecycle/session-catalog.mjs

@@ -93,6 +93,8 @@ function leadSessionRow(s, heartbeatMtimes) {
     // sessions under the sidebar Automations section instead of Recent.
     sourceType: sourceType || null,
     sourceName: clean(s.sourceName || '') || null,
+    createdAt: Number(s.createdAt) || 0,
+    inheritedFromSessionId: clean(s.inheritedFromSessionId || '') || null,
   };
 }
 

package/src/session-runtime/lifecycle/teardown.mjs

@@ -178,7 +178,7 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
     if (scope.detach) await settleDetached(withTeardownDeadline, stops);
     else await settleAll(withTeardownDeadline, stops);
     // The session went away (idle eviction included): free its save baselines.
-    if (scope.closingSessionId) forgetSessionSaveBaseline(scope.closingSessionId);
+    if (scope.closingSessionId) forgetSessionSaveBaseline(scope.closingSessionId, { releaseWriteControl: true });
     // Self-update stages in the background and swaps on the next clean launch
     // (see staged-update.mjs) — nothing installs at shutdown. On a real
     // process exit we just drop this session's live-refcount pid file so a