Add files using upload-large-folder tool

.gitattributes

@@ -687,3 +687,9 @@ benchmark/MIT_Mystery_Hunt/puzzles/by_tsv/2003/2003_www.acme-corp.com_teamGuest_
 benchmark/MIT_Mystery_Hunt/puzzles/by_tsv/2003/2003_www.acme-corp.com_teamGuest_R_1_853_index.html/29.mov filter=lfs diff=lfs merge=lfs -text
 benchmark/MIT_Mystery_Hunt/puzzles/by_tsv/2003/2003_www.acme-corp.com_teamGuest_R_1_853_index.html/30.mov filter=lfs diff=lfs merge=lfs -text
 benchmark/MIT_Mystery_Hunt/puzzles/by_tsv/2003/2003_www.acme-corp.com_teamGuest_R_1_853_index.html/4.mov filter=lfs diff=lfs merge=lfs -text
+benchmark/MIT_Mystery_Hunt/puzzles/by_tsv/2003/2003_www.acme-corp.com_teamGuest_R_1_853_index.html/5.mov filter=lfs diff=lfs merge=lfs -text
+benchmark/MIT_Mystery_Hunt/puzzles/by_tsv/2003/2003_www.acme-corp.com_teamGuest_R_1_853_index.html/6.mov filter=lfs diff=lfs merge=lfs -text
+benchmark/MIT_Mystery_Hunt/puzzles/by_tsv/2003/2003_www.acme-corp.com_teamGuest_R_1_853_index.html/7.mov filter=lfs diff=lfs merge=lfs -text
+benchmark/MIT_Mystery_Hunt/puzzles/by_tsv/2003/2003_www.acme-corp.com_teamGuest_R_1_853_index.html/8.mov filter=lfs diff=lfs merge=lfs -text
+benchmark/MIT_Mystery_Hunt/puzzles/by_tsv/2003/2003_www.acme-corp.com_teamGuest_R_1_853_index.html/9.mov filter=lfs diff=lfs merge=lfs -text
+benchmark/science_bowl/MS-Sample-Questions/Sample-Set-16/2022-MS-3.pdf filter=lfs diff=lfs merge=lfs -text

benchmark/Cybench/benchmark/bug_bounty/lunary/.dockerignore

@@ -0,0 +1,15 @@
+*/node_modules
+*npm-debug.log
+*.Dockerfile
+docker-compose*
+.env
+.dockerignore
+.git
+.gitignore
+*README.md
+*LICENSE
+.vscode
+*.next
+*.swp
+/scripts
+.env

benchmark/Cybench/benchmark/bug_bounty/lunary/.env.example

@@ -0,0 +1,19 @@
+# Next
+NEXT_PUBLIC_API_URL="http://localhost:3333"
+NEXT_PUBLIC_APP_URL="http://localhost:8080"
+
+# Database
+DATABASE_URL=<your_db_uri>
+
+# POSTGRES_USER="postgres"
+# POSTGRES_PASSWORD="mysecretpassword"
+# POSTGRES_DB="lunary"
+
+# Backend
+SKIP_EMAIL_VERIFY=true # Set to false to enable email verification
+DEFAULT_PLAN=free
+
+# Playground & Evals (Optional)
+OPENAI_API_KEY=
+OPENROUTER_API_KEY=
+ANTHROPIC_API_KEY

benchmark/Cybench/benchmark/bug_bounty/lunary/.prettierrc

@@ -0,0 +1,3 @@
+{
+  "semi": false
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/README.md

@@ -0,0 +1,89 @@
+<div align="center">
+
+# 📈 lunary
+
+**Open-source observability & prompt platform for LLMs**
+
+[website](https://lunary.ai) - [docs](https://lunary.ai/docs) - [self host](https://lunary.ai/docs/self-host)
+
+[![npm version](https://badge.fury.io/js/lunary.svg)](https://badge.fury.io/js/lunary) ![PyPI - Version](https://img.shields.io/pypi/v/llmonitor) ![GitHub last commit (by committer)](https://img.shields.io/github/last-commit/lunary-ai/lunary) ![GitHub commit activity (branch)](https://img.shields.io/github/commit-activity/w/lunary-ai/lunary)
+
+</div>
+
+## Features
+
+Lunary helps AI devs take their apps in production, with features such as:
+
+- 💵 Analytics (cost, token, latency, ..)
+- 🔍 Monitoring (logs, traces, user tracking, ..)
+- ⛩️ Prompt Templates (versioning, team collaboration, ..)
+- 🏷️ Creat fine-tuning datasets
+- 🖲️ Chat & feedback tracking
+- 🧪 Evaluations
+
+It also designed to be:
+
+- 🤖 Usable with any model, not just OpenAI
+- 📦 Easy to integrate (2 minutes)
+- 🧑‍💻 Simple to self-host
+
+## Demo
+
+https://github.com/lunary-ai/lunary/assets/5092466/a2b4ba9b-4afb-46e3-9b6b-faf7ddb4a931
+
+## ⚙️ Integration
+
+Modules available for:
+
+- [JavaScript](https://github.com/lunary-ai/lunary-js)
+- [Python](https://github.com/lunary-ai/lunary-py)
+
+Lunary natively supports:
+
+- [LangChain](https://lunary.ai/docs/langchain) (JS & Python)
+- [OpenAI module](https://lunary.ai/docs/js/openai)
+- [LiteLLM](https://docs.litellm.ai/docs/observability/lunary_integration)
+
+Additionally you can use it with any framework by wrapping the relevant methods.
+
+## 📚 Documentation
+
+Full documentation is available [on the website](https://lunary.ai/docs/intro).
+
+## ☁️ Hosted version
+
+We offer [a hosted version](https://lunary.ai) with a free plan of up to 1k requests / days.
+
+With the hosted version:
+
+- 👷 don't worry about devops or managing updates
+- 🙋 get priority 1:1 support with our team
+- 🇪🇺 your data is stored safely in Europe
+
+## Running locally
+
+Lunary is powered by Node.js.
+
+To run it locally, you'll need access to a Postgres database to set as the `DATABASE_URL` in your `.env` file.
+
+```bash
+# Clone the repository
+git clone https://github.com/lunary-ai/lunary
+
+# Copy env variables
+cp .env.example .env
+
+# Install dependencies
+npm install
+
+# Run the development server
+npm run dev
+```
+
+## 🙋 Support
+
+Need help or have questions? Chat with us on [the website](https://lunary.ai) or email us: [hello [at] lunary.ai](mailto:hello@lunary.ai). We're here to support you every step of the way.
+
+## License
+
+This project is licensed under the Apache 2.0 License.

benchmark/Cybench/benchmark/bug_bounty/lunary/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "lunary",
+  "version": "1.0.0",
+  "private": "true",
+  "scripts": {
+    "dev": "concurrently \"npm run frontend:dev\" \"npm run backend:dev\"",
+    "frontend:start": "npm -w packages/frontend run start",
+    "frontend:dev": "npm -w packages/frontend run dev",
+    "backend:start": "npm -w packages/backend run start",
+    "backend:dev": "npm -w packages/backend run dev",
+    "backend:radar": "npm -w packages/backend run radar"
+  },
+  "workspaces": [
+    "packages/*"
+  ],
+  "devDependencies": {
+    "concurrently": "^8.2.2",
+    "prettier": "^3.2.4",
+    "tsup": "^8.0.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/backend/README.md

@@ -0,0 +1,15 @@
+# backend
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.0.14. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/backend/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@lunary/backend",
+  "main": "index.ts",
+  "scripts": {
+    "dev": "tsx --env-file=.env --watch src/index.ts",
+    "start": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm",
+    "radar": "tsx --env-file=.env src/radar.ts"
+  },
+  "dependencies": {
+    "@json2csv/plainjs": "^7.0.5",
+    "@koa/cors": "^5.0.0",
+    "@sentry/node": "^7.99.0",
+    "@sentry/profiling-node": "^1.3.5",
+    "@sentry/utils": "^7.99.0",
+    "@xenova/transformers": "^2.14.2",
+    "argon2": "^0.31.2",
+    "bcrypt": "^5.1.1",
+    "jose": "^5.2.0",
+    "js-tiktoken": "1.0.7",
+    "koa": "^2.15.0",
+    "koa-bodyparser": "^4.4.1",
+    "koa-logger": "^3.2.1",
+    "koa-ratelimit": "^5.1.0",
+    "koa-router": "^12.0.1",
+    "litellm": "^0.12.0",
+    "lunary": "^0.7.2",
+    "node-cron": "^3.0.3",
+    "openai": "^4.26.0",
+    "postgres": "^3.4.3",
+    "prexit": "^2.2.0",
+    "rouge": "^1.0.3",
+    "shared": "*",
+    "stripe": "^14.14.0",
+    "washyourmouthoutwithsoap": "^1.0.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^5.0.2",
+    "@types/koa": "^2.14.0",
+    "@types/koa__cors": "^5.0.0",
+    "@types/koa-bodyparser": "^4.3.12",
+    "@types/koa-logger": "^3.1.5",
+    "@types/koa-ratelimit": "^5.0.5",
+    "@types/koa-router": "^7.4.8",
+    "@types/node": "^20.11.11",
+    "@types/node-cron": "^3.0.11"
+  }
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/backend/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "ESNext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "composite": true,
+    "strict": true,
+    "downlevelIteration": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowJs": true,
+    "baseUrl": ".",
+    "rootDir": "src",
+    "paths": {
+      "@/*": ["./*"],
+      "@/utils/*": ["src/utils/*"],
+      "@/checks/*": ["src/checks/*"],
+    },
+  },
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/db/init.sql

@@ -0,0 +1,471 @@
+create extension if not exists pg_trgm;
+create extension if not exists pgroonga;
+create extension if not exists "uuid-ossp";
+
+
+create type user_role as enum (
+  'member',
+  'admin'
+);
+
+create type org_plan as enum (
+    'free',
+    'pro',
+    'unlimited',
+    'custom'
+);
+
+create type api_key_type as enum (
+    'public',
+    'private'
+);
+
+----------
+--- TABLES 
+----------
+create table account (
+    id uuid default uuid_generate_v4() primary key,
+    created_at timestamp with time zone default now() not null,
+    email text unique, 
+    password_hash text,
+    recovery_token text,
+    name text,
+    org_id uuid,
+    role user_role,
+    verified boolean default false not null
+);
+create index on account(org_id);
+
+create table api_key (
+    id serial primary key,
+    created_at timestamp with time zone default now() not null,
+    type api_key_type not null, 
+    api_key uuid default uuid_generate_v4() not null,
+    project_id uuid not null
+);
+create index on api_key(project_id);
+
+create table external_user (
+    id serial primary key,
+    created_at timestamp with time zone default now() not null,
+    project_id uuid not null,
+    external_id character varying,
+    last_seen timestamp with time zone,
+    props jsonb
+);
+create unique index on external_user (project_id, external_id);
+create index on external_user using gin (lower((props)::text) gin_trgm_ops);
+create index on external_user using gin (lower(external_id) gin_trgm_ops);
+create index on external_user (project_id, last_seen desc);
+
+
+create table log (
+    id bigint primary key,
+    created_at timestamp with time zone default now() not null,
+    message text,
+    level text,
+    extra jsonb,
+    project_id uuid not null,
+    run_id uuid
+);
+
+create table org (
+    id uuid default uuid_generate_v4() primary key,
+    created_at timestamp with time zone default now() not null,
+    name text not null,
+    plan org_plan not null,
+    play_allowance integer default 3 not null,
+    stripe_customer text,
+    stripe_subscription text,
+    limited boolean default false not null,
+    plan_period text default 'monthly'::text not null,
+    canceled boolean default false not null
+);
+
+
+create table project (
+    id uuid default uuid_generate_v4() primary key,
+    created_at timestamp with time zone default now() not null,
+    name text not null,
+    org_id uuid not null
+);
+create index on project(org_id);
+
+
+create table run (
+    id uuid default uuid_generate_v4() primary key,
+    created_at timestamp with time zone default now() not null,
+    ended_at timestamp with time zone,
+    duration interval generated always as (ended_at - created_at) stored,
+    tags text[],
+    project_id uuid not null,
+    status text,
+    name text,
+    error jsonb,
+    input jsonb,
+    output jsonb,
+    params jsonb,
+    type text not null,
+    parent_run_id uuid,
+    prompt_tokens integer,
+    completion_tokens integer,
+    cost float,
+    external_user_id bigint,
+    feedback jsonb,
+    is_public boolean default false not null,
+    sibling_run_id uuid,
+    template_version_id integer,
+    input_text text generated always as ((input)::text) stored,
+    output_text text generated always as ((output)::text) stored,
+    error_text text generated always as ((error)::text) stored,
+    runtime text
+);
+create index on run (type, parent_run_id);
+create index on run (type);
+create index on run (duration);
+create index on run using gin (lower(name) gin_trgm_ops);
+create index on run using gin (lower(output_text) gin_trgm_ops);
+create index on run using gin (lower(input_text) gin_trgm_ops);
+create index on run using pgroonga (input_text, created_at desc);
+create index on run using pgroonga (input);
+create index on run (ended_at, created_at);
+create index on run (created_at desc);
+create index on run (created_at);
+create index on run (created_at, project_id);
+create index on run (project_id, external_user_id);
+create index on run using pgroonga (project_id, type, output_text);
+create index on run using pgroonga (project_id, type, input_text);
+create index on run (project_id, type);
+create index on run using pgroonga (project_id, type, error_text);
+create index on run (project_id, type, created_at desc);
+create index on run (project_id);
+create index on run (external_user_id);
+create index on run using gin (tags);
+create index on run (parent_run_id);
+create index on run (type, external_user_id);
+create index on run (name);
+create index on run using gin (feedback);
+
+
+create table template (
+    id serial primary key, 
+    created_at timestamp with time zone default now(),
+    owner_id uuid,
+    name text,
+    "group" text,
+    slug text,
+    project_id uuid not null,
+    mode text
+);
+
+
+create table template_version (
+    id serial primary key,
+    created_at timestamp with time zone default now() not null,
+    extra jsonb,
+    content jsonb,
+    template_id integer not null,
+    version integer,
+    test_values jsonb,
+    is_draft boolean
+);
+
+
+create table radar (
+    id serial primary key,
+    "description" text,
+    project_id uuid,
+    owner_id uuid,
+    view jsonb,
+    checks jsonb
+);
+
+create table radar_result (
+    id serial primary key,
+    radar_id integer,
+    run_id uuid,
+    created_at timestamp with time zone default now() not null,
+    results jsonb[],
+    passed boolean,
+    details jsonb
+);
+
+----------------------
+--- MATERIALIZED VIEWS
+----------------------
+create materialized view tag_cache as  
+select 
+    run.project_id,
+    unnest(run.tags) as tag,
+    now() as refreshed_at
+from 
+    run
+where 
+    run.type = 'llm'::text
+group by 
+    run.project_id, 
+    (unnest(run.tags));
+
+create unique index on tag_cache (project_id, tag);
+create index on tag_cache(project_id);
+
+
+create materialized view model_name_cache as  
+select 
+    run.project_id,
+    run.name,
+    now() as refreshed_at
+from 
+    run
+where 
+    run.type = 'llm'::text 
+    and run.name is not null
+group by 
+    run.project_id, 
+    run.name;
+
+create unique index on  model_name_cache (project_id, name);
+create index on model_name_cache(project_id);
+
+
+----------------
+--- FOREIGN KEYS 
+----------------
+alter table account add foreign key (org_id) references org(id);
+
+alter table api_key add foreign key (project_id) references project(id);
+
+-- alter table dataset add foreign key (project_id) references project(id) on delete cascade;
+
+alter table external_user add foreign key (project_id) references project(id);
+
+alter table log add foreign key (project_id) references project(id);
+alter table log add foreign key (run_id) references run(id) on delete cascade on update cascade;
+
+alter table project add foreign key (org_id) references org(id);
+
+alter table run add foreign key (project_id) references project(id) on delete cascade;
+alter table run add foreign key (parent_run_id) references run(id) on delete set null on update cascade;
+alter table run add foreign key (external_user_id) references external_user(id) on delete set null on update cascade;
+alter table run add foreign key (sibling_run_id) references run(id) on delete set null on update cascade;
+
+alter table template add foreign key (project_id) references project(id) on delete cascade;
+alter table template add foreign key (owner_id) references account(id) on delete set null;
+
+alter table template_version add foreign key (template_id) references template(id) on delete cascade;
+
+alter table radar add foreign key (project_id) references project(id) on delete cascade;
+alter table radar add foreign key (owner_id) references account(id) on delete set null;
+
+alter table radar_result add foreign key (radar_id) references radar(id) on delete cascade;
+alter table radar_result add foreign key (run_id) references run(id) on delete cascade on update cascade;
+
+update
+	api_key
+set
+	api_key = project_id
+where
+	type = 'public'; 
+
+alter table api_key 
+drop constraint "api_key_project_id_fkey", 
+add constraint "api_key_project_id_fkey" foreign key (project_id) references project (id) on delete cascade;
+
+alter table external_user 
+drop constraint "external_user_project_id_fkey", 
+add constraint "external_user_project_id_fkey" foreign key (project_id) references project (id) on delete cascade;
+
+alter table account 
+drop constraint "account_org_id_fkey", 
+add constraint "account_org_id_fkey" foreign key (org_id) references org (id) on delete cascade;
+
+alter table project 
+drop constraint "project_org_id_fkey", 
+add constraint "project_org_id_fkey" foreign key (org_id) references org (id) on delete cascade;
+
+
+-- convert radar tables to use uuids (no data yet)
+
+drop table radar;
+drop table radar_result;
+
+create table radar (
+	"id" uuid default uuid_generate_v4 (),
+	"description" text,
+	"project_id" uuid,
+	"owner_id" uuid,
+	"view" jsonb,
+	"checks" jsonb,
+	"alerts" jsonb,
+	"negative" bool,
+	constraint "radar_owner_id_fkey" foreign key ("owner_id") references "public"."account" ("id") on delete set null,
+	constraint "radar_project_id_fkey" foreign key ("project_id") references "public"."project" ("id") on delete cascade,
+	primary key ("id")
+);
+
+
+create table radar_result (
+	"id" uuid default uuid_generate_v4 (),
+	"radar_id" uuid,
+	"run_id" uuid,
+	"created_at" timestamptz not null default now(),
+	"results" _jsonb,
+	"passed" bool,
+	"details" jsonb,
+	constraint "radar_result_radar_id_fkey" foreign key ("radar_id") references "public"."radar" ("id") on delete cascade,
+	constraint "radar_result_run_id_fkey" foreign key ("run_id") references "public"."run" ("id") on delete cascade on update cascade,
+	primary key ("id")
+);
+
+
+create table evaluation (
+  id uuid default uuid_generate_v4() primary key,
+  created_at timestamp with time zone default now() not null,
+  name text not null,
+  owner_id uuid not null,
+  project_id uuid not null,
+  models text[],
+  checks jsonb,
+  constraint fk_evaluation_owner_id foreign key (owner_id) references account(id) on delete cascade,
+  constraint fk_evaluation_project_id foreign key (project_id) references project(id) on delete cascade
+);
+create index on evaluation (project_id);
+
+
+create table prompt (
+  id uuid default uuid_generate_v4() primary key,
+  created_at timestamp with time zone default now() not null,
+  evaluation_id uuid not null,
+  content jsonb not null,
+  extra jsonb,
+  constraint fk_prompt_evaluation_id foreign key (evaluation_id) references evaluation(id) on delete cascade
+);
+create index on prompt (evaluation_id);
+
+
+create table prompt_variation (
+  id uuid default uuid_generate_v4() primary key,
+  created_at timestamp with time zone default now() not null,
+  variables jsonb not null,
+  context text,
+  ideal_output text,
+  prompt_id uuid not null,
+  constraint fk_prompt_variation_prompt_id foreign key (prompt_id) references prompt(id) on delete cascade
+);
+create index on prompt_variation (prompt_id);
+
+
+
+create table evaluation_result (
+  id uuid default uuid_generate_v4() primary key,
+  evaluation_id uuid not null,
+  prompt_id uuid,
+  variation_id uuid,
+  model text not null,
+  output jsonb not null,
+  results jsonb not null,
+  passed boolean default false,
+  completion_tokens integer,
+  cost float8,
+  duration text,
+  created_at timestamp with time zone default now() not null,
+  constraint fk_evaluation_result_evaluation_id foreign key (evaluation_id) references evaluation(id) on delete cascade,
+  constraint fk_evaluation_result_prompt_id foreign key (prompt_id) references prompt(id) on delete cascade,
+  constraint fk_evaluation_result_variation_id foreign key (variation_id) references prompt_variation(id) on delete cascade
+);
+create index on evaluation_result(evaluation_id, prompt_id, variation_id, model);
+
+
+alter table prompt rename to evaluation_prompt;
+alter table prompt_variation rename to evaluation_prompt_variation;
+alter table prompt rename column content to messages
+
+-- 14/02/2024
+
+create table checklist (
+    id uuid default uuid_generate_v4() primary key,
+    slug text not null,
+    data jsonb not null,
+    type text not null,
+    created_at timestamp with time zone default now(),
+    updated_at timestamp with time zone default now(),
+    owner_id uuid not null,
+    project_id uuid not null,
+    constraint fk_checklist_owner_id foreign key (owner_id) references account(id) on delete set null,
+    constraint fk_checklist_project_id foreign key (project_id) references project(id) on delete cascade
+);
+
+create table provider (
+    id uuid default uuid_generate_v4() primary key,
+    model text not null,
+    params jsonb,
+    created_at timestamp with time zone default now(),
+    updated_at timestamp with time zone default now(),
+    owner_id uuid not null,
+    project_id uuid not null,
+    constraint fk_checklist_owner_id foreign key (owner_id) references account(id) on delete set null,
+    constraint fk_checklist_project_id foreign key (project_id) references project(id) on delete cascade
+);
+
+alter table evaluation add column checklist_id uuid references checklist(id) on delete set null;
+
+
+
+
+create table dataset (
+	id uuid not null default uuid_generate_v4() primary key,
+	created_at timestamptz not null default now(),
+	updated_at timestamptz not null default now(),
+	project_id uuid not null,
+	owner_id uuid not null,
+	slug text not null,
+	
+	foreign key (project_id) references project(id) on delete cascade,
+	foreign key (owner_id) references account(id)
+
+);
+create index on dataset (project_id, slug);
+
+
+create table dataset_prompt (
+	id uuid not null default uuid_generate_v4() primary key,
+	created_at timestamptz not null default now(),
+	dataset_id uuid not null,
+	messages jsonb not null,
+	foreign key (dataset_id) references dataset(id) on delete cascade
+);
+create index on  dataset_prompt(dataset_id);
+
+
+create table dataset_prompt_variation (
+	id uuid not null default uuid_generate_v4() primary key,
+	created_at timestamptz not null default now(),
+	variables jsonb not null,
+	context text,
+	ideal_output text,
+	prompt_id uuid not null,
+	foreign key (prompt_id) references dataset_prompt (id) on delete cascade
+);
+create index on dataset_prompt_variation(prompt_id);
+
+
+create table evaluation (
+	id uuid not null default uuid_generate_v4(),
+	created_at timestamptz not null default now() primary key,
+	name text not null,
+	project_id uuid not null,
+	owner_id uuid not null,
+	dataset_id uuid not null,
+	models _text not null,
+	checks jsonb not null,
+	foreign key (project_id) references project(id) on delete cascade,
+	foreign key (owner_id) references account(id),
+	foreign key (dataset_id) references dataset(id)
+);
+create index on evaluation(project_id);
+
+
+
+alter table evaluation_result 
+drop constraint "fk_evaluation_result_variation_id",
+add constraint "fk_evaluation_result_variation_id" foreign key (prompt_id) references dataset_prompt(id) on delete cascade;

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/README.md

@@ -0,0 +1 @@
+## Next.js

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/next.config.js

@@ -0,0 +1,56 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+  eslint: {
+    // Warning: This allows production builds to successfully complete even if
+    // your project has ESLint errors.
+    ignoreDuringBuilds: true,
+  },
+  typescript: {
+    // !! WARN !!
+    // Dangerously allow production builds to successfully complete even if
+    // your project has type errors.
+    // !! WARN !!
+    ignoreBuildErrors: true,
+  },
+  images: {
+    remotePatterns: [
+      {
+        protocol: "https",
+        hostname: "**",
+      },
+    ],
+  },
+  async rewrites() {
+    return [
+      {
+        source: "/ingest/:path*",
+        destination: "https://app.posthog.com/:path*",
+      },
+      {
+        source: "/api/v1/report",
+        destination: process.env.NEXT_PUBLIC_API_URL + "/api/report",
+      },
+      {
+        source: "/api/report",
+        destination: process.env.NEXT_PUBLIC_API_URL + "/api/report",
+      },
+      {
+        source: "/api/v1/template",
+        destination: process.env.NEXT_PUBLIC_API_URL + "/api/v1/template",
+      },
+    ]
+  },
+  webpack: (config, { webpack }) => {
+    config.plugins.push(
+      new webpack.IgnorePlugin({
+        resourceRegExp: /^pg-native$|^cloudflare:sockets$/,
+      }),
+    )
+
+    return config
+  },
+  transpilePackages: ["shared"],
+}
+
+module.exports = nextConfig

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@lunary/frontend",
+  "main": "pages/index.ts",
+  "scripts": {
+    "dev": "next dev -p 8080",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint",
+    "format": "prettier --write ./**/*.{ts,tsx}"
+  },
+  "dependencies": {
+    "@calcom/embed-react": "^1.3.0",
+    "@mantine/core": "^7.5.0",
+    "@mantine/form": "^7.5.0",
+    "@mantine/hooks": "^7.5.0",
+    "@mantine/modals": "^7.5.0",
+    "@mantine/notifications": "^7.5.0",
+    "@tabler/icons-react": "^2.46.0",
+    "@tanstack/react-table": "^8.11.2",
+    "@tanstack/react-virtual": "3.0.0-alpha.0",
+    "@types/node": "20.10.5",
+    "@types/react": "18.2.45",
+    "@types/react-dom": "18.2.18",
+    "bcrypt": "^5.1.1",
+    "crisp-sdk-web": "^1.0.21",
+    "date-fns": "^3.3.1",
+    "jose": "^5.2.0",
+    "jsonrepair": "^3.5.1",
+    "next": "^14.1.0",
+    "next-plausible": "^3.12.0",
+    "next-seo": "^6.4.0",
+    "postgres": "^3.4.3",
+    "posthog-js": "^1.103.1",
+    "random-word-slugs": "^0.1.7",
+    "react": "18.2.0",
+    "react-confetti": "^6.1.0",
+    "react-dom": "18.2.0",
+    "react-json-view-lite": "^1.2.1",
+    "recharts": "^2.11.0",
+    "shared": "*",
+    "swr": "^2.2.4"
+  },
+  "devDependencies": {
+    "@types/react": "18.2.45",
+    "@types/react-dom": "^18.2.18",
+    "postcss": "^8.4.33",
+    "postcss-preset-mantine": "^1.12.3",
+    "postcss-simple-vars": "^7.0.1"
+  }
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/_app.tsx

@@ -0,0 +1,143 @@
+import "@mantine/core/styles.css"
+import "@mantine/notifications/styles.css"
+import "../styles/globals.css"
+
+import { MantineProvider, createTheme } from "@mantine/core"
+import type { AppProps } from "next/app"
+import Head from "next/head"
+
+import Layout from "@/components/Layout"
+import AnalyticsWrapper from "@/components/Layout/Analytics"
+import { DefaultSeo } from "next-seo"
+import Link from "next/link"
+
+import { fetcher } from "@/utils/fetcher"
+import localFont from "next/font/local"
+import { SWRConfig } from "swr"
+import { AuthProvider } from "@/utils/auth"
+
+export const circularPro = localFont({
+  display: "swap",
+  fallback: [
+    "-apple-system",
+    "BlinkMacSystemFont",
+    "Segoe UI",
+    "Roboto",
+    "Helvetica",
+    "Arial",
+    "sans-serif",
+  ],
+  src: [
+    {
+      path: "../public/fonts/circular-pro-book.woff2",
+      weight: "400",
+      style: "normal",
+    },
+    {
+      path: "../public/fonts/circular-pro-medium.woff2",
+      weight: "500",
+      style: "normal",
+    },
+    {
+      path: "../public/fonts/circular-pro-bold.woff2",
+      weight: "700",
+      style: "normal",
+    },
+    // {
+    //   path: "../public/fonts/circular-pro-black.woff2",
+    //   weight: "900",
+    //   style: "normal",
+    // },
+  ],
+})
+
+const theme = createTheme({
+  defaultRadius: "md",
+  fontFamily: circularPro.style.fontFamily,
+  headings: {
+    fontWeight: "700",
+  },
+  components: {
+    Anchor: {
+      defaultProps: {
+        component: Link,
+      },
+    },
+    NavLink: {
+      defaultProps: {
+        h: 36,
+      },
+    },
+    Select: {
+      defaultProps: {
+        spellCheck: "false",
+        autoCorrect: "off",
+      },
+    },
+    Button: {
+      defaultProps: {
+        fw: "500",
+      },
+    },
+    Popover: {
+      defaultProps: {
+        withArrow: true,
+        shadow: "sm",
+      },
+    },
+    Combobox: {
+      defaultProps: {
+        withArrow: true,
+        shadow: "sm",
+      },
+    },
+    HoverCard: {
+      defaultProps: {
+        withArrow: true,
+        shadow: "sm",
+      },
+    },
+    Tooltip: {
+      defaultProps: {
+        withArrow: true,
+        shadow: "sm",
+      },
+    },
+  },
+})
+
+export default function App({ Component, pageProps }: AppProps) {
+  return (
+    <>
+      <style jsx global>{`
+        html {
+          font-family: ${circularPro.style.fontFamily};
+        }
+      `}</style>
+      <Head>
+        <link href="https://lunary.ai/logo.png" rel="icon" type="image/png" />
+      </Head>
+      <AuthProvider>
+        <SWRConfig
+          value={{
+            fetcher: fetcher.get,
+            dedupingInterval: 10000,
+          }}
+        >
+          <DefaultSeo
+            title="Dashboard"
+            titleTemplate="%s | Lunary"
+            defaultTitle="Dashboard | Lunary"
+          />
+          <MantineProvider theme={theme} defaultColorScheme="auto">
+            <AnalyticsWrapper>
+              <Layout>
+                <Component {...pageProps} />
+              </Layout>
+            </AnalyticsWrapper>
+          </MantineProvider>
+        </SWRConfig>
+      </AuthProvider>
+    </>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/_document.tsx

@@ -0,0 +1,16 @@
+import { Html, Head, Main, NextScript } from "next/document"
+import { ColorSchemeScript } from "@mantine/core"
+
+export default function Document() {
+  return (
+    <Html lang="en">
+      <Head>
+        <ColorSchemeScript defaultColorScheme="auto" />
+      </Head>
+      <body>
+        <Main />
+        <NextScript />
+      </body>
+    </Html>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/analytics.tsx

@@ -0,0 +1,235 @@
+import AgentSummary from "@/components/Analytics/AgentSummary"
+import AnalyticsCard from "@/components/Analytics/AnalyticsCard"
+import BarList from "@/components/Analytics/BarList"
+import LineChart from "@/components/Analytics/LineChart"
+import UsageSummary from "@/components/Analytics/UsageSummary"
+import { formatAppUser, formatCost } from "@/utils/format"
+
+import AppUserAvatar from "@/components/Blocks/AppUserAvatar"
+import Empty from "@/components/Layout/Empty"
+import {
+  useAppUsers,
+  useOrg,
+  useProject,
+  useRunsUsage,
+  useRunsUsageByDay,
+} from "@/utils/dataHooks"
+import {
+  Center,
+  Container,
+  Group,
+  Loader,
+  SegmentedControl,
+  SimpleGrid,
+  Stack,
+  Title,
+} from "@mantine/core"
+import { useLocalStorage } from "@mantine/hooks"
+import { IconChartAreaLine } from "@tabler/icons-react"
+import { NextSeo } from "next-seo"
+
+const calculateDailyCost = (usage) => {
+  // calculate using calcRunCost, reduce by model, and filter by type llm
+  // reduce by day
+
+  const cost = usage.reduce((acc, curr) => {
+    const { date, cost } = curr
+
+    if (!acc[date]) acc[date] = 0
+    acc[date] += cost
+
+    return acc
+  }, {})
+
+  const final = Object.keys(cost).map((date) => ({
+    date,
+    cost: cost[date],
+  }))
+
+  return final
+}
+
+export default function Analytics() {
+  const [range, setRange] = useLocalStorage({
+    key: "dateRange-analytics",
+    defaultValue: 7,
+  })
+
+  const { project } = useProject()
+
+  const { org } = useOrg()
+
+  const { usage, loading: usageLoading } = useRunsUsage(range)
+
+  const { dailyUsage, loading: dailyUsageLoading } = useRunsUsageByDay(range)
+  const { users, loading: usersLoading } = useAppUsers(range)
+
+  const loading = usageLoading || dailyUsageLoading || usersLoading
+
+  if (loading)
+    return (
+      <Center h="60vh">
+        <Loader />
+      </Center>
+    )
+
+  return (
+    <Empty
+      Icon={IconChartAreaLine}
+      title="Waiting for data..."
+      description="Analytics will appear here once you have some data."
+      showProjectId
+      enable={!loading && !project?.activated}
+    >
+      <Container size="lg" my="lg">
+        <NextSeo title="Analytics" />
+        <Stack gap="lg">
+          <Group justify="space-between">
+            <Title order={2}>Analytics</Title>
+            <SegmentedControl
+              w={300}
+              value={range.toString()}
+              onChange={(val) => setRange(parseInt(val))}
+              data={[
+                { label: "24H", value: "1" },
+                { label: "7D", value: "7" },
+                { label: "30D", value: "30" },
+                { label: "90D", value: "90" },
+              ]}
+            />
+          </Group>
+
+          <SimpleGrid cols={{ base: 1, sm: 3 }} spacing="md">
+            {usage && (
+              <>
+                <UsageSummary usage={usage} />
+                <AgentSummary usage={usage} />
+              </>
+            )}
+
+            {users && (
+              <AnalyticsCard title="Users">
+                <BarList
+                  customMetric={{
+                    label: "users",
+                    value: users.length,
+                  }}
+                  filterZero={false}
+                  data={users
+                    .sort((a, b) => a.cost - b.cost)
+                    .map((u) => ({
+                      agentRuns: u.agentRuns,
+                      cost: u.cost,
+                      barSections: [
+                        {
+                          value: "cost",
+                          tooltip: "Cost",
+                          count: u.cost,
+                          color: "teal.2",
+                        },
+                      ],
+                      ...u,
+                    }))}
+                  columns={[
+                    {
+                      name: "User",
+                      render: (u, row) => (
+                        <Group my={-4} gap="sm">
+                          <AppUserAvatar size={30} user={row} />
+                          {formatAppUser(row)}
+                        </Group>
+                      ),
+                    },
+                    {
+                      name: "Cost",
+                      key: "cost",
+                      render: formatCost,
+                      main: true,
+                    },
+                  ]}
+                />
+              </AnalyticsCard>
+            )}
+          </SimpleGrid>
+
+          {dailyUsage && (
+            <>
+              <LineChart
+                range={range}
+                title="Tokens"
+                height={230}
+                splitBy="name"
+                data={dailyUsage
+                  .filter((u) => u.type === "llm")
+                  .map((p) => ({
+                    ...p,
+                    tokens: p.completionTokens + p.promptTokens,
+                  }))}
+                props={["tokens"]}
+              />
+
+              <LineChart
+                title="Cost Usage"
+                range={range}
+                height={230}
+                formatter={formatCost}
+                data={calculateDailyCost(dailyUsage)}
+                props={["cost"]}
+              />
+
+              <LineChart
+                range={range}
+                title="Agents"
+                height={230}
+                splitBy="name"
+                data={dailyUsage
+                  .filter((u) => u.type === "agent")
+                  .map((p) => ({
+                    ...p,
+                    runs: p.success + p.errors,
+                  }))}
+                props={["runs"]}
+              />
+
+              {org?.plan === "free" && (
+                <>
+                  <LineChart
+                    blocked={true}
+                    props={["users"]}
+                    range={range}
+                    title="Avg User Cost"
+                    height={230}
+                  />
+
+                  <LineChart
+                    blocked={true}
+                    range={range}
+                    props={["users"]}
+                    title="Errors over time"
+                    height={230}
+                  />
+
+                  <LineChart
+                    blocked={true}
+                    range={range}
+                    props={["users"]}
+                    title="Avg latency"
+                    height={230}
+                  />
+
+                  <LineChart
+                    blocked={true}
+                    range={range}
+                    props={["users"]}
+                    title="Positive feedback"
+                    height={230}
+                  />
+                </>
+              )}
+            </>
+          )}
+        </Stack>
+      </Container>
+    </Empty>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/index.tsx

@@ -0,0 +1,19 @@
+import { useAuth } from "@/utils/auth"
+import { Center, Loader } from "@mantine/core"
+import Router from "next/router"
+import { useEffect } from "react"
+
+function IndexPage() {
+  const { isSignedIn } = useAuth()
+  useEffect(() => {
+    Router.replace(isSignedIn ? "/analytics" : "/login")
+  }, [])
+
+  return (
+    <Center h="100vh" w="100vw">
+      <Loader />
+    </Center>
+  )
+}
+
+export default IndexPage

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/join.tsx

@@ -0,0 +1,281 @@
+import { useEffect, useState } from "react"
+
+import {
+  Anchor,
+  Button,
+  Container,
+  Flex,
+  Paper,
+  PasswordInput,
+  Stack,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core"
+
+import { useForm } from "@mantine/form"
+import { IconAnalyze, IconAt, IconUser } from "@tabler/icons-react"
+
+import analytics from "@/utils/analytics"
+import { useAuth } from "@/utils/auth"
+import errorHandler from "@/utils/errors"
+import { fetcher } from "@/utils/fetcher"
+import { SEAT_ALLOWANCE } from "@/utils/pricing"
+import { NextSeo } from "next-seo"
+import Router, { useRouter } from "next/router"
+import Confetti from "react-confetti"
+import postgres from "postgres"
+
+const sql = postgres(process.env.DATABASE_URL!)
+
+export async function getServerSideProps(context) {
+  const { orgId } = context.query
+
+  const [org] = await sql`
+    SELECT name, plan FROM org WHERE id = ${orgId}
+  `
+
+  const [orgUserCountResult] = await sql`
+    SELECT COUNT(*) FROM account WHERE org_id = ${orgId}
+  `
+  const orgUserCount = orgUserCountResult.count
+
+  return {
+    props: { orgUserCount, orgName: org?.name, orgId, orgPlan: org?.plan },
+  }
+}
+
+function TeamFull({ orgName }) {
+  return (
+    <Container py={100} size={600}>
+      <NextSeo title="Signup" />
+      <Stack align="center" gap={30}>
+        <IconAnalyze color={"#206dce"} size={60} />
+        <Title order={2} fw={700} size={40} ta="center">
+          Sorry, ${orgName} is full
+        </Title>
+
+        <Flex align="center" gap={30}>
+          <Button size="md" onClick={() => Router.push("/")}>
+            Go back home
+          </Button>
+          <Anchor
+            component="button"
+            type="button"
+            onClick={() => {
+              $crisp.push(["do", "chat:open"])
+            }}
+          >
+            Contact support →
+          </Anchor>
+        </Flex>
+      </Stack>
+    </Container>
+  )
+}
+export default function Join({ orgUserCount, orgName, orgId, orgPlan }) {
+  const auth = useAuth()
+  const [loading, setLoading] = useState(false)
+  const [step, setStep] = useState(1)
+  const router = useRouter()
+
+  useEffect(() => {
+    router.query.step = String(step)
+    router.push(router)
+  }, [step])
+
+  const form = useForm({
+    initialValues: {
+      email: "",
+      name: "",
+      password: "",
+    },
+
+    validate: {
+      email: (val) => (/^\S+@\S+$/.test(val) ? null : "Invalid email"),
+      name: (val) => (val.length <= 2 ? "Your name that short :) ?" : null),
+      password: (val) =>
+        val.length < 6 ? "Password must be at least 6 characters" : null,
+    },
+  })
+
+  const handleSignup = async ({
+    email,
+    password,
+    name,
+  }: {
+    email: string
+    password: string
+    name: string
+  }) => {
+    setLoading(true)
+
+    const body = await errorHandler(
+      fetcher.post("/auth/signup", {
+        arg: {
+          email,
+          password,
+          name,
+          orgId,
+          signupMethod: "join",
+        },
+      }),
+    )
+
+    if (body?.token) {
+      // add ?done to the url
+      Router.replace("/signup?done")
+      auth.setJwt(body.token)
+
+      analytics.track("Join", { email, name })
+    }
+
+    setLoading(false)
+  }
+
+  const nextStep = () => {
+    if (step === 1) {
+      if (
+        form.validateField("email").hasError ||
+        form.validateField("password").hasError
+      ) {
+        return
+      }
+    }
+
+    setStep(step + 1)
+  }
+
+  if (orgUserCount >= SEAT_ALLOWANCE[orgPlan]) {
+    return <TeamFull orgName={orgName} />
+  }
+
+  return (
+    <Container py={100} size={600}>
+      <NextSeo title="Join" />
+
+      <Stack align="center" gap={50}>
+        <Stack align="center">
+          <IconAnalyze color={"#206dce"} size={60} />
+          <Title order={2} fw={700} size={40} ta="center">
+            Join {orgName}
+          </Title>
+        </Stack>
+        <Paper radius="md" p="xl" withBorder miw={350}>
+          <form onSubmit={form.onSubmit(handleSignup)}>
+            <Stack gap="xl">
+              {step === 1 && (
+                <>
+                  <Title order={2} fw={700} ta="center">
+                    Get Started
+                  </Title>
+                  <TextInput
+                    leftSection={<IconAt size="16" />}
+                    label="Email"
+                    type="email"
+                    autoComplete="email"
+                    error={form.errors.email && "Invalid email"}
+                    placeholder="Your email"
+                    {...form.getInputProps("email")}
+                  />
+
+                  <PasswordInput
+                    label="Password"
+                    autoComplete="new-password"
+                    onKeyPress={(e) => {
+                      if (e.key === "Enter") {
+                        nextStep()
+                      }
+                    }}
+                    error={form.errors.password && "Invalid password"}
+                    placeholder="Your password"
+                    {...form.getInputProps("password")}
+                  />
+
+                  <Button
+                    size="md"
+                    mt="md"
+                    onClick={nextStep}
+                    fullWidth
+                    loading={loading}
+                  >
+                    {`Continue →`}
+                  </Button>
+                </>
+              )}
+
+              {step === 2 && (
+                <>
+                  <Title order={2} fw={700} ta="center">
+                    Almost there...
+                  </Title>
+
+                  <TextInput
+                    label="Full Name"
+                    autoComplete="name"
+                    description="Only used to address you properly."
+                    leftSection={<IconUser size="16" />}
+                    placeholder="Your full name"
+                    error={form.errors.name && "This field is required"}
+                    {...form.getInputProps("name")}
+                  />
+
+                  <Stack>
+                    <Button
+                      size="md"
+                      mt="md"
+                      type="submit"
+                      fullWidth
+                      loading={loading}
+                    >
+                      {`Create account`}
+                    </Button>
+
+                    <Button
+                      size="sm"
+                      onClick={() => setStep(1)}
+                      fullWidth
+                      variant="link"
+                      color="gray.4"
+                    >
+                      {`← Go back`}
+                    </Button>
+                  </Stack>
+                </>
+              )}
+
+              {step === 3 && (
+                <>
+                  <Confetti
+                    recycle={false}
+                    numberOfPieces={500}
+                    gravity={0.3}
+                  />
+
+                  <Stack align="center">
+                    <IconAnalyze color={"#206dce"} size={60} />
+                    <Title order={2} fw={700} size={40} ta="center">
+                      You&nbsp;re all set 🎉
+                    </Title>
+
+                    <Text size="lg" mt="xs" mb="xl" fw={500}>
+                      Check your emails for the confirmation link.
+                    </Text>
+
+                    <Button
+                      onClick={() => router.push("/")}
+                      variant="outline"
+                      size="lg"
+                    >
+                      Open Dashboard
+                    </Button>
+                  </Stack>
+                </>
+              )}
+            </Stack>
+          </form>
+        </Paper>
+      </Stack>
+    </Container>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/login.tsx

@@ -0,0 +1,141 @@
+import {
+  Anchor,
+  Button,
+  Container,
+  Paper,
+  Stack,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core"
+
+import { useForm } from "@mantine/form"
+import { IconAnalyze, IconAt } from "@tabler/icons-react"
+
+import { useState } from "react"
+
+import analytics from "@/utils/analytics"
+import { fetcher } from "@/utils/fetcher"
+import { NextSeo } from "next-seo"
+import { useAuth } from "@/utils/auth"
+
+function LoginPage() {
+  const [loading, setLoading] = useState(false)
+  const auth = useAuth()
+
+  const form = useForm({
+    initialValues: {
+      email: "",
+      password: "",
+    },
+
+    validate: {
+      email: (val) => (/^\S+@\S+$/.test(val) ? null : "Invalid email"),
+      password: (val) =>
+        val.length < 6 ? "Password must be at least 6 characters" : null,
+    },
+  })
+
+  async function handleLoginWithPassword({
+    email,
+    password,
+  }: {
+    email: string
+    password: string
+  }) {
+    setLoading(true)
+
+    try {
+      const { token } = await fetcher.post("/auth/login", {
+        arg: {
+          email,
+          password,
+        },
+      })
+
+      if (!token) {
+        throw new Error("No token received")
+      }
+
+      auth.setJwt(token)
+
+      analytics.track("Login", { method: "password" })
+    } catch (error) {
+      console.error(error)
+
+      // empty local storage
+      auth.setJwt(null)
+    }
+
+    setLoading(false)
+  }
+
+  return (
+    <Container pt="60" size="600">
+      <NextSeo title="Login" />
+      <Stack align="center" gap="50">
+        <Stack align="center">
+          <IconAnalyze color="#206dce" size="60" />
+          <Title order={2} fw="700" size="40" ta="center">
+            Welcome back
+          </Title>
+        </Stack>
+        <Paper radius="md" p="xl" withBorder miw="350">
+          <Text size="lg" mb="xl" fw="500">
+            Sign In
+          </Text>
+
+          <form onSubmit={form.onSubmit(handleLoginWithPassword)}>
+            <Stack>
+              <TextInput
+                leftSection={<IconAt size="16" />}
+                label="Email"
+                type="email"
+                autoComplete="email"
+                value={form.values.email}
+                onChange={(event) =>
+                  form.setFieldValue("email", event.currentTarget.value)
+                }
+                error={form.errors.email}
+                placeholder="Your email"
+              />
+
+              <div>
+                <TextInput
+                  type="password"
+                  autoComplete="current-password"
+                  label="Password"
+                  value={form.values.password}
+                  onChange={(event) =>
+                    form.setFieldValue("password", event.currentTarget.value)
+                  }
+                  error={form.errors.password}
+                  placeholder="Your password"
+                />
+                <Anchor
+                  display="block"
+                  pt="xs"
+                  size="sm"
+                  href="/request-password-reset"
+                >
+                  Forgot password?
+                </Anchor>
+              </div>
+
+              <Button mt="md" type="submit" fullWidth loading={loading}>
+                Login
+              </Button>
+
+              <Text size="sm" style={{ textAlign: "center" }}>
+                {`Don't have an account? `}
+                <Anchor href="/signup">Sign Up</Anchor>
+              </Text>
+            </Stack>
+          </form>
+        </Paper>
+      </Stack>
+    </Container>
+  )
+}
+
+export default LoginPage

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/maintenance.tsx

@@ -0,0 +1,22 @@
+// pages/maintenance.tsx
+import { useRouter } from "next/router"
+import React, { useEffect } from "react"
+
+export default function Maintenance() {
+  const router = useRouter()
+  useEffect(() => {
+    if (process.env.NEXT_PUBLIC_MAINTENANCE_MODE !== "on") {
+      router.push("/")
+    }
+  }, [router])
+
+  return (
+    <div>
+      <h1>We&apos;re currently undergoing maintenance</h1>
+      <p>
+        Rest assured, all your new events are safely stored and will be
+        accessible once we&apos;re back.
+      </p>
+    </div>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/request-password-reset.tsx

@@ -0,0 +1,94 @@
+import {
+  Button,
+  Container,
+  Paper,
+  Stack,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core"
+import { useForm } from "@mantine/form"
+import { notifications } from "@mantine/notifications"
+import { IconAnalyze, IconAt, IconCheck } from "@tabler/icons-react"
+import { NextSeo } from "next-seo"
+import { useState } from "react"
+import errorHandler from "../utils/errors"
+
+export default function PasswordReset() {
+  const [loading, setLoading] = useState(false)
+
+  const form = useForm({
+    initialValues: {
+      email: "",
+    },
+
+    validate: {
+      email: (val) => (/^\S+@\S+$/.test(val) ? null : "Invalid email"),
+    },
+  })
+
+  async function handlePasswordReset({ email }) {
+    setLoading(true)
+
+    const res = await errorHandler(
+      fetch(`${process.env.NEXT_PUBLIC_API_URL}/auth/request-password-reset`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ email }),
+      }),
+    )
+
+    if (res.ok) {
+      notifications.show({
+        icon: <IconCheck size={18} />,
+        color: "teal",
+        title: "Email sent 💌",
+        message:
+          "Check your emails to verify your email. Please check your spam folder as we currently have deliverability issues.",
+      })
+    }
+    setLoading(false)
+  }
+
+  return (
+    <Container py={100} size={600}>
+      <NextSeo title="Login" />
+      <Stack align="center" gap={50}>
+        <Stack align="center">
+          <IconAnalyze color={"#206dce"} size={60} />
+          <Title order={2} fw={700} size={40} ta="center">
+            Forgot password
+          </Title>
+        </Stack>
+
+        <Paper radius="md" p="xl" withBorder miw={350}>
+          <Text size="lg" mb="xl" fw={500}>
+            Request reset link
+          </Text>
+
+          <form onSubmit={form.onSubmit(handlePasswordReset)}>
+            <Stack>
+              <TextInput
+                leftSection={<IconAt size="16" />}
+                label="Email"
+                type="email"
+                value={form.values.email}
+                onChange={(event) =>
+                  form.setFieldValue("email", event.currentTarget.value)
+                }
+                error={form.errors.email && "Invalid email"}
+                placeholder="Your email"
+              />
+
+              <Button mt="md" type="submit" fullWidth loading={loading}>
+                Submit
+              </Button>
+            </Stack>
+          </form>
+        </Paper>
+      </Stack>
+    </Container>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/reset-password.tsx

@@ -0,0 +1,101 @@
+import {
+  Button,
+  Container,
+  Paper,
+  PasswordInput,
+  Stack,
+  Title,
+} from "@mantine/core"
+
+import { useForm } from "@mantine/form"
+import { IconAnalyze } from "@tabler/icons-react"
+
+import { NextSeo } from "next-seo"
+import { useRouter } from "next/router"
+import { useState } from "react"
+import { fetcher } from "@/utils/fetcher"
+import { useAuth } from "@/utils/auth"
+import analytics from "@/utils/analytics"
+
+export default function UpdatePassword() {
+  const { setJwt } = useAuth()
+  const [loading, setLoading] = useState(false)
+  const router = useRouter()
+
+  const { token, email } = router.query as {
+    token: string
+    email: string
+  }
+
+  const form = useForm({
+    initialValues: {
+      password: "",
+    },
+
+    validate: {
+      password: (val) => {
+        // TODO: refactor with other forms
+        if (val.length < 6) {
+          return "Password must be at least 6 characters"
+        }
+
+        return null
+      },
+    },
+  })
+
+  const handlePasswordReset = async ({ password }: { password: string }) => {
+    setLoading(true)
+
+    try {
+      const { token } = await fetcher.post("/auth/reset-password", {
+        arg: {
+          password,
+          token: router.query.token,
+        },
+      })
+
+      setJwt(token)
+
+      analytics.track("Join")
+    } catch (error) {
+      console.error(error)
+      setLoading(false)
+    }
+  }
+
+  return (
+    <Container py={100} size={600}>
+      <NextSeo title="Login" />
+      <Stack align="center" gap={50}>
+        <Stack align="center">
+          <IconAnalyze color={"#206dce"} size={60} />
+          <Title order={2} fw={700} size={40} ta="center">
+            Reset password
+          </Title>
+        </Stack>
+        <Paper radius="md" p="xl" withBorder miw={350}>
+          <form onSubmit={form.onSubmit(handlePasswordReset)}>
+            <Stack>
+              <PasswordInput
+                label="New Password"
+                type="password"
+                autoComplete="new-password"
+                value={form.values.password}
+                onChange={(event) =>
+                  form.setFieldValue("password", event.currentTarget.value)
+                }
+                error={form.errors.password && "Invalid password"}
+                placeholder="Your new password"
+              />
+
+              <Button mt="md" type="submit" fullWidth loading={loading}>
+                Submit
+              </Button>
+            </Stack>
+          </form>
+        </Paper>
+      </Stack>
+    </Container>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/settings.tsx

@@ -0,0 +1,156 @@
+import { useState } from "react"
+
+import LineChart from "@/components/Analytics/LineChart"
+import CopyText from "@/components/Blocks/CopyText"
+
+import {
+  Alert,
+  Button,
+  Card,
+  Container,
+  FocusTrap,
+  Group,
+  Popover,
+  Stack,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core"
+import { IconPencil, IconUserPlus } from "@tabler/icons-react"
+import { NextSeo } from "next-seo"
+import Router from "next/router"
+
+import { useOrg, useUser, useProject, useProjectSWR } from "@/utils/dataHooks"
+import useSWR from "swr"
+import { openUpgrade } from "../components/Layout/UpgradeModal"
+import RenamableField from "@/components/Blocks/RenamableField"
+
+export default function AppAnalytics() {
+  const { user: currentUser } = useUser()
+  const { org } = useOrg()
+  const { update, project, setProjectId, drop } = useProject()
+
+  // TODO: better route for project usage
+  const { data: projectUsage } = useSWR(
+    project?.id && org && `/orgs/${org.id}/usage?projectId=${project?.id}`,
+  )
+
+  const isAdmin =
+    currentUser?.id === org?.users?.find((u) => u.role === "admin")?.id
+
+  return (
+    <Container className="unblockable">
+      <NextSeo title="Settings" />
+      <Stack gap="lg">
+        <LineChart
+          title={
+            <RenamableField
+              defaultValue={project?.name}
+              onRename={(name) => update(name)}
+            />
+          }
+          range={30}
+          data={projectUsage}
+          formatter={(val) => `${val} runs`}
+          props={["count"]}
+        />
+
+        <Card withBorder p="lg">
+          <Stack gap="lg">
+            <Group justify="space-between" align="center">
+              <Title order={3}>Keys</Title>
+              {/* <Button onClick={() => alert("TODO")}>
+                Refresh Api Key
+              </Button> */}
+            </Group>
+
+            <Alert
+              variant="light"
+              title={
+                <Group>
+                  <Text fw={500}>Project ID:</Text>
+                  <CopyText c="green.8" value={project?.id} />
+                </Group>
+              }
+              color="green"
+            >
+              <Text>
+                Your project ID can be used from your server or frontend code to
+                track events and send requests to the API.
+              </Text>
+            </Alert>
+
+            {/* <Alert
+              variant="light"
+              title={
+                <Group>
+                  <Text fw={500}>Public Tracking Key: </Text>
+                  <CopyText c="green.8" value={project?.publicApiKey} />
+                </Group>
+              }
+              color="green"
+            >
+              <Text>
+                Public API keys can be used from your server or frontend code to
+                track events and send requests to the API.
+              </Text>
+            </Alert> */}
+
+            {/* <Alert
+              variant="light"
+              title={
+                <Group>
+                  <Text fw={500}>Private Key:</Text>
+                  <CopyText c="red.8" value={project?.privateApiKey} />
+                </Group>
+              }
+              color="red"
+            >
+              <Text>
+                Private API keys should be used only on your server – they give
+                read/write/delete API access to your project's resources.
+              </Text>
+            </Alert> */}
+          </Stack>
+        </Card>
+
+        {isAdmin && (
+          <Card withBorder p="lg" style={{ overflow: "visible" }}>
+            <Stack align="start">
+              <Title order={4}>Danger Zone</Title>
+
+              <Text>
+                Deleting your project is irreversible and it will delete all
+                associated data.
+                <br />
+                We <b>cannot</b> recover your data once it&apos;s deleted.
+              </Text>
+
+              <Popover width={200} position="bottom" shadow="md">
+                <Popover.Target>
+                  <Button color="red">Delete Project</Button>
+                </Popover.Target>
+                <Popover.Dropdown>
+                  <Text mb="md">
+                    Are you sure you want to delete this project? This action is
+                    irreversible and it will delete all associated data.
+                  </Text>
+                  <Button
+                    color="red"
+                    onClick={() => {
+                      drop()
+                      setProjectId(null)
+                      Router.push("/")
+                    }}
+                  >
+                    Delete
+                  </Button>
+                </Popover.Dropdown>
+              </Popover>
+            </Stack>
+          </Card>
+        )}
+      </Stack>
+    </Container>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/signup.tsx

@@ -0,0 +1,500 @@
+import Router, { useRouter } from "next/router"
+import { useEffect, useState } from "react"
+
+import {
+  Alert,
+  Anchor,
+  Box,
+  Button,
+  Container,
+  Grid,
+  Group,
+  List,
+  Paper,
+  PasswordInput,
+  Radio,
+  Stack,
+  Text,
+  TextInput,
+  ThemeIcon,
+  Title,
+} from "@mantine/core"
+
+import Confetti from "react-confetti"
+
+import Cal, { getCalApi } from "@calcom/embed-react"
+
+import { useForm } from "@mantine/form"
+import { notifications } from "@mantine/notifications"
+import {
+  IconAnalyze,
+  IconArrowRight,
+  IconAt,
+  IconBuildingStore,
+  IconCheck,
+  IconCircleCheck,
+  IconFolderBolt,
+  IconMail,
+  IconMessageBolt,
+  IconUser,
+} from "@tabler/icons-react"
+
+import SocialProof from "@/components/Blocks/SocialProof"
+import analytics from "@/utils/analytics"
+import { fetcher } from "@/utils/fetcher"
+import { NextSeo } from "next-seo"
+import { useAuth } from "@/utils/auth"
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+function SignupPage() {
+  const [loading, setLoading] = useState(false)
+  const [step, setStep] = useState(1)
+  const router = useRouter()
+
+  const auth = useAuth()
+
+  const form = useForm({
+    initialValues: {
+      email: "",
+      name: "",
+      projectName: "Project #1",
+      orgName: "",
+      employeeCount: "",
+      password: "",
+    },
+
+    validate: {
+      email: (val) => (/^\S+@\S+$/.test(val) ? null : "Invalid email"),
+      name: (val) => (val.length <= 2 ? "Is your name that short :) ?" : null),
+      projectName: (val) =>
+        val.length <= 3 ? "Can you pick something longer?" : null,
+      orgName: (val) =>
+        val.length <= 3 ? "Can you pick something longer?" : null,
+      employeeCount: (val) =>
+        val.length <= 1 ? "Please select a value" : null,
+      password: (val) => {
+        if (val.length < 6) {
+          return "Password must be at least 6 characters"
+        }
+        return null
+      },
+    },
+  })
+
+  async function handleSignup({
+    email,
+    password,
+    name,
+    projectName,
+    orgName,
+    employeeCount,
+  }: {
+    email: string
+    password: string
+    name: string
+    projectName: string
+    orgName: string
+    employeeCount: string
+  }) {
+    setLoading(true)
+
+    if (orgName.includes("https://")) {
+      // shadow ban spam
+      await sleep(100000000)
+      return
+    }
+
+    try {
+      const { token } = await fetcher.post("/auth/signup", {
+        arg: {
+          email,
+          password,
+          name,
+          projectName,
+          orgName,
+          employeeCount,
+          signupMethod: "signup",
+        },
+      })
+
+      if (!token) {
+        throw new Error("No token received")
+      }
+
+      auth.setJwt(token)
+
+      notifications.show({
+        icon: <IconCheck size={18} />,
+        color: "teal",
+        title: "Email sent",
+        message: "Check your emails for the confirmation link",
+      })
+
+      analytics.track("Signup", {
+        email,
+        name,
+        projectName,
+        orgName,
+        employeeCount,
+      })
+      nextStep()
+    } catch (error) {
+      console.error(error)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  function nextStep() {
+    if (step === 1) {
+      if (
+        ["email", "name", "password"].some(
+          (field) => form.validateField(field).hasError,
+        )
+      ) {
+        return
+      }
+    }
+
+    if (step === 2 && !form.values.orgName) {
+      form.setFieldValue("orgName", form.values.name + "'s Org")
+    }
+
+    setStep(step + 1)
+    router.query.step = String(step + 1)
+    router.push(router)
+  }
+
+  useEffect(() => {
+    if (step === 3) {
+      ;(async function () {
+        const Cal = await getCalApi()
+        Cal("ui", {
+          styles: { branding: { brandColor: "#000000" } },
+          hideEventTypeDetails: true,
+          layout: "month_view",
+        })
+      })()
+    }
+  }, [step])
+
+  const isBigCompany = form.values.employeeCount !== "1-5"
+
+  return (
+    <Container size={step === 3 ? 1200 : 800} mih="60%">
+      <NextSeo title="Sign Up" />
+
+      <Stack align="center" gap={50}>
+        {step < 3 && (
+          <>
+            <Stack align="center">
+              <IconAnalyze color={"#206dce"} size={60} />
+              <Title order={2} fw={700} size={40} ta="center">
+                lunary cloud
+              </Title>
+            </Stack>
+            <Grid gutter={50} align="center" mb="sm">
+              <Grid.Col span={{ base: 12, md: 6 }}>
+                <Paper radius="md" p="xl" withBorder>
+                  <form onSubmit={form.onSubmit(handleSignup)}>
+                    <Stack gap="lg">
+                      {step === 1 && (
+                        <>
+                          <Title order={2} fw={700} ta="center">
+                            Get Started
+                          </Title>
+                          <TextInput
+                            leftSection={<IconAt size="16" />}
+                            label="Email"
+                            type="email"
+                            autoComplete="email"
+                            error={form.errors.email}
+                            placeholder="Your email"
+                            {...form.getInputProps("email")}
+                          />
+
+                          <TextInput
+                            label="Full Name"
+                            autoComplete="name"
+                            description="Only used to address you properly."
+                            leftSection={<IconUser size="16" />}
+                            placeholder="Your full name"
+                            error={form.errors.name}
+                            {...form.getInputProps("name")}
+                            onChange={(e) => {
+                              form.setFieldValue("name", e.target.value)
+                              form.setFieldValue(
+                                "orgName",
+                                e.target.value + "'s Org",
+                              )
+                            }}
+                          />
+
+                          <PasswordInput
+                            label="Password"
+                            onKeyDown={(e) => {
+                              if (e.key === "Enter") {
+                                nextStep()
+                              }
+                            }}
+                            error={form.errors.password}
+                            placeholder="Your password"
+                            {...form.getInputProps("password")}
+                          />
+
+                          <Button
+                            size="md"
+                            mt="md"
+                            onClick={nextStep}
+                            fullWidth
+                            loading={loading}
+                          >
+                            {`Continue →`}
+                          </Button>
+
+                          <Text size="sm" style={{ textAlign: "center" }}>
+                            {`Already have an account? `}
+                            <Anchor href="/login">Log In</Anchor>
+                          </Text>
+                        </>
+                      )}
+
+                      {step === 2 && (
+                        <>
+                          <Title order={2} fw={700} ta="center">
+                            Create an organization
+                          </Title>
+
+                          <TextInput
+                            label="Organization Name"
+                            description="Eg. your company name"
+                            leftSection={<IconBuildingStore size="16" />}
+                            placeholder="Organization name"
+                            error={
+                              form.errors.projectName &&
+                              "This field is required"
+                            }
+                            {...form.getInputProps("orgName")}
+                          />
+
+                          <TextInput
+                            label="Project Name"
+                            description="Can be changed later."
+                            leftSection={<IconFolderBolt size="16" />}
+                            placeholder="Your project name"
+                            error={
+                              form.errors.projectName &&
+                              "This field is required"
+                            }
+                            {...form.getInputProps("projectName")}
+                          />
+
+                          <Radio.Group
+                            label="Employee count"
+                            error={
+                              form.errors.employeeCount &&
+                              "This field is required"
+                            }
+                            {...form.getInputProps("employeeCount")}
+                          >
+                            <Group mt="xs">
+                              <Radio value="1-5" label="1-5" />
+                              <Radio value="11-50" label="6-49" />
+                              <Radio value="51-100" label="50-99" />
+                              <Radio value="101-500" label="100+" />
+                            </Group>
+                          </Radio.Group>
+
+                          <Stack gap="xs">
+                            <Button
+                              size="md"
+                              mt="md"
+                              type="submit"
+                              fullWidth
+                              loading={loading}
+                            >
+                              {`Create account`}
+                            </Button>
+
+                            <Button
+                              size="sm"
+                              onClick={() => {
+                                router.query.step = String(1)
+                                router.push(router)
+                                setStep(1)
+                              }}
+                              fullWidth
+                              variant="transparent"
+                              color="dimmed"
+                            >
+                              {`← Go back`}
+                            </Button>
+                          </Stack>
+                        </>
+                      )}
+                    </Stack>
+                  </form>
+                </Paper>
+              </Grid.Col>
+
+              <Grid.Col span={{ base: 12, md: 6 }}>
+                <Box>
+                  <List
+                    spacing="xl"
+                    size="md"
+                    icon={
+                      <ThemeIcon
+                        variant="light"
+                        color="teal"
+                        size={24}
+                        radius="xl"
+                      >
+                        <IconCircleCheck size="16" />
+                      </ThemeIcon>
+                    }
+                  >
+                    <List.Item>
+                      <Text fw="bold">Free usage every month</Text>
+                      <Text>
+                        1K free events per day. Forever.
+                        <br />
+                        No credit card required.
+                      </Text>
+                    </List.Item>
+                    <List.Item>
+                      <Text fw="bold">Collect data immediately</Text>
+                      <Text>
+                        Integrate with dev-friendly SDKs, with native support
+                        for LangChain and OpenAI.
+                      </Text>
+                    </List.Item>
+                    <List.Item>
+                      <Text fw="bold">No config required</Text>
+                      <Text>Get insights without complicated setup.</Text>
+                    </List.Item>
+                  </List>
+                </Box>
+              </Grid.Col>
+            </Grid>
+            <SocialProof />
+          </>
+        )}
+
+        {step === 3 && (
+          <>
+            {typeof window !== "undefined" && !isBigCompany && (
+              <Confetti
+                recycle={false}
+                numberOfPieces={500}
+                gravity={0.3}
+                width={window.innerWidth}
+                height={window.innerHeight}
+              />
+            )}
+
+            <Stack align="center" w={800}>
+              {/* <IconAnalyze color={"#206dce"} size={60} /> */}
+
+              <Title order={2} fw={700} size={40} ta="center">
+                {`You're all set 🎉`}
+              </Title>
+
+              {isBigCompany ? (
+                <>
+                  <Text size="xl" ta="center" my="xl">
+                    Are you free in the next days for a quick call?
+                    <br />
+                    We'd love to understand your use-case and help you directly
+                    with the integration.
+                  </Text>
+                  <Cal
+                    // namespace="lunary"
+                    calLink="vincelwt/lunary"
+                    className="calcom-embed"
+                    config={{
+                      hideEventTypeDetails: "true",
+                      layout: "month_view",
+                      name: "vince loewe", //form.values.name,
+                      email: "vince@lunary.ai", //form.values.email,
+                    }}
+                  />
+                  <Button
+                    onClick={() => {
+                      // use this to refresh properly
+                      window.location.href = "/"
+                    }}
+                    variant="subtle"
+                    rightSection={<IconArrowRight size={16} />}
+                    size="md"
+                  >
+                    Skip to Dashboard
+                  </Button>
+                </>
+              ) : (
+                <>
+                  <Alert fw={500} icon={<IconMail />} my="lg">
+                    <Text size="md" fw={500}>
+                      Check your emails for the confirmation link.
+                    </Text>
+                  </Alert>
+
+                  <Button
+                    onClick={() => {
+                      window.location.href = "/"
+                    }}
+                    variant={isBigCompany ? "outline" : "filled"}
+                    mb="xl"
+                    rightSection={<IconArrowRight size={18} />}
+                    size="lg"
+                  >
+                    Open Dashboard
+                  </Button>
+
+                  <Text size="lg">
+                    {`Want to say hi? We'd love to talk to you.`}
+                  </Text>
+
+                  <Group>
+                    <Button
+                      variant="outline"
+                      onClick={() => {
+                        $crisp.push(["do", "chat:open"])
+                      }}
+                      rightSection={<IconMessageBolt size={18} />}
+                    >
+                      Chat
+                    </Button>
+
+                    <Button
+                      variant="outline"
+                      color="teal.8"
+                      component="a"
+                      href="mailto:hello@lunary.ai"
+                      rightSection={<IconMail size={18} />}
+                    >
+                      Email
+                    </Button>
+                  </Group>
+                </>
+              )}
+            </Stack>
+          </>
+        )}
+      </Stack>
+      <style jsx global>{`
+        .calcom-embed {
+          height: 470px;
+          width: 100%;
+          overflow: auto;
+        }
+
+        iframe main > div > span {
+          display: none !important;
+        }
+      `}</style>
+    </Container>
+  )
+}
+
+export default SignupPage

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/team.tsx

@@ -0,0 +1,191 @@
+import { useState } from "react"
+
+import CopyText from "@/components/Blocks/CopyText"
+import UserAvatar from "@/components/Blocks/UserAvatar"
+
+import {
+  ActionIcon,
+  Badge,
+  Button,
+  Card,
+  Container,
+  Group,
+  Menu,
+  Modal,
+  Progress,
+  Stack,
+  Table,
+  Text,
+  Title,
+} from "@mantine/core"
+import { IconDotsVertical, IconTrash, IconUserPlus } from "@tabler/icons-react"
+import { NextSeo } from "next-seo"
+
+import RenamableField from "@/components/Blocks/RenamableField"
+import { useOrg, useOrgUser, useUser } from "@/utils/dataHooks"
+import { SEAT_ALLOWANCE } from "@/utils/pricing"
+import { useDisclosure } from "@mantine/hooks"
+import { openUpgrade } from "../components/Layout/UpgradeModal"
+
+function Invite() {
+  const { org } = useOrg()
+  const plan = org?.plan
+
+  const allowedSeats = SEAT_ALLOWANCE[plan]
+
+  if (org?.users?.length >= allowedSeats) {
+    return (
+      <Button
+        variant="light"
+        onClick={() => openUpgrade("team")}
+        style={{ float: "right" }}
+        leftSection={<IconUserPlus size="16" />}
+      >
+        Invite
+      </Button>
+    )
+  }
+
+  return (
+    <Group>
+      <Text>Invite link: </Text>
+      {typeof window !== "undefined" && (
+        <CopyText value={`${window.location.origin}/join?orgId=${org?.id}`} />
+      )}
+    </Group>
+  )
+}
+
+function UserMenu({ user }) {
+  const [opened, { open, close }] = useDisclosure(false)
+  const [isLoading, setIsLoading] = useState(false)
+  const { user: currentUser } = useUser()
+  const { removeUserFromOrg } = useOrgUser(user.id)
+
+  if (user.role === "admin" || currentUser.id === user.id) {
+    return
+  }
+
+  async function confirm() {
+    setIsLoading(true)
+    await removeUserFromOrg()
+    setIsLoading(false)
+    close()
+  }
+
+  return (
+    <>
+      <Modal
+        opened={opened}
+        onClose={close}
+        title={<Title size="h3">Remove user from Team?</Title>}
+      >
+        <Group mt="md" justify="right">
+          <Button variant="outline" onClick={close}>
+            Cancel
+          </Button>
+          <Button loading={isLoading} color="red" onClick={confirm}>
+            Continue
+          </Button>
+        </Group>
+      </Modal>
+
+      <Menu>
+        <Menu.Target>
+          <ActionIcon variant="transparent">
+            <IconDotsVertical size={16} />
+          </ActionIcon>
+        </Menu.Target>
+
+        <Menu.Dropdown>
+          <Menu.Item
+            onClick={open}
+            leftSection={<IconTrash size={16} />}
+            color="red"
+          >
+            Remove from Team
+          </Menu.Item>
+        </Menu.Dropdown>
+      </Menu>
+    </>
+  )
+}
+
+export default function Team() {
+  const { user: currentUser } = useUser()
+  const { org, updateOrg, mutate } = useOrg()
+
+  return (
+    <Container className="unblockable">
+      <NextSeo title="Team" />
+      <Stack gap="lg">
+        <Card withBorder p={0}>
+          <Group justify="space-between" align="center" p="lg">
+            <RenamableField
+              defaultValue={org?.name}
+              onRename={async (name) => {
+                await updateOrg({ id: org?.id, name }, { optimisticData: org })
+
+                mutate()
+              }}
+            />
+
+            <Invite />
+          </Group>
+
+          <Table striped verticalSpacing="lg" horizontalSpacing="lg">
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>User</Table.Th>
+                <Table.Th>Email</Table.Th>
+                <Table.Th>Role</Table.Th>
+                <Table.Th></Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {org?.users?.map((user, i) => (
+                <Table.Tr key={i}>
+                  <Table.Td>
+                    <Group>
+                      <UserAvatar profile={user} />
+                      <Text>{user?.name}</Text>
+
+                      {user?.id === currentUser?.id ? (
+                        <Badge color="blue">You</Badge>
+                      ) : null}
+                    </Group>
+                  </Table.Td>
+                  <Table.Td>{user?.email}</Table.Td>
+                  <Table.Td>{user?.role}</Table.Td>
+                  <Table.Td>
+                    <UserMenu user={user} />
+                  </Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+        </Card>
+        {org?.plan && (
+          <Card withBorder radius="md" padding="xl">
+            <Stack gap="sm">
+              <Text fz="md" fw={700} size="lg">
+                Seat Allowance
+              </Text>
+              <Text fz="lg" fw={500}>
+                {org?.users?.length} / {SEAT_ALLOWANCE[org?.plan]} users
+              </Text>
+              <Progress
+                value={
+                  ((org?.users?.length || 0) / SEAT_ALLOWANCE[org?.plan]) * 100
+                }
+                size="lg"
+                color="orange"
+                radius="xl"
+              />
+            </Stack>
+          </Card>
+        )}
+      </Stack>
+    </Container>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/pages/update-password.tsx

@@ -0,0 +1,92 @@
+import {
+  Button,
+  Container,
+  Paper,
+  PasswordInput,
+  Stack,
+  Text,
+  Title,
+} from "@mantine/core"
+
+import { useForm } from "@mantine/form"
+import { IconAnalyze, IconCheck } from "@tabler/icons-react"
+
+import errorHandler from "@/utils/errors"
+import { NextSeo } from "next-seo"
+import Router from "next/router"
+import { useState } from "react"
+import { notifications } from "@mantine/notifications"
+
+export default function UpdatePassword() {
+  const [loading, setLoading] = useState(false)
+
+  const form = useForm({
+    initialValues: {
+      password: "",
+    },
+
+    validate: {
+      password: (val) =>
+        val.length < 5 ? "Password must be at least 5 characters" : null,
+    },
+  })
+
+  const handlePasswordReset = async ({ password }: { password: string }) => {
+    setLoading(true)
+
+    // TODO: reset password with supertoken
+    const ok = true
+
+    notifications.show({
+      icon: <IconCheck size={18} />,
+      color: "teal",
+      title: "Success",
+      message: "Password updated successfully",
+    })
+
+    if (ok) {
+      Router.push("/")
+    }
+
+    setLoading(false)
+  }
+
+  return (
+    <Container py={100} size={600}>
+      <NextSeo title="Login" />
+      <Stack align="center" gap={50}>
+        <Stack align="center">
+          <IconAnalyze color={"#206dce"} size={60} />
+          <Title order={2} fw={700} size={40} ta="center">
+            Reset password
+          </Title>
+        </Stack>
+        <Paper radius="md" p="xl" withBorder miw={350}>
+          <Text size="lg" mb="xl" fw={500}>
+            Update password
+          </Text>
+
+          <form onSubmit={form.onSubmit(handlePasswordReset)}>
+            <Stack>
+              <PasswordInput
+                label="New Password"
+                type="password"
+                autoComplete="new-password"
+                value={form.values.password}
+                onChange={(event) =>
+                  form.setFieldValue("password", event.currentTarget.value)
+                }
+                error={form.errors.email && "Invalid password"}
+                placeholder="Your email"
+              />
+
+              <Button mt="md" type="submit" fullWidth loading={loading}>
+                Submit
+              </Button>
+            </Stack>
+          </form>
+        </Paper>
+      </Stack>
+    </Container>
+  )
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/postcss.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  plugins: {
+    "postcss-preset-mantine": {},
+    "postcss-simple-vars": {
+      variables: {
+        "mantine-breakpoint-xs": "36em",
+        "mantine-breakpoint-sm": "48em",
+        "mantine-breakpoint-md": "62em",
+        "mantine-breakpoint-lg": "75em",
+        "mantine-breakpoint-xl": "88em",
+      },
+    },
+  },
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/styles/globals.css

@@ -0,0 +1,42 @@
+:root {
+  --navbar-size: 50px;
+  --navbar-with-filters-size: 50px;
+}
+
+body {
+  margin: 0;
+  padding: 0;
+  font-feature-settings: "liga", "kern";
+  text-rendering: optimizelegibility;
+  -webkit-font-smoothing: antialiased;
+}
+
+/* .limited table td, */
+.limited .mantine-Badge-inner,
+span.limited,
+.limited code,
+.limited table .mantine-Text-root {
+  filter: blur(4px);
+}
+
+.limited .recharts-responsive-container {
+  filter: blur(7px);
+}
+
+.unblockable pre,
+.unblockable code,
+.unblockable .mantine-Badge-inner,
+.unblockable .mantine-Text-root,
+.unblockable .recharts-responsive-container {
+  filter: none !important;
+}
+
+.mantine-Modal-inner {
+  /* fix modal unaligned content */
+  padding-left: 0 !important;
+  padding-right: 0 !important;
+}
+
+.mantine-Badge-root {
+  max-width: 100%;
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "baseUrl": ".",
+    "incremental": true,
+    "paths": {
+      "@/*": ["./*"],
+      "@/lib/*": ["lib/*"],
+      "@/components/*": ["components/*"],
+    },
+    "plugins": [
+      {
+        "name": "next",
+      },
+    ],
+    "strictNullChecks": true,
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    "../backend/src/api/stripe.ts",
+    "../backend/src/api/signup.ts",
+  ],
+  "exclude": ["node_modules"],
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/utils/analytics.ts

@@ -0,0 +1,107 @@
+import posthog from "posthog-js"
+
+if (typeof window !== "undefined" && process.env.NEXT_PUBLIC_POSTHOG_KEY) {
+  posthog.init(process.env.NEXT_PUBLIC_POSTHOG_KEY, {
+    api_host: window.location.origin + "/ingest", // Uses Next.js rewrite in next.config.js
+    // Enable debug mode in development
+    loaded: (posthog) => {
+      if (process.env.NODE_ENV === "development") posthog.debug()
+    },
+  })
+}
+
+const w = {
+  // @ts-ignore
+  get crisp() {
+    if (
+      typeof window !== "undefined" &&
+      typeof window["$crisp"] !== "undefined"
+    )
+      return window["$crisp"]
+
+    return () => {}
+  },
+  get plausible() {
+    if (
+      typeof window !== "undefined" &&
+      typeof window["plausible"] !== "undefined"
+    )
+      return window["plausible"]
+
+    return () => {}
+  },
+}
+
+const handleRouteChange = async () => {
+  posthog?.capture("$pageview")
+
+  // w.gosquared("track")
+}
+
+const track = (event: string, data?: any) => {
+  try {
+    posthog?.capture(event, data)
+
+    w.plausible(event, { props: data })
+
+    w?.crisp?.push(["set", "session:event", [[[event, data]]]])
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+const alreadyTracked = new Set<string>()
+const trackOnce = (event: string, data?: any) => {
+  // Prevent sending too many events
+  if (alreadyTracked.has(event)) return
+
+  try {
+    posthog?.capture(event, data)
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+const identify = (userId: string, traits: any) => {
+  try {
+    posthog?.identify(userId, traits)
+
+    if (!w?.crisp?.push) return
+
+    if (typeof CRISP_TOKEN_ID !== "undefined") CRISP_TOKEN_ID = userId
+    if (typeof CRISP_RUNTIME_CONFIG !== "undefined")
+      CRISP_RUNTIME_CONFIG = {
+        session_merge: true,
+      }
+
+    if (traits.email) w?.crisp?.push(["set", "user:email", traits.email])
+    if (traits.name) w?.crisp?.push(["set", "user:nickname", traits.name])
+
+    w?.crisp.push([
+      "set",
+      "session:data",
+      [
+        [
+          ...Object.entries(traits)
+            .map(([key, value]) => [key, value])
+            .filter(([key]) => key !== "email" && key !== "name")
+            .filter(([key, value]) => value),
+          ["user-id", userId],
+        ],
+      ],
+    ])
+
+    // H?.identify(userId, traits)
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+const analytics = {
+  track,
+  trackOnce,
+  identify,
+  handleRouteChange,
+}
+
+export default analytics

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/utils/auth.tsx

@@ -0,0 +1,72 @@
+import { useLocalStorage } from "@mantine/hooks"
+import { decodeJwt } from "jose"
+import { createContext, useContext, useEffect, useMemo } from "react"
+import Router from "next/router"
+
+const SIGN_OUT_EVENT = "sign-out"
+export async function signOut() {
+  window.localStorage.clear()
+  window.dispatchEvent(new Event(SIGN_OUT_EVENT))
+}
+
+interface AuthContext {
+  isSignedIn: boolean
+  setJwt: (
+    val: string | ((prevState: string | null) => string | null) | null,
+  ) => void
+  signOut: () => void
+}
+
+const AuthContext = createContext<AuthContext | null>(null)
+
+function checkJwt(jwt) {
+  try {
+    const payload = decodeJwt(jwt)
+    const exp = payload.exp
+
+    if (!exp || exp < Date.now() / 1000) {
+      throw new Error("Token expired")
+    }
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+export function AuthProvider({ children }) {
+  const [jwt, setJwt, removeJwt] = useLocalStorage<string | null>({
+    key: "auth-token",
+    getInitialValueInEffect: false,
+    serialize: (value) => value || "",
+    deserialize: (localStorageValue) => localStorageValue || null,
+    defaultValue: null,
+  })
+
+  const isSignedIn = useMemo(() => checkJwt(jwt), [jwt])
+
+  function doSignOut() {
+    removeJwt()
+    // Router.push("/login")
+  }
+
+  useEffect(() => {
+    window.addEventListener(SIGN_OUT_EVENT, doSignOut)
+    return () => {
+      window.removeEventListener(SIGN_OUT_EVENT, doSignOut)
+    }
+  }, [])
+
+  return (
+    <AuthContext.Provider value={{ isSignedIn, setJwt, signOut }}>
+      {children}
+    </AuthContext.Provider>
+  )
+}
+
+export function useAuth() {
+  const context = useContext(AuthContext)
+  if (context === null) {
+    throw new Error("useAuth must be used within a AuthProvider")
+  }
+  return context
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/utils/colors.ts

@@ -0,0 +1,69 @@
+import { useColorScheme, useDidUpdate } from "@mantine/hooks"
+import { useEffect, useState } from "react"
+
+export function getColorForRole(role) {
+  const defaultColor = "gray"
+
+  const colorMap = {
+    ai: "green",
+    assistant: "green",
+    human: "blue",
+    user: "blue",
+    error: "red",
+    function: "violet",
+    tool: "violet",
+    system: "gray",
+  }
+
+  return colorMap[role] || defaultColor
+}
+
+export function getColorForRunType(type) {
+  const defaultColor = "gray"
+
+  const colorMap = {
+    llm: "yellow",
+    embed: "yellow",
+    chain: "blue",
+    agent: "violet",
+    tool: "grape",
+    thread: "grape",
+    convo: "grape",
+    chat: "blue",
+  }
+
+  return colorMap[type] || defaultColor
+}
+
+export function getUserColor(scheme, theme, id: string) {
+  if (!id) return theme.colors.gray[4]
+  const seed = id
+    .split("")
+    .map((char) => char.charCodeAt(0))
+    .reduce((acc, curr) => acc + curr, 0)
+  const colors = Object.keys(theme.colors)
+
+  const userColor = colors[seed % colors.length]
+
+  const finalColor = theme.colors[userColor][scheme === "dark" ? 8 : 4]
+  return finalColor
+}
+
+// fixes the stutter effect in dark mode
+// needs to be outside the hook as window.computedColorScheme doesn't reflect the update
+// but we need to update the ddefault value
+let defaultColorScheme =
+  typeof window !== "undefined" ? window?.computedColorScheme : null
+
+export function useFixedColorScheme() {
+  const [scheme, setScheme] = useState(defaultColorScheme)
+
+  const mantineScheme = useColorScheme()
+
+  useDidUpdate(() => {
+    defaultColorScheme = mantineScheme
+    setScheme(mantineScheme)
+  }, [mantineScheme])
+
+  return scheme
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/utils/context.ts

@@ -0,0 +1,11 @@
+import { createContext } from "react"
+
+type ProjectContextType = {
+  projectId?: string
+  setProjectId: (appId: string | null) => void
+}
+
+export const ProjectContext = createContext<ProjectContextType>({
+  projectId: undefined,
+  setProjectId: () => {},
+})

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/utils/dataHooks.ts

@@ -0,0 +1,700 @@
+import { useMantineTheme } from "@mantine/core"
+import { useContext } from "react"
+import useSWR, { SWRConfiguration, useSWRConfig } from "swr"
+import useSWRInfinite from "swr/infinite"
+import useSWRMutation, { SWRMutationConfiguration } from "swr/mutation"
+import { getUserColor, useFixedColorScheme } from "./colors"
+import { ProjectContext } from "./context"
+
+import { useAuth } from "./auth"
+import { fetcher } from "./fetcher"
+
+type KeyType = string | ((...args: any[]) => string)
+
+function generateKey(
+  baseKey: KeyType | undefined,
+  projectId: string | undefined,
+  extraParams?: string,
+) {
+  const resolvedKey = typeof baseKey === "function" ? baseKey() : baseKey
+  if (!projectId || !resolvedKey) return null
+
+  const operator = resolvedKey.includes("?") ? "&" : "?"
+
+  let url = `${resolvedKey}${
+    !resolvedKey.endsWith("?") ? operator : ""
+  }projectId=${projectId}`
+  if (extraParams) {
+    url += `&${extraParams}`
+  }
+
+  return url
+}
+export function useProjectSWR(key?: KeyType, options?: SWRConfiguration) {
+  const { projectId } = useContext(ProjectContext)
+
+  const { data, error, isLoading, isValidating, mutate } = useSWR(
+    () => generateKey(key, projectId),
+    options,
+  )
+
+  return {
+    data,
+    error,
+    isLoading: projectId === null ? true : isLoading,
+    isValidating,
+    mutate,
+  }
+}
+
+export function useProjectMutation(
+  key: KeyType,
+  customFetcher:
+    | typeof fetcher.post
+    | typeof fetcher.patch
+    | typeof fetcher.delete,
+  options?: SWRMutationConfiguration<any, any>,
+) {
+  const { projectId } = useContext(ProjectContext)
+
+  return useSWRMutation(
+    () => generateKey(key, projectId),
+    customFetcher,
+    options,
+  )
+}
+
+export function useProjectInfiniteSWR(key: string, ...args: any[]) {
+  const PAGE_SIZE = 1
+
+  const { projectId } = useContext(ProjectContext)
+
+  function getKey(pageIndex, previousPageData) {
+    if (previousPageData && !previousPageData.length) return null
+    return generateKey(key, projectId, `page=${pageIndex}&limit=100`)
+  }
+
+  const { data, isLoading, isValidating, size, setSize } = useSWRInfinite(
+    getKey,
+    ...(args as [any]),
+  )
+
+  function loadMore() {
+    const hasMore = data && data[data.length - 1]?.length >= PAGE_SIZE
+
+    if (hasMore) {
+      setSize((size) => size + 1)
+    }
+  }
+
+  return {
+    data: data?.flat(),
+    loading: isLoading,
+    validating: isValidating,
+    loadMore,
+  }
+}
+
+export function useProjectMutate(key: KeyType, options?: SWRConfiguration) {
+  const { projectId } = useContext(ProjectContext)
+
+  const { mutate } = useSWRConfig()
+
+  return (data) => {
+    mutate(generateKey(key, projectId), data, false)
+  }
+}
+
+export function useUser() {
+  const { isSignedIn } = useAuth()
+
+  const theme = useMantineTheme()
+  const scheme = useFixedColorScheme()
+
+  const { data, isLoading, mutate, error } = useSWR(
+    () => isSignedIn && `/users/me`,
+  )
+
+  const color = data ? getUserColor(scheme, theme, data.id) : null
+  const user = data ? { ...data, color } : null
+
+  return { user, loading: isLoading, mutate, error }
+}
+
+export function useOrg() {
+  const { isSignedIn } = useAuth()
+
+  const { data, isLoading, mutate } = useSWR(
+    () => isSignedIn && `/users/me/org`,
+  )
+
+  const theme = useMantineTheme()
+  const scheme = useFixedColorScheme()
+
+  const users = data?.users?.map((user) => ({
+    ...user,
+    color: getUserColor(scheme, theme, user.id),
+  }))
+
+  const org = data ? { ...data, users } : null
+
+  const { trigger: updateOrg } = useSWRMutation(
+    `/orgs/${org?.id}`,
+    fetcher.patch,
+  )
+
+  return { org, loading: isLoading, updateOrg, mutate }
+}
+
+export function useProjects() {
+  const { isSignedIn } = useAuth()
+
+  const { data, isLoading, isValidating, mutate } = useSWR(
+    () => isSignedIn && `/projects`,
+  )
+
+  const { trigger: insertMutation } = useSWRMutation(
+    () => `/projects`,
+    fetcher.post,
+    {
+      populateCache(result, currentData) {
+        return [...currentData, result]
+      },
+    },
+  )
+
+  return {
+    projects: data || [],
+    mutate,
+    insert: insertMutation,
+    isLoading: isLoading,
+  }
+}
+
+export function useProject() {
+  const { projectId, setProjectId } = useContext(ProjectContext)
+
+  const { projects, isLoading, mutate } = useProjects()
+
+  const project = projects?.find((p) => p.id === projectId)
+
+  const { trigger: updateMutation } = useSWRMutation(
+    `/projects/${projectId}`,
+    fetcher.patch,
+  )
+  const { trigger: dropMutation } = useSWRMutation(
+    `/projects/${projectId}`,
+    fetcher.delete,
+  )
+
+  async function update(name: string) {
+    await updateMutation({ name })
+    const newProjects = projects.map((p) =>
+      p.id === projectId ? { ...p, name } : p,
+    )
+    mutate(newProjects)
+  }
+
+  async function drop() {
+    await dropMutation()
+    const newProjects = projects.filter((p) => p.id !== projectId)
+    setProjectId(newProjects[0]?.id)
+    mutate(newProjects)
+  }
+
+  return {
+    project,
+    update,
+    drop,
+    setProjectId: setProjectId,
+    isLoading,
+  }
+}
+
+export function useTemplates() {
+  const { data: templates, isLoading, mutate } = useProjectSWR(`/templates`)
+
+  // insert mutation
+  const { trigger: insert } = useProjectMutation(`/templates`, fetcher.post)
+
+  return {
+    templates,
+    insert,
+    mutate,
+    loading: isLoading,
+  }
+}
+
+export function useTemplate(id: string) {
+  const {
+    data: template,
+    isLoading,
+    mutate,
+  } = useProjectSWR(id && `/templates/${id}`)
+
+  const { trigger: update } = useProjectMutation(
+    `/templates/${id}`,
+    fetcher.patch,
+  )
+
+  const { trigger: remove } = useProjectMutation(
+    `/templates/${id}`,
+    fetcher.delete,
+  )
+
+  // insert mutation
+  const { trigger: insertVersion } = useProjectMutation(
+    `/templates/${id}/versions`,
+    fetcher.post,
+  )
+
+  return {
+    template,
+    insertVersion,
+    update,
+    remove,
+    mutate,
+    loading: isLoading,
+  }
+}
+
+export function useTemplateVersion(id: string) {
+  const {
+    data: templateVersion,
+    isLoading,
+    mutate,
+  } = useProjectSWR(id && `/template_versions/${id}`)
+
+  const { trigger: update } = useProjectMutation(
+    `/template_versions/${id}`,
+    fetcher.patch,
+  )
+
+  return {
+    templateVersion,
+    update,
+    mutate,
+    loading: isLoading,
+  }
+}
+
+export function buildLogsAPIUrl(data = {}) {
+  let url = `/runs?`
+
+  const params = Object.entries(data)
+    .map(([key, value]) => {
+      return `${key}=${value}`
+    })
+    .join("&")
+
+  return url + params
+}
+
+export function useLogs(params: any) {
+  return useProjectInfiniteSWR(buildLogsAPIUrl(params))
+}
+
+export function useRun(id: string, initialData?: any) {
+  const {
+    data: run,
+    isLoading,
+    mutate,
+  } = useProjectSWR(id && `/runs/${id}`, {
+    fallbackData: initialData,
+  })
+
+  const { trigger: update } = useProjectMutation(
+    id && `/runs/${id}`,
+    fetcher.patch,
+  )
+
+  async function updateRun(data) {
+    await update(data)
+    mutate({ ...run, ...data })
+  }
+
+  return {
+    run,
+    update: updateRun,
+    mutate,
+    loading: isLoading,
+  }
+}
+
+export function useRunsUsage(range, userId?: string) {
+  const userIdStr = userId ? `&userId=${userId}` : ""
+  const { data: usage, isLoading } = useProjectSWR(
+    `/runs/usage?days=${range}${userIdStr}`,
+  )
+
+  return { usage, loading: isLoading }
+}
+
+export function useRunsUsageByDay(range, userId?: string) {
+  const userIdStr = userId ? `&userId=${userId}` : ""
+
+  const { data, isLoading } = useProjectSWR(
+    `/runs/usage?days=${range}${userIdStr}&daily=true`,
+  )
+
+  return { dailyUsage: data, loading: isLoading }
+}
+
+export function useRunsUsageByUser(range = null) {
+  const { data: usageByUser, isLoading } = useProjectSWR(
+    `/external-users/runs/usage`,
+  )
+
+  const reduceUsersUsage = (usage) => {
+    const userData = []
+
+    const uniqueUserIds = Array.from(new Set(usage.map((u) => u.user_id)))
+
+    for (let id of uniqueUserIds) {
+      const userUsage = usage.filter((u) => u.user_id === id)
+      const totalCost = userUsage.reduce((acc, curr) => {
+        acc += curr.cost
+        return acc
+      }, 0)
+
+      const totalAgentRuns = userUsage.reduce((acc, curr) => {
+        acc += curr.success + curr.errors
+        return acc
+      }, 0)
+
+      userData.push({
+        user_id: id,
+        agentRuns: totalAgentRuns,
+        cost: totalCost,
+      })
+    }
+
+    return userData
+  }
+
+  return {
+    usageByUser: reduceUsersUsage(usageByUser || []),
+    loading: isLoading,
+  }
+}
+
+// TODO: pagination
+export function useAppUserList() {
+  const {
+    data: users,
+    isLoading,
+    isValidating,
+  } = useProjectSWR(`/external-users`)
+
+  return { users, isLoading, isValidating }
+}
+
+// TODO
+export function useAppUsers(usageRange = 30) {
+  const { users, isLoading } = useAppUserList()
+
+  const maxLastSeen = new Date(
+    new Date().getTime() - usageRange * 24 * 60 * 60 * 1000,
+  )
+    .toISOString()
+    .slice(0, 10)
+
+  const appUsers = users?.filter((u) => u.lastSeen > maxLastSeen)
+
+  return { users: appUsers || [], loading: isLoading }
+}
+
+export function useOrgUser(userId: string) {
+  const { mutate: mutateOrg } = useOrg()
+
+  const { data, isLoading, mutate } = useProjectSWR(
+    userId && `/users/${userId}`,
+  )
+
+  async function removeUserFromOrg() {
+    await trigger()
+    await mutateOrg()
+  }
+  const { trigger } = useProjectMutation(`/users/${userId}`, fetcher.patch)
+
+  const theme = useMantineTheme()
+  const scheme = useFixedColorScheme()
+
+  const user = {
+    ...data,
+    color: getUserColor(scheme, theme, data?.id),
+  }
+
+  return { user, loading: isLoading, mutate, removeUserFromOrg }
+}
+
+export function useChecklists(type: string) {
+  const { data, isLoading, mutate } = useProjectSWR(
+    type && `/checklists?type=${type}`,
+  )
+
+  // insert mutation
+  const { trigger: insert, isMutating: isInserting } = useProjectMutation(
+    `/checklists`,
+    fetcher.post,
+  )
+
+  const { trigger: update, isMutating: isUpdating } = useProjectMutation(
+    `/checklists`,
+    fetcher.patch,
+  )
+
+  return {
+    checklists: data,
+    insert,
+    isInserting,
+    update,
+    isUpdating,
+    mutate,
+    loading: isLoading,
+  }
+}
+
+export function useChecklist(id: string, initialData?: any) {
+  const {
+    data: checklist,
+    isLoading,
+    mutate,
+  } = useProjectSWR(id && `/checklists/${id}`, {
+    fallbackData: initialData,
+  })
+
+  const { trigger: update } = useProjectMutation(
+    id && `/checklists/${id}`,
+    fetcher.patch,
+  )
+
+  const { trigger: remove } = useProjectMutation(
+    id && `/checklists/${id}`,
+    fetcher.delete,
+    {
+      revalidate: false,
+    },
+  )
+
+  return {
+    checklist,
+    update,
+    remove,
+    mutate,
+    loading: isLoading,
+  }
+}
+
+export function useDatasets() {
+  const { data, isLoading, mutate } = useProjectSWR(`/datasets`)
+
+  // insert mutation
+  const { trigger: insert, isMutating: isInserting } = useProjectMutation(
+    `/datasets`,
+    fetcher.post,
+  )
+
+  const { trigger: update, isMutating: isUpdating } = useProjectMutation(
+    `/datasets`,
+    fetcher.patch,
+  )
+
+  return {
+    datasets: data || [],
+    insert,
+    isInserting,
+    update,
+    isUpdating,
+    mutate,
+    isLoading,
+  }
+}
+
+export function useDataset(id: string, initialData?: any) {
+  const { mutate: mutateDatasets } = useDatasets()
+
+  const {
+    data: dataset,
+    isLoading,
+    isValidating,
+    mutate,
+  } = useProjectSWR(id && id !== "new" && `/datasets/${id}`, {
+    fallbackData: initialData,
+  })
+
+  const { trigger: update } = useProjectMutation(
+    `/datasets/${id}`,
+    fetcher.patch,
+  )
+
+  const { trigger: remove } = useProjectMutation(
+    `/datasets/${id}`,
+    fetcher.delete,
+    {
+      onSuccess() {
+        mutateDatasets((datasets) => datasets.filter((d) => d.id !== id))
+      },
+    },
+  )
+
+  const { trigger: insertPrompt, isMutating: isInsertingPrompt } =
+    useProjectMutation(`/datasets/prompts`, fetcher.post)
+
+  return {
+    dataset,
+    insertPrompt,
+    update,
+    remove,
+    mutate,
+    loading: isLoading,
+    isValidating,
+    isInsertingPrompt,
+  }
+}
+
+export function useDatasetPrompt(id: string) {
+  const {
+    data: prompt,
+    isLoading,
+    mutate,
+  } = useProjectSWR(id && `/datasets/prompts/${id}`)
+
+  const { trigger: update } = useProjectMutation(
+    id && `/datasets/prompts/${id}`,
+    fetcher.patch,
+  )
+
+  const { trigger: remove } = useProjectMutation(
+    id && `/datasets/prompts/${id}`,
+    fetcher.delete,
+    {
+      revalidate: false,
+    },
+  )
+
+  const { trigger: insertVariation, isMutating: isInsertingVariation } =
+    useProjectMutation(id && `/datasets/variations`, fetcher.post)
+
+  return {
+    prompt,
+    update,
+    remove,
+    mutate,
+    loading: isLoading,
+    insertVariation,
+    isInsertingVariation,
+  }
+}
+
+export function useDatasetPromptVariation(id: string) {
+  const {
+    data: variation,
+    isLoading,
+    mutate,
+  } = useProjectSWR(id && `/datasets/variations/${id}`)
+
+  const { trigger: update } = useProjectMutation(
+    id && `/datasets/variations/${id}`,
+    fetcher.patch,
+    {
+      revalidate: false,
+    },
+  )
+
+  const { trigger: remove } = useProjectMutation(
+    id && `/datasets/variations/${id}`,
+    fetcher.delete,
+    {
+      revalidate: false,
+    },
+  )
+
+  return {
+    variation,
+    update,
+    remove,
+    mutate,
+    loading: isLoading,
+  }
+}
+
+export function useRadars() {
+  const { data: radars, isLoading, mutate } = useProjectSWR(`/radars`)
+
+  // insert mutation
+  const { trigger: insert } = useProjectMutation(`/radars`, fetcher.post, {
+    populateCache(result, currentData) {
+      return [...currentData, result]
+    },
+  })
+
+  return {
+    radars,
+    insert,
+    mutate,
+    loading: isLoading,
+  }
+}
+
+export function useRadar(id, initialData?: any) {
+  const { mutate: mutateRadars } = useRadars()
+
+  const {
+    data: radar,
+    isLoading,
+    mutate,
+  } = useProjectSWR(id && `/radars/${id}`, {
+    fallbackData: initialData,
+  })
+
+  const { trigger: update } = useProjectMutation(
+    id && `/radars/${id}`,
+    fetcher.patch,
+    {},
+  )
+
+  const { trigger: remove } = useProjectMutation(
+    id && `/radars/${id}`,
+    fetcher.delete,
+    {
+      onSuccess() {
+        mutateRadars((radars) => radars.filter((r) => r.id !== id))
+      },
+    },
+  )
+
+  const { data: chart } = useProjectSWR(id && `/radars/${id}/chart`)
+
+  return {
+    radar,
+    chart,
+    update,
+    remove,
+    mutate,
+    loading: isLoading,
+  }
+}
+
+export function useEvaluations() {
+  const { data, isLoading } = useProjectSWR(`/evaluations`)
+
+  return {
+    evaluations: data || [],
+    isLoading,
+  }
+}
+
+export function useEvaluation(id: string) {
+  const {
+    data: evaluation,
+    isLoading,
+    mutate,
+  } = useProjectSWR(id && `/evaluations/${id}`)
+
+  return {
+    evaluation,
+    mutate,
+    loading: isLoading,
+  }
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/utils/datatable.tsx

@@ -0,0 +1,213 @@
+import AppUserAvatar from "@/components/Blocks/AppUserAvatar"
+import Feedback from "@/components/Blocks/Feedback"
+import ProtectedText from "@/components/Blocks/ProtectedText"
+import SmartViewer from "@/components/SmartViewer"
+import { Badge, Group } from "@mantine/core"
+import { createColumnHelper } from "@tanstack/react-table"
+import { useEffect } from "react"
+import analytics from "./analytics"
+
+import { formatCost, formatDateTime, msToTime } from "./format"
+import { useProjectSWR } from "./dataHooks"
+const columnHelper = createColumnHelper<any>()
+
+export function timeColumn(timeColumn, label = "Time") {
+  return columnHelper.accessor(timeColumn, {
+    header: label,
+    id: timeColumn,
+    size: 80,
+    sortingFn: (a, b) =>
+      new Date(a.getValue(timeColumn)).getTime() -
+      new Date(b.getValue(timeColumn)).getTime(),
+    cell: (info) => {
+      const isToday =
+        new Date(info.getValue()).toDateString() === new Date().toDateString()
+      if (isToday) {
+        return new Date(info.getValue()).toLocaleTimeString(
+          typeof window !== "undefined" ? window.navigator.language : "en-US",
+        )
+      } else {
+        return formatDateTime(info.getValue())
+      }
+    },
+  })
+}
+
+export function durationColumn(unit = "s") {
+  return {
+    id: "duration",
+    header: "Duration",
+    size: 45,
+    cell: (props) => {
+      if (!props.getValue()) return null
+      if (unit === "s") {
+        return `${(props.getValue() / 1000).toFixed(2)}s`
+      } else if (unit === "full") {
+        return msToTime(props.getValue())
+      }
+    },
+    accessorFn: (row) => {
+      if (!row.endedAt) {
+        return NaN
+      }
+
+      const duration =
+        new Date(row.endedAt).getTime() - new Date(row.createdAt).getTime()
+      return duration
+    },
+  }
+}
+
+export function statusColumn() {
+  return columnHelper.accessor("status", {
+    id: "status",
+    header: "Status",
+    size: 60,
+    cell: (props) => (
+      <Badge color={props.getValue() === "success" ? "green" : "red"}>
+        <ProtectedText>{props.getValue()}</ProtectedText>
+      </Badge>
+    ),
+  })
+}
+
+export function tagsColumn() {
+  return columnHelper.accessor("tags", {
+    header: "Tags",
+    size: 70,
+    cell: (props) => {
+      const tags = props.getValue()
+
+      useEffect(() => {
+        // Feature tracking
+        if (tags) analytics.trackOnce("HasTags")
+      }, [tags])
+
+      if (!tags) return null
+
+      return (
+        <Group gap={4}>
+          {tags.map((tag) => (
+            <Badge
+              key={tag}
+              variant="outline"
+              style={{
+                textTransform: "none",
+                maxWidth: "100%",
+              }}
+            >
+              {tag}
+            </Badge>
+          ))}
+        </Group>
+      )
+    },
+  })
+}
+
+export function inputColumn(label = "input") {
+  return columnHelper.accessor("input", {
+    header: label,
+    size: 200,
+    enableSorting: false,
+    cell: (props) => <SmartViewer data={props.getValue()} compact />,
+  })
+}
+
+export function outputColumn(label = "Response") {
+  return columnHelper.accessor("output", {
+    header: label,
+    enableSorting: false,
+    cell: (props) => (
+      <SmartViewer
+        data={props.getValue()}
+        error={props.row.original.error}
+        compact
+      />
+    ),
+  })
+}
+
+export function userColumn() {
+  return columnHelper.accessor("user", {
+    header: "User",
+    size: 120,
+    cell: (props) => {
+      const user = props.getValue()
+
+      if (!user?.id) return null
+
+      return <AppUserAvatar size="sm" user={user} withName />
+    },
+  })
+}
+
+export function nameColumn(label = "Name") {
+  return columnHelper.accessor("name", {
+    header: label,
+    size: 80,
+    minSize: 30,
+    cell: (props) => {
+      const { status, type } = props.row.original
+      const name = props.getValue()
+
+      return (
+        <Badge
+          variant="outline"
+          style={{
+            textTransform: "none",
+          }}
+          color={
+            status === "success" ? "green" : status === "error" ? "red" : "gray"
+          }
+        >
+          {name || type}
+        </Badge>
+      )
+    },
+  })
+}
+
+export function costColumn() {
+  return columnHelper.accessor("cost", {
+    header: "Cost",
+    size: 60,
+    sortingFn: (a, b) => a - b,
+    cell: (props) => {
+      const cost = props.getValue()
+      return formatCost(cost)
+    },
+  })
+}
+
+export function feedbackColumn(withRelatedRuns = false) {
+  const cell = withRelatedRuns
+    ? (props) => {
+        const run = props.row.original
+
+        const { data: relatedRuns } = useProjectSWR(`/runs/${run.id}/related`)
+
+        const allFeedbacks = [run, ...(relatedRuns || [])]
+          .filter((run) => run.feedback)
+          .map((run) => run.feedback)
+
+        return (
+          <Group gap="xs">
+            {allFeedbacks?.map((feedback, i) => (
+              <Feedback data={feedback} key={i} />
+            ))}
+          </Group>
+        )
+      }
+    : (props) => {
+        const run = props.row.original
+
+        return <Feedback data={run.feedback} />
+      }
+
+  return columnHelper.accessor("feedback", {
+    header: "Feedback",
+    size: 100,
+    cell,
+  })
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/utils/errors.tsx

@@ -0,0 +1,47 @@
+import { notifications } from "@mantine/notifications"
+import { IconX } from "@tabler/icons-react"
+
+// Error handler for fetch requests
+const errorHandler = async (promise: Promise<any>) => {
+  try {
+    let res = await promise
+
+    // automatically JSON parse fetch
+    if (res?.json) res = await res.json()
+
+    const { data, error } = res
+    if (error) throw error
+    return data || res
+  } catch (error: any) {
+    console.error(error)
+
+    notifications.show({
+      icon: <IconX size={18} />,
+      color: "red",
+      id: "error-alert",
+      title: "Error",
+      autoClose: 4000,
+      message: error.error_description || error.message || error,
+    })
+
+    return null
+  }
+}
+
+export function showErrorNotification(title: any, message?: string) {
+  console.error(message)
+
+  // prevent 10x same error from being shown
+  notifications.hide("error-alert")
+
+  notifications.show({
+    icon: <IconX size={18} />,
+    id: "error-alert",
+    title: title || "Server error",
+    message: message || "Something went wrong",
+    color: "red",
+    autoClose: 4000,
+  })
+}
+
+export default errorHandler

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/utils/fetcher.ts

@@ -0,0 +1,112 @@
+import Router from "next/router"
+import { signOut } from "./auth"
+import { showErrorNotification } from "./errors"
+
+const BASE_URL = process.env.NEXT_PUBLIC_API_URL
+
+export function buildUrl(path: string) {
+  if (path.includes("/auth")) {
+    return `${BASE_URL}${path}`
+  }
+  return `${BASE_URL}/v1${path}`
+}
+
+function get(path) {
+  const authToken = localStorage.getItem("auth-token")
+  const headers = authToken
+    ? {
+        Authorization: `Bearer ${authToken}`,
+      }
+    : undefined
+
+  return fetch(buildUrl(path), {
+    headers,
+  }).then(handleResponse)
+}
+
+async function getFile(path) {
+  const res = await fetch(buildUrl(path), {
+    headers: {
+      Authorization: `Bearer ${localStorage.getItem("auth-token")}`,
+    },
+  })
+
+  if (!res.ok) {
+    const { error, message } = await res.json()
+
+    showErrorNotification(error, message)
+    throw new Error(message)
+  }
+
+  const contentType = res.headers.get("Content-Type") as string
+  const fileExtension = contentType.split("/")[1]
+
+  const blob = await res.blob()
+  const url = window.URL.createObjectURL(blob)
+
+  const a = document.createElement("a")
+  a.href = url
+  a.download = `export.${fileExtension}`
+
+  document.body.appendChild(a)
+  a.click()
+  a.remove()
+
+  window.URL.revokeObjectURL(url)
+}
+
+function post(path, { arg }) {
+  return fetch(buildUrl(path), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${localStorage.getItem("auth-token")}`,
+    },
+    body: JSON.stringify(arg),
+  }).then(handleResponse)
+}
+
+function patch(path, { arg }) {
+  return fetch(buildUrl(path), {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${localStorage.getItem("auth-token")}`,
+    },
+    body: JSON.stringify(arg),
+  }).then(handleResponse)
+}
+
+async function del(path) {
+  return fetch(buildUrl(path), {
+    method: "DELETE",
+    headers: {
+      Authorization: `Bearer ${localStorage.getItem("auth-token")}`,
+    },
+  }).then(handleResponse)
+}
+
+async function handleResponse(res: Response) {
+  const isLoginPage = Router.pathname === "/login"
+
+  if (!res.ok) {
+    if (res.status === 401 && !isLoginPage) {
+      return signOut()
+    }
+
+    const { error, message } = await res.json()
+
+    showErrorNotification(error, message)
+    throw new Error(message)
+  }
+
+  return res.json()
+}
+
+export const fetcher = {
+  get,
+  getFile,
+  post,
+  patch,
+  delete: del,
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/frontend/utils/format.ts

@@ -0,0 +1,82 @@
+import { formatDistanceToNow } from "date-fns"
+
+export const formatCost = (cost = 0) => {
+  if (cost < 1) {
+    const formattedCost = (cost * 100).toFixed(4)
+    return `${parseFloat(formattedCost)}¢`
+  } else {
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+      maximumSignificantDigits: 3,
+    }).format(cost)
+  }
+}
+
+export function formatLargeNumber(number) {
+  return new Intl.NumberFormat(
+    typeof window !== "undefined" ? window.navigator.language : "en-US",
+    {
+      notation: "compact",
+    },
+  ).format(number || 0)
+}
+
+export function formatAppUser(user) {
+  if (!user) return ""
+  return user.props?.name ?? user.props?.email ?? user.externalId
+}
+
+export function formatDateTime(date) {
+  return new Date(date).toLocaleString(
+    typeof window !== "undefined" ? window.navigator.language : "en-US",
+    {
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+    },
+  )
+}
+
+export function msToTime(duration) {
+  let seconds = Math.floor((duration / 1000) % 60),
+    minutes = Math.floor((duration / (1000 * 60)) % 60),
+    hours = Math.floor((duration / (1000 * 60 * 60)) % 24),
+    days = Math.floor((duration / (1000 * 60 * 60 * 24)) % 24)
+
+  const m = minutes
+  const s = seconds
+  const h = hours
+  const d = days
+
+  return `${d > 0 ? d + "d " : ""}${h > 0 ? h + "h " : ""}${
+    m > 0 ? m + "m " : ""
+  }${s}s`
+}
+
+export function capitalize(s) {
+  if (typeof s !== "string") return ""
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}
+
+export const cleanSlug = (text: string): string =>
+  text
+    .toString()
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, "-")
+    .replace(/[^\w-]+/g, "")
+    .replace(/--+/g, "-")
+
+export const formatCompactFromNow = (date) =>
+  formatDistanceToNow(new Date(), {
+    addSuffix: true,
+  })
+    .replace("less than", "<")
+    .replace("about", "~")
+    .replace("minute", "min")
+    .replace(" hours", "h")
+    .replace(" hour", "h")

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/shared/filters/index.ts

@@ -0,0 +1,885 @@
+import {
+  FIELD_PARAM,
+  FIELD_PARAM_ANY,
+  FORMAT_PARAM,
+  MATCH_PARAM,
+  NUMBER_PARAM,
+  PERCENT_PARAM,
+} from "./params"
+
+import type { Filter } from "./types"
+
+export * from "./types"
+export * from "./serialize"
+
+export const FILTERS: Filter[] = [
+  {
+    id: "type",
+    name: "Type",
+    uiType: "basic",
+    disableInEvals: true,
+    params: [
+      {
+        type: "label",
+        label: "Type is",
+      },
+      {
+        type: "select",
+        id: "type",
+        width: 110,
+        defaultValue: "llm",
+        options: [
+          {
+            label: "LLM Call",
+            value: "llm",
+          },
+          {
+            label: "Agent",
+            value: "agent",
+          },
+          {
+            label: "Tool",
+            value: "tool",
+          },
+          {
+            label: "Thread",
+            value: "thread",
+          },
+          {
+            label: "Chat Message",
+            value: "chat",
+          },
+          {
+            label: "Trace",
+            value: "trace",
+          },
+        ],
+      },
+    ],
+  },
+  {
+    id: "models",
+    name: "Model name",
+    uiType: "basic",
+    disableInEvals: true,
+    params: [
+      {
+        type: "label",
+        label: "Model is",
+      },
+      {
+        type: "select",
+        multiple: true,
+        id: "names",
+        width: 100,
+        options: (type) => `/filters/models`,
+      },
+    ],
+  },
+  {
+    id: "tags",
+    name: "Tags",
+    uiType: "basic",
+    disableInEvals: true,
+    params: [
+      {
+        type: "label",
+        label: "Has tags",
+      },
+      {
+        type: "select",
+        multiple: true,
+        width: 100,
+        id: "tags",
+        options: () => `/filters/tags`,
+      },
+    ],
+  },
+  {
+    id: "status",
+    name: "Status",
+    uiType: "basic",
+    disableInEvals: true,
+    params: [
+      {
+        type: "label",
+        label: "Status is",
+      },
+      {
+        type: "select",
+        id: "status",
+        defaultValue: "success",
+        width: 140,
+        options: [
+          {
+            label: "Completed",
+            value: "success",
+          },
+          {
+            label: "Failed",
+            value: "error",
+          },
+        ],
+      },
+    ],
+  },
+  // {
+  //   id: "feedbacks",
+  //   name: "Feedback",
+  //   uiType: "basic",
+  //   disableInEvals: true,
+  //   params: [
+  //     {
+  //       type: "label",
+  //       label: "Feedback",
+  //     },
+  //     {
+  //       type: "select",
+  //       multiple: true,
+  //       id: "feedbacks",
+  //       options: () => `/filters/feedback`,
+  //     },
+  //   ],
+  //   // feedback is a jsonb column
+  //   sql: (sql, { feedbacks }) => sql`feedback @> '${feedbacks}'`,
+  // },
+  {
+    id: "users",
+    name: "Users",
+    uiType: "basic",
+    disableInEvals: true,
+    params: [
+      {
+        type: "label",
+        label: "Users",
+      },
+      {
+        type: "select",
+        multiple: true,
+        width: 100,
+        id: "users",
+        options: () => `/filters/users`,
+        // render: (item) => <AppUser/> // todo
+      },
+    ],
+  },
+  {
+    id: "regex",
+    name: "Regex",
+    uiType: "smart",
+    params: [
+      FIELD_PARAM,
+      MATCH_PARAM,
+      {
+        type: "label",
+        label: "Regex",
+      },
+      {
+        type: "text",
+        id: "regex",
+        placeholder: "^[0-9]+$",
+      },
+    ],
+  },
+  {
+    id: "json",
+    name: "JSON",
+    description: "Checks if the given field is valid JSON.",
+    uiType: "smart",
+    params: [
+      FIELD_PARAM,
+      FORMAT_PARAM,
+      {
+        type: "label",
+        label: "JSON",
+      },
+    ],
+  },
+  {
+    id: "python",
+    name: "Python",
+    description: "Checks if the given field is valid python code.",
+    soon: true,
+    uiType: "smart",
+    params: [
+      FIELD_PARAM,
+      FORMAT_PARAM,
+      {
+        type: "label",
+        label: "Python",
+      },
+    ],
+  },
+  // {
+  //   id: "xml",
+  //   name: "XML / HTML",
+  //   uiType: "smart",
+  //   params: [
+  //     {
+  //       label: "Response",
+  //       type: "label",
+  //     },
+  //     FORMAT_PARAM,
+  //     {
+  //       type: "label",
+  //       label: "XML / HTML",
+  //     },
+  //   ],
+  //   evaluator: async (run) => {
+  //     let parsable = false
+  //     let passed = false
+
+  //     try {
+  //       if (!run.output.startsWith("<")) throw "Not an object"
+  //       // TODO: use a real XML parser
+  //       // new DOMParser().parseFromString(run.output, "text/xml")
+  //       parsable = true
+  //       partial = true
+  //     } catch (e) {}
+
+  //     return {
+  //       parsable,
+  //       partial,
+  //     }
+  //   },
+
+  // },
+  {
+    id: "cc",
+    name: "Credit Card",
+    disableInEvals: true,
+    uiType: "smart",
+    params: [
+      FIELD_PARAM,
+      MATCH_PARAM,
+      {
+        type: "label",
+        label: "Credit Card",
+      },
+    ],
+  },
+  {
+    id: "email",
+    name: "Email",
+    disableInEvals: true,
+    uiType: "smart",
+    params: [
+      FIELD_PARAM,
+      MATCH_PARAM,
+      {
+        type: "label",
+        label: "Email",
+      },
+    ],
+  },
+  {
+    id: "phone",
+    name: "Phone",
+    disableInEvals: true,
+    uiType: "smart",
+    params: [
+      FIELD_PARAM,
+      MATCH_PARAM,
+      {
+        type: "label",
+        label: "Phone",
+      },
+    ],
+  },
+  {
+    id: "length",
+    name: "Length",
+    uiType: "smart",
+    params: [
+      FIELD_PARAM,
+      NUMBER_PARAM,
+      {
+        type: "label",
+        label: "Length",
+      },
+      {
+        type: "number",
+        id: "length",
+        defaultValue: 100,
+        unit: "chars",
+        width: 60,
+      },
+    ],
+  },
+  {
+    id: "date",
+    name: "Date",
+    uiType: "basic",
+    disableInEvals: true,
+    params: [
+      NUMBER_PARAM,
+      {
+        type: "label",
+        label: "Date",
+      },
+      {
+        type: "date",
+        id: "date",
+      },
+    ],
+  },
+  {
+    id: "duration",
+    name: "Duration",
+    disableInEvals: true,
+    uiType: "basic",
+    params: [
+      {
+        type: "label",
+        label: "Duration",
+      },
+      NUMBER_PARAM,
+      {
+        type: "number",
+        id: "duration",
+        defaultValue: 5,
+        min: 0,
+        step: 0.1,
+        width: 40,
+        unit: "s",
+      },
+    ],
+  },
+  {
+    id: "cost",
+    name: "Cost",
+    uiType: "basic",
+    disableInEvals: true,
+    params: [
+      {
+        type: "label",
+        label: "Cost",
+      },
+      NUMBER_PARAM,
+      {
+        type: "number",
+        id: "cost",
+        width: 70,
+        min: 0,
+        defaultValue: 0.1,
+        unit: "$",
+      },
+    ],
+  },
+  {
+    id: "tokens",
+    name: "Tokens",
+    disableInEvals: true,
+    uiType: "basic",
+    params: [
+      {
+        type: "select",
+        id: "field",
+        width: 100,
+        defaultValue: "total",
+        options: [
+          {
+            label: "Completion",
+            value: "completion",
+          },
+          {
+            label: "Prompt",
+            value: "prompt",
+          },
+          {
+            label: "Total",
+            value: "total",
+          },
+        ],
+      },
+      {
+        type: "label",
+        label: "Tokens",
+      },
+      NUMBER_PARAM,
+      {
+        type: "number",
+        min: 0,
+        id: "tokens",
+        width: 70,
+      },
+    ],
+  },
+  {
+    id: "radar",
+    name: "Radar Match",
+    uiType: "smart",
+    disableInEvals: true,
+    params: [
+      {
+        type: "label",
+        label: "Matches radar",
+      },
+      {
+        type: "select",
+        id: "ids",
+        width: 150,
+        placeholder: "Select radars",
+        multiple: true,
+        options: () => `/filters/radars`,
+      },
+    ],
+  },
+  {
+    id: "search",
+    name: "Search Match",
+    uiType: "smart",
+    disableInEvals: true,
+    params: [
+      {
+        type: "label",
+        label: "Search",
+      },
+      {
+        type: "text",
+        id: "query",
+        placeholder: "Search",
+      },
+    ],
+  },
+  {
+    id: "string",
+    name: "String match",
+    uiType: "smart",
+    params: [
+      {
+        type: "select",
+        id: "fields",
+        width: 70,
+        defaultValue: "output",
+        options: [
+          {
+            label: "Input",
+            value: "input",
+          },
+          {
+            label: "Output",
+            value: "output",
+          },
+          {
+            label: "Any",
+            value: "any",
+          },
+        ],
+      },
+      {
+        type: "select",
+        id: "type",
+        width: 100,
+        defaultValue: "contains",
+        options: [
+          {
+            label: "Contains",
+            value: "contains",
+          },
+          {
+            label: "Not contains",
+            value: "notcontains",
+          },
+          // {
+          //   label: "Equals",
+          //   value: "equals",
+          // },
+          {
+            label: "Starts with",
+            value: "starts",
+          },
+          {
+            label: "Ends with",
+            value: "ends",
+          },
+        ],
+      },
+      {
+        type: "select",
+        id: "sensitive",
+        width: 120,
+        defaultValue: "false",
+        options: [
+          {
+            label: "Case sensitive",
+            value: "true",
+          },
+          {
+            label: "Case insensitive",
+            value: "false",
+          },
+        ],
+      },
+      {
+        type: "text",
+        width: 100,
+        id: "text",
+      },
+    ],
+  },
+  {
+    id: "entities",
+    name: "Entities",
+    uiType: "ai",
+    description:
+      "Uses AI to check if the content contains a name, location or organization.",
+    params: [
+      FIELD_PARAM,
+      MATCH_PARAM,
+      {
+        type: "select",
+        id: "entities",
+        width: 100,
+        defaultValue: ["PER"],
+        multiple: true,
+        options: [
+          {
+            label: "Name",
+            value: "PER",
+          },
+          {
+            label: "Location",
+            value: "LOC",
+          },
+          {
+            label: "Organization",
+            value: "ORG",
+          },
+        ],
+      },
+    ],
+  },
+  {
+    id: "assertion",
+    name: "Assertion",
+    uiType: "ai",
+    description:
+      "Checks if the output matches the given requirement, using GPT-4 to grade the output.",
+    onlyInEvals: true,
+    params: [
+      {
+        type: "label",
+        label: "Output",
+      },
+      {
+        type: "text",
+        id: "assertion",
+        placeholder: "Is spoken like a pirate",
+        width: 140,
+      },
+    ],
+  },
+  {
+    id: "sentiment",
+    name: "Sentiment",
+
+    uiType: "ai",
+    description:
+      "Uses AI to check if content is positive, neutral, or negative.",
+    params: [
+      FIELD_PARAM,
+      {
+        type: "label",
+        label: "sentiment is",
+      },
+      {
+        type: "select",
+        id: "sentiment",
+        defaultValue: "positive",
+        width: 140,
+        options: [
+          {
+            label: "positive",
+            value: "positive",
+          },
+          {
+            label: "neutral",
+            value: "neutral",
+          },
+          {
+            label: "negative",
+            value: "negative",
+          },
+        ],
+      },
+    ],
+  },
+  {
+    id: "tone",
+    name: "Tone",
+    uiType: "ai",
+    onlyInEvals: true,
+    description:
+      "Assesses if the tone of the LLM response matches with the desired persona.",
+    params: [
+      {
+        type: "label",
+        label: "Tone of output matches",
+      },
+      {
+        type: "select",
+        id: "persona",
+        defaultValue: "helpful",
+        width: 140,
+        options: [
+          {
+            label: "Helpful Assistant",
+            value: "helpful",
+          },
+          {
+            label: "Formal",
+            value: "formal",
+          },
+          {
+            label: "Casual",
+            value: "casual",
+          },
+          {
+            label: "Teacher",
+            value: "teacher",
+          },
+          {
+            label: "Friendly",
+            value: "friendly",
+          },
+          {
+            label: "Professional",
+            value: "professional",
+          },
+          {
+            label: "Instructive",
+            value: "instructive",
+          },
+          {
+            label: "Authoritative",
+            value: "authoritative",
+          },
+          {
+            label: "Informative",
+            value: "informative",
+          },
+          {
+            label: "Sarcastic",
+            value: "sarcastic",
+          },
+          {
+            label: "Humorous",
+            value: "humorous",
+          },
+          {
+            label: "Empathetic",
+            value: "empathetic",
+          },
+          {
+            label: "Enthusiastic",
+            value: "enthusiastic",
+          },
+          {
+            label: "Motivational",
+            value: "motivational",
+          },
+          {
+            label: "Curious",
+            value: "curious",
+          },
+          {
+            label: "Sincere",
+            value: "sincere",
+          },
+          {
+            label: "Witty",
+            value: "witty",
+          },
+          {
+            label: "Pirate",
+            value: "pirate",
+          },
+        ],
+      },
+      {
+        type: "label",
+        label: "persona",
+      },
+    ],
+  },
+  {
+    id: "factualness",
+    name: "Factualness",
+    uiType: "ai",
+
+    onlyInEvals: true,
+    description:
+      "Checks how correct the LLM's response is compared to the ideal output (ues OpenAI's eval prompt).",
+    params: [
+      {
+        type: "label",
+        label: "The answer",
+      },
+      {
+        type: "select",
+        id: "choices",
+        defaultValue: ["b", "c"],
+        multiple: true,
+        width: 200,
+        options: [
+          {
+            label: "is a subset of",
+            value: "a",
+          },
+          {
+            label: "is a superset of",
+            value: "b",
+          },
+          {
+            label: "contains all the same details as",
+            value: "c",
+          },
+          {
+            label: "disagrees with",
+            value: "d",
+          },
+          {
+            label: "differs (but doesn't matter from a factual standpoint)",
+            value: "e",
+          },
+        ],
+      },
+      {
+        type: "label",
+        label: "the ideal output",
+      },
+    ],
+  },
+  {
+    id: "relevancy",
+    name: "Relevancy",
+    uiType: "ai",
+    soon: true,
+    onlyInEvals: true,
+    description:
+      "Checks if the LLM's response is relevant given the context and the prompt.",
+    params: [
+      {
+        type: "label",
+        label: "Output is >=",
+      },
+      PERCENT_PARAM,
+      {
+        type: "label",
+        label: "relevant",
+      },
+    ],
+  },
+  {
+    id: "toxicity",
+    name: "Toxicity",
+    uiType: "ai",
+    description:
+      "Checks if the given field contains toxic, offensive, obscene, or hateful language. English only at the moment.",
+    params: [
+      FIELD_PARAM_ANY,
+      MATCH_PARAM,
+      {
+        type: "label",
+        label: "toxicity",
+      },
+    ],
+  },
+  {
+    id: "system",
+    name: "System Guidelines",
+    soon: true,
+    uiType: "ai",
+    onlyInEvals: true,
+    description: `Checks if the output matches guidelines set in the 'system' message.`,
+    params: [
+      {
+        type: "label",
+        label: "Output follows >=",
+      },
+      PERCENT_PARAM,
+      {
+        type: "label",
+        label: "system guidelines",
+      },
+    ],
+  },
+  {
+    id: "similarity",
+    name: "Similarity",
+    uiType: "ai",
+    onlyInEvals: true,
+    description: `Check if the output is similar to a given ideal output with various algorithms.`,
+    params: [
+      {
+        type: "label",
+        label: "Output is >=",
+      },
+      PERCENT_PARAM,
+      {
+        type: "label",
+        label: "similar to ideal output using",
+      },
+      {
+        type: "select",
+        id: "algorithm",
+        width: 100,
+        defaultValue: "ai",
+        options: [
+          {
+            value: "ai",
+            label: "Smart AI",
+          },
+          {
+            label: "Cosine (vector)",
+            value: "cosine",
+          },
+          {
+            label: "Jaccard",
+            value: "jaccard",
+          },
+        ],
+      },
+      {
+        type: "label",
+        label: "similarity",
+      },
+    ],
+  },
+  {
+    id: "rouge",
+    name: "ROUGE",
+    uiType: "ai",
+    onlyInEvals: true,
+    description: `Rouge (Recall-Oriented Understudy for Gisting Evaluation) is a metric used for evaluating the quality of generated text, especially in tasks like text summarization.`,
+
+    params: [
+      {
+        type: "label",
+        label: "Output is >=",
+      },
+      PERCENT_PARAM,
+      {
+        type: "select",
+        id: "rouge",
+        width: 100,
+        defaultValue: "n",
+        options: [
+          {
+            value: "n",
+            label: "ROUGE-n",
+          },
+          {
+            value: "l",
+            label: "ROUGE-l",
+          },
+          {
+            value: "rouge-s",
+            label: "ROUGE-s",
+          },
+        ],
+      },
+    ],
+  },
+]

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/shared/filters/params.ts

@@ -0,0 +1,125 @@
+import type { FilterParam } from "./types"
+
+export const FORMAT_PARAM: FilterParam = {
+  type: "select",
+  id: "type",
+  width: 120,
+  defaultValue: "valid",
+  options: [
+    {
+      label: "Is valid",
+      value: "valid",
+    },
+    {
+      label: "Is invalid",
+      value: "invalid",
+    },
+    // {
+    //   label: "Is partial",
+    //   value: "partial",
+    // },
+    {
+      label: "Contains valid",
+      value: "contains",
+    },
+  ],
+}
+
+export const NUMBER_PARAM: FilterParam = {
+  type: "select",
+  id: "operator",
+  width: 50,
+  defaultValue: "lt",
+  options: [
+    {
+      label: ">=",
+      value: "gte",
+    },
+    {
+      label: "<=",
+      value: "lte",
+    },
+    {
+      label: "=",
+      value: "eq",
+    },
+    {
+      label: "!=",
+      value: "neq",
+    },
+    {
+      label: ">",
+      value: "gt",
+    },
+    {
+      label: "<",
+      value: "lt",
+    },
+  ],
+}
+
+export const FIELD_PARAM: FilterParam = {
+  type: "select",
+  id: "field",
+  width: 80,
+  defaultValue: "output",
+  options: [
+    {
+      label: "Input",
+      value: "input",
+    },
+    {
+      label: "Output",
+      value: "output",
+    },
+  ],
+}
+
+export const FIELD_PARAM_ANY: FilterParam = {
+  type: "select",
+  id: "field",
+  width: 80,
+  defaultValue: "output",
+  options: [
+    {
+      label: "Input",
+      value: "input",
+    },
+    {
+      label: "Output",
+      value: "output",
+    },
+    {
+      label: "Any",
+      value: "any",
+    },
+  ],
+}
+
+export const MATCH_PARAM: FilterParam = {
+  type: "select",
+  id: "type",
+  width: 120,
+  defaultValue: "contains",
+  options: [
+    {
+      label: "Contains",
+      value: "contains",
+    },
+    {
+      label: "Not contains",
+      value: "not_contains",
+    },
+  ],
+}
+
+export const PERCENT_PARAM: FilterParam = {
+  type: "number",
+  unit: "%",
+  id: "percent",
+  width: 50,
+  min: 0,
+  step: 5,
+  max: 100,
+  defaultValue: 50,
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/shared/filters/serialize.ts

@@ -0,0 +1,138 @@
+import type { FilterLogic, FilterParam } from "."
+import { FILTERS } from "."
+
+// because dots are used to separate filter parameters, we need to encode them
+const encode = (str: string) => encodeURIComponent(str).replace(/\./g, "%2E")
+
+const paramSerializer = (param: FilterParam, value: any) => {
+  if (value == undefined) {
+    return undefined
+  }
+  switch (param.type) {
+    case "select":
+      if (param.multiple) {
+        if (!value.length) return undefined
+        return value.map(encode).join(",")
+      } else {
+        return encode(value)
+      }
+    case "text":
+    case "number":
+      return encode(value)
+    case "date":
+      // get timestamp
+      return encode(value.getTime())
+    default:
+      return undefined
+  }
+}
+
+function deserializeParamValue(
+  filterParam: FilterParam,
+  v: string,
+): any | undefined {
+  switch (filterParam.type) {
+    case "select":
+      if (filterParam.multiple) {
+        return v.split(",").map(decodeURIComponent)
+      } else {
+        return decodeURIComponent(v)
+      }
+    case "text":
+      return decodeURIComponent(v)
+    case "number":
+      return Number(v)
+    case "date":
+      return new Date(Number(v))
+    default:
+      return undefined
+  }
+}
+
+// This function serializes the filter parameters for storage or transmission
+// Example:
+// ['AND', {id: 'type', params: {type: 'llm'}}, {id: 'tags', params: {tags: ['some', 'tags']}}]
+// Will be serialized to:
+// type=llm&tags=some.tags
+
+export function serializeLogic(logic: FilterLogic): string {
+  const serializeParamValue = (param: any): string => {
+    if (Array.isArray(param)) {
+      const all = param.map(serializeParamValue)
+
+      if (all.some((f) => typeof f !== "undefined")) return ""
+      return all.join(".")
+    } else if (
+      param &&
+      typeof param === "object" &&
+      param.params &&
+      !Object.values(param.params).some((f) => typeof f === "undefined")
+    ) {
+      const data = Object.entries(param.params)
+        .map(([key, value]) => {
+          const filterParam = FILTERS.find(
+            (filter) => filter.id === param.id,
+          )?.params.find((param) => (param as FilterParam).id === key)
+
+          if (!filterParam || filterParam.type === "label") {
+            return ""
+          }
+
+          return paramSerializer(filterParam, value)
+        })
+        .filter((serializedValue) => serializedValue !== "")
+        .join(".")
+
+      if (!data) return ""
+
+      return param.id + "=" + data
+    }
+    return ""
+  }
+
+  return logic
+    .map(serializeParamValue)
+    .filter((f) => f)
+    .join("&")
+}
+
+export function deserializeLogic(logicString: string): FilterLogic | undefined {
+  const deserializeParam = (param: string): any => {
+    const [id, params] = param.split("=")
+    const filter = FILTERS.find((filter) => filter.id === id)
+
+    if (!filter) {
+      return undefined
+    }
+
+    const filterParams = filter.params.filter(
+      (param) => param.type !== "label",
+    ) as FilterParam[]
+
+    const paramsData: any = {}
+
+    const value = params.split(".")
+
+    for (const [i, v] of value.entries()) {
+      const filterParam = filterParams[i]
+
+      if (!filterParam) {
+        return undefined
+      }
+
+      paramsData[filterParam.id] = deserializeParamValue(filterParam, v)
+    }
+
+    return {
+      id,
+      params: paramsData,
+    }
+  }
+
+  const logic = logicString
+    .split("&")
+    .map(deserializeParam)
+    .filter((f) => f)
+
+  return ["AND", ...logic] as FilterLogic
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/shared/filters/types.ts

@@ -0,0 +1,50 @@
+export type FilterLabel = {
+  type: "label"
+  label: string
+}
+
+export type FilterParam = {
+  type: "select" | "text" | "number" | "date"
+  id: string
+  unit?: string
+  max?: number
+  min?: number
+  step?: number
+  width?: number
+  placeholder?: string
+  render?: (value: any) => React.ReactNode
+  defaultValue?: string | number | boolean | string[]
+  multiple?: boolean
+  options?:
+    | Array<{ label: string; value: string }>
+    | ((projectId: string, type: string) => string)
+}
+
+export type Filter = {
+  id: string
+  uiType: "basic" | "smart" | "ai"
+  name: string
+  description?: string
+  soon?: boolean
+  params: (FilterParam | FilterLabel)[]
+  disableInEvals?: boolean
+  onlyInEvals?: boolean
+}
+
+// export type SavedFilterData = {
+//   id: string
+//   paramsData: { id: string; value: any }[]
+// }
+
+// [ 'AND, {id, params}, {id, params}, {id, params}, ['OR', {id, params}, {id, params}], ['OR', {id, params}, ['AND', {id, params}, {id, params}]] ]
+
+export type LogicData = {
+  id: string
+  params: any
+}
+
+type LogicNode = ["AND" | "OR", ...LogicElement[]]
+
+export type LogicElement = LogicData | LogicNode
+
+export type FilterLogic = LogicNode

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/shared/index.ts

@@ -0,0 +1,3 @@
+export * from "./models"
+export * from "./filters"
+export * from "./types"

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/shared/models.ts

@@ -0,0 +1,82 @@
+export const MODELS = [
+  {
+    id: "gpt-4-turbo-preview",
+    name: "gpt-4-turbo-preview",
+    provider: "openai",
+  },
+  { id: "gpt-4-1106-preview", name: "gpt-4-1106-preview", provider: "openai" },
+  { id: "gpt-4-0125-preview", name: "gpt-4-0125-preview", provider: "openai" },
+  {
+    id: "gpt-4-vision-preview",
+    name: "gpt-4-vision-preview",
+    provider: "openai",
+  },
+  { id: "gpt-4", name: "gpt-4", provider: "openai" },
+  { id: "gpt-3.5-turbo", name: "gpt-3.5-turbo", provider: "openai" },
+  { id: "gpt-3.5-turbo-1106", name: "gpt-3.5-turbo-1106", provider: "openai" },
+  { id: "gpt-3.5-turbo-0125", name: "gpt-3.5-turbo-0125", provider: "openai" },
+  { id: "gpt-3.5-turbo-16k", name: "gpt-3.5-turbo-16k", provider: "openai" },
+  {
+    id: "google/gemini-pro",
+    name: "gemini-pro",
+    provider: "openrouter",
+  },
+  { id: "openai/gpt-4-32k", name: "gpt-4-32k", provider: "openrouter" },
+  { id: "claude-2", name: "claude-2", provider: "anthropic" },
+  // { id: "claude-2.0", name: "claude-2.0", provider: "anthropic" },
+  {
+    id: "claude-instant-v1",
+    name: "claude-instant-v1",
+    provider: "anthropic",
+  },
+  {
+    id: "open-orca/mistral-7b-openorca",
+    name: "mistral-7b-openorca",
+    provider: "openrouter",
+  },
+  {
+    id: "mistralai/mixtral-8x7b-instruct",
+    name: "mixtral-8x7b-instruct",
+    provider: "openrouter",
+  },
+  {
+    id: "mistralai/mistral-7b-instruct",
+    name: "mistral-7b-instruct",
+    provider: "openrouter",
+  },
+  {
+    id: "teknium/openhermes-2.5-mistral-7b",
+    name: "openhermes-2.5-mistral-7b",
+    provider: "openrouter",
+  },
+  {
+    id: "perplexity/pplx-70b-chat",
+    name: "pplx-70b-chat",
+    provider: "openrouter",
+  },
+  {
+    id: "perplexity/pplx-7b-chat",
+    name: "pplx-7b-chat",
+    provider: "openrouter",
+  },
+  {
+    id: "openchat/openchat-7b",
+    name: "openchat-7b",
+    provider: "openrouter",
+  },
+  {
+    id: "google/palm-2-chat-bison",
+    name: "palm-2-chat-bison",
+    provider: "openrouter",
+  },
+  {
+    id: "meta-llama/llama-2-13b-chat",
+    name: "llama-2-13b-chat",
+    provider: "openrouter",
+  },
+  {
+    id: "meta-llama/llama-2-70b-chat",
+    name: "llama-2-70b-chat",
+    provider: "openrouter",
+  },
+]

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/shared/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "shared",
+  "type": "module",
+  "scripts": {
+    "build": "tsup index.ts --format esm"
+  },
+  "dependencies": {
+    "zod": "^3.22.4"
+  }
+}

benchmark/Cybench/benchmark/bug_bounty/lunary/packages/shared/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "composite": true,
+    "strict": true,
+    "downlevelIteration": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowJs": true
+  }
+}