coding-tool-x 3.8.4 → 3.8.6

package/src/platforms/channel-auth-registry.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const { readAllNativeOAuth } = require('./native-oauth-adapters');
+const oauthStore = require('./oauth-credentials-service');
+const { getOmpAuthProviderSnapshot } = require('./drivers/omp/auth-providers');
+
+function getRegistry() {
+  return require('./registry').createPlatformRegistry();
+}
+
+function safeRef(value = {}) {
+  return {
+    credentialId: String(value.credentialId || '').trim(),
+    providerId: String(value.providerId || '').trim(),
+    accountId: String(value.accountId || '').trim(),
+    identityKey: String(value.identityKey || '').trim(),
+    accountEmail: String(value.accountEmail || '').trim()
+  };
+}
+
+function nativeCandidate(adapter, metadata, credential) {
+  const ref = safeRef({
+    credentialId: credential?.id,
+    providerId: metadata.providerId || credential?.providerId,
+    accountId: metadata.accountId || credential?.accountId,
+    identityKey: metadata.identityKey,
+    accountEmail: metadata.accountEmail || credential?.accountEmail
+  });
+  return {
+    id: ref.credentialId || `${adapter}:${ref.accountId || ref.identityKey || ref.accountEmail || ref.providerId}`,
+    tool: adapter,
+    authMode: 'oauth',
+    authRef: ref,
+    authSource: 'synced-local',
+    authStatus: 'available',
+    providerId: ref.providerId,
+    accountId: ref.accountId,
+    accountEmail: ref.accountEmail,
+    expiresAt: credential?.expiresAt || metadata.expiresAt || null,
+    lastSyncAt: credential?.updatedAt || new Date().toISOString()
+  };
+}
+
+function scanNative(adapter) {
+  const native = readAllNativeOAuth(adapter) || [];
+  const synced = native.length ? oauthStore.syncLocalCredential(adapter) : null;
+  const credentials = synced?.credentials || [];
+  const candidates = native.map((metadata, index) => nativeCandidate(adapter, metadata, credentials[index]));
+  return {
+    candidates,
+    nativeState: {
+      available: candidates.length > 0,
+      candidateCount: candidates.length,
+      checkedAt: new Date().toISOString()
+    },
+    warnings: candidates.length ? [] : [`${adapter}: unavailable: no local OAuth credential`]
+  };
+}
+
+function scanOmp() {
+  const snapshot = getOmpAuthProviderSnapshot({ forceRefresh: true, accountCheck: true });
+  const hasAccounts = (snapshot.providers || []).some(provider => (
+    provider.loggedIn === true && Array.isArray(provider.accounts) && provider.accounts.length > 0
+  ));
+  let synced = null;
+  if (hasAccounts) {
+    try {
+      synced = oauthStore.syncLocalCredential('omp');
+    } catch {
+      synced = null;
+    }
+  }
+  const credentials = synced?.credentials || [];
+  const candidates = [];
+  for (const provider of snapshot.providers || []) {
+    if (provider.loggedIn !== true || !Array.isArray(provider.accounts) || provider.accounts.length === 0) continue;
+    for (const account of provider.accounts) {
+      const accountId = account.id || account.accountId || account.index;
+      const accountEmail = account.email || account.accountEmail || account.identity;
+      const identityKey = account.identityKey || accountEmail || accountId;
+      const credential = credentials.find(item => (
+        item.providerId === provider.id
+        && (item.accountId === String(accountId || '') || item.accountEmail === String(accountEmail || ''))
+      ));
+      const ref = safeRef({
+        credentialId: credential?.id,
+        providerId: provider.id,
+        accountId,
+        identityKey,
+        accountEmail
+      });
+      if (!ref.accountId && !ref.identityKey && (provider.accounts || []).length > 1) continue;
+      candidates.push({
+        id: credential?.id || `omp:${provider.id}:${ref.accountId || ref.identityKey || 'account'}`,
+        tool: 'omp',
+        authMode: 'oauth',
+        authRef: ref,
+        authSource: 'synced-local',
+        authStatus: ref.accountId || ref.identityKey ? 'available' : 'ambiguous',
+        oauthProviderId: provider.id,
+        providerId: provider.id,
+        accountId: ref.accountId,
+        accountEmail: ref.accountEmail
+      });
+    }
+  }
+  return {
+    candidates,
+    nativeState: { available: snapshot.available === true, providers: snapshot.providers || [], checkedAt: snapshot.checkedAt },
+    warnings: candidates.length ? [] : [snapshot.reason || 'omp: unavailable: no logged-in local provider']
+  };
+}
+
+const adapters = Object.freeze({
+  claude: {
+    scan: () => scanNative('claude'),
+    usage: (ref) => oauthStore.fetchCredentialUsage('claude', ref.credentialId),
+    quota: (ref) => oauthStore.fetchCredentialUsage('claude', ref.credentialId),
+    channelServicePath: './drivers/claude/channels-implementation'
+  },
+  codex: {
+    scan: () => scanNative('codex'),
+    usage: (ref) => oauthStore.fetchCredentialUsage('codex', ref.credentialId),
+    quota: (ref) => oauthStore.fetchCredentialUsage('codex', ref.credentialId),
+    channelServicePath: './drivers/codex/channels-implementation'
+  },
+  gemini: {
+    scan: () => scanNative('gemini'),
+    usage: (ref) => oauthStore.fetchCredentialUsage('gemini', ref.credentialId),
+    quota: (ref) => oauthStore.fetchCredentialUsage('gemini', ref.credentialId),
+    channelServicePath: './drivers/gemini/channels-implementation'
+  },
+  omp: {
+    scan: scanOmp,
+    quota: async () => ({ status: 'unavailable', error: 'OMP native OAuth quota is unavailable' }),
+    channelServicePath: './drivers/omp/channels-implementation'
+  }
+});
+
+function getOAuthManifests() {
+  return getRegistry().list({ enabledOnly: false }).filter(manifest => (
+    manifest.auth?.oauth?.adapter && adapters[manifest.auth.oauth.adapter]
+  ));
+}
+function getChannelAuthAdapter(platform) {
+  const key = String(platform || '').trim().toLowerCase();
+  const manifest = getOAuthManifests().find(item => item.key === key);
+  const adapterId = manifest?.auth?.oauth?.adapter;
+  const adapter = adapterId ? adapters[adapterId] : null;
+  if (!adapter) return null;
+  return {
+    ...adapter,
+    platform: manifest.key,
+    adapterId,
+    policy: manifest.auth.oauth.policy,
+    quotaId: manifest.auth.oauth.quota || null
+  };
+}
+
+function listChannelAuthPlatforms() {
+  return getOAuthManifests().map(manifest => manifest.key);
+}
+
+
+module.exports = { getChannelAuthAdapter, listChannelAuthPlatforms, safeRef };

package/src/platforms/channel-auth-service.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const { getChannelAuthAdapter, listChannelAuthPlatforms, safeRef } = require('./channel-auth-registry');
+
+const quotaCache = new Map();
+const QUOTA_TTL_MS = 5 * 60 * 1000;
+
+function getAdapter(platform) {
+  const adapter = getChannelAuthAdapter(platform);
+  if (!adapter) throw new Error(`Unsupported channel auth platform: ${platform}`);
+  return adapter;
+}
+
+function matchChannel(channel, candidate) {
+  if (!channel || channel.authMode !== 'oauth') return false;
+  const ref = safeRef(channel.authRef);
+  const next = safeRef(candidate.authRef);
+  if (ref.credentialId && next.credentialId && ref.credentialId === next.credentialId) return true;
+  if ((ref.accountId || ref.identityKey) && (next.accountId || next.identityKey)) {
+    const sameProvider = !ref.providerId || !next.providerId || ref.providerId === next.providerId;
+    return sameProvider && (ref.accountId || ref.identityKey) === (next.accountId || next.identityKey);
+  }
+  if (ref.accountEmail && next.accountEmail) return ref.accountEmail === next.accountEmail;
+  return false;
+}
+
+function resolveChannelAuthRef(adapter, channel) {
+  const current = safeRef(channel?.authRef);
+  let scanned;
+  try {
+    scanned = adapter.scan();
+  } catch {
+    return current;
+  }
+
+  const candidates = Array.isArray(scanned?.candidates) ? scanned.candidates : [];
+  const matched = candidates.find(candidate => matchChannel(channel, candidate));
+  if (matched) return safeRef(matched.authRef);
+
+  // A channel created before OAuth credentials were synced can have no stable
+  // reference. Only auto-select when the local scan found exactly one account.
+  if (!current.credentialId && !current.providerId && !current.accountId
+    && !current.identityKey && !current.accountEmail && candidates.length === 1) {
+    return safeRef(candidates[0].authRef);
+  }
+
+  return current;
+}
+
+function getChannel(platform, channelId) {
+  if (!channelId) return null;
+  const adapter = getAdapter(platform);
+  const service = require(adapter.channelServicePath);
+  return (service.getChannels?.().channels || []).find(channel => channel.id === channelId) || null;
+}
+
+function getChannelAuth(platform, { channelId = '' } = {}) {
+  const adapter = getAdapter(platform);
+  const result = adapter.scan();
+  return {
+    channel: getChannel(platform, channelId),
+    candidates: result.candidates || [],
+    nativeState: result.nativeState || { available: false },
+    warnings: result.warnings || []
+  };
+}
+
+function syncLocalChannelAuth(platform, options = {}) {
+  return getChannelAuth(platform, options);
+}
+
+async function fetchChannelAuthQuota(platform, channelId, { refresh = false } = {}) {
+  const adapter = getAdapter(platform);
+  const checkedAt = () => new Date().toISOString();
+  const channel = getChannel(platform, channelId);
+  if (!channel) return { quota: null, status: 'unavailable', checkedAt: checkedAt(), warning: 'Channel not found' };
+  if (channel.authMode !== 'oauth') return { quota: null, status: 'unsupported', checkedAt: checkedAt(), warning: 'Channel is not OAuth' };
+  const ref = resolveChannelAuthRef(adapter, channel);
+  const cacheKey = `${adapter.adapterId}:${channelId}:${ref.credentialId || ref.providerId}:${ref.accountId || ref.identityKey || ref.accountEmail}`;
+  const cached = quotaCache.get(cacheKey);
+  if (!refresh && cached && Date.now() - cached.checkedAtMs < QUOTA_TTL_MS) return cached.value;
+  try {
+    const usage = await (adapter.usage || adapter.quota)(ref);
+    const result = {
+      ...(usage?.quota ? usage : {
+        quota: null,
+        status: usage?.status || 'unavailable',
+        warning: usage?.error || 'Quota unavailable'
+      }),
+      checkedAt: checkedAt()
+    };
+    quotaCache.set(cacheKey, { checkedAtMs: Date.now(), value: result });
+    return result;
+  } catch (error) {
+    return { quota: null, status: 'unavailable', checkedAt: checkedAt(), warning: error.message };
+  }
+}
+
+module.exports = {
+  getChannelAuth,
+  syncLocalChannelAuth,
+  fetchChannelAuthQuota,
+  listChannelAuthPlatforms,
+  safeRef,
+  matchChannel,
+  resolveChannelAuthRef
+};