@codemieai/code 0.0.57 → 0.1.0

package/scripts/sonar/run-local-sonar.js

@@ -0,0 +1,405 @@
+// Copyright 2026 EPAM Systems, Inc. (“EPAM”)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const { spawn } = require('node:child_process');
+const fs = require('node:fs');
+const http = require('node:http');
+const https = require('node:https');
+const path = require('node:path');
+
+const REPOSITORY_ROOT = path.resolve(__dirname, '../..');
+const CONNECTED_MODE_PATH = path.resolve(REPOSITORY_ROOT, '.sonarlint/connectedMode.json');
+const SONAR_PROPERTIES_PATH = path.resolve(REPOSITORY_ROOT, 'sonar-project.properties');
+const SERVER_TIMEOUT_MS = 5000;
+const PAGE_SIZE = 500;
+
+function log(message) {
+    process.stdout.write(`[sonar-local] ${message}\n`);
+}
+
+function logError(message) {
+    process.stderr.write(`[sonar-local] ${message}\n`);
+}
+
+function readConnectedModeConfig() {
+    if (!fs.existsSync(CONNECTED_MODE_PATH)) {
+        throw new Error(`Missing SonarLint connected mode config: ${CONNECTED_MODE_PATH}`);
+    }
+
+    const rawContent = fs.readFileSync(CONNECTED_MODE_PATH, 'utf8');
+    const parsedConfig = JSON.parse(rawContent);
+    const sonarHostUrl = parsedConfig.sonarQubeUri;
+    const sonarProjectKey = parsedConfig.projectKey;
+
+    if (!sonarHostUrl || !sonarProjectKey) {
+        throw new Error(
+            `SonarLint connected mode config must define both "sonarQubeUri" and "projectKey": ${CONNECTED_MODE_PATH}`,
+        );
+    }
+
+    return { sonarHostUrl, sonarProjectKey };
+}
+
+function readSonarProperties() {
+    if (!fs.existsSync(SONAR_PROPERTIES_PATH)) {
+        throw new Error(`Missing Sonar project configuration: ${SONAR_PROPERTIES_PATH}`);
+    }
+
+    const properties = {};
+    const rawContent = fs.readFileSync(SONAR_PROPERTIES_PATH, 'utf8');
+
+    for (const rawLine of rawContent.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+
+        const separatorIndex = line.indexOf('=');
+        if (separatorIndex === -1) {
+            continue;
+        }
+
+        const key = line.slice(0, separatorIndex).trim();
+        const value = line.slice(separatorIndex + 1).trim();
+        properties[key] = value;
+    }
+
+    return properties;
+}
+
+function createRequestModule(targetUrl) {
+    return targetUrl.protocol === 'https:' ? https : http;
+}
+
+function resolveBranchName() {
+    const overrideBranchName = process.env.SONAR_BRANCH_NAME?.trim();
+    if (overrideBranchName) {
+        return overrideBranchName;
+    }
+
+    const gitEntryPath = path.resolve(REPOSITORY_ROOT, '.git');
+    if (!fs.existsSync(gitEntryPath)) {
+        throw new Error('Unable to locate .git metadata. Set SONAR_BRANCH_NAME explicitly and retry.');
+    }
+
+    let gitDirPath = gitEntryPath;
+    const gitEntryStat = fs.statSync(gitEntryPath);
+    if (gitEntryStat.isFile()) {
+        const gitPointer = fs.readFileSync(gitEntryPath, 'utf8').trim();
+        const gitDirPrefix = 'gitdir:';
+        if (!gitPointer.startsWith(gitDirPrefix)) {
+            throw new Error('Unable to resolve git metadata directory. Set SONAR_BRANCH_NAME explicitly and retry.');
+        }
+
+        gitDirPath = path.resolve(REPOSITORY_ROOT, gitPointer.slice(gitDirPrefix.length).trim());
+    }
+
+    const headPath = path.join(gitDirPath, 'HEAD');
+    if (!fs.existsSync(headPath)) {
+        throw new Error('Unable to locate git HEAD. Set SONAR_BRANCH_NAME explicitly and retry.');
+    }
+
+    const headContents = fs.readFileSync(headPath, 'utf8').trim();
+    const refPrefix = 'ref: refs/heads/';
+    if (!headContents.startsWith(refPrefix)) {
+        throw new Error('Unable to determine the current git branch from HEAD. Set SONAR_BRANCH_NAME explicitly.');
+    }
+
+    return headContents.slice(refPrefix.length);
+}
+
+function runCommand(command, args, options = {}) {
+    const { env = process.env, description = command } = options;
+
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: REPOSITORY_ROOT,
+            env,
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+
+        child.on('error', (error) => {
+            reject(new Error(`Failed to start ${description}: ${error.message}`));
+        });
+
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+
+            reject(new Error(`${description} exited with code ${code}`));
+        });
+    });
+}
+
+function resolveScannerCommand() {
+    const scannerCommand = process.env.SONAR_SCANNER_PATH?.trim() || 'sonar-scanner';
+
+    if (scannerCommand === 'sonar-scanner') {
+        const pathEntries = (process.env.PATH || '').split(path.delimiter);
+        const executableNames =
+            process.platform === 'win32'
+                ? ['sonar-scanner.cmd', 'sonar-scanner.bat', 'sonar-scanner.exe']
+                : ['sonar-scanner'];
+
+        const foundScanner = pathEntries.some((entry) =>
+            executableNames.some((name) => fs.existsSync(path.join(entry, name))),
+        );
+        if (!foundScanner) {
+            throw new Error(
+                'sonar-scanner was not found. Install the official SonarScanner CLI or set SONAR_SCANNER_PATH.',
+            );
+        }
+    } else if (!fs.existsSync(scannerCommand)) {
+        throw new Error(`SONAR_SCANNER_PATH does not exist: ${scannerCommand}`);
+    }
+
+    return scannerCommand;
+}
+
+function sonarRequestJson(sonarHostUrl, sonarToken, endpoint, searchParams = {}) {
+    return new Promise((resolve, reject) => {
+        const requestUrl = new URL(endpoint, sonarHostUrl);
+        for (const [key, value] of Object.entries(searchParams)) {
+            if (value !== undefined && value !== null && value !== '') {
+                requestUrl.searchParams.set(key, String(value));
+            }
+        }
+
+        const request = createRequestModule(requestUrl).request(
+            requestUrl,
+            {
+                method: 'GET',
+                timeout: SERVER_TIMEOUT_MS,
+                headers: {
+                    Authorization: `Basic ${Buffer.from(`${sonarToken}:`).toString('base64')}`,
+                    Accept: 'application/json',
+                },
+            },
+            (response) => {
+                const chunks = [];
+                response.on('data', (chunk) => chunks.push(chunk));
+                response.on('end', () => {
+                    const rawBody = Buffer.concat(chunks).toString('utf8');
+                    if (response.statusCode && response.statusCode >= 400) {
+                        reject(new Error(`Sonar API request failed (${response.statusCode}) for ${requestUrl.pathname}.`));
+                        return;
+                    }
+
+                    try {
+                        resolve(JSON.parse(rawBody));
+                    } catch (error) {
+                        reject(new Error(`Failed to parse Sonar API response for ${requestUrl.pathname}: ${error.message}`));
+                    }
+                });
+            },
+        );
+
+        request.on('timeout', () => {
+            request.destroy(new Error(`Timed out after ${SERVER_TIMEOUT_MS}ms`));
+        });
+
+        request.on('error', (error) => {
+            reject(new Error(`Sonar API request failed for ${requestUrl.pathname}: ${error.message}`));
+        });
+
+        request.end();
+    });
+}
+
+async function fetchPaginatedItems(fetchPage) {
+    const items = [];
+    let page = 1;
+    let total = 0;
+    let pageSize = 0;
+
+    do {
+        const response = await fetchPage(page);
+        const responseItems = response.issues ?? response.hotspots ?? [];
+        items.push(...responseItems);
+        total = response.total ?? response.paging?.total ?? responseItems.length;
+        pageSize = response.ps ?? response.paging?.pageSize ?? responseItems.length;
+        page += 1;
+    } while (items.length < total && pageSize > 0);
+
+    return items;
+}
+
+function stripProjectKey(component, projectKey) {
+    const componentPrefix = `${projectKey}:`;
+    if (!component) {
+        return '(unknown component)';
+    }
+
+    return component.startsWith(componentPrefix) ? component.slice(componentPrefix.length) : component;
+}
+
+function formatIssue(issue, projectKey) {
+    const location = `${stripProjectKey(issue.component, projectKey)}:${issue.line ?? 1}`;
+    return `- [${issue.severity}] [${issue.type}] ${location} ${issue.rule}: ${issue.message}`;
+}
+
+function formatHotspot(hotspot, projectKey) {
+    const location = `${stripProjectKey(hotspot.component, projectKey)}:${hotspot.line ?? 1}`;
+    return `- ${location} ${hotspot.ruleKey ?? hotspot.rule ?? 'unknown-rule'}: ${hotspot.message}`;
+}
+
+async function collectSonarDetails({ sonarHostUrl, sonarProjectKey, branchName, sonarToken }) {
+    const qualityGate = await sonarRequestJson(sonarHostUrl, sonarToken, '/api/qualitygates/project_status', {
+        projectKey: sonarProjectKey,
+        branch: branchName,
+    });
+
+    const issues = await fetchPaginatedItems((page) =>
+        sonarRequestJson(sonarHostUrl, sonarToken, '/api/issues/search', {
+            componentKeys: sonarProjectKey,
+            branch: branchName,
+            resolved: 'false',
+            p: page,
+            ps: PAGE_SIZE,
+            s: 'FILE_LINE',
+            asc: 'true',
+        }),
+    );
+
+    const hotspots = await fetchPaginatedItems((page) =>
+        sonarRequestJson(sonarHostUrl, sonarToken, '/api/hotspots/search', {
+            projectKey: sonarProjectKey,
+            branch: branchName,
+            status: 'TO_REVIEW',
+            p: page,
+            ps: PAGE_SIZE,
+        }),
+    );
+
+    return { hotspots, issues, qualityGate };
+}
+
+function printSonarDetails(details, context) {
+    const { hotspots, issues, qualityGate } = details;
+    const { branchName, sonarProjectKey } = context;
+
+    log(`Project: ${sonarProjectKey}`);
+    log(`Branch: ${branchName}`);
+    log(`Quality gate: ${qualityGate.projectStatus.status}`);
+
+    const failedConditions = (qualityGate.projectStatus.conditions ?? []).filter(
+        (condition) => condition.status === 'ERROR',
+    );
+    if (failedConditions.length > 0) {
+        log('Failing gate conditions:');
+        for (const condition of failedConditions) {
+            log(
+                `- ${condition.metricKey}: actual=${condition.actualValue ?? 'n/a'}, threshold=${condition.errorThreshold ?? 'n/a'}`,
+            );
+        }
+    } else {
+        log('Failing gate conditions: none');
+    }
+
+    log(`Blocking security hotspots: ${hotspots.length}`);
+    for (const hotspot of hotspots) {
+        log(formatHotspot(hotspot, sonarProjectKey));
+    }
+
+    const bugsAndVulnerabilities = issues.filter((issue) => issue.type === 'BUG' || issue.type === 'VULNERABILITY');
+    log(`Bugs and vulnerabilities: ${bugsAndVulnerabilities.length}`);
+    for (const issue of bugsAndVulnerabilities) {
+        log(formatIssue(issue, sonarProjectKey));
+    }
+
+    log(`All unresolved issues: ${issues.length}`);
+    for (const issue of issues) {
+        log(formatIssue(issue, sonarProjectKey));
+    }
+}
+
+async function printFailureDetails(context) {
+    try {
+        const details = await collectSonarDetails(context);
+        printSonarDetails(details, context);
+    } catch (detailsError) {
+        logError(`Failed to fetch Sonar details after scan failure: ${detailsError.message}`);
+    }
+}
+
+async function main() {
+    const { sonarHostUrl, sonarProjectKey } = readConnectedModeConfig();
+    const sonarProperties = readSonarProperties();
+    const sonarToken = process.env.SONAR_TOKEN?.trim();
+    const branchName = resolveBranchName();
+
+    if (!sonarToken) {
+        log('Skipping Sonar scan because SONAR_TOKEN is not set.');
+        process.exit(0);
+    }
+
+    log(`Using SonarQube project "${sonarProjectKey}" from .sonarlint/connectedMode.json.`);
+    log(`Running analysis for branch "${branchName}".`);
+
+    if (sonarProperties['sonar.projectKey'] && sonarProperties['sonar.projectKey'] !== sonarProjectKey) {
+        log(
+            `Overriding sonar.projectKey="${sonarProperties['sonar.projectKey']}" with connected-mode project key "${sonarProjectKey}".`,
+        );
+    }
+
+    if (process.env.SONAR_SKIP_TESTS?.trim()) {
+        log('Skipping test run (SONAR_SKIP_TESTS is set). Using existing coverage.xml.');
+    } else {
+        log('Generating coverage.xml...');
+        await runCommand(
+            'poetry',
+            ['run', 'pytest', 'tests/', '-W', 'ignore::DeprecationWarning', '--cov', '--cov-report=xml:coverage.xml'],
+            { description: 'coverage generation' },
+        );
+    }
+
+    const scannerCommand = resolveScannerCommand();
+    log(`Running sonar-scanner against ${sonarHostUrl}.`);
+    try {
+        await runCommand(
+            scannerCommand,
+            [
+                `-Dsonar.projectKey=${sonarProjectKey}`,
+                `-Dsonar.branch.name=${branchName}`,
+                '-Dsonar.qualitygate.wait=true',
+            ],
+            {
+                description: 'sonar-scanner',
+                env: {
+                    ...process.env,
+                    SONAR_HOST_URL: sonarHostUrl,
+                    SONAR_TOKEN: sonarToken,
+                },
+            },
+        );
+    } catch (error) {
+        await printFailureDetails({
+            branchName,
+            sonarHostUrl,
+            sonarProjectKey,
+            sonarToken,
+        });
+        throw error;
+    }
+
+    log('Sonar scan completed successfully.');
+}
+
+main().catch((error) => {
+    logError(error.message);
+    process.exit(1);
+});

package/scripts/test-desktop-telemetry.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { resolve } from 'path';
+
+function printUsage() {
+  console.log(`Usage: node scripts/test-desktop-telemetry.js [options]
+
+Options:
+  --latest                 Use the most recently updated Desktop session (default)
+  --session <local_id>     Use a specific Desktop local session id
+  --dry-run                Build and sync through processors without remote writes (default)
+  --live                   Attempt real sync using stored SSO credentials
+  --target-url <url>       Override API base URL for sync
+  --codemie-url <url>      Override CodeMie URL for credential lookup
+  --codemie-home <dir>     Override CODEMIE_HOME for isolated local output
+  --limit <count>          Number of recent sessions to search while resolving --session (default: 20)
+  --help                   Show this help
+`);
+}
+
+function parseArgs(argv) {
+  const args = {
+    latest: true,
+    sessionId: undefined,
+    dryRun: true,
+    targetUrl: undefined,
+    codeMieUrl: undefined,
+    codemieHome: undefined,
+    limit: 20
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    switch (arg) {
+      case '--latest':
+        args.latest = true;
+        break;
+      case '--session':
+        args.sessionId = argv[index + 1];
+        args.latest = false;
+        index += 1;
+        break;
+      case '--dry-run':
+        args.dryRun = true;
+        break;
+      case '--live':
+        args.dryRun = false;
+        break;
+      case '--target-url':
+        args.targetUrl = argv[index + 1];
+        index += 1;
+        break;
+      case '--codemie-url':
+        args.codeMieUrl = argv[index + 1];
+        index += 1;
+        break;
+      case '--codemie-home':
+        args.codemieHome = argv[index + 1];
+        index += 1;
+        break;
+      case '--limit':
+        args.limit = Number.parseInt(argv[index + 1], 10);
+        index += 1;
+        break;
+      case '--help':
+        printUsage();
+        process.exit(0);
+      default:
+        console.error(`Unknown argument: ${arg}`);
+        printUsage();
+        process.exit(1);
+    }
+  }
+
+  return args;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (args.codemieHome) {
+  process.env.CODEMIE_HOME = resolve(args.codemieHome);
+}
+
+const distRoot = resolve(process.cwd(), 'dist');
+if (!existsSync(distRoot)) {
+  console.error('dist/ is missing. Run: rtk npm run build');
+  process.exit(1);
+}
+
+const [
+  { discoverClaudeDesktopSessions },
+  { ClaudeDesktopTelemetryAdapter },
+  { SessionStore },
+  { getSessionConversationPath, getSessionMetricsPath },
+  { SessionSyncer },
+  { CodeMieSSO },
+  { detectGitBranch, detectGitRemoteRepo },
+] = await Promise.all([
+  import('../dist/telemetry/clients/claude-desktop/claude-desktop.discovery.js'),
+  import('../dist/telemetry/clients/claude-desktop/ClaudeDesktopTelemetryAdapter.js'),
+  import('../dist/agents/core/session/SessionStore.js'),
+  import('../dist/agents/core/session/session-config.js'),
+  import('../dist/providers/plugins/sso/session/SessionSyncer.js'),
+  import('../dist/providers/plugins/sso/sso.auth.js'),
+  import('../dist/utils/processes.js')
+]);
+
+const discoveredSessions = await discoverClaudeDesktopSessions(0);
+const recentSessions = discoveredSessions
+  .sort((a, b) => b.updatedAt - a.updatedAt)
+  .slice(0, Number.isFinite(args.limit) && args.limit > 0 ? args.limit : 20);
+
+const selected = args.sessionId
+  ? recentSessions.find((session) => session.externalSessionId === args.sessionId)
+  : recentSessions[0];
+
+if (!selected) {
+  console.error('No matching Claude Desktop local session found.');
+  process.exit(1);
+}
+
+const sessionStore = new SessionStore();
+let session = await sessionStore.findSessionByExternalId('claude-desktop', selected.externalSessionId);
+
+if (!session) {
+  const [gitBranch, repository] = await Promise.all([
+    detectGitBranch(selected.workingDirectory),
+    detectGitRemoteRepo(selected.workingDirectory)
+  ]);
+
+  session = {
+    sessionId: randomUUID(),
+    agentName: 'claude-desktop',
+    provider: 'ai-run-sso',
+    startTime: selected.createdAt,
+    workingDirectory: selected.workingDirectory,
+    gitBranch: gitBranch || undefined,
+    repository: repository || undefined,
+    status: 'active',
+    activeDurationMs: 0,
+    correlation: {
+      status: 'matched',
+      agentSessionId: selected.agentSessionId,
+      agentSessionFile: selected.transcriptPath,
+      retryCount: 0
+    },
+    runtimeCheckpoint: {
+      externalSessionId: selected.externalSessionId,
+      transcriptPath: selected.transcriptPath,
+      lastDiscoveredAt: Date.now(),
+      lastSeenActivityAt: selected.updatedAt
+    }
+  };
+
+  await sessionStore.saveSession(session);
+}
+
+const targetUrl = args.targetUrl
+  || process.env.CODEMIE_TEST_API_URL
+  || process.env.CODEMIE_API_URL
+  || 'http://127.0.0.1:3000';
+const codeMieUrl = args.codeMieUrl
+  || process.env.CODEMIE_TEST_CODEMIE_URL
+  || process.env.CODEMIE_URL
+  || targetUrl;
+
+let cookies = '';
+if (!args.dryRun) {
+  const credentials = await new CodeMieSSO().getStoredCredentials(codeMieUrl);
+  if (!credentials?.cookies) {
+    console.error(`No stored SSO credentials found for ${codeMieUrl}`);
+    process.exit(1);
+  }
+  cookies = Object.entries(credentials.cookies)
+    .map(([key, value]) => `${key}=${value}`)
+    .join('; ');
+}
+
+const adapter = new ClaudeDesktopTelemetryAdapter();
+const parsedSession = await adapter.parseSession(selected, session.sessionId);
+const context = {
+  apiBaseUrl: targetUrl,
+  cookies,
+  clientType: 'claude-desktop',
+  version: readCliVersion(),
+  dryRun: args.dryRun,
+  sessionId: session.sessionId,
+  agentSessionId: selected.agentSessionId,
+  agentSessionFile: selected.transcriptPath
+};
+
+const processed = await adapter.processParsedSession(parsedSession, context);
+const syncResult = await new SessionSyncer().sync(session.sessionId, context);
+const metricsPath = getSessionMetricsPath(session.sessionId);
+const conversationPath = getSessionConversationPath(session.sessionId);
+
+console.log('Claude Desktop telemetry simulation');
+console.log(`  mode:              ${args.dryRun ? 'dry-run' : 'live'}`);
+console.log(`  local session:     ${selected.externalSessionId}`);
+console.log(`  cli session:       ${selected.agentSessionId}`);
+console.log(`  codemie session:   ${session.sessionId}`);
+console.log(`  updated at:        ${new Date(selected.updatedAt).toISOString()}`);
+console.log(`  transcript:        ${selected.transcriptPath}`);
+console.log(`  messages parsed:   ${parsedSession.messages.length}`);
+console.log(`  metrics path:      ${metricsPath}${existsSync(metricsPath) ? '' : ' (missing)'}`);
+console.log(`  conversation path: ${conversationPath}${existsSync(conversationPath) ? '' : ' (missing)'}`);
+console.log(`  processors:        ${processed.success ? 'ok' : 'failed'} (${processed.totalRecords} records)`);
+console.log(`  sync:              ${syncResult.success ? 'ok' : 'failed'} (${syncResult.message})`);
+
+if (existsSync(metricsPath)) {
+  const lines = readFileSync(metricsPath, 'utf-8').split('\n').filter(Boolean).length;
+  console.log(`  metrics lines:     ${lines}`);
+}
+
+if (existsSync(conversationPath)) {
+  const lines = readFileSync(conversationPath, 'utf-8').split('\n').filter(Boolean).length;
+  console.log(`  conversation lines:${String(lines).padStart(2, ' ')}`);
+}
+
+function readCliVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(process.cwd(), 'package.json'), 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}