A Private, Local-First Career Operating System with Desktop AI
Commercial job trackers and cloud-based AI tools harvest private resumes, leak confidential salary histories, and drop streaming context the moment you switch pages. atTrack was created to solve this fundamentally: an open-source, local-first desktop application where your career data stays in SQLite on your own machine, while background AI workers assist your job search seamlessly across route changes.
100% Local-First Architecture
All resumes, cover letters, application statuses, and vector embeddings are stored locally in SQLite with zero cloud dependencies.
Route-Persistent Multi-Session SSE Queue
Global root ChatQueueProvider manages independent concurrent AI generations that stream in background workers as you browse.
Safety-Gated Database Mutations
AI tool calls for destructive database actions require explicit user confirmation through an interactive 60-second modal.
Embedded Vector Search
Powered by sqlite-vec for instant semantic matching across resumes, interview questions, and job descriptions on-device.
Get Started in Under 60 Seconds
Clone the repository, install dependencies, and launch your local atTrack development environment.
- Node.js 20.x or higher (LTS recommended)
- Git 2.40+
- C++ Build Tools (required only if building native SQLite binaries on Windows)
Clone the Repository
Clone the official atTrack open-source repository from GitHub to your local workspace.
git clone https://github.com/KamrulIslamArnob/atTrack-Playground.git cd atTrack-Playground
Install Dependencies
Install the unified Next.js, Electron, and AI SDK dependencies using your preferred package manager.
npm install
Configure Environment
Copy the sample environment configuration and supply your AI model provider API key (OpenAI, Anthropic, or Google Gemini).
cp .env.example .env.local
Launch Desktop or Web Dev Server
Start the Next.js web interface or launch the standalone Electron desktop window with hot reload.
npm run dev
Installation, Runtime Modes & Desktop Packaging
Run atTrack in local browser mode, run in native Electron development, or package native binaries for Windows & macOS.
1. Web Application Mode
Runs Next.js 16 App Router on local port 3788 with full SQLite and streaming SSE capabilities.
npm run dev
2. Native Electron Desktop Dev Mode
Prepares the Electron bridge and launches the native desktop window with hardware acceleration.
npm run electron:dev
3. Full Verification & Typechecking
Runs strict TypeScript compiler checks and verifies all test suites across SQLite and streaming queues.
npm run typecheck && npm run lint
| Target Platform | Build Command | Artifact Output |
|---|---|---|
| Windows Installer (.exe / NSIS) | npm run electron:build:win | build/atTrack Setup 0.1.0.exe |
| macOS Universal Binary (.dmg) | npm run electron:build:mac | build/atTrack-0.1.0-universal.dmg |
| Cross-Platform Multi-Target Build | npm run electron:build:all | build/ (Windows + macOS production installers) |
Core Workflows & Daily Operations
Mastering the career tracker, background AI copilot, and on-device vector search.
Visual Career Board & Application Tracking
Organize opportunities across customizable Kanban columns from Wishlist to Applied, Technical Screen, and Offer.
Multi-Session Background AI Copilot
Chat with AI models to tailor bullet points, draft outreach emails, and generate mock interview questions.
On-Device Semantic Vector Search
Locate relevant career experiences and past interview answers instantly using local embeddings.
Architecture Contracts & Relational Schema
Clean TypeScript interface contracts and SQLite table definitions powering atTrack.
Global root-level context managing multi-session background streams and FIFO queues.
export interface ChatTask {
id: string;
sessionId: string;
query: string;
status: "queued" | "streaming" | "completed" | "error";
error?: string;
createdAt: number;
}
export interface SessionStreamState {
isStreaming: boolean;
activeChunk: string;
activeThinking?: string;
sources?: ChatSource[];
approval?: DbApprovalPayload;
error?: string;
}
export interface ChatQueueContextValue {
tasks: ChatTask[];
activeStreams: Record<string, SessionStreamState>;
enqueueMessage: (sessionId: string, query: string, attachments?: any[]) => Promise<void>;
cancelStream: (sessionId: string) => void;
getStreamState: (sessionId: string) => SessionStreamState | undefined;
activeApproval: DbApprovalPayload | null;
handleApprovalAction: (allow: boolean) => Promise<void>;
}Propose-then-approve contract for safety-gated destructive AI database mutations.
export interface DbApprovalPayload {
approvalId: string;
label: string;
preview: string;
sql: string;
tableName: string;
targetCount: number;
expiresAt: number; // UTC timestamp in ms (Date.now() + 60_000)
}chat_sessions & chat_messages
SQLite relational tables with monotonic sequence ordering ensuring lossless dual-tier sync.
CREATE TABLE IF NOT EXISTS chat_sessions ( id TEXT PRIMARY KEY, title TEXT NOT NULL, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL ); CREATE TABLE IF NOT EXISTS chat_messages ( id TEXT PRIMARY KEY, session_id TEXT NOT NULL, seq INTEGER NOT NULL, role TEXT NOT NULL, content TEXT NOT NULL, thinking TEXT, created_at INTEGER NOT NULL, FOREIGN KEY (session_id) REFERENCES chat_sessions(id) ON DELETE CASCADE ); CREATE INDEX IF NOT EXISTS idx_chat_messages_session_seq ON chat_messages(session_id, seq);
System Topology & Streaming Pipeline
Deep dive into atTrack multi-tier architecture, background scheduler, and SSE stream demuxing.
Next.js 16 App Router & Electron 43 Shell
React 19 Server & Client Components rendered inside an Electron desktop window with secure IPC bridges and dark/light system theme sync.
ChatQueueProvider & Session Isolation Registry
Root-level FIFO task scheduler managing concurrent streams. Each session retains isolated message buffers, loading states, and independent AbortControllers.
4-Stage SSE Demuxer & Thinking Block Extractor
Preserves trailing partial buffers (lines.pop()), cleanly demuxes internal model <think> reasoning tokens from final markdown, and intercepts tool_calls.
SQLite 3 Authority & sqlite-vec Embedded Search
Two-tier storage architecture syncing client-side localStorage mirrors with authoritative SQLite databases and on-device vector embeddings.
Step-by-Step Tutorial: Background AI & Safe Mutation
A concrete walkthrough demonstrating background streaming across route changes and safety approvals.
Start AI Generation in Chat Drawer
Freely Navigate Between Pages
AI Proposes Destructive Cleanup
Review Collapsible SQL & Confirm
Interactive 60s Safety Approval Simulator
Experience the human-in-the-loop safety countdown and anti-replay single-use token architecture.
Configuration & Environment Variables
Full reference for setting up API keys, database paths, and custom server ports.
| Variable Key | Required | Default | Description |
|---|---|---|---|
| OPENAI_API_KEY | Optional | — | API key for OpenAI models (GPT-4o, o3-mini). |
| ANTHROPIC_API_KEY | Optional | — | API key for Anthropic Claude models (Claude 3.7 Sonnet). |
| GEMINI_API_KEY | Optional | — | API key for Google Gemini models (Gemini 2.5 Flash / Pro). |
| PORT | Optional | 3788 | Custom local port for the Next.js development and production server. |
| SQLITE_DB_PATH | Optional | ./data/attrack.sqlite | Filesystem path to the local SQLite database file. |
| ENABLE_VECTOR_SEARCH | Optional | true | Enables sqlite-vec vector embedding creation and semantic search. |
Development, Testing & Contribution Guidelines
How to contribute to atTrack, run concurrency test suites, and submit pull requests.
Multi-Session Concurrency Test
node scripts/verify-ai-chat-concurrency.js
Launches 10 parallel chat sessions and verifies zero stream cross-talk or race conditions.
Safety Approval Gate Test
node scripts/verify-db-approval.js
Tests 60s timeout expiration, token replay attack prevention, and safe Deny fallback.
Two-Tier SQLite Roundtrip Test
node scripts/verify-sqlite-persistence.js
Validates monotonic sequence ordering across 1,000 rapid chat messages.
- Follow TypeScript strict mode with 0 compiler errors (verify with npx tsc --noEmit).
- Never introduce external telemetry or cloud tracking libraries — privacy is non-negotiable.
- Ensure all destructive database tools follow the propose-only contract with DbApprovalPayload.
- Submit pull requests against the main branch with clear description and passing verification scripts.
Security Model & Privacy Guarantees
How atTrack safeguards your personal career data and prevents rogue AI tool execution.
Zero-Cloud Local Storage
All resumes, documents, and application notes are written directly to your local filesystem in encrypted SQLite databases. We operate zero telemetry servers.
Propose-Then-Approve Safety Gate
AI tools cannot execute destructive database mutations (e.g. DELETE, DROP, batch updates) without explicit human confirmation in an interactive modal.
Single-Use Anti-Replay Tokens
Approval requests generate short-lived in-memory cryptographic tokens with strict 60-second timeouts, preventing token reuse or replay attacks.
Got Questions?
We've Got Answers
Everything you need to know about atTrack architecture, offline capabilities, and local LLM inference.
Kamrul Islam Arnob
Lead Maintainer
Have a question about the roadmap, architecture, or contributing? Reach out directly.
atTrack is cross-platform. It runs as a native desktop app on macOS (Apple Silicon & Intel) and Windows 10/11 via Electron 43, as well as a standalone web app in any modern browser.
MIT License
SPDX: MIT · Copyright © 2026 atTrack Core Contributors & AtTech Studio