# EveryOS 🖥️

EveryOS is a self-hosted, desktop-style web GUI for managing Linux servers. Install it on an existing Debian or Ubuntu machine and manage it from any browser on your laptop or phone: files, Docker apps, terminal, services, monitoring, updates and backups in one place.

EveryOS is not a new operating system or a VNC stream. Linux keeps running underneath, and EveryOS gives you a browser-based workspace on top of it.

---

## ✨ Features

* 🪟 **Desktop in the browser** – movable, snappable windows, virtual desktops, dock, launcher and widgets
* 🐳 **Docker & App Store** – install self-hosted apps from catalogs, manage containers and Compose projects, roll back deployments
* 🧩 **Desktop apps & SDK** – signed desktop apps in isolated windows, an official catalog and a community registry for your own apps
* 📁 **Files & disks** – private home folders, trash, one-click USB disk mounting and Google Drive integration
* 💻 **Real terminal** – a real Linux shell in the browser, tied to each user's own Linux account
* 📊 **System monitoring** – live CPU, memory, disk and network readings, systemd services, logs and package updates
* 🤖 **AI assistants** – chat with local models (Ollama, LM Studio, llama.cpp, vLLM), Hermes Agent or OpenClaw
* 🏠 **Home Assistant** – rooms, devices and live states in a dedicated panel and desktop widgets
* 🔔 **Notifications** – ntfy, Telegram, e-mail or webhook
* 💾 **Encrypted backups** – off-site copies to another disk, S3-compatible storage or Google Drive
* 🌍 **10 languages** – English, Turkish, German, Spanish, French, Italian, Japanese, Korean, Russian and Simplified Chinese

---

## 🏗️ Architecture

EveryOS runs as services on the Linux machine you want to manage:

1. **Web Client (React)**
   A desktop-style interface with windows, dock, widgets and apps.

2. **API (Hono, unprivileged)**
   Handles accounts, sessions, permissions and app data. It never runs as root.

3. **Agent (privileged)**
   Executes a defined set of validated system operations: Docker, disks, services, packages and Linux accounts.

4. **Update Worker**
   Installs signed releases and supervises package and database recovery.

```
[ Browser ]  →  [ Hono API + SQLite ]  →  [ Privileged Agent ]  →  [ Linux host / Docker ]
```

---

## 🚀 Getting Started

### Requirements

* Debian 12+, Ubuntu 22.04+ or a compatible APT/systemd host
* ARM64 or AMD64 (Raspberry Pi works too)
* Docker (optional, for Docker and App Store features)

### Installation

```bash
curl -fsSL https://github.com/goktugcy/everyos/releases/latest/download/install.sh | sudo bash
```

The installer verifies the signed release and bundles its own Node.js runtime.

### Open your workspace

```bash
sudo cat /var/lib/everyos/setup-token
```

Then open `http://<your-server-ip>:7470`, enter the token and create your administrator account.

---

## 🛠️ Tech Stack

* TypeScript & Node.js (API, agent, CLI)
* React, Vite, Tailwind CSS, Radix UI, Zustand (web client)
* Hono & WebSocket (API and real-time updates)
* SQLite (application database)
* Docker & Docker Compose (self-hosted apps)
* CodeMirror, xterm.js, pdf.js, Excalidraw (official desktop apps)
* Cloudflare Workers, D1 & R2 (community app registry)
* Debian packages & systemd (distribution)
* Vitest & Playwright (testing), GitHub Actions (CI/CD)

---

## 🔐 Security

* Administrator, Operator and Viewer roles with server-enforced permissions
* Two-factor authentication with recovery codes
* Unprivileged API with a separate, validated privileged agent
* Audit log for security-relevant actions
* Ed25519-signed releases and app packages

---

## 📄 License

MIT License

---

## 🌐 Links

* GitHub: [https://github.com/goktugcy/everyos](https://github.com/goktugcy/everyos)
* Releases: [https://github.com/goktugcy/everyos/releases](https://github.com/goktugcy/everyos/releases)
* Community Registry: [https://registry.everyos.net](https://registry.everyos.net)

---

EveryOS brings everyday Linux server administration into a familiar desktop, right in your browser.


EveryOS is a self-hosted, desktop-style web GUI for Linux servers that brings Docker apps, files, a real terminal, system monitoring, updates and encrypted backups into one browser-based workspace.

EveryOS

# Tavily Web Search Skill for OpenClaw 🦀

A lightweight Tavily web search skill for OpenClaw that works without `pip` and without third-party Python packages.

This skill is designed for minimal Linux environments such as:

- Raspberry Pi
- Ubuntu Server
- small VPS setups
- systems where installing Python packages is unavailable, restricted, or intentionally avoided

Instead of using the `tavily-python` SDK, this skill calls the Tavily REST API directly using Python's standard library.

## Features

- Tavily web search through direct REST API calls
- No `pip install` required
- No external Python dependencies
- Works well on Raspberry Pi and Ubuntu Server
- Supports general search and news search
- Supports answer summaries, images, and domain filtering
- Easy to integrate into OpenClaw skills
- Simple secret-file based API key setup

## Why this version exists

The official Tavily Python SDK is convenient, but some environments do not have a practical or desirable `pip` workflow.

This skill exists for setups where you want:

- a small footprint
- no package installation step
- predictable deployment
- compatibility with minimal server environments
- a solution that keeps working even on systems where Python package installation is restricted

This is especially useful on Raspberry Pi, Ubuntu Server, and other minimal Linux systems where you may prefer to avoid virtual environments, extra package managers, or external Python dependencies for a simple search integration.

## Folder Structure

```text
skills/tavily/
├── SKILL.md
├── .secrets/
│   └── tavily.key
└── scripts/
    └── tavily_search.py
```

## Secret Setup

Create the secret directory:

```bash
mkdir -p skills/tavily/.secrets
chmod 700 skills/tavily/.secrets
```

Create the key file:

```bash
nano skills/tavily/.secrets/tavily.key
```

The file must contain only your raw Tavily API key:

```
tvly-xxxxxxxxxxxxxxxx
```

Do **not** write:

```
TAVILY_API_KEY=tvly-xxxxxxxxxxxxxxxx
```

Set permissions:

```bash
chmod 600 skills/tavily/.secrets/tavily.key
```

## Usage

Basic search:

```bash
python3 skills/tavily/scripts/tavily_search.py --query "latest AI news"
```

News-focused search:

```bash
python3 skills/tavily/scripts/tavily_search.py --query "gold prices" --topic news
```

Advanced search:

```bash
python3 skills/tavily/scripts/tavily_search.py --query "raspberry pi ubuntu server optimization" --depth advanced
```

JSON output:

```bash
python3 skills/tavily/scripts/tavily_search.py --query "python asyncio" --json
```

## Supported Options

| Option              | Description                  |
| ------------------- | ---------------------------- |
| `--query`           | **required** search query    |
| `--topic`           | `general` or `news`          |
| `--depth`           | `basic` or `advanced`        |
| `--max-results`     | number of results            |
| `--no-answer`       | disable answer summary       |
| `--raw-content`     | include parsed raw content   |
| `--images`          | include image results        |
| `--include-domains` | restrict to selected domains |
| `--exclude-domains` | filter out selected domains  |
| `--json`            | output raw JSON              |

## OpenClaw Integration

This skill is meant to be used from OpenClaw through `SKILL.md`.

Typical usage flow:

1. The user asks for web search or recent information
2. OpenClaw invokes the Tavily skill
3. The skill runs `scripts/tavily_search.py`
4. The script reads the API key from `.secrets/tavily.key`
5. Results are returned in a format suitable for summarization

## Why no pip is required

This project intentionally avoids the Tavily Python SDK and other third-party dependencies.

That means:

- there is no `pip install` step
- there is no dependency on `tavily-python`
- there is no virtual environment requirement just to use the skill
- deployment stays simple on minimal systems

The script uses only Python's standard library to call the Tavily REST API directly.

## Security Notes

- The `.secrets` directory should never be committed
- Your API key should stay only on the target machine
- This repository should contain code and documentation only
- Add `.secrets/` to `.gitignore`
- Keep `tavily.key` readable only by the user or service that runs the skill

Example `.gitignore` entries:

```
.secrets/
__pycache__/
*.pyc
```

## Requirements

- Python 3
- Network access to Tavily API
- A valid Tavily API key
- No additional Python packages are required

## Motivation

This project is especially useful for:

- Raspberry Pi home server setups
- Ubuntu Server deployments
- minimal VPS environments
- offline-managed or tightly controlled systems
- users who want Tavily search without SDK installation
- environments where `pip` is unavailable, restricted, or intentionally avoided

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.


A lightweight Tavily web search skill for OpenClaw that works without pip and without third-party Python packages.

Tavily web search for OpenClaw

# 🔥 Hono + ⚡️ Supabase Boilerplate

This project is a backend boilerplate built using the Hono framework. Cloudfare Workers are used to host the backend. It includes integration with Supabase and handles user authentication and authorization.

| [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier) | [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/goktugcy/hono-boilerplate/blob/main/LICENSE) | ![GitHub Created At](https://img.shields.io/github/created-at/goktugcy/hono-boilerplate) | ![GitHub Repo stars](https://img.shields.io/github/stars/goktugcy/hono-boilerplate?style=flat) | ![GitHub forks](https://img.shields.io/github/forks/goktugcy/hono-boilerplate?style=flat) |
|---|---|---|---|---|


## Installation 🚀

After cloning the repository, install the necessary dependencies by running:

```sh
bun install
```

## Configuration ✨

Edit the `.wrangler.toml` file to include the necessary environment variables:

```sh
STAGE = "dev" # dev or prod
# Supabase
SUPABASE_URL=
SUPABASE_SERVICE_KEY=
SUPABASE_ANON_KEY=

```

## Structure 🎄

```
.
├── src
│   ├── controllers
│   │   ├── AuthController.ts
│   │   ├── CountryController.ts
│   ├── middlewares
│   │   ├── authMiddleware.ts
│   ├── db
│   │   ├── supabaseClient.ts
│   ├── routes.ts
│   ├── helpers.ts
├── index.ts
├── wrangler.toml
├── package.json
├── README.md
├── tsconfig.json
├── .gitignore
├── bun.lockb

```

## Usage 🍻

To start the server, run:

```sh
bun dev
```

Deploy the server to Cloudfare Workers by running:

```sh
bun run deploy
```

## Authentication 🛡 
 
The boilerplate includes an authentication middleware that checks if the user is authenticated. The middleware is used in the routes.ts file to protect routes that require authentication.

```ts
import { authMiddleware } from './middlewares/authMiddleware';

router.get('/countries', authMiddleware, CountryController.index);
```
#### Token Extraction: The middleware extracts the accessToken and refreshToken from the request cookies.

#### Token Verification: 
* If the accessToken is expired but the refreshToken is valid, it requests a new accessToken using the refreshToken.
* If both tokens are missing, it responds with an error.
* If the accessToken is present, it verifies the token using Supabase's authentication service.

## Supabase Client Usage ⚡️

The project uses two Supabase clients: `supabaseAnon` and `supabaseService`. These clients are created in the [`getSupabaseClient`](src/db/supabaseClient.ts) function in [src/db/supabaseClient.ts](src/db/supabaseClient.ts).

### `supabaseAnon`

The `supabaseAnon` client is used for operations that do not require elevated privileges. It is created using the anonymous key (`SUPABASE_ANON_KEY`) and is configured to not automatically refresh tokens, persist sessions, or detect sessions in URLs.

Example usage:
```ts
import { getSupabaseClient } from "./src/db/supabaseClient";

const getCountries = async (c: Context) => {
  const { supabaseAnon } = getSupabaseClient(c);
  let { data: countries, error } = await supabaseAnon.from("countries").select("*");

  if (error) {
    return c.json({ error: error.message }, 400);
  }

  return c.json(countries, 200);
};
```

### `supabaseService`

The `supabaseService` client is used for operations that require elevated privileges, such as authentication and user management. It is created using the service key (`SUPABASE_SERVICE_KEY`).

Example usage:
```ts
import { getSupabaseClient } from "./src/db/supabaseClient";

const login = async (c: Context) => {
  const { supabaseService } = getSupabaseClient(c);
  const { email, password } = await c.req.json<{ email: string; password: string }>();

  const { data, error } = await supabaseService.auth.signInWithPassword({
    email,
    password,
  });

  if (error) {
    return c.json({ error: error.message }, 400);
  }

  const accessToken = data.session?.access_token;
  const refreshToken = data.session?.refresh_token;

  if (!accessToken || !refreshToken) {
    return c.json({ error: "Token creation failed" }, 500);
  }

  setAuthCookies(c, accessToken, refreshToken);

  return c.json({ message: "Login successful", accessToken, refreshToken }, 200);
};
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

This project is a backend boilerplate built using the Hono framework. Cloudfare Workers are used to host the backend. It includes integration with Supabase and handles user authentication and authorization.


🔥 Hono + ⚡️ Supabase Boilerplate

# Support Desk

Tenant-aware B2B customer support platform built with Laravel, Inertia, Vue, Sanctum, PostgreSQL, Redis queues, Reverb, and a shadcn/Tailwind-inspired admin and portal UI.

## Implemented Production Core

- Provider admin console and customer portal
- Provider Command Center for platform health, customer workspaces, configuration coverage, and quick admin actions
- Tenant-scoped companies, users, roles, invitations, tickets, comments, attachments, API tokens, webhooks, and audit logs
- Company-based 24/7 SLA policies with first-response and resolution breach tracking
- Real dashboard metrics for provider operations and customer portal workspaces
- Attachment allowlist validation with file type and size limits
- Invitation revoke/resend and user role/status management
- Webhook delivery visibility, test delivery, manual retry, and secret rotation
- API v1 ticket endpoints with idempotent ticket creation, OpenAPI documentation, and company-gated Swagger UI
- Company-scoped human ticket numbers such as `#100001`, with numeric portal/admin ticket URLs and legacy public-id redirects
- Database + mail notification center with header inbox dropdown, read/unread filters, and a full notifications archive
- Personal and shared saved ticket views for admin and portal ticket lists
- Provider bulk ticket actions for status, assignment, priority, and tags
- Public knowledge base for portal/API clients plus provider-managed internal content
- Provider canned responses with ticket/requester/company variables
- Ticket comment mentions with ticket-access scoping
- Provider ticket merge and split workflows with ticket events and audit logs
- CSAT surveys sent on first resolution, with single-use token responses
- Synchronous CSV/PDF exports for ticket and CSAT reports
- Async report center with queued CSV/PDF exports, history, status, download, and errors
- Knowledge base v2 with category hierarchy, article edit/delete, version history, and portal helpful feedback
- Provider automation rules with trigger/condition/action execution logs
- Provider-agnostic inbound email webhook for Mailgun/Postmark/SendGrid/generic payloads with `Message-Id` dedupe
- Laravel Reverb/Echo private channels for live notification, ticket, report export, and webhook delivery updates
- Global header search across tickets, comments, companies, users, and knowledge base with tenant scoping and PostgreSQL full-text indexes where supported
- CSAT resend/reminder support plus summary metrics on reports
- Webhook public delivery IDs, payload viewer, custom test payloads, audit filters/detail/CSV export
- Attachment security through MIME, extension, and size allowlists
- Portal branding settings and user notification delivery preferences

## Setup

```bash
composer install
npm install
cp .env.example .env
php artisan key:generate
php artisan migrate --seed
npm run build
```

The default example environment expects PostgreSQL, Redis, and the PHP Redis extension. For a lightweight local-only run without Redis, set `CACHE_STORE=array` and `QUEUE_CONNECTION=sync` in `.env`.

Create or update a provider admin:

```bash
php artisan support:create-provider-admin admin@example.com --password=password
```

Run the local app, queue workers, Reverb, logs, and Vite:

```bash
composer run dev
```

If you change `BROADCAST_CONNECTION`, `REVERB_*`, or any `VITE_*` value, restart `composer run dev` so Laravel and Vite both read the new environment.

## Operations

SLA breaches are marked by the scheduled command:

```bash
php artisan support:check-sla-breaches
```

In production, run Laravel scheduler every minute and keep queue workers alive for the `default`, `notifications`, `webhooks`, `reports`, and `automation` queues. Start Reverb when `BROADCAST_CONNECTION=reverb`.

```bash
php artisan queue:work redis --queue=default,notifications,webhooks,reports,automation --tries=3 --timeout=120
```

The scheduler marks SLA breaches and requeues stale report exports:

```bash
php artisan support:check-sla-breaches
php artisan support:recover-report-exports
```

Attachment upload validation is configured with:

```env
SUPPORT_ATTACHMENT_MAX_KB=20480
SUPPORT_ATTACHMENT_ALLOWED_MIMES=text/plain,text/csv,application/pdf,image/png,image/jpeg,image/gif,application/zip,application/json,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
SUPPORT_ATTACHMENT_ALLOWED_EXTENSIONS=txt,csv,pdf,png,jpg,jpeg,gif,zip,json,docx,xlsx
```

Inbound email webhooks are available at:

```text
POST /inbound-email/{mailgun|postmark|sendgrid|generic}
```

Set `INBOUND_EMAIL_SECRET` to require `X-Support-Inbound-Secret`. Messages are matched by company payload/default company, sender email, and ticket numbers like `#100001`.

Reverb local configuration:

```env
BROADCAST_CONNECTION=reverb
REVERB_APP_ID=local
REVERB_APP_KEY=local
REVERB_APP_SECRET=local
REVERB_HOST=127.0.0.1
REVERB_PORT=8080
REVERB_SCHEME=http
VITE_REVERB_ENABLED=true
```

Keep `VITE_REVERB_ENABLED=false` unless `php artisan reverb:start` is running; otherwise the browser will try to connect to port `8080`.

## API

API clients are managed from the customer portal. Use bearer tokens against `/api/v1`.

The OpenAPI description is available at [docs/openapi.yaml](docs/openapi.yaml).
Interactive Swagger UI is available at `/api-docs` for provider admins and for client companies with API docs access enabled.

Provider admins can enable or disable client-company API docs access from company detail pages and the Command Center.

Ticket creation supports an optional `Idempotency-Key` header. Reusing a key with the same body returns the stored response; reusing it with a different body returns a validation error.

Default API token abilities now include ticket creation/read/comment, attachment upload, public knowledge base read, company-safe bulk ticket updates, report exports, and CSAT writes. `/api/v1/meta/ticket-options` requires either `tickets:read` or `tickets:create`.

Webhook deliveries are signed with:

- `X-Support-Event`
- `X-Support-Delivery`
- `X-Support-Timestamp`
- `X-Support-Signature: sha256=<hmac>`

The signature payload is `<timestamp>.<json-body>` using the endpoint secret.

## Verification

```bash
php artisan test
npm run typecheck
npm run build
npm run e2e
```

## Production Checklist

- Configure `.env` with `APP_ENV=production`, `APP_DEBUG=false`, a stable `APP_KEY`, PostgreSQL, Redis, mail, storage, and `APP_URL`.
- Run `php artisan migrate --force` and create the first provider admin with `php artisan support:create-provider-admin`.
- Run a queue worker for `default,notifications,webhooks,reports,automation` and run Laravel scheduler every minute.
- Start Reverb only when `BROADCAST_CONNECTION=reverb`, then set `VITE_REVERB_ENABLED=true` before building assets.
- Keep `storage/` and `bootstrap/cache/` writable by the PHP process.
- Review attachment MIME, extension, and max-size allowlists before enabling customer uploads.
- Verify `/up`, login, ticket create/comment, report export, webhook retry, and notification delivery after deploy.
- Back up PostgreSQL and persisted attachment/report storage on the same retention schedule.
- Run `php artisan test`, `npm run typecheck`, `npm run build`, and `npm run e2e` in CI before release.

## Roadmap

The current production workflow roadmap is implemented. Future work can focus on report scheduling, richer article approval workflows, provider-facing API clients for operational actions, and deeper full-text search ranking.

Tenant-aware B2B customer support platform built with Laravel, Inertia, Vue, Sanctum, PostgreSQL, Redis queues, Reverb, and Tailwind-inspired admin and portal UI.

B2b Support Desk

# Noderax 🚀

Noderax is an agent-based infrastructure control plane that helps you manage servers, automate operations, and monitor your systems from a single platform.

It combines a central API (control plane), a web interface, and lightweight Go agents running on your nodes.

---

## ✨ Features

* 🧠 **Agent-based architecture** – lightweight Go agents run on each node
* 🖥️ **Central control plane** – manage all infrastructure from one API
* 🌐 **Web UI** – simple and modern interface for operations
* 🔐 **Self-hosted** – full control over your infrastructure
* ⚡ **Real-time operations** – instant communication between nodes and control plane
* 🔌 **API-first design** – easily integrate with other systems

---

## 🏗️ Architecture

Noderax consists of three main components:

1. **Control Plane (API)**
   The brain of the system that manages nodes, tasks, and orchestration.

2. **Agents (Go)**
   Lightweight services running on each server, responsible for executing commands and reporting status.

3. **Web UI**
   A dashboard to monitor and control your infrastructure.

```
[ Web UI ]  →  [ Control Plane API ]  →  [ Agents on Nodes ]
```

---

## 🚀 Getting Started

### Prerequisites

* Docker (recommended)
* Go (for agents)
* Node.js (for frontend if developing)

### Installation

#### 1. Clone the repository

```bash
git clone https://github.com/noderax/<repo>.git
cd <repo>
```

#### 2. Setup environment

```bash
cp .env.example .env
```

#### 3. Start services

```bash
docker compose up -d
```

---

## 🤖 Running Agents

Install and run the agent on your server:

```bash
# example
go build -o noderax-agent
./noderax-agent --server=<CONTROL_PLANE_URL> --token=<TOKEN>
```

---

## 🔌 API Usage

Noderax exposes a REST API for managing infrastructure.

Example:

```bash
curl -H "Authorization: Bearer <token>" \
  https://your-noderax-instance/api/nodes
```

---

## 📦 Use Cases

* Server orchestration
* Infrastructure monitoring
* Remote command execution
* DevOps automation
* Multi-node management

---

## 🛠️ Tech Stack

* Go (agents)
* Node.js / TypeScript (API & services)
* Web UI (modern frontend stack)
* Docker (deployment)

---

## 🔐 Security

* Token-based authentication
* Secure agent communication
* Self-hosted deployment model

---

## 🤝 Contributing

1. Fork the repo
2. Create your branch (`git checkout -b feature/awesome-feature`)
3. Commit your changes
4. Push and open a PR

---

## 📄 License

MIT License

---

## 🌐 Links

* Website: [https://noderax.net/](https://noderax.net/)
* GitHub: [https://github.com/noderax](https://github.com/noderax)

---

Noderax aims to simplify infrastructure management by giving developers full control with minimal complexity.


Noderax is a modern platform that provides scalable backend solutions, developer tools, and infrastructure services to build and manage applications efficiently.

Noderax Platform

# RSS News API  ![Telegram](https://kufgxlvheldohsqwdpxo.supabase.co/storage/v1/object/public/pub/111.png?t=2024-09-24T20%3A28%3A16.689Z)

This project is an RSS News API that fetches RSS feeds from various sources, stores them in a Supabase database, and sends notifications to a Telegram channel.

![RSS News API](https://kufgxlvheldohsqwdpxo.supabase.co/storage/v1/object/public/pub/Ekran%20Resmi%202024-09-24%2022.31.44.png)

## Getting Started

### Prerequisites

- Hono
- npm
- Cloudflare Workers
- Supabase account
- Telegram Bot

### Installation

1. Clone the repository:
    ```sh
    git clone https://github.com/yourusername/rss-news-api.git
    cd rss-news-api
    ```

2. Install the dependencies:
    ```sh
    npm install
    ```

### Configuration

1. Configure the `wrangler.toml` file for Cloudflare Workers:
    ```toml
    name = "rss-news-api"
    type = "javascript"

    [env]
    SUPABASE_URL = "https://your-supabase-url.supabase.co"
    SUPABASE_KEY = "your-supabase-key"
    TELEGRAM_BOT_URL = "https://api.telegram.org/bot<your-bot-token>/sendMessage"
    CHAT_ID = "-100232xxxxxx"

    [[triggers.crons]]
    schedule = "*/1 * * * *" # Runs every minute
    ```

### Running the Project

1. Start the development server:
    ```sh
    wrangler dev
    ```

2. Deploy to Cloudflare Workers:
    ```sh
    wrangler publish
    ```

### Usage

The API provides the following endpoints:

- `GET /`: Returns a welcome message.
- `GET /news`: Fetches news from the database.
- `GET /health`: Checks the health of the Supabase connection.
- `GET /check-feeds`: Manually triggers the RSS feed check and notification process.

### Project Structure

- `src/index.ts`: Main entry point for the Cloudflare Worker.
- `src/services/rssService.ts`: Contains the logic for fetching RSS feeds and sending notifications.
- `src/db/supabase.ts`: Contains the logic for interacting with the Supabase database.
- `wrangler.toml`: Configuration file for Cloudflare Workers.

### Contributing

1. Fork the repository.
2. Create a new branch (`git checkout -b feature-branch`).
3. Make your changes.
4. Commit your changes (`git commit -m 'Add some feature'`).
5. Push to the branch (`git push origin feature-branch`).
6. Open a pull request.

### License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

### Acknowledgements

- [Hono](https://hono.dev/) - A small, simple, and fast web framework for Cloudflare Workers.
- [Supabase](https://supabase.io/) - An open-source Firebase alternative.
- [Telegram Bot API](https://core.telegram.org/bots/api) - The Bot API is an HTTP-based interface created for developers keen on building bots for Telegram.


This project is an RSS News API that fetches RSS feeds from various sources, stores them in a Supabase database, and sends notifications to a Telegram channel.

RSS Telegram Notifier

# Shortender

Shortender is a Nuxt.js project designed to provide URL shortening services. This README provides an overview of the project structure, installation instructions, and usage guidelines.
![Görsel Açıklaması](https://ktiuprnnoyajjicmyysg.supabase.co/storage/v1/object/sign/image/Ekran%20Resmi%202024-07-25%2016.59.23.png?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1cmwiOiJpbWFnZS9Fa3JhbiBSZXNtaSAyMDI0LTA3LTI1IDE2LjU5LjIzLnBuZyIsImlhdCI6MTcyMTkxNjk3MiwiZXhwIjo0NTYwMTU2OTcyfQ.CU0cRTTn2EgBCVYQMeWBEkRRsL8amCWaF0ekzPLIjAk&t=2024-07-25T14%3A16%3A12.968Z)

## Project Structure

The project consists of the following main directories and files:

- [`.gitignore`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2F.gitignore%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/.gitignore"): Git configuration to ignore specific files and directories.
- [`.npmrc`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2F.npmrc%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/.npmrc"): Configuration file for npm.
- [`nuxt.config.ts`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fnuxt.config.ts%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/nuxt.config.ts"): Nuxt.js configuration file.
- [`package-lock.json`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fpackage-lock.json%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/package-lock.json"): Auto-generated file that locks the versions of a project's dependencies.
- [`package.json`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fpackage.json%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/package.json"): Project metadata and dependencies.
- [`pnpm-lock.yaml`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fpnpm-lock.yaml%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/pnpm-lock.yaml"): Lockfile for pnpm dependencies.
- [`tailwind.config.js`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Ftailwind.config.js%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/tailwind.config.js"): Tailwind CSS configuration file.
- [`tsconfig.json`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Ftsconfig.json%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/tsconfig.json"): TypeScript configuration file.
- [`yarn.lock`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fyarn.lock%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/yarn.lock"): Lockfile for yarn dependencies.

### Directories

- [`.idea`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2F.idea%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/.idea"): Contains IDE-specific configurations.
- [`assets/css`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fassets%2Fcss%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/assets/css"): Contains the Tailwind CSS file.
- [`components`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fcomponents%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/components"): Contains Vue components such as `Header.vue`, `LinkItem.vue`, `Notification.vue`, and `NotificationManager.vue`.
- [`composables`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fcomposables%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/composables"): Contains custom hooks like `useExternalRedirect.ts` and `useNotification.ts`.
- [`layouts`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Flayouts%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/layouts"): Contains the default layout for the application.
- [`middleware`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fmiddleware%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/middleware"): Contains authentication middleware.
- [`pages`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fpages%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/pages"): Contains the different pages of the application, including dynamic routes.
- [`public`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Fpublic%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/public"): Contains static files like `favicon.ico`.
- [`types`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fgoktugceyhan%2FDesktop%2FShortender%2Ftypes%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/goktugceyhan/Desktop/Shortender/types"): Contains TypeScript definitions for Supabase.

## Installation

To set up the project locally, follow these steps:

1. Clone the repository:
   ```bash
   git clone <repository_url>
   ```

2. Navigate to the project directory:
   ```bash
   cd <repository_directory>
   ```

3. Install the dependencies:
   ```bash
   yarn install
   ```

4. Create a `.env` file in the root directory and fill in the necessary environment variables:
   ```plaintext
   APP_URL=localhost:3000
   SUPABASE_URL=<your_supabase_url>
   SUPABASE_KEY=<your_supabase_key>
   ```

5. Start the development server:
   ```bash
   yarn start
   ```

## Usage

Once the development server is running, you can access the application in your web browser at `http://localhost:3000`.

## Contributing

If you would like to contribute to this project, please follow these steps:

1. Fork the repository.
2. Create a new branch (`git checkout -b feature-branch`).
3. Make your changes.
4. Commit your changes (`git commit -m 'Add some feature'`).
5. Push to the branch (`git push origin feature-branch`).
6. Open a pull request.

## License

This project is licensed under the MIT License. See the `LICENSE` file for more details.


Nuxt + Tailwind + Supabase Link Shortener

Shortender is a Nuxt.js project designed to provide URL shortening services.



Shortender


# Device Detector

Device Detector is a utility class for identifying user browser, operating system, device type, and preferred language based on HTTP headers. 

## Features

- Detects user's browser from the User-Agent header.
- Identifies user's operating system from the User-Agent header.
- Determines user's device type from the User-Agent header.
- Retrieves user's preferred language from the Accept-Language header.

## Installation & Usage

You can install the package via Composer:

```bash
composer require goktugceyhan/device-detector
```

2. **Include the Class in Your Laravel Project:**

   ` use Goktugceyhan\DeviceDetector\Detector; `


### Get User Browser

```php
browser = Detector::getUserBrowser();
echo $browser; // Outputs the user's browser
```

### Get User Operating System

```php
$os = Detector::getUserOS();
echo $os; // Outputs the user's operating system
```

### Get User Device

```php
$device = Detector::getUserDevice();
echo $device; // Outputs the user's device type
```

### Get User Preferred Language

```php
$language = Detector::getUserLanguage();
echo $language; // Outputs the user's preferred language
```

### Get All User Information

```php
$userInfo = Detector::getUserInfo();
print_r($userInfo); // Outputs an associative array of user information
```

## Methods

### `getUserBrowser()`

Retrieves the user's browser based on the `User-Agent` header.

### `getUserOS()`

Retrieves the user's operating system based on the `User-Agent` header.

### `getUserDevice()`

Retrieves the user's device type based on the `User-Agent` header.

### `getUserLanguage()`

Retrieves the user's preferred language based on the `Accept-Language` header.

### `getUserInfo()`

Retrieves all user information (browser, OS, device, language) in an associative array.

## Contributing

1. Fork the repository.
2. Create a new branch: `git checkout -b feature/your-feature-name`.
3. Make your changes and commit them: `git commit -m 'Add some feature'`.
4. Push to the branch: `git push origin feature/your-feature-name`.
5. Open a pull request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


Device Detector is a utility class for identifying user browser, operating system, device type, and preferred language based on HTTP headers.

Device Detector



#  Tuya Rest API Service

This project utilizes RESTful APIs to control your devices on the Tuya IoT platform.

## Installation

1. **Install Dependencies:**

   ```bash
   npm install
   ```
2. **Set Environment Variables:**

Set the following environment variables to run the project:
```
CLIENT_ID: Client ID obtained from the Tuya platform.
CLIENT_SECRET: Client secret obtained from the Tuya platform.
DEVICE_ID: Identifiers of the Tuya devices you want to control (comma-separated list).
SWITCH_COMMAND: Command code used for switching in your Tuya devices.
```


## API USAGE

#### Switch the Tuya lamb on/off

```
  GET /power
```

| Parameter | Type    | Description              |
| :-------- | :------- | :------------------------- |
| `CLIENT_ID` | `string` | **REQUIRED** |
| `CLIENT_SECRET` | `string` | **REQUIRED** |
| `DEVICE_ID` | `string` | **REQUIRED** |


## Tuya IoT services

https://iot.tuya.com/


This project utilizes RESTful APIs to control your devices on the Tuya IoT platform.
Switch the Tuya lamb on/off


Tuya Rest API Service


# Audio to Text AI Tool

An artificial intelligence supported NodeJS application that allows the audio file to be displayed as pdf after converting it to text with the Whisper tool.

## Tools & Frameworks

- OpenAI Whisper
- AdonisJS
- Typescript


An artificial intelligence supported NodeJS application that allows the audio file to be displayed as pdf after converting it to text with the Whisper tool.

Note AI

# ExpressTS Boilerplate

This project is a basic template built using Express.js and TypeScript. It includes the following features:

- Usage of Express.js
- Development with TypeScript
- Modular route structures
- Example of a basic auth service
- MongoDB integration

## Getting Started

These instructions will help you run the project on your local machine.

1. Clone the repository:

```bash
git clone https://github.com/goktugcy/ExpressTS-Boilerplate.git
```

```bash
Navigate to the project folder: cd ExpressTS-Boilerplate
```

Install the required dependencies:

```bash
npm install
```

Start the project:

```bash
npm run dev
```

Open your browser and go to http://localhost:5002 to see the "Hello World" message.

## Routes and Authentication

This boilerplate provides a modular route structure and includes an example of basic authentication using middleware. Let's dive into the details:

### Route Structure

The route structure follows a modular pattern, which helps keep your code organized as your application grows. The `src/routes` directory contains individual route modules, each handling specific routes and their associated logic.

To define new routes or extend existing ones, you can create additional route modules in the `src/routes` directory and include them in the main `src/app.ts` file.

### Authentication

The example authentication system in this boilerplate demonstrates the basic flow of user registration, login, and protected routes using middleware.

1. **Registration**: The `/register` endpoint in `routes.ts` allows users to register by providing a username, email, and password. Passwords are hashed before being stored in the database.

2. **Login**: The `/login` endpoint in `routes.ts` handles user logins. It checks the provided credentials against the stored hashed password and issues a JSON Web Token (JWT) upon successful login.

3. **Protected Routes**: The boilerplate includes of a protected routes that requires authentication. The `authenticateMiddleware` middleware is applied to this route to ensure that only authenticated users can access it. If a user is not authenticated, they will receive a 401 Unauthorized response.

 


This project is a basic template built using Express.js and TypeScript , MongoDB. Modular route structures. 

Express Typescript Boilerplate Backend

I took part as lead backend developer in thecsociety project, which is a platform that brings together students and companies.

Göktuğ Ceyhan

Projects

Loading...