lingling 2.0.0__tar.gz

lingling-2.0.0/LICENSE

@@ -0,0 +1,24 @@
+Lingling License
+
+Copyright (c) 2026 huranth
+
+You are free to use and run this software, in whole or in part, for any
+purpose, at no cost.
+
+You may NOT:
+  - sell this software, or offer it (modified or not) as a paid product or
+    paid service;
+  - distribute modified versions of this software, or publish derivative
+    works based on it.
+
+The above copyright notice and this permission notice shall be included in
+all copies of the software.
+
+All rights not expressly granted above are reserved by the copyright holder.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

lingling-2.0.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: lingling
+Version: 2.0.0
+Summary: Official OpenCode, but your requests ride rotating Tor exit lanes.
+Author: huranth
+License: LicenseRef-Lingling
+Project-URL: Homepage, https://github.com/huranth/lingling
+Project-URL: Repository, https://github.com/huranth/lingling
+Project-URL: Issues, https://github.com/huranth/lingling/issues
+Keywords: opencode,tor,proxy,llm,rate-limit
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: Proxy Servers
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: stem==1.8.2
+Requires-Dist: cryptography>=41
+Dynamic: license-file
+
+# Lingling
+
+### What even is this?
+
+OpenCode gives away genuinely good models for free. The catch: they throttle
+you by IP, so right when the conversation gets good — bam, wall. Very rude.
+
+Lingling fixes this the fun way. It spins up a little kitchen of Tor exit
+lanes on your machine, each one a different country, and puts your requests
+on whichever lane is hot. One exit gets throttled? Cute. Your traffic is
+already on another one. You never see the limit. You just keep typing.
+
+```
+pip install lingling
+lingling               # = opencode, but the requests ride Tor
+lingling --help        # anything after `lingling` goes to opencode untouched
+```
+
+First run downloads the Tor Expert Bundle (~30 MB) into Lingling's per-user
+data directory (`%LOCALAPPDATA%\lingling` on Windows, `~/.local/share/lingling`
+on Linux, `~/Library/Application Support/lingling` on macOS; override with
+`LINGLING_DATA_DIR`). After that, launching looks like this — a few seconds
+of kitchen noises while the first lane cooks, then opencode opens:
+
+```
+ ⠋ glazing the tunnel
+ served! lanes are hot -- proof is in the other window.
+```
+
+### "Sure, but how do I know it's not lying?"
+
+Fair. That's what the proof window is for. A second console pops up next to
+your editor and shows every single model call, live: which lane it rode,
+which country, which exit IP, what came back, how big, how fast.
+
+```
+13:52:55  #3.1  lane 2 {de} 185.220.100.243  ->  muse-spark-1.2-contributor-free
+13:53:00    | #3.1 200 81.4 KB in 2.7s
+13:53:01  #4.1  lane 3 {nl} 192.42.116.113  ->  muse-spark-1.2-contributor-free
+13:53:03    | #4.1 200 79.6 KB in 2.6s
+13:53:07  * lane 4 hit a hidden limit -- your traffic moved to a fresh lane
+```
+
+No gaslighting. If the pane says bytes are flowing through a German exit,
+your tokens are flowing through a German exit. `--no-proof` if you trust us.
+(You shouldn't trust anyone. That's the point of the window.)
+
+### How a limit dies without you noticing
+
+A Tor tunnel is end-to-end TLS, so a 429 can't be spotted in flight — instead,
+every 45 seconds each lane fires a real probe at the upstream and rats itself
+out. The moment a lane comes back throttled:
+
+1. it's yanked from rotation **before** your next request would have touched
+   it — your traffic just... continues, elsewhere;
+2. the throttled lane is taken out back and re-cooked from scratch: fresh
+   tor process, fresh keys, fresh guards, fresh exit IP. We don't negotiate
+   with rate limits;
+3. if the same lane keeps getting burned, it gets a new country too
+   (`us → de → nl → fr → ro → …`). A new personality, basically.
+
+Lanes that just fall over get poked, restarted, re-cooked, and — if they're
+truly hopeless — benched with a note in the proof window. You'll see the whole
+drama live, which is honestly half the fun.
+
+### "Wait, how can it see each request? Isn't TLS encrypted?"
+
+Very observant. opencode holds one TLS connection open for your whole
+session, so a normal proxy sees one opaque pipe, not individual calls. So
+Lingling does a magic trick: it mints a throwaway certificate authority **on
+your own machine**, hands it to opencode (and only opencode), and unwraps
+`opencode.ai` traffic just long enough to read the model name off each
+request before re-encrypting it through a lane to the real server.
+
+Everything stays end-to-end TLS over Tor. The only new thing that can see
+your traffic is... your own computer, which could already see your traffic.
+`LINGLING_NO_MITM=1` turns the trick off if it makes you itchy (you'll get
+per-tunnel proof instead of per-request).
+
+### Fresh every time
+
+Every launch wipes lane keys, guards, and circuit state — yesterday's exits
+are dead to us. The only thing kept is tor's cached copy of the public relay
+directory, because re-downloading that every launch is how you turn a
+five-second boot into a two-minute boot. Orphaned `tor.exe` processes from a
+crashed run are swept up before new lanes take their ports.
+
+### Flags Lingling keeps for itself
+
+| Flag | What it does |
+|---|---|
+| `--lanes N` | how many lanes to keep warm (default 5, env `LINGLING_TOR_COUNT`) |
+| `--no-tor` | skip the lanes, run opencode on your own IP like a civilian |
+| `--no-proof` | no proof window (coward's mode) |
+| `--demo [question]` | fire one real Muse Spark request through a lane, show receipts |
+
+Everything else is handed to opencode byte-for-byte. We don't touch it,
+we don't parse it, we don't want to know.
+
+### Under the hood
+
+```
+lingling/cli.py      entry point, loader, opencode launch
+lingling/lanes.py    Tor lane lifecycle: boot, regenerate, country rotation
+lingling/relay.py    local CONNECT relay, least-busy lane picking, MITM handoff
+lingling/mitm.py     local CA + per-request interception for opencode.ai
+lingling/health.py   probe daemon: burns, deaths, dramatic recoveries
+lingling/proof.py    the proof window (event log + live tail)
+lingling/netutil.py  raw SOCKS5 / HTTPS-over-SOCKS primitives
+lingling/demo.py     lingling --demo
+lingling/winjob.py   Windows Job Object so tor.exe dies with us
+```
+
+Runtime state (tor, lanes, proof log, local CA) lives in the per-user data
+directory — never in the package, never in your project folder.
+
+Requirements: Python 3.11+, Windows/macOS/Linux, and `opencode` on your PATH.
+Runs entirely on your machine. Nothing calls home. The kitchen is local.

lingling-2.0.0/README.md

@@ -0,0 +1,118 @@
+# Lingling
+
+### What even is this?
+
+OpenCode gives away genuinely good models for free. The catch: they throttle
+you by IP, so right when the conversation gets good — bam, wall. Very rude.
+
+Lingling fixes this the fun way. It spins up a little kitchen of Tor exit
+lanes on your machine, each one a different country, and puts your requests
+on whichever lane is hot. One exit gets throttled? Cute. Your traffic is
+already on another one. You never see the limit. You just keep typing.
+
+```
+pip install lingling
+lingling               # = opencode, but the requests ride Tor
+lingling --help        # anything after `lingling` goes to opencode untouched
+```
+
+First run downloads the Tor Expert Bundle (~30 MB) into Lingling's per-user
+data directory (`%LOCALAPPDATA%\lingling` on Windows, `~/.local/share/lingling`
+on Linux, `~/Library/Application Support/lingling` on macOS; override with
+`LINGLING_DATA_DIR`). After that, launching looks like this — a few seconds
+of kitchen noises while the first lane cooks, then opencode opens:
+
+```
+ ⠋ glazing the tunnel
+ served! lanes are hot -- proof is in the other window.
+```
+
+### "Sure, but how do I know it's not lying?"
+
+Fair. That's what the proof window is for. A second console pops up next to
+your editor and shows every single model call, live: which lane it rode,
+which country, which exit IP, what came back, how big, how fast.
+
+```
+13:52:55  #3.1  lane 2 {de} 185.220.100.243  ->  muse-spark-1.2-contributor-free
+13:53:00    | #3.1 200 81.4 KB in 2.7s
+13:53:01  #4.1  lane 3 {nl} 192.42.116.113  ->  muse-spark-1.2-contributor-free
+13:53:03    | #4.1 200 79.6 KB in 2.6s
+13:53:07  * lane 4 hit a hidden limit -- your traffic moved to a fresh lane
+```
+
+No gaslighting. If the pane says bytes are flowing through a German exit,
+your tokens are flowing through a German exit. `--no-proof` if you trust us.
+(You shouldn't trust anyone. That's the point of the window.)
+
+### How a limit dies without you noticing
+
+A Tor tunnel is end-to-end TLS, so a 429 can't be spotted in flight — instead,
+every 45 seconds each lane fires a real probe at the upstream and rats itself
+out. The moment a lane comes back throttled:
+
+1. it's yanked from rotation **before** your next request would have touched
+   it — your traffic just... continues, elsewhere;
+2. the throttled lane is taken out back and re-cooked from scratch: fresh
+   tor process, fresh keys, fresh guards, fresh exit IP. We don't negotiate
+   with rate limits;
+3. if the same lane keeps getting burned, it gets a new country too
+   (`us → de → nl → fr → ro → …`). A new personality, basically.
+
+Lanes that just fall over get poked, restarted, re-cooked, and — if they're
+truly hopeless — benched with a note in the proof window. You'll see the whole
+drama live, which is honestly half the fun.
+
+### "Wait, how can it see each request? Isn't TLS encrypted?"
+
+Very observant. opencode holds one TLS connection open for your whole
+session, so a normal proxy sees one opaque pipe, not individual calls. So
+Lingling does a magic trick: it mints a throwaway certificate authority **on
+your own machine**, hands it to opencode (and only opencode), and unwraps
+`opencode.ai` traffic just long enough to read the model name off each
+request before re-encrypting it through a lane to the real server.
+
+Everything stays end-to-end TLS over Tor. The only new thing that can see
+your traffic is... your own computer, which could already see your traffic.
+`LINGLING_NO_MITM=1` turns the trick off if it makes you itchy (you'll get
+per-tunnel proof instead of per-request).
+
+### Fresh every time
+
+Every launch wipes lane keys, guards, and circuit state — yesterday's exits
+are dead to us. The only thing kept is tor's cached copy of the public relay
+directory, because re-downloading that every launch is how you turn a
+five-second boot into a two-minute boot. Orphaned `tor.exe` processes from a
+crashed run are swept up before new lanes take their ports.
+
+### Flags Lingling keeps for itself
+
+| Flag | What it does |
+|---|---|
+| `--lanes N` | how many lanes to keep warm (default 5, env `LINGLING_TOR_COUNT`) |
+| `--no-tor` | skip the lanes, run opencode on your own IP like a civilian |
+| `--no-proof` | no proof window (coward's mode) |
+| `--demo [question]` | fire one real Muse Spark request through a lane, show receipts |
+
+Everything else is handed to opencode byte-for-byte. We don't touch it,
+we don't parse it, we don't want to know.
+
+### Under the hood
+
+```
+lingling/cli.py      entry point, loader, opencode launch
+lingling/lanes.py    Tor lane lifecycle: boot, regenerate, country rotation
+lingling/relay.py    local CONNECT relay, least-busy lane picking, MITM handoff
+lingling/mitm.py     local CA + per-request interception for opencode.ai
+lingling/health.py   probe daemon: burns, deaths, dramatic recoveries
+lingling/proof.py    the proof window (event log + live tail)
+lingling/netutil.py  raw SOCKS5 / HTTPS-over-SOCKS primitives
+lingling/demo.py     lingling --demo
+lingling/winjob.py   Windows Job Object so tor.exe dies with us
+```
+
+Runtime state (tor, lanes, proof log, local CA) lives in the per-user data
+directory — never in the package, never in your project folder.
+
+Requirements: Python 3.11+, Windows/macOS/Linux, and `opencode` on your PATH.
+Runs entirely on your machine. Nothing calls home. The kitchen is local.

lingling-2.0.0/lingling/__init__.py

@@ -0,0 +1,21 @@
+"""Lingling -- official OpenCode, but your requests ride rotating Tor lanes."""
+
+import os
+import sys
+from pathlib import Path
+
+__version__ = "2.0.0"
+
+
+def data_dir() -> Path:
+    """Per-user runtime state (tor, lanes, proof log). Lives outside the
+    package -- a pip install must never write into site-packages."""
+    override = os.environ.get("LINGLING_DATA_DIR")
+    if override:
+        return Path(override)
+    if sys.platform == "win32":
+        base = os.environ.get("LOCALAPPDATA") or str(Path.home() / "AppData" / "Local")
+        return Path(base) / "lingling"
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / "lingling"
+    return Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share")) / "lingling"

lingling-2.0.0/lingling/__main__.py

@@ -0,0 +1,4 @@
+from .cli import entry
+
+if __name__ == "__main__":
+    entry()

lingling-2.0.0/lingling/cli.py

@@ -0,0 +1,277 @@
+"""lingling -- official OpenCode, riding rotating Tor lanes.
+
+CLI entrypoint: boots Tor lanes, starts the local relay, then execs opencode
+with HTTPS_PROXY pointed at it; all other args pass through untouched.
+"""
+
+from __future__ import annotations
+
+import itertools
+import os
+import shutil
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+
+from . import __version__, data_dir, proof
+from .health import HealthDaemon
+from .lanes import TorManager
+from .relay import Relay
+
+DATA_DIR = data_dir()
+PROOF_LOG = DATA_DIR / "proof.log"
+
+DEFAULT_COUNTRIES = ["us", "de", "nl", "fr", "ro", "gb", "ca", "se", "pl", "ch"]
+
+_KITCHEN_LINES = [
+    "cooking the lanes", "baking it", "warming the exits",
+    "glazing the tunnel", "seasoning the circuits", "proofing the dough",
+    "preheating the relays", "tasting the traffic",
+]
+
+_SPIN = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+_PHRASE_COLORS = ["38;5;215", "38;5;222", "38;5;180", "38;5;173",
+                  "38;5;114", "38;5;109", "38;5;139", "38;5;175"]
+
+
+def _c(text: str, code: str) -> str:
+    if os.environ.get("NO_COLOR") or not sys.stdout.isatty():
+        return text
+    return f"\x1b[{code}m{text}\x1b[0m"
+
+
+class _Loader:
+    """Self-rewriting status line; deliberately vibe-only, no lane counts or progress bar."""
+
+    def __init__(self) -> None:
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def set(self, detail: str = "") -> None:
+        # Kept for API compatibility; details are intentionally not shown.
+        pass
+
+    def start(self) -> None:
+        if not sys.stdout.isatty():
+            return
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def _run(self) -> None:
+        tick = itertools.count()
+        while not self._stop.is_set():
+            t = next(tick)
+            spin = _c(_SPIN[t % len(_SPIN)], "1;38;5;220")
+            idx = (t // 24) % len(_KITCHEN_LINES)
+            msg = _c(_KITCHEN_LINES[idx], _PHRASE_COLORS[idx])
+            sys.stdout.write(f"\r\x1b[K {spin} {msg}")
+            sys.stdout.flush()
+            time.sleep(0.09)
+
+    def stop(self, final: str = "") -> None:
+        self._stop.set()
+        if self._thread:
+            self._thread.join(timeout=2)
+            self._thread = None
+        if sys.stdout.isatty():
+            sys.stdout.write("\r\x1b[K")
+            if final:
+                sys.stdout.write(final + "\n")
+            sys.stdout.flush()
+
+
+def _parse_args(argv: list[str]) -> dict:
+    """Split lingling's own flags from args passed through to opencode."""
+    opts = {
+        "lanes": int(os.environ.get("LINGLING_TOR_COUNT", "5") or 5),
+        "no_tor": False,
+        "no_proof": False,
+        "proof_tail": None,
+        "demo": False,
+        "passthrough": [],
+    }
+    skip = False
+    for i, a in enumerate(argv):
+        if skip:
+            skip = False
+            continue
+        if a == "--proof":
+            opts["proof_tail"] = argv[i + 1] if i + 1 < len(argv) else ""
+            skip = True
+        elif a == "--demo":
+            opts["demo"] = True
+        elif a == "--lanes":
+            try:
+                opts["lanes"] = max(1, int(argv[i + 1]))
+                opts["lanes_explicit"] = True
+            except (IndexError, ValueError):
+                pass
+            skip = True
+        elif a == "--no-tor":
+            opts["no_tor"] = True
+        elif a == "--no-proof":
+            opts["no_proof"] = True
+        else:
+            opts["passthrough"].append(a)
+    return opts
+
+
+def main(argv: list[str]) -> int:
+    opts = _parse_args(argv)
+
+    if opts["proof_tail"] is not None:
+        return proof.tail(Path(opts["proof_tail"] or str(PROOF_LOG)))
+
+    if opts["demo"]:
+        from .demo import run_demo
+        question = " ".join(opts["passthrough"]).strip() or (
+            "In one sentence: who are you, and what exit node do you think "
+            "this request came from?")
+        lanes = opts["lanes"] if opts.get("lanes_explicit") else 2
+        return run_demo(question, lanes=lanes)
+
+    if "--version" in opts["passthrough"] or "-v" in opts["passthrough"]:
+        print(f"lingling {__version__} (wraps opencode)")
+        return 0
+
+    opencode = shutil.which("opencode")
+    if opencode is None:
+        print("lingling: couldn't find `opencode` on your PATH.")
+        print("Install it first (https://opencode.ai) and re-run.")
+        return 1
+
+    loader = _Loader()
+    loader.start()
+    manager: TorManager | None = None
+    daemon: HealthDaemon | None = None
+    relay: Relay | None = None
+    direct = opts["no_tor"]
+
+    try:
+        if not direct:
+            manager = TorManager(
+                DATA_DIR, count=opts["lanes"],
+                exit_countries=DEFAULT_COUNTRIES,
+                tor_exe=os.environ.get("LINGLING_TOR_EXE", ""),
+                log=lambda *a: None,
+            )
+            loader.set()
+            err = manager.setup_lanes()
+            if err:
+                loader.stop(_c(f" !! tor unavailable ({err}) -- going direct",
+                               "33"))
+                direct = True
+            else:
+                emit = proof.make_emitter(PROOF_LOG)
+                daemon = HealthDaemon(manager, event=emit,
+                                      log=lambda *a: None)
+
+                # Boot order: only lane 1 cooks in the foreground; the rest follow in background.
+                first = manager.lanes[0]
+                manager.start_lanes([first])
+
+                # Block until lane 1 provably carries traffic, else the user's first prompt dies.
+                deadline = time.time() + 150
+                while time.time() < deadline:
+                    verdict = daemon.probe_lane(first)
+                    if verdict == "healthy":
+                        first.healthy = True
+                        first.unhealthy_cycles = 0
+                        break
+                    if verdict == "burned":
+                        first.burned_cycles += 1
+                        daemon._heal_burn(first)
+                    time.sleep(2)
+                if first.healthy is not True:
+                    loader.stop(_c(" !! the kitchen stayed cold -- "
+                                   "going direct", "31"))
+                    direct = True
+                    manager.stop_all()
+                daemon.start()
+
+        if direct:
+            loader.stop()
+            print(_c("lingling: no lanes -- opencode rides your own IP.\n",
+                     "33"))
+            return _run_opencode(opencode, opts["passthrough"], None)
+
+        emit = proof.make_emitter(PROOF_LOG)
+        relay = Relay(manager, event=emit)
+        port = relay.start()
+
+        # Per-request proof via local TLS termination; best-effort, falls back to blind tunnels.
+        ca_pem = None
+        if os.environ.get("LINGLING_NO_MITM", "").lower() not in ("1", "true"):
+            try:
+                from . import mitm
+                relay.cert_shop = mitm.CertShop(DATA_DIR / "mitm")
+                ca_pem = relay.cert_shop.ca_pem_path
+            except Exception:  # noqa: BLE001
+                pass
+
+        loader.stop(_c(" served! lanes are hot -- proof is in the other "
+                       "window.", "1;32"))
+        if not opts["no_proof"]:
+            proof.spawn_proof_window(PROOF_LOG)
+
+        # Remaining lanes bootstrap in background; health probes join them to rotation as they come up.
+        rest = manager.lanes[1:]
+        if rest:
+            def _cook_rest() -> None:
+                for lane in rest:
+                    emit({"type": "lane", "kind": "heal", "t": time.time(),
+                          "lane": lane.index, "cc": lane.exit_country,
+                          "ip": "",
+                          "msg": f"lane {lane.index} {{{lane.exit_country}}} "
+                                 f"registering in the background ..."})
+                manager.start_lanes(rest)
+
+            threading.Thread(target=_cook_rest, name="lane-cook",
+                             daemon=True).start()
+
+        env = dict(os.environ)
+        for var in ("HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"):
+            env[var] = f"http://127.0.0.1:{port}"
+        env["NO_PROXY"] = env["no_proxy"] = "localhost,127.0.0.1"
+        if ca_pem:
+            # Let opencode trust our local CA so we can log each model call.
+            env["NODE_EXTRA_CA_CERTS"] = str(ca_pem)
+        return _run_opencode(opencode, opts["passthrough"], env)
+    finally:
+        if daemon:
+            daemon.stop()
+        if relay:
+            relay.stop()
+        if manager and not direct:
+            manager.stop_all()
+        if not direct:
+            try:
+                proof.make_emitter(PROOF_LOG)(proof.DONE)
+            except Exception:  # noqa: BLE001
+                pass
+
+
+def _run_opencode(binary: str, args: list[str],
+                  env: dict | None) -> int:
+    """Exec opencode with stdio inherited so it owns the terminal."""
+    try:
+        proc = subprocess.Popen([binary, *args], env=env)
+    except OSError as exc:
+        print(f"lingling: couldn't launch opencode: {exc}")
+        return 1
+    try:
+        return proc.wait()
+    except KeyboardInterrupt:
+        try:
+            proc.terminate()
+            proc.wait(timeout=5)
+        except Exception:  # noqa: BLE001
+            pass
+        return 130
+
+
+def entry() -> None:
+    sys.exit(main(sys.argv[1:]))