coding-tool-x 3.8.4 → 3.8.6

package/src/platforms/drivers/generic-jsonl.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const fs = require('fs/promises');
+const path = require('path');
+
+function failure({ platform, operation, error, root, filePath }) {
+  const result = {
+    status: 'failed',
+    platform,
+    capability: 'sessions',
+    operation,
+    error: error && error.message ? error.message : String(error)
+  };
+  if (root) result.root = root;
+  if (filePath) result.filePath = filePath;
+  if (error) Object.defineProperty(result, 'cause', { value: error, enumerable: false });
+  return result;
+}
+
+function getMappedValue(source, mapping, fallback) {
+  if (!mapping) return fallback;
+  if (mapping === 'basename') return fallback;
+  return String(mapping).split('.').reduce((value, key) => (
+    value && Object.prototype.hasOwnProperty.call(value, key) ? value[key] : undefined
+  ), source);
+}
+
+function normalizeMessage(entry, mapping) {
+  const role = getMappedValue(entry, mapping.role, entry.role);
+  const content = getMappedValue(entry, mapping.content, entry.content);
+  const timestamp = getMappedValue(entry, mapping.timestamp, entry.timestamp);
+  const model = getMappedValue(entry, mapping.model, entry.model);
+  const message = { ...entry };
+  if (role !== undefined) message.role = role;
+  if (content !== undefined) message.content = content;
+  if (timestamp !== undefined) message.timestamp = timestamp;
+  if (model !== undefined) message.model = model;
+  return message;
+}
+
+function compileSessionGlob(sessionGlob) {
+  if (!sessionGlob) return {
+    matches: name => name.endsWith('.jsonl'),
+    sessionIdFromName: name => name.endsWith('.jsonl') ? name.slice(0, -'.jsonl'.length) : name
+  };
+
+  const pattern = String(sessionGlob);
+  let source = '^';
+  for (const char of pattern) {
+    if (char === '*') source += '.*';
+    else if (char === '?') source += '.';
+    else source += char.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
+  }
+  source += '$';
+  const matcher = new RegExp(source);
+  const extension = path.extname(pattern);
+  return {
+    matches: name => matcher.test(name),
+    sessionIdFromName: name => extension && name.endsWith(extension) ? name.slice(0, -extension.length) : name
+  };
+}
+
+function deriveSessionId(basename, mapping, first) {
+  if (!mapping.sessionId || mapping.sessionId === 'basename') return basename;
+  return getMappedValue(first, mapping.sessionId, basename) || basename;
+}
+
+function needsInventoryRead(mapping) {
+  return Boolean(
+    mapping.sessionId && mapping.sessionId !== 'basename'
+      || mapping.projectName && mapping.projectName !== 'basename'
+  );
+}
+
+async function readFirstJsonLine(fsImpl, filePath) {
+  const content = await fsImpl.readFile(filePath, 'utf8');
+  const line = String(content).split(/\r?\n/).find(candidate => candidate.trim());
+  return line ? JSON.parse(line) : {};
+}
+
+function createGenericJsonlDriver({ platform, manifest = {}, fsImpl = fs } = {}) {
+  const sessionRoot = manifest.paths && manifest.paths.sessions;
+  const mapping = manifest.sessionMapping || {};
+  const sessionGlob = compileSessionGlob(manifest.sessionGlob);
+
+  return {
+    platform,
+    capability: 'sessions',
+    async inventory() {
+      try {
+        const names = await fsImpl.readdir(sessionRoot);
+        const descriptors = [];
+        const readInventoryFields = needsInventoryRead(mapping);
+        for (const name of names) {
+          if (!sessionGlob.matches(name)) continue;
+          const filePath = path.join(sessionRoot, name);
+          const stat = await fsImpl.stat(filePath);
+          const basename = sessionGlob.sessionIdFromName(name);
+          const first = readInventoryFields ? await readFirstJsonLine(fsImpl, filePath) : {};
+          descriptors.push({
+            filePath,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            sessionId: deriveSessionId(basename, mapping, first),
+            projectHint: getMappedValue(first, mapping.projectName)
+          });
+        }
+        return descriptors;
+      } catch (error) {
+        return failure({ platform, operation: 'inventory', root: sessionRoot, error });
+      }
+    },
+    async parse(descriptor) {
+      const filePath = descriptor && descriptor.filePath;
+      try {
+        const content = await fsImpl.readFile(filePath, 'utf8');
+        const parsedLines = [];
+        for (const line of String(content).split(/\r?\n/)) {
+          if (!line.trim()) continue;
+          parsedLines.push(JSON.parse(line));
+        }
+        const first = parsedLines[0] || {};
+        const mappedMessages = getMappedValue(first, mapping.messages);
+        const sourceMessages = Array.isArray(mappedMessages) ? mappedMessages : parsedLines;
+        const descriptorSessionId = descriptor.sessionId || sessionGlob.sessionIdFromName(path.basename(filePath));
+        const sessionId = descriptor.sessionId || deriveSessionId(descriptorSessionId, mapping, first);
+        const projectName = getMappedValue(first, mapping.projectName, descriptor.projectHint);
+        return {
+          sessionId,
+          projectName,
+          filePath,
+          messages: sourceMessages.map(message => normalizeMessage(message, mapping))
+        };
+      } catch (error) {
+        return failure({ platform, operation: 'parse', filePath, error });
+      }
+    }
+  };
+}
+
+module.exports = { createGenericJsonlDriver };

package/src/platforms/drivers/generic-mcp.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const fs = require('fs/promises');
+const path = require('path');
+
+const { createSecureFileDriver } = require('./secure-file-driver');
+function resolveTarget(manifest) {
+  if (manifest.mcpFormat !== 'json') throw new Error("Manifest mcpFormat must be 'json'");
+  const raw = manifest.resourceMappings && manifest.resourceMappings.mcp;
+  if (typeof raw !== 'string' || !raw.trim()) throw new Error('Manifest requires resourceMappings.mcp');
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) throw new Error('MCP mapping must be a filesystem path');
+  const home = manifest.paths && manifest.paths.home;
+  return path.resolve(home || process.cwd(), raw);
+}
+
+function createGenericMcpDriver({ platform, manifest = {}, fsImpl = fs } = {}) {
+  return createSecureFileDriver({
+    platform,
+    capability: 'mcp',
+    manifest,
+    fsImpl,
+    labels: {
+      pathContainsSymlink: value => `MCP path contains symlink: ${value}`,
+      pathDoesNotExist: value => `MCP path does not exist: ${value}`,
+      mappingEscapesHome: 'MCP mapping escapes platform home',
+      targetChanged: 'MCP target changed during operation',
+      descriptorReadUnavailable: 'MCP descriptor read is unavailable',
+      descriptorIdentityUnavailable: 'MCP descriptor identity is unavailable',
+      pathComponentNotDirectory: value => `MCP path component is not a directory: ${value}`,
+      temporaryPathChanged: 'MCP temporary path changed during write',
+      serializedValueMustBeString: 'MCP value must be JSON serializable'
+    },
+    resolveTarget,
+    deserialize: value => JSON.parse(value),
+    serialize: value => {
+      if (value === undefined) throw new Error('MCP value is required');
+      const encoded = JSON.stringify(value, null, 2);
+      if (encoded === undefined) throw new Error('MCP value must be JSON serializable');
+      return `${encoded}\n`;
+    }
+  });
+}
+
+module.exports = { createGenericMcpDriver };

package/src/platforms/drivers/generic-openai-compatible.js

@@ -0,0 +1,45 @@
+'use strict';
+
+function requestFailure(platform, error, message = 'OpenAI-compatible request failed') {
+  const result = new Error(message);
+  result.platform = platform;
+  result.capability = 'channels';
+  result.operation = 'request';
+  if (error) Object.defineProperty(result, 'cause', { value: error, enumerable: false });
+  return result;
+}
+
+function createGenericOpenAICompatibleDriver({ platform, manifest = {}, fetchImpl = globalThis.fetch } = {}) {
+  const baseUrl = String((manifest.paths && manifest.paths.baseUrl) || manifest.baseUrl || '').replace(/\/+$/, '');
+  if (!baseUrl) throw new Error(`Missing base URL for ${platform}`);
+  return {
+    platform,
+    capability: 'channels',
+    normalizeEndpoint(pathname = '') {
+      return `${baseUrl}/${String(pathname).replace(/^\/+/, '')}`;
+    },
+    buildHeaders(channel = {}) {
+      const headers = { 'Content-Type': 'application/json' };
+      if (channel.apiKey) headers.Authorization = `Bearer ${channel.apiKey}`;
+      return headers;
+    },
+    async request(pathname, channel, init = {}) {
+      try {
+        const response = await fetchImpl(this.normalizeEndpoint(pathname), {
+          ...init,
+          headers: { ...this.buildHeaders(channel), ...(init.headers || {}) }
+        });
+        if (!response.ok) {
+          const cause = new Error(`HTTP ${response.status}`);
+          throw requestFailure(platform, cause, `OpenAI-compatible request failed: ${response.status}`);
+        }
+        return await response.json();
+      } catch (error) {
+        if (error && error.platform === platform && error.operation === 'request') throw error;
+        throw requestFailure(platform, error);
+      }
+    }
+  };
+}
+
+module.exports = { createGenericOpenAICompatibleDriver };

package/src/platforms/drivers/generic-prompt.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const fs = require('fs/promises');
+const path = require('path');
+
+const { createSecureFileDriver } = require('./secure-file-driver');
+function resolveTarget(manifest) {
+  const mapped = manifest.resourceMappings && manifest.resourceMappings.prompts;
+  const raw = typeof mapped === 'string' && mapped.trim() ? mapped : manifest.promptFile;
+  if (typeof raw !== 'string' || !raw.trim()) throw new Error('Manifest requires a prompt path');
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) throw new Error('Prompt mapping must be a filesystem path');
+  const home = manifest.paths && manifest.paths.home;
+  return path.resolve(home || process.cwd(), raw);
+}
+
+function createGenericPromptDriver({ platform, manifest = {}, fsImpl = fs } = {}) {
+  return createSecureFileDriver({
+    platform,
+    capability: 'prompts',
+    manifest,
+    fsImpl,
+    labels: {
+      pathContainsSymlink: value => `Prompt path contains symlink: ${value}`,
+      pathDoesNotExist: value => `Prompt path does not exist: ${value}`,
+      mappingEscapesHome: 'Prompt mapping escapes platform home',
+      targetChanged: 'Prompt target changed during operation',
+      descriptorReadUnavailable: 'Prompt descriptor read is unavailable',
+      descriptorIdentityUnavailable: 'Prompt descriptor identity is unavailable',
+      pathComponentNotDirectory: value => `Prompt path component is not a directory: ${value}`,
+      temporaryPathChanged: 'Prompt temporary path changed during write',
+      serializedValueMustBeString: 'Prompt text must be a string'
+    },
+    resolveTarget,
+    serialize: text => {
+      if (typeof text !== 'string') throw new Error('Prompt text must be a string');
+      return text;
+    }
+  });
+}
+
+module.exports = { createGenericPromptDriver };