The favourites page is broken #6
Description
The favourites page is broken, it does not display the correct link to the saved page, and when we click on it, we get a 404 error.
my bookmark object in localStorage:
[
{
"id": "1988114304382697907",
"parent_id": null,
"date": "2025-11-11T05:19:22",
"username": "the_osps",
"content": "Send a phone call from AI agent, in an API call. https://t.co/ubbXZoicIi",
"github_repo": "https://github.com/microsoft/call-center-ai",
"github_card_image": "https://opengraph.githubassets.com/801aec0450/microsoft/call-center-ai",
"view_count": 801,
"markdown_content": "\n**Phone Calls as an API: Your Code Just Got a Voice**\n\nImagine your application detecting a critical event—a server outage, a fraudulent transaction, a delivery exception—and instead of just sending an email or a text, it can pick up the phone and explain the situation in a clear, natural voice to the person who needs to know. That's the kind of power we're starting to see with AI agents, and now you can essentially trigger one with a simple API call.\n\nThis isn't about robotic, pre-recorded messages. We're talking about dynamic, AI-driven conversations that can understand context and respond intelligently. It turns a one-way notification into a two-way dialogue, all managed from your code.\n\n### What It Does\n\nThe Call Center AI repository from Microsoft provides a framework for building voice-based AI agents. At its core, it enables you to initiate a real-time phone call where an AI agent can converse with a human. You provide the context and the goal, and the system handles the speech-to-text, the natural language processing to understand the user, the reasoning to formulate a response, and the text-to-speech to reply aloud.\n\nIt's like having a programmable, infinitely-scalable customer service rep or notification system that you can spin up with a `POST` request.\n\n### Why It's Cool\n\nThe \"wow\" factor here isn't just that it makes phone calls; it's *how* it does it. This isn't a simple, linear IVR (\"Press 1 for support\"). The agent is built to handle the fluid nature of human conversation.\n\n* **Dynamic and Context-Aware:** The agent can access external data. For example, if a user calls about an order, the agent can pull the latest shipping status from a database in real-time and relay that information naturally.\n* **Real-time Reasoning:** It doesn't just match keywords. It uses a language model to understand the intent behind what the caller is saying and can navigate complex questions or unexpected turns in the conversation.\n* **Developer-Friendly Architecture:** The project is structured in a way that's familiar to developers. You can plug in different components, like your preferred LLM (e.g., from OpenAI or Azure) or your own telephony provider, giving you flexibility and control.\n* **Practical Use Cases:** Think beyond customer service. This is perfect for proactive alerts (e.g., \"Hi, this is your monitoring system. Service X is down. Should I page the on-call engineer?\"), appointment reminders that can reschedule, or interactive surveys.\n\n### How to Try It\n\nThe best way to get a feel for this is to see the code. The repository is a blueprint, so you'll need to set up a few services to run it yourself.\n\n1. **Head over to the GitHub repo:** [microsoft/call-center-ai](https://github.com/microsoft/call-center-ai)\n2. The `README` is your starting point. It outlines the architecture and the prerequisites you'll need, which typically include:\n * An Azure subscription (for services like Speech Services)\n * An LLM endpoint (like Azure OpenAI or OpenAI API)\n * A telephony provider (like Azure Communication Services) to handle the actual phone calls.\n3. Follow the setup instructions in the `/docs` folder to get the sample agent deployed and connected. It will walk you through configuring your environment variables and deploying the services.\n\nWhile there isn't a one-click demo, the repository provides a solid foundation to build and test your own AI-powered calling agent.\n\n### Final Thoughts\n\nThis project opens up a new category of application interaction. As developers, we're used to building for screens—clicks, taps, and scrolls. Tools like this let us build for ears and voices, which is a far more natural and accessible interface for many situations.\n\nThe barrier to creating sophisticated voice AI is getting lower. With this as a starting point, you could prototype a proactive notification system or an interactive helpline in a weekend. It’s a powerful step towards making our applications not just smarter, but also more human in how they communicate.\n\n---\n\n@githubprojects"
},
{
"id": "1987893480438595979",
"parent_id": null,
"date": "2025-11-10T14:41:53",
"username": "the_osps",
"content": "A terminal-based dashboard for managing cron jobs locally and on servers. https://t.co/NoYNUW6r8c",
"github_repo": "https://github.com/antoniorodr/cronboard",
"github_card_image": "https://opengraph.githubassets.com/5427a0e279/antoniorodr/cronboard",
"view_count": 706,
"markdown_content": "\n# Cronboard: A Terminal Dashboard for Your Cron Jobs\n\nIf you've ever managed cron jobs, you know the pain: editing crontab files in a terminal text editor, trying to remember the exact syntax, and debugging why your job didn't run. It's one of those necessary but clunky parts of system administration and development workflows.\n\nWhat if you could visualize and manage all your scheduled tasks in one clean, terminal-based interface? That's exactly what Cronboard delivers - a dashboard for your cron jobs that works both locally and on remote servers.\n\n## What It Does\n\nCronboard is a terminal application that scans your system's cron jobs and displays them in an organized, interactive dashboard. Instead of digging through crontab files, you get a clear overview of all scheduled tasks, their schedules, and their status. It's like having a GUI for cron, but right in your terminal where you already work.\n\n## Why It's Cool\n\nThe beauty of Cronboard is how it tackles a common problem with an elegant, developer-friendly solution. Instead of memorizing cron syntax or juggling multiple crontab files, you get immediate visibility into what's scheduled and when. The interface shows you exactly when each job will run next, making it much easier to debug timing issues or conflicts.\n\nIt works seamlessly across environments too - whether you're managing local development crontabs or connecting to remote servers. The terminal-based approach means no heavy GUI dependencies, and it fits naturally into existing DevOps workflows. For teams managing complex scheduled tasks across multiple servers, this could be a game-changer for maintenance and onboarding.\n\n## How to Try It\n\nGetting started with Cronboard is straightforward:\n\n```bash\n# Clone the repository\ngit clone https://github.com/antoniorodr/cronboard.git\n\n# Navigate to the project directory\ncd cronboard\n\n# Install dependencies (assuming it's a Node.js project)\nnpm install\n\n# Run the dashboard\nnpm start\n```\n\nThe project README has detailed installation and usage instructions for different environments. Since it's terminal-based, you'll be up and running in minutes without complex setup procedures.\n\n## Final Thoughts\n\nCronboard feels like one of those tools that makes you wonder why nobody built it sooner. It doesn't try to reinvent cron - instead, it makes the existing tool more accessible and manageable. For developers who regularly work with scheduled tasks, whether for data processing, cleanup jobs, or regular maintenance scripts, this could significantly reduce the cognitive overhead of cron management.\n\nIt's particularly useful when you're inheriting a server with existing cron jobs and need to quickly understand what's running and when. The visual timeline alone makes it worth trying out.\n\nCheck out the project on GitHub and see how it might simplify your cron workflow.\n\n[@githubprojects](https://twitter.com/githubprojects)"
},
{
"id": "1990433664698564705",
"parent_id": null,
"date": "2025-11-17T14:55:40",
"username": "the_osps",
"content": "WhatsApp REST API with support for UI, Webhooks, and MCP https://t.co/5Bfhqs9Z1N",
"github_repo": "https://github.com/aldinokemal/go-whatsapp-web-multidevice",
"github_card_image": "https://opengraph.githubassets.com/42bcd647ab/aldinokemal/go-whatsapp-web-multidevice",
"view_count": 3899,
"markdown_content": "\n**Build a WhatsApp REST API with UI, Webhooks, and MCP Support**\n\nEver wanted to integrate WhatsApp messaging into your application without dealing with the official, often restrictive, Business API? Maybe you need to automate messages, sync notifications, or build a custom dashboard for customer support. The official routes can be complex, but there's a clever open-source project that gives you direct control.\n\nThis project, `go-whatsapp-web-multidevice`, creates a bridge between your code and WhatsApp Web. It wraps the multi-device capability into a clean REST API, complete with a built-in UI, webhooks for real-time events, and even MCP (Message Content Platform) support. It's essentially a self-hosted WhatsApp gateway.\n\n**What It Does**\n\nIn short, this tool runs a local server that acts as a client for WhatsApp Web. Once you authenticate by scanning a QR code, the server exposes a set of RESTful endpoints. You can use these endpoints to send messages, manage chats, and receive incoming messages via configurable webhooks. The built-in web UI lets you interact with your WhatsApp account directly from your browser, while the API handles the programmatic heavy lifting.\n\n**Why It's Cool**\n\nThe real power here lies in its flexibility and feature set. Instead of just a basic sender, you get a suite of tools that cover most integration needs.\n\n* **REST API:** The core feature. Send messages, media, and manage contacts with simple HTTP requests, making it accessible from any programming language.\n* **Built-in UI:** You're not working blind. The project includes a clean interface to view your chats and send messages manually, which is great for testing and light use.\n* **Webhook Support:** This is a game-changer for automation. Instead of constantly polling the API, you can set up a webhook URL to receive instant notifications for incoming messages and other events.\n* **MCP Integration:** The inclusion of Message Content Platform support opens up advanced possibilities for message parsing, filtering, and routing, which is fantastic for building sophisticated chat bots or moderation tools.\n\n**How to Try It**\n\nGetting started is straightforward. You'll need Go installed on your machine.\n\n1. Clone the repository and navigate into the directory:\n ```bash\n git clone https://github.com/aldinokemal/go-whatsapp-web-multidevice\n cd go-whatsapp-web-multidevice\n ```\n2. Install the dependencies and run the server:\n ```bash\n go mod tidy\n go run main.go\n ```\n3. Open your browser to `http://localhost:9000`. You'll see a QR code.\n4. Scan the QR code with your WhatsApp mobile app (Linked Devices > Link a Device).\n5. That's it. You're now connected. You can start using the web UI at `http://localhost:9000` or hit the REST API endpoints directly (check the project's README for the full list).\n\n**Final Thoughts**\n\nThis project is a solid tool for developers who need a programmable interface to WhatsApp for prototyping, personal projects, or internal tools. It elegantly sidesteps the need for official approval and provides all the essential building blocks in one place. Just remember, as it interacts with WhatsApp Web, you should be mindful of rate limits and use it responsibly to avoid any issues with your account. If you've been looking for a way to hook your apps into WhatsApp, this is a fantastic place to start.\n\n---\n\n*Found this project interesting? Follow us at [@githubprojects](https://twitter.com/githubprojects) for more cool developer tools and repos.*"
},
{
"id": "1992586293180825624",
"parent_id": null,
"date": "2025-11-23T13:29:27",
"username": "the_osps",
"content": "Lightning-fast, on-device TTS — running natively via ONNX. https://t.co/FR4KpKn7Pg",
"github_repo": "https://github.com/supertone-inc/supertonic",
"github_card_image": "https://opengraph.githubassets.com/0c632f3bd5/supertone-inc/supertonic",
"view_count": 1266,
"markdown_content": "\n# Supertonic: Lightning-Fast, On-Device Text-to-Speech\n\nRemember when high-quality text-to-speech meant calling out to cloud APIs and dealing with latency, network issues, and privacy concerns? What if you could run TTS locally with performance that rivals cloud services? That's exactly what Supertonic delivers.\n\nThis open-source project brings production-ready text-to-speech directly to your device, leveraging ONNX Runtime for native performance. No internet connection required, no data leaving your device—just fast, reliable speech synthesis wherever your code runs.\n\n## What It Does\n\nSupertonic is an on-device text-to-speech engine that runs completely locally using ONNX Runtime. It takes text input and generates high-quality speech audio without needing to connect to external services. The project provides both the core inference engine and ready-to-use voice models, making it easy to integrate TTS capabilities into various applications.\n\nThe system supports multiple languages and voices out of the box, with audio quality that stands up against cloud-based alternatives. Everything runs native on your hardware—whether that's a desktop, mobile device, or edge computing platform.\n\n## Why It's Cool\n\nThe magic here isn't just that it runs locally—it's how well it runs locally. By building on ONNX, Supertonic achieves near-instant inference times that feel responsive even for interactive applications. The team has optimized the models to balance quality with performance, so you get natural-sounding speech without the computational overhead that typically makes on-device TTS impractical.\n\nPrivacy becomes a non-issue since audio never leaves the user's device. This opens up TTS for sensitive applications like medical apps, confidential document reading, or any scenario where data sovereignty matters. Plus, you eliminate the latency of round-trips to cloud services, making it perfect for real-time applications.\n\nDevelopers will appreciate that it's not just another research project—it's built with production use in mind. The clean API, comprehensive documentation, and pre-trained models mean you can actually use this in real applications today.\n\n## How to Try It\n\nGetting started is straightforward. Clone the repository and check out the examples:\n\n```bash\ngit clone https://github.com/supertone-inc/supertonic\ncd supertonic\n```\n\nThe project includes sample code showing how to initialize the engine and generate speech. You'll need Python and the required dependencies (check the repo's requirements.txt), then you can start synthesizing text immediately with the provided models.\n\nFor a quick test, run the basic example to hear the quality for yourself. The repository includes everything you need—no external accounts or API keys required.\n\n## Final Thoughts\n\nSupertonic feels like one of those projects that could quietly change how we think about TTS in applications. While cloud TTS services will still have their place, having a high-quality local alternative opens up new possibilities. I can see this being particularly useful for embedded systems, privacy-focused apps, or any project where reliability can't depend on network connectivity.\n\nThe fact that it's open source means we can all benefit from and contribute to making on-device TTS even better. This is the kind of practical tool that solves real problems without overcomplicating things—exactly what developers need.\n\n---\n*Follow for more cool projects: @githubprojects*"
},
{
"id": "1988822692565512353",
"parent_id": null,
"date": "2025-11-13T04:14:15",
"username": "the_osps",
"content": "A next-generation HTTP stealth proxy which perfectly cloaks requests as the Chrome browser https://t.co/e4CNa7efZC",
"github_repo": "https://github.com/mandatoryprogrammer/thermoptic",
"github_card_image": "https://opengraph.githubassets.com/7b259f535b/mandatoryprogrammer/thermoptic",
"view_count": 2641,
"markdown_content": "\n**Title: Thermoptic: The HTTP Proxy That Mimics Chrome Perfectly**\n\n**Intro**\n\nEver needed to make HTTP requests that blend in completely with regular web traffic? Most proxies and scraping tools have a tell – some header is slightly off, the TLS fingerprint is wrong, or the request pattern just doesn't look human. That's where Thermoptic comes in.\n\nIt's a next-generation stealth proxy built in Rust that makes your traffic look exactly like it's coming from a real Chrome browser. For developers working on web scraping, automation, or security testing, this is a tool that aims to solve the fingerprinting problem head-on.\n\n**What It Does**\n\nThermoptic is an HTTP proxy that sits between your client and the internet. You send your requests to it, and it rewrites them on the fly. But it doesn't just change a user-agent string. It performs a deep transformation of your entire HTTP request, from the headers down to the low-level network characteristics, to perfectly mimic a request from a specific, real version of Google Chrome.\n\n**Why It's Cool**\n\nThe magic of Thermoptic isn't just in swapping headers. Plenty of tools do that. Its cleverness lies in the depth of its mimicry.\n\n* **Comprehensive Header Management:** It doesn't just add a Chrome user-agent. It strips your client's original headers and injects a complete, accurate set of headers that a real instance of Chrome for that version would send. This includes the correct `sec-ch-ua` and other client hint headers.\n* **TLS Fingerprint Cloaking:** This is a big one. Many advanced systems perform TLS fingerprinting to identify clients. Thermoptic ensures its TLS handshake is identical to Chrome's, making it much harder to detect at the protocol level.\n* **HTTP/2 and ALPN Simulation:** It can advertise the same Application-Layer Protocol Negotiation (ALPN) IDs as Chrome, ensuring the negotiation to HTTP/2 looks authentic.\n* **It's a Proxy, Not a Library:** You don't have to rewrite your application. You can point any existing tool—like `curl`, a script, or a full-blown app—at the Thermoptic proxy and it instantly benefits from the cloaking.\n\n**How to Try It**\n\nGetting started is straightforward, especially if you have Rust's toolchain installed.\n\n1. Clone the repository:\n ```bash\n git clone https://github.com/mandatoryprogrammer/thermoptic\n cd thermoptic\n ```\n2. Run the proxy (defaults to port 8080):\n ```bash\n cargo run\n ```\n3. Configure your application to use `http://127.0.0.1:8080` as its HTTP proxy. For a quick test with `curl`:\n ```bash\n curl -x http://127.0.0.1:8080 --proxy-insecure http://httpbin.org/headers\n ```\n\nCheck the response from `httpbin.org/headers`. You'll see that the request appears to come from Chrome, not `curl`.\n\n**Final Thoughts**\n\nThermoptic feels like a specialized tool for a specific but important niche. If you're tired of getting blocked by sophisticated anti-bot systems during legitimate scraping or security research, this is absolutely worth a look. It tackles the problem of detection at a deeper level than most utilities. It's not a magic bullet, but it raises the bar significantly for anyone trying to tell your automated traffic apart from a real user browsing with Chrome.\n\n---\n\n*Follow us for more interesting projects: @githubprojects*"
}
]
