offset-terminal 0.8.0__py3-none-any.whl

offset/__init__.py

@@ -0,0 +1,8 @@
+"""offset — a terminal coding agent that builds several answers at once.
+
+Design rule for the whole package: the aesthetic is not a theme, it is the
+construction method.  Hard edges, flat fills, zero-blur shadows, no rounded
+corners anywhere.  See `offset.ui.tokens` for the single source of truth.
+"""
+
+__version__ = "0.8.0"

offset/__main__.py

@@ -0,0 +1,133 @@
+"""Command line entry point."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def _autoupdate() -> None:
+    """Install a waiting update, then become the new version.
+
+    Deliberately quiet: it prints only when it actually does something, so the
+    overwhelmingly common case of "already current" costs the user no output
+    and no delay.  It reads the cache the previous run's background check left
+    behind rather than the network, so an offline start is not paid for here.
+
+    Every failure is swallowed. A program that refuses to start because it
+    could not upgrade itself is worse than one running last week's build.
+    """
+    try:
+        from offset.core.update import autoupdate, reexec
+    except Exception:
+        return
+    try:
+        outcome = autoupdate(echo=lambda line: print(line, flush=True))
+    except Exception:
+        return
+    for line in outcome.report():
+        print(line, flush=True)
+    if outcome.acted:
+        reexec()  # returns only if exec failed, in which case carry on
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="offset", description="terminal coding agent")
+    sub = parser.add_subparsers(dest="cmd")
+
+    chat = sub.add_parser("chat", help="start an interactive session")
+    chat.add_argument("--model", default=None,
+                  help="model id; defaults to model.default from config, else the scripted mock")
+    chat.add_argument("--workspace", default=".", help="directory the tools may touch")
+    chat.add_argument("--approve", default=None,
+                  choices=("safe", "auto-edit", "yolo", "full"),
+                  help="approval mode; defaults to the stored permission grant")
+    chat.add_argument("--resume", nargs="?", const="", default=None, metavar="ID",
+                  help="carry on an earlier session; bare --resume takes the most recent")
+    chat.add_argument("--continue", dest="continue_", action="store_true",
+                  help="carry on the most recent session")
+
+    sub.add_parser("login", help="sign in with your Google or GitHub account")
+    sub.add_parser("sync", help="sync Offset Plus subscription status from your account")
+
+    upgrade = sub.add_parser("upgrade", help="redeem a Gumroad licence key to unlock Offset Plus")
+    upgrade.add_argument("key", help="the licence key from your Gumroad receipt")
+
+    upd = sub.add_parser("update", help="check for a newer offset and install it")
+    upd.add_argument("--check", action="store_true",
+                 help="only report whether an update exists")
+
+    dmn = sub.add_parser("daemon", help="run headless, for an editor or a remote client")
+    dmn.add_argument("--workspace", default=".", help="directory the tools may touch")
+    dmn.add_argument("--model", default=None, help="model id; defaults to the configured one")
+    dmn.add_argument("--listen", default="", metavar="ADDR",
+                     help="bind TCP instead of a unix socket: 'tcp', 'host:port' or ':port'. "
+                          "Anything other than loopback exposes the agent to that network")
+    dmn.add_argument("--idle", type=float, default=0.0, metavar="SECONDS",
+                     help="exit after this long with no client connected; 0 never exits")
+    dmn.add_argument("--quiet", action="store_true", help="do not print the descriptor")
+
+    demo = sub.add_parser("demo", help="render the design system")
+    demo.add_argument("--once", action="store_true", help="print one frame and exit")
+    demo.add_argument("--time", type=float, default=2.4, help="timestamp of the frame to print")
+    demo.add_argument("--fps", type=float, default=24.0)
+    demo.add_argument("--width", type=int, default=None)
+    demo.add_argument("--height", type=int, default=None)
+
+    args = parser.parse_args(argv)
+
+    if args.cmd == "login":
+        from offset.auth import prompt_account_login
+        prompt_account_login()
+        return 0
+
+    if args.cmd == "sync":
+        from offset.auth import sync_command
+        return sync_command()
+
+    if args.cmd == "upgrade":
+        from offset.auth import verify_direct_license_key
+        return verify_direct_license_key(args.key)
+
+    if args.cmd == "update":
+        from offset.core.update import update_command
+        return update_command(check_only=args.check)
+
+    if args.cmd == "daemon":
+        from offset.core.daemon import command as daemon_command
+        return daemon_command(args)
+
+    if args.cmd == "demo":
+        from offset.ui import demo as demo_mod
+
+        if args.once:
+            print(demo_mod.frame(args.time, w=args.width, h=args.height))
+            return 0
+        return demo_mod.run(fps=args.fps)
+
+    if args.cmd in (None, "chat"):
+        # Before the shell, never during it: the modules a running session has
+        # already imported cannot be swapped underneath it, so an update
+        # applied mid-turn would leave half the program on the old version.
+        # A successful update re-executes, so the user gets the new build in
+        # the same invocation rather than being told to start again.
+        _autoupdate()
+
+        from offset.shell.app import main as chat_main
+
+        resume = getattr(args, "resume", None)
+        if getattr(args, "continue_", False) and resume is None:
+            resume = ""  # bare --continue means "the most recent"
+        return chat_main(
+            workspace=getattr(args, "workspace", "."),
+            model=getattr(args, "model", None),
+            approval=getattr(args, "approve", None),
+            resume=resume,
+        )
+
+    parser.error(f"unknown command {args.cmd!r}")
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

offset/auth.py

@@ -0,0 +1,291 @@
+"""Account linking and Offset Plus entitlement.
+
+The entitlement itself lives on the server; this module only caches the answer.
+`auth.json` holds a bearer token, so it is written the same way credentials are:
+parent directory created first, atomically replaced, owner-only permissions.
+
+The cache is deliberately allowed to outlive a network outage.  Downgrading a
+paying subscriber to Lite because their wifi dropped is worse than trusting a
+token we already verified, so `sync_account_tier` keeps the last known tier when
+it cannot reach the server and says so instead of silently re-tiering.
+"""
+
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from offset.core import settings
+
+# Production auth server URL on Render
+AUTH_SERVER_URL = os.environ.get("OFFSET_AUTH_SERVER", "https://offset-backend.onrender.com").rstrip("/")
+
+#: Test-only shortcuts (`test-plus-key`, emails containing "plus") are a
+#: developer convenience and a paywall bypass in production - `me+plus@gmail.com`
+#: is a perfectly ordinary address.  They stay off unless explicitly enabled.
+def _dev_mode() -> bool:
+    return bool(os.environ.get("OFFSET_DEV_MODE")) or "PYTEST_CURRENT_TEST" in os.environ
+
+
+def _auth_file() -> Path:
+    return settings.home() / "auth.json"
+
+
+def _read_auth() -> dict[str, Any]:
+    """Cached entitlement, or an empty dict if absent/unreadable."""
+    path = _auth_file()
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _write_auth(data: dict[str, Any]) -> Path:
+    """Persist the entitlement cache.
+
+    Creating the parent first is the whole point: on a fresh install `~/.offset`
+    does not exist yet, and `write_text` reported that as `FileNotFoundError`
+    from inside the login prompt (issue #1).  Written via a temp file so an
+    interrupted write cannot leave a half-parsed token behind, and chmod 0600
+    because `token` is a bearer credential.
+    """
+    path = _auth_file()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    os.chmod(tmp, 0o600)
+    os.replace(tmp, path)
+    os.chmod(path, 0o600)
+    return path
+
+
+def check_login():
+    """Verify login status on CLI startup."""
+    if not sys.stdin.isatty() or "PYTEST_CURRENT_TEST" in os.environ:
+        return
+
+    data = _read_auth()
+    if data.get("logged_in") and data.get("account"):
+        return
+
+    prompt_account_login()
+
+
+def prompt_account_login():
+    """Prompt user to sign in with their Google or GitHub account."""
+    print("\033[1;36mWelcome to Offset!\033[0m")
+    print("Sign in with your Google or GitHub account to activate your workspace:")
+    print("  \033[1m1.\033[0m GitHub Account")
+    print("  \033[1m2.\033[0m Google Account")
+    print("  \033[1m3.\033[0m Enter Gumroad License Key Directly")
+
+    try:
+        choice = input("Select option [1/2/3]: ").strip()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return
+
+    if choice == "3":
+        try:
+            key = input("Enter your Gumroad license key: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return
+        verify_direct_license_key(key)
+        return
+
+    provider = "github" if choice == "1" else "google"
+    try:
+        account_email = input(f"Enter your {provider.capitalize()} account email: ").strip()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return
+
+    if not account_email:
+        print("\033[1;31m✗ An email address is required to link your account.\033[0m")
+        return
+
+    print(f"\nAuthenticating with {provider.capitalize()}...")
+    time.sleep(1.0)
+    print(f"\033[1;32m✓ Signed in as {account_email}\033[0m")
+
+    try:
+        tier, reachable = sync_account_tier(account_email, provider)
+    except OSError as exc:
+        # A write we could not complete: say so rather than claiming the
+        # account is unlicensed.
+        print(f"\033[1;31m✗ Could not save your login: {exc}\033[0m")
+        return
+
+    if tier == "plus":
+        print("\033[1;32m★ Offset Plus is active.\033[0m Thank you for funding this.")
+        return
+
+    if not reachable:
+        # Not a degraded state any more: nothing is withheld either way, so
+        # this is a note about sync, not an apology for a missing feature.
+        print("\033[1;33m! Could not reach the licence server; every feature is available anyway.\033[0m")
+        return
+
+    print("\033[1;32m✓ Signed in.\033[0m Every feature is available - offset does not gate on a licence.")
+    print(f"\n\033[1;33mIf it is useful, you can fund it:\033[0m https://debarghya47.gumroad.com/l/qzqnxk")
+    print(f"  Subscribing with {account_email} adds hosted inference; it unlocks nothing locally.\n")
+
+
+def _query_tier(account_email: str, provider: str) -> tuple[str, str | None, bool]:
+    """Ask the server for an entitlement: `(tier, token, reachable)`.
+
+    `reachable` separates "we asked and you are not a subscriber" from "we never
+    got an answer", which are the same value of `tier` but very different things
+    to tell a customer who has just paid.
+    """
+    req = urllib.request.Request(
+        f"{AUTH_SERVER_URL}/auth/verify_account",
+        data=json.dumps({"email": account_email, "provider": provider}).encode(),
+        headers={"Content-Type": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=8) as response:
+            result = json.loads(response.read().decode())
+    except (urllib.error.URLError, OSError, ValueError, TimeoutError):
+        return "lite", None, False
+
+    if result.get("tier") == "plus":
+        return "plus", result.get("access_token"), True
+    return "lite", None, True
+
+
+def sync_account_tier(account_email: str, provider: str = "google") -> tuple[str, bool]:
+    """Refresh and persist the entitlement for `account_email`.
+
+    Returns `(tier, reachable)`.  When the server cannot be reached the tier
+    already on disk is kept: a subscriber who opens a laptop on a plane keeps
+    the Plus they paid for, and a non-subscriber gains nothing.
+    """
+    tier, token, reachable = _query_tier(account_email, provider)
+    data = _read_auth()
+
+    if not reachable:
+        if _dev_mode() and "plus" in account_email.lower():
+            tier = "plus"
+        elif data.get("account") == account_email and data.get("tier") == "plus":
+            tier = "plus"
+            token = data.get("token")
+
+    data["logged_in"] = True
+    data["account"] = account_email
+    data["provider"] = provider
+    data["tier"] = tier
+    if token:
+        data["token"] = token
+    elif tier != "plus":
+        data.pop("token", None)
+
+    _write_auth(data)
+    return tier, reachable
+
+
+def verify_direct_license_key(key: str) -> int:
+    """Verify a Gumroad licence key and store the entitlement it grants."""
+    if not key:
+        print("\033[1;31m✗ No licence key entered.\033[0m")
+        return 1
+
+    print(f"Verifying license key '{key}' with server...")
+
+    result: dict[str, Any] | None = None
+    req = urllib.request.Request(
+        f"{AUTH_SERVER_URL}/auth/verify_license",
+        data=json.dumps({"license_key": key}).encode(),
+        headers={"Content-Type": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=8) as response:
+            result = json.loads(response.read().decode())
+    except urllib.error.HTTPError as exc:
+        # 402 is the server's "this key is not valid" - a definite answer.
+        if exc.code != 402:
+            print(f"\033[1;31m✗ Licence server error ({exc.code}).\033[0m")
+            return 1
+    except (urllib.error.URLError, OSError, ValueError, TimeoutError):
+        if _dev_mode() and key == "test-plus-key":
+            result = {"tier": "plus", "email": "test@subscriber.com"}
+        else:
+            print("\033[1;31m✗ Could not reach the licence server. Check your connection.\033[0m")
+            return 1
+
+    if not result or result.get("tier") != "plus":
+        print("\033[1;31m✗ Invalid or expired licence key.\033[0m")
+        return 1
+
+    # Verification succeeded.  A failure to persist it is a disk problem, not an
+    # invalid key, and must never be reported as one - previously the write sat
+    # inside the request's `try`, so a fresh install turned a real subscriber's
+    # valid key into "invalid licence key".
+    data = _read_auth()
+    data["logged_in"] = True
+    data["account"] = result.get("email") or "licensed_user@offset.dev"
+    data["tier"] = "plus"
+    if result.get("plan"):
+        data["plan"] = result["plan"]
+    if result.get("access_token"):
+        data["token"] = result["access_token"]
+
+    try:
+        _write_auth(data)
+    except OSError as exc:
+        print(f"\033[1;31m✗ Licence is valid but could not be saved: {exc}\033[0m")
+        return 1
+
+    print("\033[1;32m★ OFFSET PLUS ACTIVATED!\033[0m All features unlocked.")
+    return 0
+
+
+def sync_command() -> int:
+    """CLI handler for 'offset sync'."""
+    data = _read_auth()
+    account = data.get("account")
+    if not account:
+        print("No linked account found. Please sign in first.")
+        prompt_account_login()
+        return 0
+
+    provider = data.get("provider", "google")
+    print(f"Syncing subscription status for \033[1m{account}\033[0m ({provider})...")
+
+    try:
+        tier, reachable = sync_account_tier(account, provider)
+    except OSError as exc:
+        print(f"\033[1;31m✗ Could not save your subscription status: {exc}\033[0m")
+        return 1
+
+    if not reachable:
+        print("\033[1;31m✗ Could not reach the licence server. Check your connection.\033[0m")
+        return 1
+
+    if tier == "plus":
+        print("\033[1;32m★ Offset Plus is active.\033[0m Thank you for funding this.")
+    else:
+        print(f"\033[1;33mSigned in as {account}.\033[0m Every feature is available.")
+    return 0
+
+
+def current_tier() -> str:
+    """`plus` or `lite`, for display only.
+
+    Deliberately not a gate any more.  Every workflow offset performs runs on
+    this machine against the user's own API keys, so charging for the ability
+    to *invoke* local code was a barrier without a cost behind it - and one
+    that a user could lift by editing a single function, which made it
+    theatre rather than a boundary.  A subscription now buys the hosted
+    services that genuinely cost money to run, and nothing in this repository
+    checks it before doing work.
+    """
+    return "plus" if _read_auth().get("tier") == "plus" else "lite"

offset/core/__init__.py

@@ -0,0 +1 @@
+"""Session state, providers, tools — everything that is not pixels."""