thehardwarestore.ai

Notte is a full-stack web AI agent framework and browser automation SDK. The implementation is a multi-package Python monorepo: notte-core provides shared domain models, actions, error hierarchies, telemetry, and configuration; notte-browser implements Playwright/Patchright browser control, DOM snapshotting, scraping pipelines, and form-filling heuristics; notte-agent contains the LLM-driven agent loop, deterministic fallback, and workflow execution; notte-llm wraps LiteLLM with structured completions, retries, and a file-based prompt library; notte-sdk is the client for the hosted Notte cloud API with remote sessions, agents, vaults, personas, and serverless functions; notte-integrations adds notifiers and third-party CDP session providers. Primary entry points are `NotteClient` for cloud usage, `NotteSession` for local browser automation, and `Agent`/`AgentFallback` for autonomous and hybrid scripted-agent workflows.

This repository is the canonical source for **OpenClaw Agent Skills**, a collection of portable, reusable agent workflows (skills) for coding agents such as Claude Code, Codex, Pi, and OpenClaw. The primary deliverable is not a standalone application but a set of self-contained skills that provide automated code review (autoreview), redacted session publication (beam), session transcript provenance (agent-transcript), local session viewing (session-viewer), behavior validation (behavior-validator), and remote test orchestration (crabbox). Each skill lives under `skills/<name>/` with a required `SKILL.md` file and auxiliary scripts, tests, and references. The repository also includes cross-platform installer (`scripts/install-skills`) and validator (`scripts/validate-skills`) scripts that support symlink or copy installation into agent skill directories. Architecturally, the skills are independent of each other and are consumed by agents via direct symlink/copy. The most complex skill is `autoreview`, which performs a full AI-driven code review pipeline: capture git diff/commit/working-tree state, build a review prompt with evidence, invoke one of several engines (Codex, Claude, Amp, Pi) via subprocess, parse structured JSON reports, and produce a final review result with security hardening (isolation probes, credential scanning, terminal escape prevention). The `autoreview` script is monolithic (~80k tokens) but contains reusable patterns for safe subprocess environment sanitization, git diff collection, JSON extraction from noisy output, and engine isolation verification. The `session-viewer` skill provides a polished local HTML renderer for agent session JSONL files, with importers for multiple session formats. The `beam` skill focuses on redacted publication of coding sessions to a read-only catalog. The codebase demonstrates high engineering craftsmanship: extensive test coverage (Python unittest, Jest for TypeScript, shell-based harness), security-conscious patterns (symlink validation, stat-preserving writes, process group signal handling, environment sanitization), and cross-platform support (Windows, macOS, Linux via CI). The test suite is especially thorough for `autoreview`, covering edge cases like CRLF handling, binary files, merge commits, worktrees, shallow clones, and sensitive path patterns. The installer pattern (symlink for development, copy for vendored snapshots) is designed to minimize drift while allowing zero-setup downstream usage. Overall, the repository is actively maintained, uses modern tooling (Python 3.14, Node 26, TypeScript 7), and is well-suited for teams adopting agent-assisted development workflows who need reusable, vetted skill definitions.

PiDeck is an open-source Electron desktop application that serves as a comprehensive workbench for AI coding agents, primarily wrapping the `pi` coding agent and the DeepSeek Harness (DSH) backend. It provides a rich session-centric chat workspace with features including multi-project management, Git integration, a built-in terminal, voice transcription, image generation, scheduled automation tasks, a desktop pet companion, and extensive configuration options. The application supports importing sessions from other tools like Claude, Codex, Cursor, and OpenCode, and offers a web service variant for remote access. Architecturally, PiDeck follows the standard Electron pattern with a main process (Node.js services, IPC handlers, filesystem operations), a preload script for secure IPC bridging, and a renderer process built with React 19, TypeScript, Jotai for state management, and Tailwind CSS v4 with shadcn/ui-style components. The codebase is organized into `src/main/` for backend services, `src/renderer/` for the UI, and `src/shared/` for cross-process types and utilities. Key entry points include the main process index, renderer bootstrap, and numerous IPC modules that validate inputs and delegate to domain services. Data flows center on session files stored in JSONL format (for pi) or compressed JSONL (for DSH), with model catalogs, usage statistics, and configuration persisted in user data directories. The application manages multiple backends through a unified session catalog, with runtime state synchronized via IPC events and Jotai atoms. External dependencies include the pi-coding-agent CLI, DSH runtime packages, node-pty for terminal emulation, whisper.cpp for local speech-to-text, and electron-updater for cross-platform updates. The codebase demonstrates strong engineering practices with extensive unit tests (node:test), Playwright E2E tests, pure-function modules extracted for testability, and consistent IPC boundary validation patterns.

Huginn is a self-hosted, hackable automation platform built as a Ruby on Rails application. It allows users to create and chain 'agents' that monitor, scrape, transform, and act on data from hundreds of sources (web, RSS, email, Twitter, Telegram, Slack, OpenAI, etc.) via an event-driven architecture. Agents are polymorphic Ruby classes with a consistent lifecycle: scheduled checks, event reception, and event emission. The system supports Liquid templating for dynamic configuration, OAuth services, file pointers, and background job processing via DelayedJob. The codebase is extensive with 80+ agent types, reusable concerns (WebRequestConcern, LiquidInterpolatable, FormConfigurable), and a comprehensive test suite. While primarily an application, it includes a small research dataset (ANEW sentiment norms) used by a sentiment analysis agent, but the dominant character is clearly a production automation service.

GPT Researcher is an autonomous research agent that produces comprehensive, cited reports from web and local sources. In production, it operates as a full-stack web application: a FastAPI backend (main.py, backend/server/app.py) exposes REST and WebSocket endpoints for initiating research, streaming progress, and retrieving reports. A Next.js frontend (frontend/nextjs/) provides the user interface, and a lightweight vanilla JS frontend (frontend/scripts.js) is also available. The core Python package (gpt_researcher/) can be used programmatically via the GPTResearcher class or as a CLI tool (cli.py). Architecture follows a planner-executor pattern: given a research task, the system generates sub-queries, executes them in parallel across 20+ search engine wrappers (Tavily, Google, Bing, Brave, DuckDuckGo, ArXiv, PubMed, etc.), scrapes the resulting URLs using multiple backends (BeautifulSoup, browser automation, PyMuPDF, FireCrawl), filters and compresses the context using embedding or keyword-based methods, and finally generates a structured report with citations. The system supports multiple report types (summary, detailed, deep research) and multi-agent orchestrations (LangGraph, AG2) for more complex workflows. Key data flows: user query to sub-query generation (LLM) to parallel search across configured retrievers to URL scraping to context compression to source curation to report generation (LLM) to output as markdown/PDF/DOCX. Real-time progress is streamed via WebSocket. External dependencies include LLM providers (OpenAI, Anthropic, Google, Ollama, etc.), search APIs (Tavily, SerpAPI, etc.), and optional services (MCP servers, vector stores, image generation APIs). The codebase demonstrates strong engineering practices: extensive test suite (200+ tests), plugin architecture for retrievers, configurable context filters, cost tracking, and evaluation frameworks for quality and hallucination. However, it carries maintenance risks from its large dependency surface, multiple parallel agent implementations, and reliance on rapidly-changing external APIs.

Atlantis is a self-hosted Go application that automates Terraform and OpenTofu workflows triggered by pull request events. It listens for webhooks from GitHub, GitLab, Bitbucket Cloud/Server, Azure DevOps, and Gitea, then executes Terraform commands (plan, apply, import, state rm, version) and reports results via PR comments and commit statuses. The system enforces approval, mergeability, and policy requirements, supports drift detection and remediation, and provides a web UI for lock management and streaming logs. The architecture is a monolithic server with modular components: HTTP controllers for webhook handling, command runners for orchestrating workflows, step runners for individual Terraform operations, VCS client abstractions for multi-provider support, and pluggable persistence (BoltDB embedded, optional Redis, S3 for plan storage). Configuration is layered via server-side YAML, repo-level atlantis.yaml, and CLI flags. Key entry points include main.go (CLI), cmd/server.go (server command), server/controllers/events/events_controller.go (webhook dispatcher), and server/events/command_runner.go (command orchestration). External dependencies include Terraform/OpenTofu binaries, Conftest for policy checks, VCS APIs, and optional Redis/S3. The codebase demonstrates strong engineering practices with extensive unit/integration/e2e tests, instrumentation for metrics, structured logging, and security-conscious design (webhook signature validation, path traversal prevention, shell injection mitigation). While the project is actively maintained, technical drift is medium due to large dependency surface, mock generation sprawl, and complex VCS integration parity.

actions/github-script is a GitHub Action that allows users to run JavaScript/TypeScript scripts in their workflows with access to a pre-authenticated GitHub API client and other GitHub Action toolkit packages. The action executes user-provided scripts as asynchronous functions within a context that includes github, context, core, glob, io, exec, getOctokit, and require objects. Scripts can make GitHub API calls, perform file operations, and return values that become action outputs. The architecture follows standard GitHub Action patterns with TypeScript source code compiled and bundled via ncc into a single distributable file. Key components include async-function.ts for safely executing user scripts, create-configured-getoctokit.ts for creating secondary authenticated clients with inherited configuration, and wrap-require.ts for handling module resolution. The action integrates with GitHub's retry and request-logging plugins and supports configurable retries, user-agent, base URL, and result encoding.

This is a production-grade, AI-powered code review automation tool that integrates with multiple version control systems (GitHub, GitLab, Bitbucket Cloud/Server, Azure DevOps, Gitea) and multiple LLM providers (OpenAI, Claude, Gemini, Ollama, Bedrock, OpenRouter, Azure OpenAI). The system is implemented as a Python async CLI application, packaged as a Docker image, and includes CI/CD integration templates for GitHub Actions, GitLab CI, Jenkins, Bitbucket Pipelines, and Azure Pipelines. Architecturally, it follows a clean layered design: a CLI layer (Typer) drives commands; a configuration layer (Pydantic Settings with multiple file/env sources) manages nested settings for LLM, VCS, agent, review, artifacts, and logging; a service layer orchestrates the review process through runners, gateways, and internal services (prompt building, diff analysis, policy enforcement, cost tracking, artifact persistence); and a client layer provides unified abstractions for VCS and LLM providers with provider-specific implementations. The tool supports multiple review modes: inline comments on specific code lines, summary comments on the entire PR, context review (full repository exploration via an optional agent loop), and reply to existing comments. The agent loop uses a ReAct pattern with tool execution (shell commands like `rg`, `cat`, `git`) to gather deeper context, with duplicate detection and context limits. A dry-run mode allows testing without posting to VCS. The system also includes a hook service for lifecycle events, cost tracking per request, and optional artifact saving of LLM interactions. Key strengths include extensive test coverage (unit tests with fake clients and fixtures), generic reusable components (HTTP client with retry, pagination helpers, diff parser, LLM output JSON parser, cost service), and a well-structured configuration system that supports discriminated unions for provider-specific settings. The codebase is actively maintained, uses modern Python async patterns, and demonstrates high craftsmanship in its abstraction layers and separation of concerns.

Modern Industrialization is a comprehensive tech mod for Minecraft (NeoForge) that introduces a progressive automation system. It adds hundreds of machines, multiblocks, pipes, energy networks, and a full nuclear reactor simulation, all driven by a data-driven material and recipe system. The mod features a component-based machine architecture where each block entity is composed of modular NBT-serializable components with client-server sync, a custom vendored Fabric Transfer API for fluid/item storage with transactional rollback, and a sophisticated pipe network manager for item, fluid, and energy transport. It includes extensive compatibility layers for KubeJS scripting, JEI/REI/EMI recipe viewing, AE2 integration, Jade tooltips, and Sodium/Embeddium performance optimizations. The codebase is large but well-structured, with procedural texture generation, runtime datagen, and a robust multiblock shape matching system. It demonstrates strong engineering practices in mod development, particularly in its component abstraction, network management, and transactional resource handling.

Budibase is an open-source low-code platform for building AI agents, internal applications, and automations. It provides a visual builder (Svelte frontend) for designing screens, data models, and workflows, backed by a Koa.js server and worker services. The platform supports multi-tenancy, self-hosting via Docker/Kubernetes, and a cloud offering. Core capabilities include a drag-and-drop app builder, an automation engine with triggers and steps, AI agent creation with LLM integration and knowledge bases, external datasource connectivity (REST, SQL, NoSQL, S3, etc.), role-based access control, SCIM provisioning, and audit logging. The architecture follows a monorepo pattern with distinct packages for server, worker, builder, client, pro features, CLI, and shared libraries, using CouchDB as the primary document store, Redis for caching/queues, and S3/MinIO for object storage.

The Universal Intel Chipset Device Updater is a Windows PowerShell utility that automates the detection, download, verification, and silent installation of Intel Chipset Device Software (INF files). It scans the system for Intel chipset hardware, matches detected devices against a curated database of INF packages, downloads the correct installer from primary (GitHub) or backup mirrors, verifies integrity via SHA-256 hashes and Intel digital signatures, creates a system restore point, and installs the INF files without unnecessary drivers or bloatware. The tool supports interactive, automatic, and quiet modes, making it suitable for home users, IT technicians, and MDM deployments (Intune, SCCM, Workspace ONE, PDQ Deploy). Architecturally, the system is composed of several PowerShell scripts with batch launchers, distributed as a self-extracting executable (SFX). The main updater script (universal-intel-chipset-device-updater.ps1) orchestrates the workflow: hardware detection via get-intel-hwids.ps1, database parsing from Markdown files, download management, multi-layer security verification, and installation. A companion INF extractor script (universal-intel-chipset-inf-extractor.ps1) handles extraction from modern Intel installers using NanaZip. The codebase emphasizes safety with self-hash verification, automatic update checks, EOL package handling, and cAVS audio conflict safeguards. While primarily an application, the repository also contains data assets: a comprehensive INF database (intel-chipset-infs-latest.md with 6954 entries), download lists with SHA-256 hashes, and extensive documentation including AI audit reports and deployment guides. These data files are tightly coupled to the tool's operation but represent a structured, maintainable knowledge base for Intel chipset support across generations.

This is a Node.js automation tool that deploys and maintains Cloudflare Web Application Firewall (WAF) custom rules across all zones in a Cloudflare account. It runs as a long-lived daemon (via PM2) with scheduled cron jobs: one fetches the latest expressions from the repository (git pull) and another updates the WAF rules via the Cloudflare Rulesets API. The service parses rule expressions from a markdown file, applies user configuration (PHP/WordPress support, custom allowlist/blocklist per zone, external IP threat feeds from SniffCat and AbuseIPDB), and syncs the resulting custom rules and IP lists to Cloudflare. It includes robust error notification via email and Discord webhooks with batched alert delivery. The codebase is well-structured, thoroughly tested (Jest), and actively maintained with frequent updates.

Baudbot is a persistent AI agent system designed for engineering teams, running on Linux and integrated with Slack. It features a control agent that triages requests and spawns ephemeral dev-agent workers for end-to-end coding tasks (branch → code → PR → CI), while a sentry-agent handles incident investigation. The system maintains persistent team memory to learn repository quirks and collaboration preferences, with a strong focus on security through hardened permissions, tool guards, session logging with redaction, and manifest integrity verification. Architecture separates admin-managed source from immutable runtime deployments, communicates via Unix domain sockets and a local HTTP API, and supports extensibility through TypeScript extensions and agent skills.

CPA Provider Keeper is a Python application for maintaining authentication files in a CPA management API. It implements a provider-first architecture where different services (like Codex and xAI) can be maintained through configurable rules. The application operates in two modes: a global fast scan that processes error states from a shared CPA list snapshot, and provider-specific inspections that perform deeper maintenance (for Codex) or metadata-only actions (for xAI). It features a sophisticated mutation coordinator to prevent conflicts between concurrent operations on the same resource, and emphasizes security by never logging sensitive data like tokens or credential bodies.

n8n is a production-grade workflow automation and AI agent platform. In production, it runs as a Node.js Express server with a Vue 3 frontend, executing user-defined workflows composed of nodes (triggers, actions, LLM calls). Workflows can be triggered manually, via webhooks, schedules, or events, and the execution engine handles concurrency, retries, errors, and data passing between nodes. The platform supports AI agents through an SDK that manages LLM calls, tool execution, memory, conversation loops, and MCP (Model Context Protocol) integration, enabling autonomous multi-step agents. Architecturally, the monorepo is organized into backend (packages/cli, packages/core, @n8n/engine), frontend (packages/frontend/editor-ui), database layer (@n8n/db with TypeORM), AI/agent packages (@n8n/agents, @n8n/ai-utilities, @n8n/instance-ai), and a vast node/credential library (packages/nodes-base, @n8n/nodes-langchain). Dependency injection is handled by @n8n/di, controllers are decorated with @RestController, and database models use a forked TypeORM. The system supports multiple database backends (PostgreSQL, SQLite) and can scale with Redis and worker processes. Key data flows: Workflow definitions are persisted in the database with version history. Execution data (inputs, outputs, binary data) is stored for monitoring and replay. The AI agent runtime uses a persistent message store for conversation memory, supports checkpoint/restore for long-running agents, and integrates with external LLMs (OpenAI, Anthropic, etc.) via a unified model factory. The platform exposes REST APIs for CRUD operations on workflows, credentials, users, and executions, as well as WebSocket push for real-time UI updates. External dependencies include a database, optional Redis for scaling, and numerous third-party services via nodes and credentials.

This repository provides a collection of shell scripts to automate the setup and management of an IPsec VPN server on Linux. It supports multiple VPN protocols (IPsec/L2TP, IPsec/XAuth, IKEv2) and a wide range of Linux distributions including Ubuntu, Debian, CentOS, Rocky Linux, AlmaLinux, Oracle Linux, and Alpine Linux. The main entry point is `vpnsetup.sh`, which detects the OS and runs the appropriate installer. The project also includes helper scripts for user management, IKEv2 certificate handling, upgrades, and uninstallation. Additionally, it offers an Azure ARM template for cloud deployment. The code is well-structured with OS-specific installers, common bash utility functions, and extensive documentation in multiple languages. It is a mature, widely-used DevOps tool for system administrators.

Auto PY to EXE is a desktop application that provides a graphical interface for converting Python scripts (.py) into standalone Windows executables (.exe) using PyInstaller under the hood. The application is structured as a Python package with a web-based frontend served locally via the Eel framework, which bridges JavaScript UI components with a Python backend. The backend handles argument parsing, configuration management, file dialogs (via tkinter), and orchestrates PyInstaller execution, capturing logs and output to display in real-time in the browser UI. The tool supports a wide range of PyInstaller options, including onefile/onedir modes, console hiding, icon assignment, additional files, and many advanced flags, all exposed through a dynamically generated settings panel. It also includes version checking against GitHub API for both itself and PyInstaller, along with compatibility shims (e.g., for Python 3.12 bottle issues). The codebase is well-organized into distinct modules (validation, packaging, UI, dialogs, utils, shims) with a clear separation between Python backend and frontend presentation, though some cross-module coupling exists via a global config singleton. Tests cover basic packaging, library imports, and dependency availability, though they are limited in scope.

KiKit is a Python CLI tool, library, and KiCAD plugin for automating PCB panelization and fabrication output. It takes KiCAD board files (S-expression format) and produces panelized PCBs with v-cuts, mouse bites, tooling holes, fiducials, and frames. It also exports manufacturing files (Gerbers, drill, assembly data) tailored to popular fab houses (JLCPCB, PCBWay, OSH Park), generates 3D-printable solder paste stencils, performs DRC checks, and creates presentation pages for boards. The architecture is modular: core geometric operations use Shapely, interval algebra, and a custom S-expression parser; an extensible plugin system allows custom layout, tab, and cut strategies. The tool integrates deeply with KiCAD’s pcbnew API and supports multiple KiCAD versions (6–9) through version-specific adapters. While primarily a production tool for hardware engineers, its clean separation of parsing, geometry, and CLI makes several components reusable in other PCB-adjacent projects.

This repository is a macOS iMessage/SMS automation tool called `imsg`. It provides a CLI and JSON-RPC interface for reading, watching, and sending messages. The architecture has three layers: a Swift CLI that parses commands and outputs NDJSON or plain text; a core library (`IMsgCore`) that reads the local Messages SQLite database and manages the bridge to Messages.app; and an injected Objective-C dylib (`IMsgHelper`) that hooks into private IMCore APIs for advanced features like typing indicators, polls, stickers, rich links, and message mutations. The tool can fall back to AppleScript automation for basic sends when the bridge is unavailable (e.g., SIP enabled). The RPC server runs over stdio, making it suitable for integration with AI agents and scripts. The codebase is well-tested with unit tests for all layers, including native Objective-C tests for the injected helper. It demonstrates deep reverse-engineering of Apple's private messaging protocols and careful handling of platform-specific quirks. The primary data flow is read-only from the local `chat.db` SQLite database for history and live updates, with write operations going through either AppleScript (via `osascript`) or the injected bridge (via UUID-keyed IPC queues). External dependencies include SQLite.swift, PhoneNumberKit, ffmpeg, afconvert, and private macOS frameworks (IMCore, CNContactStore). The build system uses SwiftPM with custom scripts for universal macOS binaries and Linux static archives. The project is actively maintained with CI, releases, and a documentation site.