coding-tool-x 3.8.4 → 3.8.5

package/src/{server/services/opencode-sessions.js → platforms/drivers/opencode/sessions-implementation.js}

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { DatabaseSync } = require('node:sqlite');
-const { NATIVE_PATHS, PATHS } = require('../../config/paths');
+const { NATIVE_PATHS, PATHS } = require('../../../config/paths');
 
 /**
  * OpenCode 会话服务
@@ -11,14 +11,35 @@ const { NATIVE_PATHS, PATHS } = require('../../config/paths');
 
 const PROJECT_ORDER_FILE = PATHS.opencodeProjectOrder;
 const SESSION_ORDER_FILE = PATHS.opencodeSessionOrder;
-const OPENCODE_DB_PATH = path.join(NATIVE_PATHS.opencode.data, 'opencode.db');
-const COUNTS_CACHE_TTL_MS = 30 * 1000;
-const EMPTY_COUNTS = Object.freeze({ projectCount: 0, sessionCount: 0 });
+let opencodeDataDirOverride = null;
 
-let countsCache = {
-  expiresAt: 0,
-  value: EMPTY_COUNTS
-};
+function configure({ pathContext } = {}) {
+  opencodeDataDirOverride = pathContext?.customized
+    ? (pathContext.native?.data || null)
+    : null;
+}
+
+function getOpenCodeDbPath(dataDir = opencodeDataDirOverride || NATIVE_PATHS.opencode.data) {
+  const configuredPath = typeof process.env.OPENCODE_DB_PATH === 'string'
+    ? process.env.OPENCODE_DB_PATH.trim()
+    : '';
+  if (configuredPath && fs.existsSync(configuredPath)) return configuredPath;
+
+  const defaultPath = path.join(dataDir, 'opencode.db');
+  if (fs.existsSync(defaultPath)) return defaultPath;
+
+  try {
+    return fs.readdirSync(dataDir, { withFileTypes: true })
+      .filter(entry => entry.isFile() && /^opencode-.*\.db$/.test(entry.name))
+      .map(entry => {
+        const filePath = path.join(dataDir, entry.name);
+        return { filePath, mtimeMs: fs.statSync(filePath).mtimeMs };
+      })
+      .sort((a, b) => b.mtimeMs - a.mtimeMs)[0]?.filePath || defaultPath;
+  } catch (_) {
+    return defaultPath;
+  }
+}
 
 function ensureParentDir(filePath) {
   const dir = path.dirname(filePath);
@@ -71,6 +92,48 @@ function parseJsonMaybe(raw, fallback = null) {
   }
 }
 
+function isAbsolutePath(value) {
+  return typeof value === 'string' && (
+    path.isAbsolute(value)
+    || /^[a-zA-Z]:[\\/]/.test(value)
+    || value.startsWith('\\\\')
+  );
+}
+
+function getEmbeddedProjectMetadata(directory) {
+  if (!isAbsolutePath(directory)) return null;
+
+  const projectDirectory = path.normalize(directory);
+  const projectsDirectory = path.dirname(projectDirectory);
+  if (path.basename(projectsDirectory) !== 'projects') return null;
+
+  const hostDataDirectory = path.dirname(projectsDirectory);
+  const hostDatabasePath = path.join(hostDataDirectory, 'app.sqlite');
+  if (!fs.existsSync(hostDatabasePath)) return null;
+
+  let hostDb;
+  try {
+    hostDb = new DatabaseSync(hostDatabasePath, { readOnly: true, timeout: 1000 });
+    const project = hostDb.prepare(
+      'SELECT name, metadata_json FROM projects WHERE id = ? LIMIT 1'
+    ).get(path.basename(projectDirectory));
+    if (!project) return null;
+
+    const metadata = parseJsonMaybe(project.metadata_json, {});
+    const linkedDirs = Array.isArray(metadata?.linkedDirs) ? metadata.linkedDirs : [];
+    const fullPath = linkedDirs.find(isAbsolutePath) || '';
+    const displayName = typeof project.name === 'string' && project.name.trim()
+      ? project.name.trim()
+      : (fullPath ? path.basename(fullPath) : path.basename(projectDirectory));
+
+    return { displayName, fullPath };
+  } catch (_) {
+    return null;
+  } finally {
+    try { hostDb?.close(); } catch (_) {}
+  }
+}
+
 function extractTextContent(content) {
   if (typeof content === 'string') {
     return content;
@@ -152,7 +215,7 @@ function toIsoTime(input) {
 
 function _openCodeDb() {
   if (!isOpenCodeInstalled()) return null;
-  const db = new DatabaseSync(OPENCODE_DB_PATH, { readOnly: false, timeout: 5000 });
+  const db = new DatabaseSync(getOpenCodeDbPath(), { readOnly: false, timeout: 5000 });
   db.exec('PRAGMA foreign_keys = ON');
   return db;
 }
@@ -193,12 +256,9 @@ function buildContext(text, keyword, contextLength = 35) {
 
 // 检查 OpenCode 是否安装
 function isOpenCodeInstalled() {
-  return fs.existsSync(OPENCODE_DB_PATH);
+  return fs.existsSync(getOpenCodeDbPath());
 }
 
-function invalidateProjectAndSessionCountsCache() {
-  countsCache = { expiresAt: 0, value: EMPTY_COUNTS };
-}
 
 // ---------------------------------------------------------------------------
 // Project / session order (file-based)
@@ -239,6 +299,9 @@ function removeSessionFromOrder(projectId, sessionId) {
 
 function getProjectDisplayName(project) {
   if (!project) return 'Unknown';
+  if (typeof project.name === 'string' && project.name.trim()) {
+    return project.name.trim();
+  }
   const worktree = project.worktree || '';
   if (worktree) {
     const parsed = parseJsonMaybe(project.data);
@@ -250,6 +313,14 @@ function getProjectDisplayName(project) {
   return project.id || 'Unknown';
 }
 
+function getDisplayNameForPath(projectPath, fallback) {
+  if (typeof projectPath === 'string' && projectPath.trim() && projectPath !== '/') {
+    const name = path.basename(projectPath);
+    if (name) return name;
+  }
+  return fallback;
+}
+
 function getSessionLocation(sessionId) {
   const row = getSessionRowById(sessionId);
   if (!row) return null;
@@ -260,24 +331,15 @@ function getSessionLocation(sessionId) {
 // Database query functions (parameterized)
 // ---------------------------------------------------------------------------
 
-function queryProjectAndSessionCounts() {
-  const rows = _query(`
-    SELECT
-      (SELECT COUNT(*) FROM project) AS project_count,
-      (SELECT COUNT(*) FROM session WHERE time_archived IS NULL) AS session_count
-  `);
-  return rows.length > 0 ? rows[0] : { project_count: 0, session_count: 0 };
-}
 
 function getProjectRows() {
   return _query(`
     SELECT
-      p.id,
-      p.worktree,
-      p.time_created,
-      p.time_updated,
-      p.time_archived,
-      p.data
+      p.*,
+      (SELECT s.directory FROM session s
+       WHERE s.project_id = p.id AND s.time_archived IS NULL
+       ORDER BY s.time_updated DESC LIMIT 1) AS session_directory,
+      (SELECT COUNT(*) FROM session s WHERE s.project_id = p.id AND s.time_archived IS NULL) AS session_count
     FROM project p
     ORDER BY p.time_updated DESC
   `);
@@ -303,7 +365,22 @@ function getSessionRowsByProjectId(projectId) {
       s.time_created,
       s.time_updated,
       s.time_compacting,
-      s.time_archived
+      s.time_archived,
+      (
+        COALESCE((
+          SELECT SUM(LENGTH(CAST(m.data AS BLOB)))
+          FROM message m
+          WHERE m.session_id = s.id
+        ), 0)
+        + COALESCE((
+          SELECT SUM(LENGTH(CAST(p.data AS BLOB)))
+          FROM part p
+          WHERE p.session_id = s.id
+        ), 0)
+        + COALESCE(LENGTH(CAST(s.title AS BLOB)), 0)
+        + COALESCE(LENGTH(CAST(s.slug AS BLOB)), 0)
+        + COALESCE(LENGTH(CAST(s.directory AS BLOB)), 0)
+      ) AS storage_size
     FROM session s
     WHERE s.project_id = ?
       AND s.time_archived IS NULL
@@ -331,7 +408,22 @@ function getSessionRowById(sessionId) {
       s.time_created,
       s.time_updated,
       s.time_compacting,
-      s.time_archived
+      s.time_archived,
+      (
+        COALESCE((
+          SELECT SUM(LENGTH(CAST(m.data AS BLOB)))
+          FROM message m
+          WHERE m.session_id = s.id
+        ), 0)
+        + COALESCE((
+          SELECT SUM(LENGTH(CAST(p.data AS BLOB)))
+          FROM part p
+          WHERE p.session_id = s.id
+        ), 0)
+        + COALESCE(LENGTH(CAST(s.title AS BLOB)), 0)
+        + COALESCE(LENGTH(CAST(s.slug AS BLOB)), 0)
+        + COALESCE(LENGTH(CAST(s.directory AS BLOB)), 0)
+      ) AS storage_size
     FROM session s
     WHERE s.id = ?
     LIMIT 1
@@ -372,7 +464,8 @@ function normalizeSession(session, projectId) {
   return {
     sessionId: session.id,
     mtime: toIsoTime(session.time_updated) || new Date().toISOString(),
-    size: 0, // SQLite doesn't track file size natively
+    // SQLite has no per-session file, so use the UTF-8 size of its stored payloads.
+    size: Number(session.storage_size) || 0,
     filePath: `opencode://${projectId}/${session.id}`,
     gitBranch: null,
     firstMessage: session.title || null,
@@ -392,15 +485,26 @@ function normalizeSession(session, projectId) {
 // ---------------------------------------------------------------------------
 
 function getProjects(_options = {}) {
-  const projects = getProjectRows().map((project) => ({
-    name: project.id,
-    displayName: getProjectDisplayName(project),
-    fullPath: project.worktree || '/',
-    path: project.worktree || '/',
-    sessionCount: 0,
-    lastUsed: toIsoTime(project.time_updated),
-    source: 'opencode'
-  }));
+  const projects = getProjectRows().map((project) => {
+    const fallbackPath = project.worktree && project.worktree !== '/'
+      ? project.worktree
+      : project.session_directory || project.worktree || '/';
+    const embeddedProject = getEmbeddedProjectMetadata(fallbackPath);
+    const fullPath = embeddedProject?.fullPath || fallbackPath;
+    const fallbackDisplayName = embeddedProject?.displayName
+      || getProjectDisplayName({ ...project, worktree: fullPath });
+    return {
+      name: project.id,
+      displayName: embeddedProject?.fullPath
+        ? getDisplayNameForPath(fullPath, fallbackDisplayName)
+        : fallbackDisplayName,
+      fullPath,
+      path: fullPath,
+      sessionCount: Number(project.session_count) || 0,
+      lastUsed: toIsoTime(project.time_updated),
+      source: 'opencode'
+    };
+  });
 
   const order = getProjectOrder();
   return sortByOrder(projects, order, (a, b) => (b.lastUsed || '').localeCompare(a.lastUsed || ''));
@@ -446,7 +550,8 @@ function searchSessions(keyword) {
 
         if (data && data.role === 'user') {
           text = extractTextFromMessageData(data);
-        } else {
+        }
+        if (!text) {
           const messageParts = partsByMessageId.get(message.id) || [];
           for (const part of messageParts) {
             const partData = parseJsonMaybe(part.data, null);
@@ -509,7 +614,7 @@ function getSessionById(sessionId) {
   return {
     sessionId,
     mtime: toIsoTime(location.sessionData.time_updated) || new Date().toISOString(),
-    size: 0,
+    size: Number(location.sessionData.storage_size) || 0,
     filePath: `opencode://${location.projectId}/${sessionId}`,
     source: 'opencode',
     directory: location.directory || null,
@@ -518,6 +623,56 @@ function getSessionById(sessionId) {
   };
 }
 
+function getSessionStatus(sessionId) {
+  const session = getSessionById(sessionId);
+  if (!session) return null;
+  return {
+    sessionId,
+    lastModified: Date.parse(session.mtime) || null,
+    size: session.size || 0,
+    filePath: session.filePath
+  };
+}
+
+function getSessionMessages(sessionId, options = {}) {
+  const session = getSessionById(sessionId);
+  if (!session) return null;
+  const page = Math.max(1, Number.parseInt(options.page, 10) || 1);
+  const limit = Math.max(1, Math.min(200, Number.parseInt(options.limit, 10) || 50));
+  const order = String(options.order || 'desc').toLowerCase() === 'asc' ? 'asc' : 'desc';
+  const ordered = order === 'asc' ? [...session.messages] : [...session.messages].reverse();
+  const offset = (page - 1) * limit;
+  return {
+    messages: ordered.slice(offset, offset + limit),
+    metadata: { sessionId, messageCount: session.messages.length },
+    pagination: {
+      page,
+      limit,
+      total: session.messages.length,
+      hasMore: offset + limit < session.messages.length
+    }
+  };
+}
+
+function getSessionOutline(sessionId) {
+  const session = getSessionById(sessionId);
+  if (!session) return null;
+  let userMessageNumber = 0;
+  return {
+    sessionId,
+    items: session.messages.flatMap(message => {
+      if (message.role !== 'user') return [];
+      userMessageNumber += 1;
+      const firstLine = String(message.content || '').trim().split(/\r?\n/, 1)[0] || '（空消息）';
+      return [{
+        userMessageNumber,
+        preview: firstLine.length > 42 ? `${firstLine.slice(0, 42)}...` : firstLine,
+        timestamp: message.timestamp
+      }];
+    })
+  };
+}
+
 function buildSessionMessages(sessionId) {
   const messages = getMessageRowsBySessionId(sessionId);
   const parts = getPartRowsBySessionId(sessionId);
@@ -534,9 +689,8 @@ function buildSessionMessages(sessionId) {
     const messageParts = partsByMessageId.get(message.id) || [];
 
     let content = '';
-    if (data && data.role === 'user') {
-      content = extractTextFromMessageData(data);
-    } else if (messageParts.length > 0) {
+    content = extractTextFromMessageData(data);
+    if (!content && messageParts.length > 0) {
       content = messageParts
         .map(part => {
           const partData = parseJsonMaybe(part.data, null);
@@ -574,7 +728,7 @@ function deleteSession(sessionId) {
   );
 
   try {
-    const { deleteAlias } = require('./alias');
+    const { deleteAlias } = require('../../../server/services/alias');
     deleteAlias(sessionId);
   } catch (err) {
     // ignore alias cleanup errors
@@ -583,7 +737,7 @@ function deleteSession(sessionId) {
   removeSessionFromOrder(location.projectId, sessionId);
 
   try {
-    const { getForkRelations, saveForkRelations } = require('./sessions');
+    const { getForkRelations, saveForkRelations } = require('../claude/sessions-implementation');
     const relations = getForkRelations();
     delete relations[sessionId];
     Object.keys(relations).forEach((key) => {
@@ -596,7 +750,6 @@ function deleteSession(sessionId) {
     // ignore fork relation cleanup errors
   }
 
-  invalidateProjectAndSessionCountsCache();
   return { success: true, projectName: location.projectId, sessionId };
 }
 
@@ -700,7 +853,7 @@ function forkSession(sessionId) {
   }
 
   try {
-    const { getForkRelations, saveForkRelations } = require('./sessions');
+    const { getForkRelations, saveForkRelations } = require('../claude/sessions-implementation');
     const relations = getForkRelations();
     relations[newSessionId] = sessionId;
     saveForkRelations(relations);
@@ -708,7 +861,6 @@ function forkSession(sessionId) {
     // ignore
   }
 
-  invalidateProjectAndSessionCountsCache();
   return { success: true, sessionId: newSessionId, forkedFrom: sessionId };
 }
 
@@ -730,7 +882,7 @@ function deleteProject(projectId) {
   const deletedSessionIds = sessionRows.map(row => row.id);
 
   try {
-    const { deleteAlias } = require('./alias');
+    const { deleteAlias } = require('../../../server/services/alias');
     deletedSessionIds.forEach(id => {
       try { deleteAlias(id); } catch (_) {}
     });
@@ -739,32 +891,27 @@ function deleteProject(projectId) {
   _exec(`DELETE FROM project WHERE id = ?`, projectId);
 
   removeProjectFromOrder(projectId);
-  invalidateProjectAndSessionCountsCache();
   return { success: true, projectId, deletedSessions: deletedSessionIds.length };
 }
 
 function getProjectAndSessionCounts(options = {}) {
-  if (options.force) {
-    invalidateProjectAndSessionCountsCache();
-  } else if (countsCache.expiresAt > Date.now()) {
-    return countsCache.value;
-  }
-
-  const row = queryProjectAndSessionCounts();
-  const result = {
-    projectCount: Number(row.project_count) || 0,
-    sessionCount: Number(row.session_count) || 0
+  const projects = getProjects(options);
+  return {
+    projectCount: projects.length,
+    sessionCount: projects.reduce((sum, project) => sum + project.sessionCount, 0)
   };
-
-  countsCache = { expiresAt: Date.now() + COUNTS_CACHE_TTL_MS, value: result };
-  return result;
 }
 
 module.exports = {
+  configure,
+  getOpenCodeDbPath,
   isOpenCodeInstalled,
   getProjects,
   getSessionsByProjectId,
   getSessionById,
+  getSessionStatus,
+  getSessionMessages,
+  getSessionOutline,
   searchSessions,
   getRecentSessions,
   deleteSession,

package/src/platforms/drivers/opencode/sessions.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { createCapabilityDriver } = require('../../../shared/capability-driver');
+
+function createDriver(context = {}) {
+  return createCapabilityDriver({
+    ...context,
+    platform: 'opencode',
+    capability: 'sessions',
+    servicePath: './opencode/sessions-implementation',
+    localServicePath: '../platforms/drivers/opencode/sessions-implementation',
+    methods: {
+      getProjects: 'getProjects',
+      recent: 'getRecentSessions',
+      search: 'searchSessions',
+      getSessionById: 'getSessionById',
+      delete: 'deleteSession',
+      fork: 'forkSession',
+      saveSessionOrder: 'saveSessionOrder',
+      status: 'getSessionStatus',
+      outline: 'getSessionOutline',
+      isAvailable: 'isOpenCodeInstalled'
+    },
+    customMethods: {
+      listSessions: (service, ...args) => {
+        const method = service.getSessionsByProjectId || service.getSessionsByProject;
+        if (typeof method !== 'function') return undefined;
+        return method.apply(service, args);
+      },
+      messages: (service, sessionId, options) => {
+        if (typeof service.getSessionMessages === 'function') {
+          return service.getSessionMessages(sessionId, options);
+        }
+        const session = typeof service.getSessionById === 'function'
+          ? service.getSessionById(sessionId)
+          : null;
+        return session?.messages || [];
+      }
+    },
+    onSuccess: operation => {
+      if (['delete', 'fork', 'saveSessionOrder'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('opencode');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

package/src/{server/services/opencode-statistics-service.js → platforms/drivers/opencode/statistics-implementation.js}

@@ -3,8 +3,8 @@ const {
   getStatistics: getSharedStatistics,
   getDailyStatistics: getSharedDailyStatistics,
   getTodayStatistics: getSharedTodayStatistics
-} = require('./statistics-service');
-const { normalizeUsageTokens, toNumber } = require('./proxy-log-helper');
+} = require('../../../server/services/statistics-service');
+const { normalizeUsageTokens, toNumber } = require('../../../server/services/usage-log-utils');
 
 const TOOL_TYPE = 'opencode';
 

package/src/platforms/drivers/opencode/statistics.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { createCapabilityDriver } = require('../../../shared/capability-driver');
+
+function createDriver(context = {}) {
+  return createCapabilityDriver({
+    ...context,
+    platform: 'opencode',
+    capability: 'statistics',
+    servicePath: './opencode/statistics-implementation',
+    localServicePath: '../opencode/statistics-implementation',
+    methods: {"getStatistics":"getStatistics","getDailyStatistics":"getDailyStatistics","getTodayStatistics":"getTodayStatistics","recordRequest":"recordRequest","resetStatistics":"resetStatistics"}
+  });
+}
+
+module.exports = { createDriver };