@codemieai/code 0.0.57 → 0.0.58

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';
+  }
+}

package/scripts/test-proxy-endpoint.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/**
+ * Send a sample /v1/messages request to the local CodeMie proxy daemon.
+ *
+ * - Auto-discovers URL and gateway key from ~/.codemie/proxy-daemon.json
+ *   (override with --url and --gateway-key)
+ * - Sends Anthropic-style headers and a tiny payload
+ * - Supports both buffered and streaming (SSE) responses
+ *
+ * Usage:
+ *   node scripts/test-proxy-endpoint.js                       # auto-discover, non-streaming
+ *   node scripts/test-proxy-endpoint.js --stream              # SSE streaming
+ *   node scripts/test-proxy-endpoint.js --url http://localhost:4001 --gateway-key codemie-proxy
+ *   node scripts/test-proxy-endpoint.js --model claude-sonnet-4-5 --message "Hello"
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const STATE_FILE = process.env.CODEMIE_HOME
+  ? join(process.env.CODEMIE_HOME, 'proxy-daemon.json')
+  : join(homedir(), '.codemie', 'proxy-daemon.json');
+
+function printUsage() {
+  console.log(`Usage: node scripts/test-proxy-endpoint.js [options]
+
+Options:
+  --url <base-url>          Proxy base URL (default: read from state file)
+  --gateway-key <key>       Static bearer key (default: read from state file)
+  --endpoint <path>         Endpoint path (default: /v1/messages)
+  --model <id>              Model ID (default: claude-sonnet-4-5)
+  --message <text>          Prompt text (default: "Test proxy endpoint")
+  --max-tokens <n>          Max tokens (default: 32)
+  --stream                  Use SSE streaming
+  --no-anthropic-version    Don't send anthropic-version header
+  -h, --help                Show this help`);
+}
+
+function parseArgs(argv) {
+  const opts = {
+    endpoint: '/v1/messages',
+    message: 'Test proxy endpoint',
+    model: 'claude-sonnet-4-5',
+    maxTokens: 32,
+    stream: false,
+    sendAnthropicVersion: true,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') { opts.help = true; return opts; }
+    if (arg === '--url')          { opts.url = argv[++i]; continue; }
+    if (arg === '--gateway-key')  { opts.gatewayKey = argv[++i]; continue; }
+    if (arg === '--endpoint')     { opts.endpoint = argv[++i] || opts.endpoint; continue; }
+    if (arg === '--message')      { opts.message = argv[++i] || opts.message; continue; }
+    if (arg === '--model')        { opts.model = argv[++i] || opts.model; continue; }
+    if (arg === '--max-tokens')   {
+      const v = Number.parseInt(argv[++i] || '', 10);
+      if (Number.isFinite(v) && v > 0) opts.maxTokens = v;
+      continue;
+    }
+    if (arg === '--stream')                  { opts.stream = true; continue; }
+    if (arg === '--no-anthropic-version')    { opts.sendAnthropicVersion = false; continue; }
+  }
+  return opts;
+}
+
+async function loadDaemonState() {
+  try {
+    const raw = await readFile(STATE_FILE, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) { printUsage(); process.exit(0); }
+
+  if (!args.url || !args.gatewayKey) {
+    const state = await loadDaemonState();
+    if (state) {
+      args.url ??= state.url;
+      args.gatewayKey ??= state.gatewayKey;
+      console.log(`[test] Using daemon at ${args.url} (profile: ${state.profile})`);
+    }
+  }
+
+  if (!args.url) {
+    console.error(`No proxy URL. Provide --url or start the daemon: codemie proxy start`);
+    process.exit(1);
+  }
+  if (!args.gatewayKey) {
+    console.error(`No gateway key. Provide --gateway-key or start the daemon: codemie proxy start`);
+    process.exit(1);
+  }
+
+  let baseUrl;
+  try { baseUrl = new URL(args.url); }
+  catch { console.error(`Invalid URL: ${args.url}`); process.exit(1); }
+
+  const endpoint = args.endpoint.startsWith('/') ? args.endpoint : `/${args.endpoint}`;
+  const targetUrl = new URL(endpoint, baseUrl);
+
+  const body = {
+    model: args.model,
+    messages: [{ role: 'user', content: args.message }],
+    max_tokens: args.maxTokens,
+    stream: args.stream,
+  };
+
+  const headers = {
+    'Content-Type': 'application/json',
+    Accept: args.stream ? 'text/event-stream' : 'application/json',
+    Authorization: `Bearer ${args.gatewayKey}`,
+  };
+  if (args.sendAnthropicVersion) headers['anthropic-version'] = '2023-06-01';
+
+  console.log(`[test] POST ${targetUrl.href}`);
+  console.log(`[test] Headers: ${JSON.stringify({ ...headers, Authorization: 'Bearer ***' })}`);
+  console.log(`[test] Body:    ${JSON.stringify(body)}`);
+
+  const startMs = Date.now();
+  let response;
+  try {
+    response = await fetch(targetUrl, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+  } catch (error) {
+    console.error(`[test] Request failed: ${error.message}`);
+    process.exit(1);
+  }
+
+  const ttfbMs = Date.now() - startMs;
+  console.log(`\n[test] Status:  ${response.status} ${response.statusText}  (TTFB ${ttfbMs}ms)`);
+  console.log(`[test] Response headers:`);
+  for (const [k, v] of response.headers.entries()) {
+    console.log(`         ${k}: ${v}`);
+  }
+
+  if (args.stream) {
+    if (!response.body) {
+      console.error('[test] No response body for streaming');
+      process.exit(1);
+    }
+    console.log('\n[test] --- SSE stream ---');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let chunkCount = 0;
+    let totalBytes = 0;
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      chunkCount += 1;
+      totalBytes += value.length;
+      process.stdout.write(decoder.decode(value, { stream: true }));
+    }
+    const totalMs = Date.now() - startMs;
+    console.log(`\n[test] --- end (${chunkCount} chunks, ${totalBytes} bytes, ${totalMs}ms total) ---`);
+  } else {
+    const text = await response.text();
+    const totalMs = Date.now() - startMs;
+    console.log(`\n[test] Body (${text.length} bytes, ${totalMs}ms total):`);
+    console.log(text);
+  }
+
+  if (!response.ok) process.exit(1);
+}
+
+main().catch(err => { console.error(err); process.exit(1); });