codesesh 1.0.8 → 1.0.9

package/dist/{chunk-RBCCNCDO.js → chunk-ZDH2BKQK.js}

@@ -32,14 +32,14 @@ import {
   reportFieldMismatch,
   resolveSessionTitle,
   safeParseJsonRecord
-} from "./chunk-YLXHGL4S.js";
+} from "./chunk-MOZLVHCC.js";
 
-// ../core/dist/chunk-V6GZEKLJ.mjs
+// ../core/dist/chunk-SJU7QB6Z.mjs
 import { statSync } from "fs";
 import { readdirSync, statSync as statSync2 } from "fs";
 import { join } from "path";
 import { existsSync as existsSync2, readFileSync, statSync as statSync3 } from "fs";
-import { join as join3, basename, dirname } from "path";
+import { join as join3, basename, dirname, isAbsolute as isAbsolute2, relative, sep } from "path";
 import { existsSync } from "fs";
 import { homedir, platform } from "os";
 import { isAbsolute, join as join2, resolve } from "path";
@@ -68,6 +68,12 @@ import * as zlib from "zlib";
 import { createHash as createHash2 } from "crypto";
 import { readFileSync as readFileSync8 } from "fs";
 import { join as join13 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { homedir as homedir4, platform as platform4 } from "os";
+import { join as join15 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { homedir as homedir5, platform as platform5 } from "os";
+import { join as join16 } from "path";
 function fingerprintMatches(ref, cached) {
   return typeof cached?.sourceFingerprint === "string" && cached.sourceFingerprint === ref.fingerprint;
 }
@@ -1423,6 +1429,16 @@ var ClaudeCodeAgent = class extends SingleFileSessionSource {
     }
     return false;
   }
+  filterCachedSessions(sessions) {
+    const basePath = this.basePath ?? this.findBasePath();
+    if (!basePath) return sessions;
+    return sessions.filter((session) => {
+      const sourcePath = this.sessionMetaMap.get(session.reference.sessionId)?.sourcePath;
+      if (!sourcePath) return true;
+      const path = relative(basePath, sourcePath);
+      return path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute2(path);
+    });
+  }
   listSessionSources(options) {
     if (!this.basePath) return [];
     const projectDirs = this.listProjectDirs();
@@ -8305,6 +8321,674 @@ function isMissingDirectory(error) {
   const code = error.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
+function parseDeepChatJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function deepChatTokens(metadata) {
+  const input = asNumber(metadata.inputTokens);
+  const output = asNumber(metadata.outputTokens);
+  if (input === void 0 && output === void 0) return void 0;
+  const cacheRead = Math.max(0, asNumber(metadata.cachedInputTokens) ?? 0);
+  const cacheCreate = Math.max(0, asNumber(metadata.cacheWriteInputTokens) ?? 0);
+  return {
+    input: Math.max(0, input ?? 0),
+    output: Math.max(0, output ?? 0),
+    cache_read: Math.min(cacheRead, Math.max(0, input ?? 0)),
+    cache_create: Math.min(cacheCreate, Math.max(0, (input ?? 0) - cacheRead))
+  };
+}
+function deepChatAssistantPart(block) {
+  const time_created = asNumber(block.timestamp);
+  const content = asString(block.content);
+  if (block.type === "tool_call") {
+    const tool = asRecord(block.tool_call);
+    if (!tool) return null;
+    const status = block.status === "pending" || block.status === "loading" ? "running" : block.status === "error" || block.status === "denied" ? "error" : "completed";
+    const output = parseDeepChatJson(tool.response);
+    return {
+      type: "tool",
+      tool: asString(tool.name) ?? "unknown",
+      callID: asString(tool.id),
+      time_created,
+      state: {
+        status,
+        input: parseDeepChatJson(tool.params),
+        output,
+        error: status === "error" ? output ?? content : void 0,
+        metadata: asRecord(block.extra)
+      }
+    };
+  }
+  if (block.type === "image") {
+    const image = asRecord(block.image_data);
+    const data = asString(image?.data);
+    const mime = asString(image?.mimeType);
+    if (data && mime) return { type: "image", data, mime_type: mime, time_created };
+  }
+  if (!content) return null;
+  return {
+    type: block.type === "reasoning_content" ? "reasoning" : "text",
+    text: content,
+    time_created
+  };
+}
+function deepChatStoredBlockPart(row) {
+  const extra = asRecord(parseDeepChatJson(row.extra_json));
+  return deepChatAssistantPart({
+    type: row.block_type,
+    content: row.text_content,
+    status: row.status,
+    timestamp: extra?.timestamp ?? row.updated_at,
+    extra: extra?.extra,
+    tool_call: {
+      id: row.tool_call_id,
+      name: row.tool_name,
+      params: row.tool_params,
+      response: row.tool_response
+    },
+    image_data: { data: extra?.imageData, mimeType: row.image_mime_type }
+  });
+}
+function deepChatUserParts(content) {
+  const parts = [];
+  const text = asString(content.text);
+  if (text) parts.push({ type: "text", text });
+  for (const file of asArray(content.files) ?? []) {
+    const record = asRecord(file);
+    const path = asString(record?.path);
+    const name = asString(record?.name);
+    if (path || name) parts.push({ type: "text", text: `Attachment: ${path ?? name}` });
+  }
+  for (const link of asArray(content.links) ?? []) {
+    if (typeof link === "string") parts.push({ type: "text", text: link });
+  }
+  return parts;
+}
+function deepChatRawParts(role, content) {
+  const parsed = parseDeepChatJson(content);
+  if (role === "user") {
+    const user = asRecord(parsed);
+    if (user) return deepChatUserParts(user);
+  }
+  if (Array.isArray(parsed)) {
+    const parts = [];
+    for (const value of parsed) {
+      const block = asRecord(value);
+      const part = block ? deepChatAssistantPart(block) : null;
+      if (part) parts.push(part);
+    }
+    return parts;
+  }
+  return typeof parsed === "string" && parsed ? [{ type: "text", text: parsed }] : [];
+}
+var AGENT_METADATA11 = getAgentCatalogEntry("deepchat");
+function resolveDeepChatDataRoot() {
+  const configured = readEnvPath("DEEPCHAT_USER_DATA_DIR");
+  if (configured) return configured;
+  if (platform4() === "darwin") return join15(homedir4(), "Library", "Application Support", "DeepChat");
+  if (platform4() === "win32") {
+    return join15(readEnvPath("APPDATA") ?? join15(homedir4(), "AppData", "Roaming"), "DeepChat");
+  }
+  return join15(readEnvPath("XDG_CONFIG_HOME") ?? join15(homedir4(), ".config"), "DeepChat");
+}
+function accumulateUsage(session, row) {
+  const model = asString(row.model) ?? session.model;
+  const provider = asString(row.provider) ?? session.provider;
+  const tokens = deepChatTokens(row);
+  if (!tokens && asNumber(row.totalTokens) === void 0) return;
+  const input = tokens?.input ?? 0;
+  const output = tokens?.output ?? 0;
+  const total = Math.max(0, asNumber(row.totalTokens) ?? input + output);
+  const { result: estimate, unpricedModels } = capturePricingMisses(
+    () => estimateTokenCost(model, tokens)
+  );
+  for (const missing of unpricedModels) session.unpricedModels.add(missing);
+  const cost = estimate ?? 0;
+  const stats = session.head.stats;
+  stats.total_input_tokens += input;
+  stats.total_output_tokens += output;
+  stats.total_tokens = (stats.total_tokens ?? 0) + total;
+  stats.total_cache_read_tokens = (stats.total_cache_read_tokens ?? 0) + (tokens?.cache_read ?? 0);
+  stats.total_cache_create_tokens = (stats.total_cache_create_tokens ?? 0) + (tokens?.cache_create ?? 0);
+  stats.total_cost += cost;
+  if (cost > 0) stats.cost_source = "estimated";
+  if (model && total > 0) {
+    const usage = session.head.model_usage ??= /* @__PURE__ */ Object.create(null);
+    usage[model] = (usage[model] ?? 0) + total;
+  }
+  const messageId = asString(row.message_id);
+  if (!messageId) return;
+  const previous = session.messageUsage.get(messageId);
+  session.messageUsage.set(messageId, {
+    model,
+    provider,
+    cost: (previous?.cost ?? 0) + cost,
+    tokens: {
+      input: (previous?.tokens.input ?? 0) + input,
+      output: (previous?.tokens.output ?? 0) + output,
+      cache_read: (previous?.tokens.cache_read ?? 0) + (tokens?.cache_read ?? 0),
+      cache_create: (previous?.tokens.cache_create ?? 0) + (tokens?.cache_create ?? 0)
+    }
+  });
+}
+var DeepChatAgent = class extends DatabaseSessionSource {
+  name = AGENT_METADATA11.name;
+  displayName = AGENT_METADATA11.displayName;
+  sourceRoot;
+  constructor(options = {}) {
+    super();
+    this.sourceRoot = options.sourceRoot ?? resolveDeepChatDataRoot();
+  }
+  getDatabasePath() {
+    return firstExisting(join15(this.sourceRoot, "app_db", "agent.db"));
+  }
+  isAvailable() {
+    return isSqliteAvailable() && this.getDatabasePath() !== null;
+  }
+  getSessionWatchPlan() {
+    return {
+      status: "supported",
+      targets: [{ root: this.sourceRoot, path: join15(this.sourceRoot, "app_db", "agent.db") }]
+    };
+  }
+  readDatabase(read) {
+    const path = this.getDatabasePath();
+    if (!path) throw new Error("DeepChat agent.db is missing");
+    return this.scanStep("reading unencrypted DeepChat agent.db", path, () => {
+      const db = openDbReadOnly(path);
+      if (!db)
+        throw new Error("Cannot open DeepChat agent.db; only unencrypted databases are supported");
+      try {
+        return db.transaction(() => read(db))();
+      } finally {
+        db.close();
+      }
+    });
+  }
+  scan(options) {
+    if (!this.getDatabasePath()) return [];
+    return this.readDatabase((db) => {
+      const projections = this.readProjections(db);
+      const selected = /* @__PURE__ */ new Set();
+      const children = /* @__PURE__ */ new Map();
+      for (const [id, projection] of projections) {
+        const parent = projection.head.parent_reference?.sessionId;
+        if (parent && projections.has(parent)) {
+          const siblings = children.get(parent) ?? [];
+          siblings.push(id);
+          children.set(parent, siblings);
+        } else if (matchesScanWindow(projection.head.time_updated ?? projection.head.time_created, options)) {
+          selected.add(id);
+        }
+      }
+      if (options?.includeRelatedSessions !== false) {
+        for (const id of selected) {
+          for (const child of children.get(id) ?? []) selected.add(child);
+        }
+      }
+      const sessions = [];
+      for (const id of selected) {
+        const projection = projections.get(id);
+        if (projection.head.stats.message_count === 0) continue;
+        this.rememberSession(id, {
+          sourceFingerprint: projection.signature.digest("hex"),
+          headParserVersion: "deepchat-v1",
+          unpricedModels: [...projection.unpricedModels]
+        });
+        sessions.push(projection.head);
+      }
+      sessions.sort(
+        (left, right) => (right.time_updated ?? 0) - (left.time_updated ?? 0) || left.reference.sessionId.localeCompare(right.reference.sessionId)
+      );
+      options?.onProgress?.({
+        total: selected.size,
+        processed: selected.size,
+        sessions: sessions.length
+      });
+      return sessions;
+    });
+  }
+  readProjections(db, sessionId) {
+    const filter = sessionId ? "AND s.id = ?" : "";
+    const bindings = sessionId ? [sessionId] : [];
+    const projections = /* @__PURE__ */ new Map();
+    const sessions = db.prepare(`
+      SELECT s.id, s.agent_id, s.title, s.project_dir, s.parent_session_id,
+        s.created_at, s.updated_at, s.revision, d.model_id, d.provider_id
+      FROM new_sessions s LEFT JOIN deepchat_sessions d ON d.id = s.id
+      WHERE s.is_draft = 0 ${filter}
+      ORDER BY s.id
+    `).iterate(...bindings);
+    for (const row of sessions) {
+      const id = String(row.id);
+      const parent = asString(row.parent_session_id);
+      projections.set(id, {
+        head: {
+          ...this.sessionIdentity(id),
+          title: resolveSessionTitle(asString(row.title), null, null),
+          directory: asString(row.project_dir) ?? "",
+          parent_reference: parent ? { agentName: this.name, sessionId: parent } : void 0,
+          time_created: Number(row.created_at),
+          time_updated: Number(row.updated_at),
+          stats: { message_count: 0, total_input_tokens: 0, total_output_tokens: 0, total_cost: 0 }
+        },
+        agentId: String(row.agent_id),
+        model: asString(row.model_id) ?? null,
+        provider: asString(row.provider_id) ?? null,
+        signature: createHash3("sha256").update(JSON.stringify(row)),
+        unpricedModels: /* @__PURE__ */ new Set(),
+        messageUsage: /* @__PURE__ */ new Map()
+      });
+    }
+    const usageRows = db.prepare(`
+      SELECT u.session_id, u.message_id, u.usage_id, u.created_at, u.updated_at,
+        u.model_id AS model, u.provider_id AS provider,
+        u.input_tokens AS inputTokens, u.output_tokens AS outputTokens,
+        u.total_tokens AS totalTokens, u.cached_input_tokens AS cachedInputTokens,
+        u.cache_write_input_tokens AS cacheWriteInputTokens
+      FROM deepchat_usage_stats u JOIN new_sessions s ON s.id = u.session_id
+      WHERE s.is_draft = 0 ${filter}
+      ORDER BY u.session_id, u.usage_id
+    `).iterate(...bindings);
+    for (const row of usageRows) {
+      const projection = projections.get(String(row.session_id));
+      accumulateUsage(projection, row);
+      projection.signature.update(JSON.stringify(row));
+      projection.head.time_updated = Math.max(
+        projection.head.time_updated ?? 0,
+        Number(row.created_at)
+      );
+    }
+    const messageRows = db.prepare(`
+      SELECT m.id, m.session_id, m.order_seq, m.role, m.status, m.metadata, m.updated_at
+      FROM deepchat_messages m JOIN new_sessions s ON s.id = m.session_id
+      WHERE s.is_draft = 0 ${filter}
+      ORDER BY m.session_id, m.order_seq, m.id
+    `).iterate(...bindings);
+    for (const row of messageRows) {
+      const projection = projections.get(String(row.session_id));
+      projection.signature.update(JSON.stringify(row));
+      projection.head.stats.message_count += 1;
+      projection.head.time_updated = Math.max(
+        projection.head.time_updated ?? 0,
+        Number(row.updated_at)
+      );
+      const metadata = asRecord(parseDeepChatJson(row.metadata));
+      if (row.role === "assistant" && metadata && !projection.messageUsage.has(String(row.id))) {
+        accumulateUsage(projection, { ...metadata, message_id: row.id });
+      }
+    }
+    const blockActivity = db.prepare(`
+      SELECT m.session_id, COUNT(*) AS block_count, MAX(b.updated_at) AS updated_at,
+        SUM(b.updated_at) AS block_revision
+      FROM deepchat_assistant_blocks b
+      JOIN deepchat_messages m ON m.id = b.message_id
+      JOIN new_sessions s ON s.id = m.session_id
+      WHERE s.is_draft = 0 ${filter}
+      GROUP BY m.session_id ORDER BY m.session_id
+    `).iterate(...bindings);
+    for (const row of blockActivity) {
+      const projection = projections.get(String(row.session_id));
+      projection.signature.update(JSON.stringify(row));
+      projection.head.time_updated = Math.max(
+        projection.head.time_updated ?? 0,
+        Number(row.updated_at)
+      );
+    }
+    return projections;
+  }
+  getSessionData(sessionId) {
+    return this.readDatabase((db) => {
+      const projection = this.readProjections(db, sessionId).get(sessionId);
+      if (!projection) throw new Error(`DeepChat session not found: ${sessionId}`);
+      const partsByMessage = this.readStructuredParts(db, sessionId);
+      const rows = db.prepare(`
+        SELECT id, role, content, metadata, status, created_at, updated_at
+        FROM deepchat_messages WHERE session_id = ? ORDER BY order_seq, id
+      `).iterate(sessionId);
+      const messages = [];
+      for (const row of rows) {
+        if (row.role !== "user" && row.role !== "assistant") continue;
+        const id = String(row.id);
+        const metadata = asRecord(parseDeepChatJson(row.metadata));
+        const usage = projection.messageUsage.get(id);
+        messages.push({
+          id,
+          role: row.role,
+          agent: row.role === "assistant" ? projection.agentId : void 0,
+          time_created: Number(row.created_at),
+          time_completed: row.status === "pending" ? void 0 : Number(row.updated_at),
+          model: usage?.model ?? asString(metadata?.model) ?? projection.model,
+          provider: usage?.provider ?? asString(metadata?.provider) ?? projection.provider,
+          tokens: usage?.tokens,
+          cost: usage?.cost,
+          cost_source: usage && usage.cost > 0 ? "estimated" : void 0,
+          parts: partsByMessage.get(id) ?? deepChatRawParts(row.role, String(row.content))
+        });
+      }
+      return { ...projection.head, messages };
+    });
+  }
+  readStructuredParts(db, sessionId) {
+    const parts = /* @__PURE__ */ new Map();
+    const blocks = db.prepare(`
+      SELECT b.* FROM deepchat_assistant_blocks b
+      JOIN deepchat_messages m ON m.id = b.message_id
+      WHERE m.session_id = ? ORDER BY b.message_id, b.block_index
+    `).iterate(sessionId);
+    for (const block of blocks) {
+      const id = String(block.message_id);
+      const messageParts = parts.get(id) ?? [];
+      const part = deepChatStoredBlockPart(block);
+      if (part) messageParts.push(part);
+      parts.set(id, messageParts);
+    }
+    const users = db.prepare(`
+      SELECT u.message_id, u.text FROM deepchat_user_messages u
+      JOIN deepchat_messages m ON m.id = u.message_id WHERE m.session_id = ?
+    `).iterate(sessionId);
+    for (const user of users) parts.set(String(user.message_id), deepChatUserParts(user));
+    const attachments = db.prepare(`
+      SELECT f.message_id, f.path, f.name FROM deepchat_user_message_files f
+      JOIN deepchat_messages m ON m.id = f.message_id
+      WHERE m.session_id = ? ORDER BY f.message_id, f.ordinal
+    `).iterate(sessionId);
+    for (const attachment of attachments) {
+      parts.get(String(attachment.message_id))?.push(...deepChatUserParts({ files: [attachment] }));
+    }
+    const links = db.prepare(`
+      SELECT l.message_id, l.url FROM deepchat_user_message_links l
+      JOIN deepchat_messages m ON m.id = l.message_id
+      WHERE m.session_id = ? ORDER BY l.message_id, l.ordinal
+    `).iterate(sessionId);
+    for (const link of links)
+      parts.get(String(link.message_id))?.push(...deepChatUserParts({ links: [link.url] }));
+    return parts;
+  }
+};
+function jsonRecord(value) {
+  return asRecord(typeof value === "string" ? JSON.parse(value) : value);
+}
+function nonnegative(value) {
+  return Math.max(0, asNumber(value) ?? 0);
+}
+function tokensFromStats(stats) {
+  if (!stats) return void 0;
+  const input = asRecord(stats.inputTokenDetails);
+  const output = asRecord(stats.outputTokenDetails);
+  return {
+    input: asNumber(stats.inputTokens) ?? nonnegative(input?.noCacheTokens) + nonnegative(input?.cacheReadTokens) + nonnegative(input?.cacheWriteTokens),
+    output: asNumber(stats.outputTokens) ?? nonnegative(output?.textTokens) + nonnegative(output?.reasoningTokens),
+    cache_read: nonnegative(input?.cacheReadTokens),
+    cache_create: nonnegative(input?.cacheWriteTokens),
+    reasoning: nonnegative(output?.reasoningTokens)
+  };
+}
+function messageCost(stats, model, tokens) {
+  const costs = (asArray(stats?.costs) ?? []).flatMap((value) => {
+    const cost2 = asRecord(value);
+    return cost2 ? [cost2] : [];
+  });
+  if (costs.length > 0 && costs.every((cost2) => cost2.currency === "USD")) {
+    return {
+      cost: costs.reduce((sum, cost2) => sum + nonnegative(cost2.amount), 0),
+      costSource: costs.some((cost2) => nonnegative(cost2.computedRequestCount) > 0) ? "estimated" : "recorded"
+    };
+  }
+  const cost = estimateTokenCost(model, tokens ? { ...tokens, reasoning: 0 } : void 0);
+  return {
+    cost: cost ?? void 0,
+    costSource: cost === null ? void 0 : "estimated"
+  };
+}
+function convertPart(part) {
+  const type = asString(part.type);
+  const text = asString(part.text);
+  if ((type === "text" || type === "reasoning") && text) return { type, text };
+  if (type === "dynamic-tool" || type?.startsWith("tool-")) {
+    const state = asString(part.state);
+    const failed = state === "output-error" || state === "output-denied";
+    return {
+      type: "tool",
+      tool: asString(part.toolName) ?? (type === "dynamic-tool" ? "unknown" : type.slice(5)),
+      callID: asString(part.toolCallId),
+      title: asString(part.title),
+      state: {
+        status: failed ? "error" : state === "output-available" ? "completed" : "running",
+        input: part.input,
+        output: part.output,
+        error: failed ? part.errorText ?? "Tool execution failed" : void 0,
+        metadata: part.providerMetadata
+      }
+    };
+  }
+  if (type === "file") {
+    const url = asString(part.url);
+    const mime = asString(part.mediaType);
+    if (url && mime?.startsWith("image/")) return { type: "image", url, mime_type: mime };
+    const label = asString(part.filename) ?? url;
+    return label ? { type: "text", text: `Attachment: ${label}` } : null;
+  }
+  const data = asRecord(part.data);
+  if (type === "data-error") {
+    const message = asString(data?.message);
+    return message ? { type: "text", text: message } : null;
+  }
+  if (type === "data-compact" || type === "data-code" || type === "data-translation") {
+    const content = asString(data?.content);
+    return content ? { type: "text", text: content } : null;
+  }
+  return null;
+}
+function cherryStudioTranscript(rows) {
+  const builder = new TranscriptBuilder();
+  const modelUsage = /* @__PURE__ */ Object.create(null);
+  let totalTokens = 0;
+  for (const row of rows) {
+    if (row.role !== "user" && row.role !== "assistant") continue;
+    const data = jsonRecord(row.data);
+    const snapshot = jsonRecord(row.message_snapshot);
+    const modelSnapshot = asRecord(snapshot?.model);
+    const uniqueModel = asString(row.model_id);
+    const separator = uniqueModel?.indexOf("::") ?? -1;
+    const model = asString(modelSnapshot?.id) ?? (separator >= 0 ? uniqueModel?.slice(separator + 2) : uniqueModel);
+    const provider = asString(modelSnapshot?.provider) ?? (separator >= 0 ? uniqueModel?.slice(0, separator) : void 0);
+    const stats = row.role === "assistant" ? jsonRecord(row.stats) : void 0;
+    const tokens = tokensFromStats(stats);
+    const total = nonnegative(stats?.totalTokens ?? (tokens?.input ?? 0) + (tokens?.output ?? 0));
+    totalTokens += total;
+    if (model && total > 0) modelUsage[model] = (modelUsage[model] ?? 0) + total;
+    const message = builder.appendMessage({
+      id: String(row.id),
+      role: row.role,
+      timestampMs: Number(row.created_at),
+      agent: asString(snapshot?.name),
+      model,
+      provider,
+      tokens,
+      ...messageCost(stats, model, tokens),
+      parts: (asArray(data?.parts) ?? []).flatMap((value) => {
+        const part = asRecord(value);
+        const converted = part ? convertPart(part) : null;
+        return converted ? [converted] : [];
+      })
+    });
+    if (row.status !== "pending") message.time_completed = Number(row.updated_at);
+  }
+  const transcript = builder.finish();
+  return {
+    ...transcript,
+    stats: { ...transcript.stats, total_tokens: totalTokens },
+    modelUsage
+  };
+}
+var AGENT_METADATA12 = getAgentCatalogEntry("cherrystudio");
+function resolveCherryStudioDataRoot() {
+  const configured = readEnvPath("CHERRYSTUDIO_USER_DATA_DIR");
+  if (configured) return configured;
+  if (platform5() === "darwin")
+    return join16(homedir5(), "Library", "Application Support", "CherryStudio");
+  if (platform5() === "win32") {
+    return join16(readEnvPath("APPDATA") ?? join16(homedir5(), "AppData", "Roaming"), "CherryStudio");
+  }
+  return join16(readEnvPath("XDG_CONFIG_HOME") ?? join16(homedir5(), ".config"), "CherryStudio");
+}
+function liveRows(db, table, alias) {
+  const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+  return columns.some((column) => column.name === "deleted_at") ? `${alias}.deleted_at IS NULL` : "1 = 1";
+}
+function activeBranch(rows, activeId) {
+  const byId = new Map(rows.map((row) => [String(row.id), row]));
+  const selected = [];
+  const visited = /* @__PURE__ */ new Set();
+  let id = asString(activeId);
+  while (id) {
+    if (visited.has(id)) throw new Error("Cherry Studio message branch contains a cycle");
+    visited.add(id);
+    const row = byId.get(id);
+    if (!row) break;
+    selected.push(row);
+    id = asString(row.parent_id);
+  }
+  return selected.reverse();
+}
+var CherryStudioAgent = class extends DatabaseSessionSource {
+  name = AGENT_METADATA12.name;
+  displayName = AGENT_METADATA12.displayName;
+  sourceRoot;
+  constructor(options = {}) {
+    super();
+    this.sourceRoot = options.sourceRoot ?? resolveCherryStudioDataRoot();
+  }
+  getDatabasePath() {
+    return firstExisting(join16(this.sourceRoot, "Data", "cherrystudio.sqlite"));
+  }
+  isAvailable() {
+    return isSqliteAvailable() && this.getDatabasePath() !== null;
+  }
+  getSessionWatchPlan() {
+    return {
+      status: "supported",
+      targets: [
+        { root: this.sourceRoot, path: join16(this.sourceRoot, "Data", "cherrystudio.sqlite") }
+      ]
+    };
+  }
+  readDatabase(read) {
+    const path = this.getDatabasePath();
+    if (!path) throw new Error("Cherry Studio 2.x cherrystudio.sqlite is missing");
+    return this.scanStep("reading Cherry Studio 2.x cherrystudio.sqlite", path, () => {
+      const db = openDbReadOnly(path);
+      if (!db) throw new Error("Cannot open Cherry Studio database");
+      try {
+        return db.transaction(() => read(db))();
+      } finally {
+        db.close();
+      }
+    });
+  }
+  scan(options) {
+    if (!this.getDatabasePath()) return [];
+    return this.readDatabase((db) => {
+      const sessions = [];
+      for (const kind of ["agent", "topic"]) {
+        for (const projection of this.readConversations(db, kind)) {
+          const { messages: _messages, ...head } = projection.session;
+          if (!head.stats.message_count || !matchesScanWindow(head.time_updated ?? head.time_created, options))
+            continue;
+          this.rememberSession(head.reference.sessionId, {
+            sourceFingerprint: projection.fingerprint,
+            headParserVersion: "cherrystudio-v1",
+            unpricedModels: projection.unpricedModels
+          });
+          sessions.push(head);
+        }
+      }
+      sessions.sort(
+        (left, right) => (right.time_updated ?? 0) - (left.time_updated ?? 0) || left.reference.sessionId.localeCompare(right.reference.sessionId)
+      );
+      options?.onProgress?.({
+        total: sessions.length,
+        processed: sessions.length,
+        sessions: sessions.length
+      });
+      return sessions;
+    });
+  }
+  getSessionData(sessionId) {
+    const separator = sessionId.indexOf(":");
+    const kind = sessionId.slice(0, separator);
+    const id = sessionId.slice(separator + 1);
+    if (kind !== "agent" && kind !== "topic" || !id)
+      throw new Error(`Invalid Cherry Studio session: ${sessionId}`);
+    return this.readDatabase((db) => {
+      for (const projection of this.readConversations(db, kind, id)) return projection.session;
+      throw new Error(`Cherry Studio session not found: ${sessionId}`);
+    });
+  }
+  *readConversations(db, kind, id) {
+    const table = kind === "agent" ? "agent_session" : "topic";
+    const messageTable = kind === "agent" ? "agent_session_message" : "message";
+    const foreignKey = kind === "agent" ? "session_id" : "topic_id";
+    const filter = `${liveRows(db, table, "s")} ${id ? "AND s.id = ?" : ""}`;
+    const bindings = id ? [id] : [];
+    const headers = db.prepare(`
+      SELECT s.id, s.name, s.created_at, s.updated_at, s.last_activity_at,
+        ${kind === "agent" ? "w.path AS directory, NULL AS active_node_id" : "NULL AS directory, s.active_node_id"}
+      FROM ${table} s ${kind === "agent" ? "LEFT JOIN agent_workspace w ON w.id = s.workspace_id" : ""}
+      WHERE ${filter}
+    `).all(...bindings);
+    const byId = new Map(headers.map((row) => [String(row.id), row]));
+    const messages = db.prepare(`
+      SELECT m.id, m.${foreignKey} AS conversation_id, m.role, m.data, m.stats,
+        m.model_id, m.message_snapshot, m.status, m.created_at, m.updated_at,
+        ${kind === "topic" ? "m.parent_id" : "NULL AS parent_id"}
+      FROM ${messageTable} m JOIN ${table} s ON s.id = m.${foreignKey}
+      WHERE ${filter} AND ${liveRows(db, messageTable, "m")}
+      ORDER BY m.${foreignKey}, m.created_at, m.id
+    `).iterate(...bindings);
+    let currentId;
+    let rows = [];
+    for (const row of messages) {
+      const nextId = String(row.conversation_id);
+      if (currentId !== void 0 && nextId !== currentId) {
+        yield this.projectConversation(kind, byId.get(currentId), rows);
+        rows = [];
+      }
+      currentId = nextId;
+      rows.push(row);
+    }
+    if (currentId !== void 0) yield this.projectConversation(kind, byId.get(currentId), rows);
+  }
+  projectConversation(kind, row, rows) {
+    const selected = kind === "topic" ? activeBranch(rows, row.active_node_id) : rows;
+    const { result: transcript, unpricedModels } = capturePricingMisses(
+      () => cherryStudioTranscript(selected)
+    );
+    const signature = createHash4("sha256").update(JSON.stringify(row));
+    for (const message of selected) signature.update(JSON.stringify(message));
+    const session = {
+      ...this.sessionIdentity(`${kind}:${row.id}`),
+      title: resolveSessionTitle(
+        asString(row.name),
+        firstUserMessageTitle(transcript.messages),
+        "Cherry Studio"
+      ),
+      directory: asString(row.directory) || this.sourceRoot,
+      time_created: Number(row.created_at),
+      time_updated: Number(row.last_activity_at),
+      stats: transcript.stats,
+      model_usage: transcript.modelUsage,
+      messages: transcript.messages
+    };
+    return { session, fingerprint: signature.digest("hex"), unpricedModels };
+  }
+};
 var RUNTIME_REGISTRATIONS = {
   claudecode: {
     create: () => new ClaudeCodeAgent(),
@@ -8345,6 +9029,14 @@ var RUNTIME_REGISTRATIONS = {
   dsh: {
     create: () => new DshAgent(),
     resolveDataRoot: resolveDshDataRoot
+  },
+  deepchat: {
+    create: () => new DeepChatAgent(),
+    resolveDataRoot: resolveDeepChatDataRoot
+  },
+  cherrystudio: {
+    create: () => new CherryStudioAgent(),
+    resolveDataRoot: resolveCherryStudioDataRoot
   }
 };
 var AGENT_REGISTRATIONS = Object.freeze(
@@ -8387,4 +9079,4 @@ export {
   createRegisteredAgents,
   getAgentInfoMap
 };
-//# sourceMappingURL=chunk-RBCCNCDO.js.map
+//# sourceMappingURL=chunk-ZDH2BKQK.js.map