@bniladridas/cursor 0.1.7

package/src/utils/version.cpp

@@ -0,0 +1,175 @@
+#include "version.h"
+#include <filesystem>
+#include <iostream>
+#include <string>
+
+#include <curl/curl.h>
+
+#ifdef __APPLE__
+#include <mach-o/dyld.h>
+#endif
+
+namespace {
+
+size_t write_to_string(void *ptr, size_t size, size_t nmemb, void *userdata) {
+  auto *str = static_cast<std::string *>(userdata);
+  str->append(static_cast<char *>(ptr), size * nmemb);
+  return size * nmemb;
+}
+
+size_t write_to_file(void *ptr, size_t size, size_t nmemb, void *userdata) {
+  auto *file = static_cast<FILE *>(userdata);
+  return fwrite(ptr, size, nmemb, file);
+}
+
+std::string get_platform_binary_name() {
+#ifdef _WIN32
+  return "cursor-windows.exe";
+#elif defined(__APPLE__)
+  return "cursor-macos";
+#else
+  return "cursor-linux";
+#endif
+}
+
+std::string get_exe_path() {
+  try {
+    return std::filesystem::canonical("/proc/self/exc").string();
+  } catch (...) {
+  }
+#ifdef __APPLE__
+  char buf[1024];
+  uint32_t size = sizeof(buf);
+  if (_NSGetExecutablePath(buf, &size) == 0) {
+    return std::filesystem::canonical(buf).string();
+  }
+#endif
+  return {};
+}
+
+std::string fetch_latest_version() {
+  CURL *curl = curl_easy_init();
+  if (!curl)
+    return {};
+
+  std::string response;
+  curl_easy_setopt(curl, CURLOPT_URL,
+                   "https://api.github.com/repos/bniladridas/cursor/releases/"
+                   "latest");
+  curl_easy_setopt(curl, CURLOPT_USERAGENT, "cursor-agent");
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_to_string);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT, 5L);
+
+  CURLcode res = curl_easy_perform(curl);
+  curl_easy_cleanup(curl);
+
+  if (res != CURLE_OK)
+    return {};
+
+  auto tag_pos = response.find("\"tag_name\":\"");
+  if (tag_pos == std::string::npos)
+    return {};
+  tag_pos += 13;
+  auto tag_end = response.find("\"", tag_pos);
+  return response.substr(tag_pos, tag_end - tag_pos);
+}
+
+} // namespace
+
+namespace Version {
+
+const char *get_version() { return cursor_version_string; }
+
+const char *get_build_info() {
+  static std::string build_info;
+  if (build_info.empty()) {
+    build_info = std::string(__DATE__) + " " + __TIME__;
+  }
+  return build_info.c_str();
+}
+
+void print_version_info() {
+  std::cout << "Cursor v" << get_version() << "\n";
+  std::cout << "Built: " << get_build_info() << "\n";
+}
+
+std::string check_update() {
+  std::string latest = fetch_latest_version();
+  if (latest.empty() || latest == get_version())
+    return {};
+  return latest;
+}
+
+bool download_and_install(const std::string &version) {
+  std::string binary_name = get_platform_binary_name();
+  std::string url =
+      "https://github.com/bniladridas/cursor/releases/download/" + version +
+      "/" + binary_name;
+
+  std::string tmp = "/tmp/cursor-update-" + version;
+#ifdef _WIN32
+  tmp += ".exe";
+#endif
+
+  std::cout << "Downloading v" << version << "...\n";
+
+  FILE *fp = fopen(tmp.c_str(), "wb");
+  if (!fp) {
+    std::cerr << "Failed to create temp file\n";
+    return false;
+  }
+
+  CURL *curl = curl_easy_init();
+  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+  curl_easy_setopt(curl, CURLOPT_USERAGENT, "cursor-agent");
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_to_file);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
+  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT, 300L);
+
+  CURLcode res = curl_easy_perform(curl);
+  curl_easy_cleanup(curl);
+  fclose(fp);
+
+  if (res != CURLE_OK) {
+    std::cerr << "Download failed: " << curl_easy_strerror(res) << "\n";
+    std::filesystem::remove(tmp);
+    return false;
+  }
+
+  std::filesystem::permissions(tmp,
+                               std::filesystem::perms::owner_exec |
+                                   std::filesystem::perms::owner_read |
+                                   std::filesystem::perms::owner_write,
+                               std::filesystem::perm_options::add);
+
+  std::string exe = get_exe_path();
+  if (exe.empty()) {
+    std::cerr << "Downloaded to: " << tmp << "\nManually replace binary.\n";
+    return false;
+  }
+
+  std::string backup = exe + ".bak";
+  std::error_code ec;
+  std::filesystem::rename(exe, backup, ec);
+  if (ec) {
+    std::cerr << "Failed to backup: " << ec.message() << "\n";
+    std::filesystem::remove(tmp);
+    return false;
+  }
+
+  std::filesystem::rename(tmp, exe, ec);
+  if (ec) {
+    std::cerr << "Failed to install: " << ec.message() << "\n";
+    std::filesystem::rename(backup, exe);
+    std::filesystem::remove(tmp);
+    return false;
+  }
+
+  std::cout << "Updated to v" << version << " successfully!\n";
+  return true;
+}
+
+} // namespace Version

package/tests/e2e/docker-compose.yml

@@ -0,0 +1,195 @@
+networks:
+  e2e-network:
+    driver: bridge
+
+services:
+  mock-together:
+    image: nginx:alpine
+    entrypoint: ["/bin/sh", "/start_nginx.sh"]
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "--spider", "http://127.0.0.1/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 10s
+    container_name: mock-together
+    environment:
+      - MOCK_TYPE=together
+    ports:
+      - "8081:80"
+    volumes:
+      - ./tests/mocks/start_nginx.sh:/start_nginx.sh:ro
+    networks:
+      - e2e-network
+
+  mock-cerebras:
+    image: nginx:alpine
+    entrypoint: ["/bin/sh", "/start_nginx.sh"]
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "--spider", "http://127.0.0.1/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 10s
+    container_name: mock-cerebras
+    environment:
+      - MOCK_TYPE=cerebras
+    ports:
+      - "8082:80"
+    volumes:
+      - ./tests/mocks/start_nginx.sh:/start_nginx.sh:ro
+    networks:
+      - e2e-network
+
+  mock-fireworks:
+    image: nginx:alpine
+    entrypoint: ["/bin/sh", "/start_nginx.sh"]
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "--spider", "http://127.0.0.1/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 10s
+    container_name: mock-fireworks
+    environment:
+      - MOCK_TYPE=fireworks
+    ports:
+      - "8083:80"
+    volumes:
+      - ./tests/mocks/start_nginx.sh:/start_nginx.sh:ro
+    networks:
+      - e2e-network
+
+  mock-groq:
+    image: nginx:alpine
+    entrypoint: ["/bin/sh", "/start_nginx.sh"]
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "--spider", "http://127.0.0.1/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 10s
+    container_name: mock-groq
+    environment:
+      - MOCK_TYPE=groq
+    ports:
+      - "8084:80"
+    volumes:
+      - ./tests/mocks/start_nginx.sh:/start_nginx.sh:ro
+    networks:
+      - e2e-network
+
+  mock-deepseek:
+    image: nginx:alpine
+    entrypoint: ["/bin/sh", "/start_nginx.sh"]
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "--spider", "http://127.0.0.1/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 10s
+    container_name: mock-deepseek
+    environment:
+      - MOCK_TYPE=deepseek
+    ports:
+      - "8085:80"
+    volumes:
+      - ./tests/mocks/start_nginx.sh:/start_nginx.sh:ro
+    networks:
+      - e2e-network
+
+  mock-openai:
+    image: nginx:alpine
+    entrypoint: ["/bin/sh", "/start_nginx.sh"]
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "--spider", "http://127.0.0.1/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 10s
+    container_name: mock-openai
+    environment:
+      - MOCK_TYPE=openai
+    ports:
+      - "8086:80"
+    volumes:
+      - ./tests/mocks/start_nginx.sh:/start_nginx.sh:ro
+    networks:
+      - e2e-network
+
+  mock-ollama:
+    image: nginx:alpine
+    entrypoint: ["/bin/sh", "/start_nginx.sh"]
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "--spider", "http://127.0.0.1/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 10s
+    container_name: mock-ollama
+    environment:
+      - MOCK_TYPE=ollama
+    ports:
+      - "11434:80"
+    volumes:
+      - ./tests/mocks/start_nginx.sh:/start_nginx.sh:ro
+    networks:
+      - e2e-network
+
+  e2e-tests:
+    build:
+      context: .
+      dockerfile: .github/packaging/docker/Dockerfile
+      target: builder
+    container_name: cursor-e2e-tests
+    depends_on:
+      - mock-together
+      - mock-cerebras
+      - mock-fireworks
+      - mock-groq
+      - mock-deepseek
+      - mock-openai
+      - mock-ollama
+    environment:
+      - TOGETHER_API_KEY=test-key
+      - CEREBRAS_API_KEY=test-key
+      - FIREWORKS_API_KEY=test-key
+      - GROQ_API_KEY=test-key
+      - DEEPSEEK_API_KEY=test-key
+      - OPENAI_API_KEY=test-key
+      - SERPAPI_KEY=test-key
+      - OLLAMA_HOST=http://mock-ollama:11434
+      - TEST_MODE=1
+      - BUILDKIT_INLINE_CACHE=1
+    volumes:
+      - .:/app
+      - /app/build
+      - /root/.cache
+    working_dir: /app
+    user: root
+    command:
+      - "bash"
+      - "-c"
+      - "ulimit -c unlimited && /app/tests/e2e/run_tests_in_docker.sh || touch /app/tests/e2e/.e2e_failed"
+    security_opt:
+      - seccomp:unconfined
+    cap_add:
+      - SYS_PTRACE
+    stop_grace_period: 10s
+    stop_signal: SIGTERM
+    healthcheck:
+      test: ["CMD", "true"]
+      interval: 60s
+      timeout: 5s
+      retries: 1
+    restart: "no"
+    networks:
+      - e2e-network
+    deploy:
+      resources:
+        limits:
+          cpus: '2'
+          memory: 4G
+          pids: 1024
+    tmpfs:
+      - /tmp:exec,mode=1777

package/tests/e2e/run_e2e_tests.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/expect -f
+
+set timeout 30
+set test_passed 1
+set BINARY_PATH $env(BINARY_PATH)
+
+# Function to run a test
+proc run_test {test_name mode_selection expected_response} {
+    global test_passed BINARY_PATH
+
+    send_user "Running test: $test_name\n"
+
+    # Start the agent
+    spawn $BINARY_PATH
+    expect "Mode"
+
+    # Select online mode
+    send "1\r"
+    expect "Provider"
+
+    # Select the provider
+    send "$mode_selection\r"
+    expect "Ready"
+
+    # Send a test message
+    send "Hello\r"
+    expect {
+        "$expected_response" {
+            send_user "✓ Test $test_name passed\n"
+        }
+        timeout {
+            send_user "✗ Test $test_name failed: timeout\n"
+            set test_passed 0
+        }
+        eof {
+            send_user "✗ Test $test_name failed: unexpected EOF\n"
+            set test_passed 0
+        }
+    }
+
+    # Exit
+    send "exit\r"
+    expect eof
+}
+
+# Test Fireworks
+run_test "Fireworks" "3" "Mock Fireworks response"
+
+# Test Groq
+run_test "Groq" "4" "Mock Groq response"
+
+# Test DeepSeek
+run_test "DeepSeek" "5" "Mock DeepSeek response"
+
+# Test OpenAI
+run_test "OpenAI" "6" "Mock OpenAI response"
+
+# Test Together (existing)
+run_test "Together" "1" "Mock Together AI response"
+
+# Test Cerebras (existing)
+run_test "Cerebras" "2" "Mock Cerebras response"
+
+if {$test_passed} {
+    send_user "All E2E tests passed!\n"
+    exit 0
+} else {
+    send_user "Some E2E tests failed!\n"
+    exit 1
+}

package/tests/e2e/run_tests_in_docker.sh

@@ -0,0 +1,115 @@
+#!/bin/bash
+set -e
+set -o pipefail
+
+# Cleanup function to ensure proper shutdown
+cleanup() {
+    local exit_code=$?
+    echo "=== Cleaning up test environment ==="
+    # Kill any remaining child processes
+    pkill -P $$ 2>/dev/null || true
+    # Return the exit code without exiting
+    return $exit_code
+}
+
+# Set up trap to ensure cleanup runs on exit and preserves exit code
+handle_exit() {
+    cleanup
+    exit $?
+}
+trap handle_exit EXIT INT TERM
+
+# Print environment for debugging
+echo "=== Environment ==="
+printenv | sort
+echo "=================="
+
+# Enable core dumps for debugging segfaults
+ulimit -c unlimited
+
+# Set test data directory
+export TEST_DATA_DIR="/tmp/cursor_test_data"
+
+# Clean up any previous builds
+echo "=== Cleaning previous builds ==="
+rm -rf /tmp/app
+mkdir -p /tmp/app
+
+# Copy only the necessary files using cp
+echo "=== Copying application files ==="
+cp -r /app/. /tmp/app/
+rm -rf /tmp/app/build
+rm -rf /tmp/app/.git
+
+# Verify expect is installed
+echo "=== Verifying test dependencies ==="
+command -v expect >/dev/null 2>&1 || { echo >&2 "expect is required but not installed. Aborting."; exit 1; }
+command -v python3 >/dev/null 2>&1 || { echo >&2 "python3 is required but not installed. Aborting."; exit 1; }
+
+# Wait for mock services to be ready
+echo "=== Waiting for mock services to be ready ==="
+for service in mock-together mock-cerebras mock-fireworks mock-groq mock-deepseek mock-openai mock-ollama; do
+    echo "Waiting for $service..."
+    timeout 60 bash -c "until wget -qO- http://$service/health 2>/dev/null | grep -q 'healthy'; do sleep 2; done" || {
+        echo "Service $service failed to become ready"
+        exit 1
+    }
+    echo "$service is ready"
+done
+
+# Build the project
+echo "=== Building the project ==="
+cd /tmp/app
+mkdir -p build
+cd build
+cmake ..
+make -j1
+
+# Set binary path for E2E tests
+export BINARY_PATH="/tmp/app/build/bin/cursor-agent"
+
+# Run unit tests
+echo "=== Running unit tests ==="
+ctest --output-on-failure
+
+# Run E2E tests
+echo "=== Running E2E tests ==="
+cd ../tests/e2e
+chmod +x ./run_e2e_tests.sh
+
+# Create test data directory
+mkdir -p "$TEST_DATA_DIR"
+
+# Set environment variables for debugging
+export EXPECT_DEBUG=1
+
+# Run tests with a longer timeout and better error handling
+set +e
+start_time=$(date +%s)
+timeout 600s ./run_e2e_tests.sh > >(tee -a e2e_test.log) 2>&1
+result=$?
+end_time=$(date +%s)
+duration=$((end_time - start_time))
+set -e
+
+# Copy all test artifacts to the host
+cp -r e2e_test.log "$TEST_DATA_DIR/"* /app/tests/e2e/ 2>/dev/null || true
+
+# Check test results
+if [ $result -eq 0 ]; then
+    echo "=== E2E tests completed successfully in ${duration}s ==="
+    echo "=== Test logs saved to /app/tests/e2e/e2e_test.log ==="
+    touch /app/tests/e2e/.e2e_success
+    # Exit with success code
+    exit 0
+else
+    echo "=== E2E tests failed after ${duration}s (exit code: $result) ==="
+    echo "=== Last 50 lines of test output ==="
+    tail -n 50 e2e_test.log || true
+    echo "=== Expect debug logs ==="
+    cat "$TEST_DATA_DIR/"expect_*.log 2>/dev/null || echo "No debug logs available"
+    echo "========================="
+    echo "=== Full test log available in /app/tests/e2e/e2e_test.log ==="
+    # Exit with failure code
+    exit $result
+fi

package/tests/main_test.cpp

@@ -0,0 +1,16 @@
+#include "version.h"
+#include <gtest/gtest.h>
+
+// Basic test to verify the testing framework works
+TEST(BasicTest, SanityCheck) { EXPECT_EQ(1 + 1, 2); }
+
+// Test for version functionality
+TEST(VersionTest, VersionCommand) {
+  const char *version = Version::get_version();
+  EXPECT_STREQ(version, cursor_version_string);
+}
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}

package/tests/mocks/mock_ollama.py

@@ -0,0 +1,98 @@
+import http.server
+import socketserver
+import json
+import time
+
+class Handler(http.server.BaseHTTPRequestHandler):
+    def _set_headers(self, content_type='application/json'):
+        self.send_response(200)
+        self.send_header('Content-type', content_type)
+        self.end_headers()
+
+    def do_HEAD(self):
+        """Handle HEAD requests (used for health checks)"""
+        self._set_headers('text/plain')
+
+    def do_GET(self):
+        if self.path == '/' or self.path == '/health':
+            self._set_headers('text/plain')
+            self.wfile.write(b'healthy\n')
+        elif self.path == '/api/tags':
+            self._set_headers()
+            response = {
+                'models': [
+                    {
+                        'name': 'llama3',
+                        'modified_at': '2023-09-23T00:00:00Z',
+                        'size': 4096,
+                        'digest': 'mock-digest-123',
+                        'details': {
+                            'format': 'gguf',
+                            'family': 'llama',
+                            'parameter_size': '8B',
+                            'quantization_level': 'Q4_0'
+                        }
+                    }
+                ]
+            }
+            self.wfile.write(json.dumps(response).encode('utf-8'))
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def do_POST(self):
+        content_length = int(self.headers['Content-Length'])
+        post_data = self.rfile.read(content_length)
+
+        try:
+            data = json.loads(post_data.decode('utf-8'))
+
+            if self.path == '/api/generate':
+                self._set_headers()
+                response = {
+                    'model': data.get('model', 'llama3'),
+                    'created_at': '2023-09-23T00:00:00Z',
+                    'response': 'This is a mock response from Ollama.',
+                    'done': True,
+                    'context': [0] * 64,  # Mock context
+                    'total_duration': 1000000000,  # 1 second in nanoseconds
+                    'load_duration': 100000000,
+                    'prompt_eval_count': len(data.get('prompt', '').split()),
+                    'eval_count': 10,
+                    'eval_duration': 900000000
+                }
+                self.wfile.write(json.dumps(response).encode('utf-8'))
+            elif self.path == '/api/chat':
+                self._set_headers()
+                response = {
+                    'model': data.get('model', 'llama3.2:3b'),
+                    'created_at': '2023-09-23T00:00:00Z',
+                    'message': {
+                        'role': 'assistant',
+                        'content': 'This is a mock response from Ollama.'
+                    },
+                    'done': True,
+                    'total_duration': 1000000000,
+                    'load_duration': 100000000,
+                    'prompt_eval_count': 10,
+                    'eval_count': 10,
+                    'eval_duration': 900000000
+                }
+                self.wfile.write(json.dumps(response).encode('utf-8'))
+            else:
+                self.send_response(404)
+                self.end_headers()
+
+        except json.JSONDecodeError:
+            self.send_response(400)
+            self.end_headers()
+            self.wfile.write(b'Invalid JSON')
+
+def run(server_class=http.server.HTTPServer, handler_class=Handler, port=11434):
+    server_address = ('0.0.0.0', port)
+    httpd = server_class(server_address, handler_class)
+    print(f'Starting mock Ollama server on port {port}...')
+    httpd.serve_forever()
+
+if __name__ == '__main__':
+    run()