abstract-claude 0.1.0__tar.gz

abstract_claude-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: abstract-claude
+Version: 0.1.0
+Summary: Fresh Claude Code session manager: settings-only template, durable OAuth, quota fallback wrapper, and a web console.
+Author: jrputkey
+License: MIT
+Project-URL: Homepage, https://abstractendeavors.com
+Keywords: claude,claude-code,oauth,cli
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# abstract-claude
+
+Fresh **Claude Code** session manager: a settings-only template, durable OAuth,
+automatic quota fallback, and a web console — packaged as one `pip`-installable CLI.
+
+## Install
+
+```bash
+pip install abstract-claude                 # from your index
+# or from the private index:
+pip install -i https://<index>/api/pypi/simple/ abstract-claude
+```
+
+## Quickstart
+
+```bash
+abstract-claude init                        # materialize AC_ROOT (config + template)
+abstract-claude serve                       # web console (default http://127.0.0.1:9111)
+sudo abstract-claude install-service        # install + enable the systemd unit
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `serve [--host --port]` | Run the web console (Model+fallback, OAuth, Template+reset, Session settings). |
+| `init` | Create `AC_ROOT` with `config.json` + `template/` from shipped defaults. |
+| `save-template` | Capture current `~/.claude/settings.json` + minimal flags as the template. |
+| `restore` | Create a fresh `~/.claude` (settings + flags) if it doesn't exist. |
+| `reset [-y]` | Wipe ALL Claude state (transcripts/history/creds) → reseed template → clean session. |
+| `oauth-status` / `oauth-set <token>` | Show / store the durable 1-year `claude-auth` token. |
+| `launch -- <claude args>` | Launch Claude Code, auto-switching to the fallback model when the default is over quota. |
+| `install-service [--user]` | Write + enable `9111_abstract_claude_web.service` (needs sudo). |
+
+## How it works
+
+- **Template = config only.** `template/settings.json` + a minimal `~/.claude.json`
+  (onboarding/trust flags). No credentials, history, or transcripts — a reset gives a
+  genuinely clean session, not a restored snapshot.
+- **OAuth is not templated.** Login rides on the durable 1-year `CLAUDE_CODE_OAUTH_TOKEN`
+  (managed by `claude-auth`), so a fresh session auto-authenticates — no `/login`.
+- **Quota fallback is the wrapper.** Claude Code's `fallbackModel` only fires on
+  *overload*, never on quota; `autoContinueAtUsageLimit` doesn't exist before v2.1.234.
+  `abstract-claude launch` handles the real case: default Fable maxed → run on Opus 4.8.
+  Wire it up with:
+  ```bash
+  alias claude='abstract-claude launch --dangerously-skip-permissions'
+  ```
+
+## Config
+
+`AC_ROOT` (default `/srv/abstract_claude`) holds `config.json`:
+
+```json
+{ "listen_host": "127.0.0.1", "listen_port": 9111,
+  "default_model": "claude-fable-5[1m]", "quota_fallback_model": "claude-opus-4-8",
+  "preflight_quota_check": true }
+```
+
+Override the data root with `AC_ROOT=/path abstract-claude ...`.

abstract_claude-0.1.0/README.md

@@ -0,0 +1,60 @@
+# abstract-claude
+
+Fresh **Claude Code** session manager: a settings-only template, durable OAuth,
+automatic quota fallback, and a web console — packaged as one `pip`-installable CLI.
+
+## Install
+
+```bash
+pip install abstract-claude                 # from your index
+# or from the private index:
+pip install -i https://<index>/api/pypi/simple/ abstract-claude
+```
+
+## Quickstart
+
+```bash
+abstract-claude init                        # materialize AC_ROOT (config + template)
+abstract-claude serve                       # web console (default http://127.0.0.1:9111)
+sudo abstract-claude install-service        # install + enable the systemd unit
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `serve [--host --port]` | Run the web console (Model+fallback, OAuth, Template+reset, Session settings). |
+| `init` | Create `AC_ROOT` with `config.json` + `template/` from shipped defaults. |
+| `save-template` | Capture current `~/.claude/settings.json` + minimal flags as the template. |
+| `restore` | Create a fresh `~/.claude` (settings + flags) if it doesn't exist. |
+| `reset [-y]` | Wipe ALL Claude state (transcripts/history/creds) → reseed template → clean session. |
+| `oauth-status` / `oauth-set <token>` | Show / store the durable 1-year `claude-auth` token. |
+| `launch -- <claude args>` | Launch Claude Code, auto-switching to the fallback model when the default is over quota. |
+| `install-service [--user]` | Write + enable `9111_abstract_claude_web.service` (needs sudo). |
+
+## How it works
+
+- **Template = config only.** `template/settings.json` + a minimal `~/.claude.json`
+  (onboarding/trust flags). No credentials, history, or transcripts — a reset gives a
+  genuinely clean session, not a restored snapshot.
+- **OAuth is not templated.** Login rides on the durable 1-year `CLAUDE_CODE_OAUTH_TOKEN`
+  (managed by `claude-auth`), so a fresh session auto-authenticates — no `/login`.
+- **Quota fallback is the wrapper.** Claude Code's `fallbackModel` only fires on
+  *overload*, never on quota; `autoContinueAtUsageLimit` doesn't exist before v2.1.234.
+  `abstract-claude launch` handles the real case: default Fable maxed → run on Opus 4.8.
+  Wire it up with:
+  ```bash
+  alias claude='abstract-claude launch --dangerously-skip-permissions'
+  ```
+
+## Config
+
+`AC_ROOT` (default `/srv/abstract_claude`) holds `config.json`:
+
+```json
+{ "listen_host": "127.0.0.1", "listen_port": 9111,
+  "default_model": "claude-fable-5[1m]", "quota_fallback_model": "claude-opus-4-8",
+  "preflight_quota_check": true }
+```
+
+Override the data root with `AC_ROOT=/path abstract-claude ...`.

abstract_claude-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "abstract-claude"
+version = "0.1.0"
+description = "Fresh Claude Code session manager: settings-only template, durable OAuth, quota fallback wrapper, and a web console."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "jrputkey" }]
+keywords = ["claude", "claude-code", "oauth", "cli"]
+dependencies = []
+
+[project.scripts]
+abstract-claude = "abstract_claude.cli:main"
+
+[project.urls]
+Homepage = "https://abstractendeavors.com"
+
+[tool.pypit]
+github_push = false
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+abstract_claude = ["templates/*.json"]

abstract_claude-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

abstract_claude-0.1.0/src/abstract_claude/__init__.py

@@ -0,0 +1,2 @@
+"""abstract_claude — fresh Claude Code session manager (template, OAuth, quota fallback, console)."""
+__version__ = "0.1.0"

abstract_claude-0.1.0/src/abstract_claude/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

abstract_claude-0.1.0/src/abstract_claude/actions.py

@@ -0,0 +1,135 @@
+"""Core actions: template save/restore/reset, oauth, state, and root init."""
+import os
+import shutil
+
+from . import paths
+from .paths import (CONFIG_PATH, HOME, LIVE_CLAUDE_DIR, LIVE_DOTCLAUDE,
+                    LIVE_SETTINGS, ROOT, TEMPLATE_DIR, TPL_DOTCLAUDE, TPL_SETTINGS)
+from .util import load_json, run, save_json, which_claude_auth
+
+# Session-settings surfaced by the console (valid keys in current CC schema).
+BOOL_KEYS = [
+    "enableArtifact", "workflowKeywordTriggerEnabled", "promptSuggestionEnabled",
+    "awaySummaryEnabled", "skipDangerousModePermissionPrompt", "autoCompactEnabled",
+    "switchModelsOnFlag", "autoScrollEnabled", "fileCheckpointingEnabled",
+    "terminalProgressBarEnabled", "remoteControlAtStartup", "inputNeededNotifEnabled",
+    "agentPushNotifEnabled",
+]
+EFFORT_VALUES = ["low", "medium", "high", "xhigh"]
+PERM_MODES = ["acceptEdits", "auto", "bypassPermissions", "default", "plan"]
+
+# Minimal flags a fresh ~/.claude.json needs to skip onboarding/trust prompts.
+FLAG_KEYS = ["hasCompletedOnboarding", "bypassPermissionsModeAccepted",
+             "hasSeenAutoModeEntryWarning", "hasSeenTasksHint"]
+
+
+def _pkg_default(name):
+    """Read a shipped default template file from package data."""
+    try:
+        from importlib.resources import files
+        return (files("abstract_claude.templates") / name).read_text()
+    except Exception:
+        return None
+
+
+def init_root():
+    """Materialize AC_ROOT with config.json + template/ from shipped defaults if missing."""
+    os.makedirs(TEMPLATE_DIR, exist_ok=True)
+    created = []
+    if not os.path.exists(CONFIG_PATH):
+        save_json(CONFIG_PATH, dict(paths.DEFAULTS))
+        created.append(CONFIG_PATH)
+    for dst, name in ((TPL_SETTINGS, "settings.json"), (TPL_DOTCLAUDE, "dot-claude.json")):
+        if not os.path.exists(dst):
+            data = _pkg_default(name)
+            if data is not None:
+                with open(dst, "w") as f:
+                    f.write(data)
+                created.append(dst)
+    return created
+
+
+def save_template():
+    """Capture current settings.json + derive minimal flags into the template."""
+    os.makedirs(TEMPLATE_DIR, exist_ok=True)
+    live = load_json(LIVE_SETTINGS, {})
+    save_json(TPL_SETTINGS, live)
+    dot = load_json(LIVE_DOTCLAUDE, {})
+    flags = {k: bool(dot.get(k, True)) for k in FLAG_KEYS}
+    save_json(TPL_DOTCLAUDE, flags)
+    return {"ok": True, "out": f"saved settings + flags -> {TEMPLATE_DIR}"}
+
+
+def restore():
+    """Create a fresh ~/.claude (settings + flags) if it does not exist."""
+    if os.path.isdir(LIVE_CLAUDE_DIR):
+        return {"ok": True, "out": "~/.claude exists (use reset to force a fresh session)"}
+    os.makedirs(LIVE_CLAUDE_DIR, mode=0o700, exist_ok=True)
+    tpl = load_json(TPL_SETTINGS, {})
+    save_json(LIVE_SETTINGS, tpl)
+    save_json(LIVE_DOTCLAUDE, load_json(TPL_DOTCLAUDE, {}))
+    return {"ok": True, "out": "fresh ~/.claude created; login via CLAUDE_CODE_OAUTH_TOKEN"}
+
+
+def reset():
+    """Wipe ALL prior state, then reseed the template -> a clean session."""
+    shutil.rmtree(LIVE_CLAUDE_DIR, ignore_errors=True)
+    try:
+        os.remove(LIVE_DOTCLAUDE)
+    except FileNotFoundError:
+        pass
+    r = restore()
+    r["out"] = "wiped prior state; " + r["out"]
+    return r
+
+
+def oauth_status():
+    r = run([which_claude_auth(), "status"], timeout=20)
+    return (r["out"] + (("\n" + r["err"]) if r["err"] else "")).strip()
+
+
+def oauth_set(token):
+    token = (token or "").strip()
+    if not token.startswith("sk-ant-"):
+        return {"ok": False, "err": "token must start with sk-ant-"}
+    return run([which_claude_auth(), "set", token])
+
+
+def oauth_probe():
+    return run([which_claude_auth(), "probe"], timeout=40)
+
+
+def set_model(default_model=None, quota_fallback_model=None, fallback_model=None):
+    live = load_json(LIVE_SETTINGS, {})
+    cfg = load_json(CONFIG_PATH, {})
+    if default_model:
+        live["model"] = default_model
+        cfg["default_model"] = default_model
+    if fallback_model is not None:
+        fm = [x for x in fallback_model if x]
+        if fm:
+            live["fallbackModel"] = fm
+        else:
+            live.pop("fallbackModel", None)
+    if quota_fallback_model:
+        cfg["quota_fallback_model"] = quota_fallback_model
+    save_json(LIVE_SETTINGS, live)
+    save_json(CONFIG_PATH, cfg)
+    return {"ok": True}
+
+
+def build_state():
+    ver = run(["claude", "--version"], timeout=15)
+    return {
+        "config": paths.load_config(),
+        "live_settings": load_json(LIVE_SETTINGS, {}),
+        "template_settings": load_json(TPL_SETTINGS, {}),
+        "template_dotclaude": load_json(TPL_DOTCLAUDE, {}),
+        "oauth": oauth_status(),
+        "version": ver["out"] or ver["err"],
+        "bool_keys": BOOL_KEYS,
+        "effort_values": EFFORT_VALUES,
+        "perm_modes": PERM_MODES,
+        "live_settings_path": LIVE_SETTINGS,
+        "root": ROOT,
+    }

abstract_claude-0.1.0/src/abstract_claude/cli.py

@@ -0,0 +1,136 @@
+"""Command-line interface: `abstract-claude <subcommand>`."""
+import argparse
+import json
+import os
+import sys
+
+from . import __version__, actions
+from .paths import ROOT
+
+UNIT = "9111_abstract_claude_web.service"
+
+
+def _p(obj):
+    if isinstance(obj, dict):
+        print(obj.get("out") or obj.get("err") or json.dumps(obj))
+    else:
+        print(obj)
+
+
+def cmd_serve(a):
+    from .server import serve
+    serve(host=a.host, port=a.port)
+
+
+def cmd_init(a):
+    created = actions.init_root()
+    print("initialized " + ROOT)
+    for c in created:
+        print("  + " + c)
+    if not created:
+        print("  (already initialized)")
+
+
+def cmd_save_template(a):
+    _p(actions.save_template())
+
+
+def cmd_restore(a):
+    _p(actions.restore())
+
+
+def cmd_reset(a):
+    if not a.yes:
+        ans = input("Wipe ALL Claude state and start fresh? type RESET: ").strip()
+        if ans != "RESET":
+            print("aborted")
+            return 1
+    _p(actions.reset())
+
+
+def cmd_oauth_status(a):
+    print(actions.oauth_status())
+
+
+def cmd_oauth_set(a):
+    _p(actions.oauth_set(a.token))
+
+
+def cmd_launch(a):
+    from .launch import launch
+    return launch(a.args)
+
+
+def cmd_install_service(a):
+    from .paths import load_config
+    if os.geteuid() != 0:
+        print("run with sudo: sudo abstract-claude install-service", file=sys.stderr)
+        return 1
+    exe = os.environ.get("AC_EXE") or sys.argv[0]
+    if not os.path.isabs(exe):
+        import shutil
+        exe = shutil.which("abstract-claude") or exe
+    port = load_config()["listen_port"]
+    unit = f"""[Unit]
+Description=abstract_claude console
+After=network.target
+
+[Service]
+Type=simple
+User={a.user}
+Group={a.user}
+Environment=HOME=/home/{a.user}
+Environment=AC_HOST=127.0.0.1
+Environment=AC_PORT={port}
+Environment=AC_ROOT={ROOT}
+ExecStart={exe} serve
+Restart=on-failure
+RestartSec=3
+
+[Install]
+WantedBy=multi-user.target
+"""
+    dst = f"/etc/systemd/system/{UNIT}"
+    with open(dst, "w") as f:
+        f.write(unit)
+    os.system("systemctl daemon-reload")
+    os.system(f"systemctl enable --now {UNIT}")
+    print(f"installed {dst} -> http://127.0.0.1:{port}")
+    print(f"logs: journalctl -u {UNIT} -f")
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    ap = argparse.ArgumentParser(prog="abstract-claude",
+                                 description="Fresh Claude Code session manager.")
+    ap.add_argument("-V", "--version", action="version", version=f"abstract-claude {__version__}")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser("serve", help="run the web console")
+    s.add_argument("--host"); s.add_argument("--port", type=int)
+    s.set_defaults(fn=cmd_serve)
+
+    sub.add_parser("init", help="materialize AC_ROOT (config + template)").set_defaults(fn=cmd_init)
+    sub.add_parser("save-template", help="save current settings as template").set_defaults(fn=cmd_save_template)
+    sub.add_parser("restore", help="create fresh ~/.claude if missing").set_defaults(fn=cmd_restore)
+
+    r = sub.add_parser("reset", help="wipe all state -> fresh session")
+    r.add_argument("-y", "--yes", action="store_true"); r.set_defaults(fn=cmd_reset)
+
+    sub.add_parser("oauth-status", help="show claude-auth status").set_defaults(fn=cmd_oauth_status)
+    o = sub.add_parser("oauth-set", help="store a 1-year token")
+    o.add_argument("token"); o.set_defaults(fn=cmd_oauth_set)
+
+    l = sub.add_parser("launch", help="launch Claude with quota fallback")
+    l.add_argument("args", nargs=argparse.REMAINDER); l.set_defaults(fn=cmd_launch)
+
+    i = sub.add_parser("install-service", help="install+enable systemd unit (sudo)")
+    i.add_argument("--user", default=os.environ.get("SUDO_USER") or "solcatcher")
+    i.set_defaults(fn=cmd_install_service)
+
+    a = ap.parse_args(argv)
+    return a.fn(a) or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

abstract_claude-0.1.0/src/abstract_claude/launch.py

@@ -0,0 +1,47 @@
+"""`abstract-claude launch` — start Claude Code with automatic quota fallback."""
+import os
+import re
+import subprocess
+
+from .paths import load_config
+from .util import real_claude
+
+LIMIT_RE = re.compile(r"(reached your .*limit|usage limit reached|Fable .*limit)", re.I)
+
+
+def _is_headless(argv):
+    return any(a in ("-p", "--print") for a in argv)
+
+
+def launch(argv):
+    cfg = load_config()
+    real = real_claude()
+    default_model = cfg.get("default_model") or "claude-fable-5"
+    fallback_model = cfg.get("quota_fallback_model") or "claude-opus-4-8"
+    preflight = cfg.get("preflight_quota_check", True)
+    env = dict(os.environ)
+    env["HOME"] = os.path.expanduser("~")
+
+    if _is_headless(argv):
+        p = subprocess.run([real, "--model", default_model, *argv],
+                           capture_output=True, text=True, env=env)
+        out = (p.stdout or "") + (p.stderr or "")
+        if LIMIT_RE.search(out) and default_model != fallback_model:
+            print(f"[claude-launch] {default_model} over quota — retrying on {fallback_model}",
+                  flush=True)
+            os.execvpe(real, [real, "--model", fallback_model, *argv], env)
+        print(p.stdout, end="")
+        return p.returncode
+
+    model = default_model
+    if preflight and default_model != fallback_model:
+        try:
+            probe = subprocess.run([real, "-p", "--model", default_model, "ok"],
+                                   capture_output=True, text=True, timeout=30, env=env)
+            if LIMIT_RE.search((probe.stdout or "") + (probe.stderr or "")):
+                print(f"[claude-launch] {default_model} is maxed — starting on {fallback_model}",
+                      flush=True)
+                model = fallback_model
+        except Exception:
+            pass
+    os.execvpe(real, [real, "--model", model, *argv], env)

abstract_claude-0.1.0/src/abstract_claude/paths.py

@@ -0,0 +1,29 @@
+"""Path + config resolution. Runtime data root is AC_ROOT (default /srv/abstract_claude)."""
+import os
+
+ROOT = os.environ.get("AC_ROOT", "/srv/abstract_claude")
+HOME = os.path.expanduser("~")
+
+CONFIG_PATH = os.path.join(ROOT, "config.json")
+TEMPLATE_DIR = os.path.join(ROOT, "template")
+TPL_SETTINGS = os.path.join(TEMPLATE_DIR, "settings.json")
+TPL_DOTCLAUDE = os.path.join(TEMPLATE_DIR, "dot-claude.json")
+
+LIVE_CLAUDE_DIR = os.path.join(HOME, ".claude")
+LIVE_SETTINGS = os.path.join(LIVE_CLAUDE_DIR, "settings.json")
+LIVE_DOTCLAUDE = os.path.join(HOME, ".claude.json")
+
+DEFAULTS = {
+    "listen_host": "127.0.0.1",
+    "listen_port": 9111,
+    "default_model": "claude-fable-5[1m]",
+    "quota_fallback_model": "claude-opus-4-8",
+    "preflight_quota_check": True,
+}
+
+
+def load_config():
+    from .util import load_json
+    cfg = dict(DEFAULTS)
+    cfg.update(load_json(CONFIG_PATH, {}))
+    return cfg

abstract_claude-0.1.0/src/abstract_claude/server.py

@@ -0,0 +1,218 @@
+"""Web console served by `abstract-claude serve`."""
+import json
+import os
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from . import actions
+from .paths import load_config
+from .util import save_json
+from .paths import LIVE_SETTINGS
+
+
+class Handler(BaseHTTPRequestHandler):
+    def _send(self, code, body, ctype="application/json"):
+        data = body.encode() if isinstance(body, str) else body
+        self.send_response(code)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def _json(self, code, obj):
+        self._send(code, json.dumps(obj))
+
+    def _body(self):
+        n = int(self.headers.get("Content-Length", 0) or 0)
+        if not n:
+            return {}
+        try:
+            return json.loads(self.rfile.read(n).decode() or "{}")
+        except Exception:
+            return {}
+
+    def log_message(self, *a):
+        pass
+
+    def do_GET(self):
+        if self.path == "/" or self.path.startswith("/?"):
+            return self._send(200, PAGE, "text/html; charset=utf-8")
+        if self.path == "/api/state":
+            return self._json(200, actions.build_state())
+        return self._json(404, {"error": "not found"})
+
+    def do_POST(self):
+        b = self._body()
+        try:
+            if self.path == "/api/settings":
+                s = b.get("settings")
+                if not isinstance(s, dict):
+                    return self._json(400, {"error": "settings must be an object"})
+                save_json(LIVE_SETTINGS, s)
+                return self._json(200, {"ok": True, "written": LIVE_SETTINGS})
+            if self.path == "/api/model":
+                actions.set_model(b.get("default_model"), b.get("quota_fallback_model"),
+                                  b.get("fallback_model"))
+                return self._json(200, {"ok": True})
+            if self.path == "/api/template/save":
+                return self._json(200, actions.save_template())
+            if self.path == "/api/template/reset":
+                if b.get("confirm") != "RESET":
+                    return self._json(400, {"error": "type RESET to confirm"})
+                return self._json(200, actions.reset())
+            if self.path == "/api/oauth/set":
+                r = actions.oauth_set(b.get("token"))
+                return self._json(200 if r["ok"] else 400, r)
+            if self.path == "/api/oauth/probe":
+                return self._json(200, actions.oauth_probe())
+        except Exception as e:
+            return self._json(500, {"error": str(e)})
+        return self._json(404, {"error": "not found"})
+
+
+def serve(host=None, port=None):
+    actions.init_root()
+    cfg = load_config()
+    host = os.environ.get("AC_HOST", host or cfg["listen_host"])
+    port = int(os.environ.get("AC_PORT", port or cfg["listen_port"]))
+    srv = ThreadingHTTPServer((host, port), Handler)
+    print(f"abstract_claude console on http://{host}:{port}", flush=True)
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        pass
+
+
+PAGE = r"""<!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>abstract_claude console</title>
+<style>
+:root{--bg:#0d1117;--panel:#161b22;--line:#30363d;--fg:#e6edf3;--mut:#8b949e;
+--acc:#4c8dff;--ok:#3fb950;--warn:#d29922;--bad:#f85149;}
+*{box-sizing:border-box}
+body{margin:0;font:14px/1.5 ui-sans-serif,system-ui,sans-serif;background:var(--bg);color:var(--fg)}
+header{padding:16px 20px;border-bottom:1px solid var(--line);display:flex;align-items:baseline;gap:12px}
+h1{font-size:16px;margin:0;font-weight:600}
+.ver{color:var(--mut);font-size:12px}
+main{max-width:920px;margin:0 auto;padding:20px;display:grid;gap:16px}
+.card{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:16px}
+.card h2{margin:0 0 12px;font-size:14px;font-weight:600;letter-spacing:.3px}
+label{display:block;color:var(--mut);font-size:12px;margin:8px 0 3px}
+input,select{width:100%;background:#0d1117;border:1px solid var(--line);color:var(--fg);
+padding:7px 9px;border-radius:7px;font:13px monospace}
+.row{display:grid;grid-template-columns:1fr 1fr;gap:12px}
+.toggles{display:grid;grid-template-columns:1fr 1fr;gap:6px 18px;margin-top:6px}
+.tog{display:flex;align-items:center;gap:8px;color:var(--fg);font-size:13px}
+.tog input{width:auto}
+button{background:var(--acc);color:#fff;border:0;padding:8px 14px;border-radius:7px;
+cursor:pointer;font-size:13px;font-weight:600;margin-top:12px}
+button.ghost{background:#21262d;border:1px solid var(--line)}
+button.danger{background:var(--bad)}
+pre{background:#0d1117;border:1px solid var(--line);border-radius:7px;padding:10px;
+overflow:auto;font-size:12px;color:var(--mut);white-space:pre-wrap;margin:8px 0 0}
+.msg{font-size:12px;margin-top:8px;min-height:16px}
+.msg.ok{color:var(--ok)} .msg.bad{color:var(--bad)}
+.hint{color:var(--mut);font-size:12px;margin:4px 0}
+.flex{display:flex;gap:10px;flex-wrap:wrap;align-items:center}
+</style></head>
+<body>
+<header><h1>abstract_claude console</h1><span class="ver" id="ver"></span></header>
+<main>
+
+<div class="card">
+  <h2>Model &amp; fallback</h2>
+  <div class="row">
+    <div><label>Default model (settings.json)</label><input id="model"></div>
+    <div><label>Quota fallback → (wrapper: Fable maxed → this)</label><input id="qfb"></div>
+  </div>
+  <label>fallbackModel chain (overload only, comma-separated)</label>
+  <input id="fbchain" placeholder="claude-opus-4-8, claude-sonnet-5">
+  <p class="hint">fallbackModel fires on overload/unavailable, never on quota. The quota
+  switch is handled by <code>abstract-claude launch</code> using the value above.</p>
+  <button onclick="saveModel()">Save model config</button>
+  <div class="msg" id="m-model"></div>
+</div>
+
+<div class="card">
+  <h2>OAuth (claude-auth)</h2>
+  <pre id="oauth">loading…</pre>
+  <div class="flex"><button class="ghost" onclick="probe()">Live probe</button></div>
+  <label>Set / replace 1-year token (sk-ant-oat…)</label>
+  <input id="token" placeholder="sk-ant-oat01…">
+  <button onclick="setToken()">Store token</button>
+  <p class="hint">Re-minting needs a browser: run <code>claude-auth mint</code> in a
+  terminal, or paste a token minted elsewhere.</p>
+  <div class="msg" id="m-oauth"></div>
+</div>
+
+<div class="card">
+  <h2>Template &amp; fresh session</h2>
+  <p class="hint">Template = settings.json + flags only. Reset wipes ALL prior state and
+  reseeds the template → a clean session. Login rides on the durable env token.</p>
+  <div class="row">
+    <div><label>template/settings.json</label><pre id="tpl-set"></pre></div>
+    <div><label>template/dot-claude.json → ~/.claude.json</label><pre id="tpl-dot"></pre></div>
+  </div>
+  <div class="flex"><button class="ghost" onclick="saveTpl()">Save current settings as template</button></div>
+  <label>Type RESET to wipe &amp; start fresh</label>
+  <div class="flex">
+    <input id="confirm" placeholder="RESET" style="max-width:160px">
+    <button class="danger" onclick="reset()">reset (fresh session)</button>
+  </div>
+  <div class="msg" id="m-tpl"></div>
+</div>
+
+<div class="card">
+  <h2>Session settings (settings.json)</h2>
+  <div class="row">
+    <div><label>Permission default mode</label><select id="perm"></select></div>
+    <div><label>Effort level</label><select id="effort"></select></div>
+  </div>
+  <div class="toggles" id="toggles"></div>
+  <button onclick="saveSettings()">Save session settings</button>
+  <p class="hint" id="settings-path"></p>
+  <div class="msg" id="m-set"></div>
+</div>
+
+</main>
+<script>
+let S={};const $=id=>document.getElementById(id);
+function msg(id,t,ok){const e=$(id);e.textContent=t;e.className="msg "+(ok?"ok":"bad");}
+async function api(p,b){const o=b?{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(b)}:{};const r=await fetch(p,o);return{status:r.status,data:await r.json()};}
+async function load(){
+  const {data}=await api("/api/state");S=data;
+  $("ver").textContent=(data.version||"")+"  ·  "+(data.root||"");
+  $("model").value=data.live_settings.model||data.config.default_model||"";
+  $("qfb").value=data.config.quota_fallback_model||"";
+  $("fbchain").value=(data.live_settings.fallbackModel||[]).join(", ");
+  $("oauth").textContent=data.oauth||"(no status)";
+  $("tpl-set").textContent=JSON.stringify(data.template_settings,null,2);
+  $("tpl-dot").textContent=JSON.stringify(data.template_dotclaude,null,2);
+  $("settings-path").textContent="writes: "+data.live_settings_path;
+  const perm=$("perm");perm.innerHTML="";data.perm_modes.forEach(v=>perm.add(new Option(v,v)));
+  perm.value=((data.live_settings.permissions||{}).defaultMode)||"bypassPermissions";
+  const eff=$("effort");eff.innerHTML="";data.effort_values.forEach(v=>eff.add(new Option(v,v)));
+  eff.value=data.live_settings.effortLevel||"high";
+  const t=$("toggles");t.innerHTML="";
+  data.bool_keys.forEach(k=>{const c=!!data.live_settings[k];const w=document.createElement("label");
+    w.className="tog";w.innerHTML=`<input type="checkbox" data-k="${k}" ${c?"checked":""}> ${k}`;t.appendChild(w);});
+}
+async function saveModel(){
+  const fb=$("fbchain").value.split(",").map(s=>s.trim()).filter(Boolean);
+  const{status,data}=await api("/api/model",{default_model:$("model").value.trim(),quota_fallback_model:$("qfb").value.trim(),fallback_model:fb});
+  msg("m-model",status==200?"Saved.":"Error: "+(data.error||""),status==200);load();
+}
+async function saveSettings(){
+  const s=JSON.parse(JSON.stringify(S.live_settings||{}));
+  s.permissions=s.permissions||{};s.permissions.defaultMode=$("perm").value;s.effortLevel=$("effort").value;
+  document.querySelectorAll("#toggles input").forEach(c=>{s[c.dataset.k]=c.checked;});
+  const{status,data}=await api("/api/settings",{settings:s});
+  msg("m-set",status==200?("Saved → "+data.written):"Error: "+(data.error||""),status==200);load();
+}
+async function saveTpl(){const{status,data}=await api("/api/template/save",{});msg("m-tpl",status==200?(data.out||"Saved."):"Error: "+(data.err||data.error||""),status==200);load();}
+async function reset(){const{status,data}=await api("/api/template/reset",{confirm:$("confirm").value.trim()});msg("m-tpl",status==200?(data.out||"Fresh."):"Error: "+(data.error||data.err||""),status==200);$("confirm").value="";load();}
+async function setToken(){const{status,data}=await api("/api/oauth/set",{token:$("token").value});msg("m-oauth",status==200?(data.out||"Stored."):"Error: "+(data.error||data.err||""),status==200);$("token").value="";load();}
+async function probe(){msg("m-oauth","probing…",true);const{data}=await api("/api/oauth/probe",{});msg("m-oauth",(data.out||data.err||"done"),data.ok);}
+load();
+</script>
+</body></html>"""

abstract_claude-0.1.0/src/abstract_claude/templates/dot-claude.json

@@ -0,0 +1,6 @@
+{
+  "hasCompletedOnboarding": true,
+  "bypassPermissionsModeAccepted": true,
+  "hasSeenAutoModeEntryWarning": true,
+  "hasSeenTasksHint": true
+}

abstract_claude-0.1.0/src/abstract_claude/templates/settings.json

@@ -0,0 +1,20 @@
+{
+  "permissions": {
+    "defaultMode": "bypassPermissions"
+  },
+  "model": "claude-fable-5[1m]",
+  "enableArtifact": false,
+  "workflowKeywordTriggerEnabled": false,
+  "effortLevel": "high",
+  "promptSuggestionEnabled": false,
+  "awaySummaryEnabled": false,
+  "skipDangerousModePermissionPrompt": true,
+  "autoCompactEnabled": false,
+  "switchModelsOnFlag": false,
+  "autoScrollEnabled": true,
+  "fileCheckpointingEnabled": false,
+  "terminalProgressBarEnabled": false,
+  "remoteControlAtStartup": false,
+  "inputNeededNotifEnabled": true,
+  "agentPushNotifEnabled": true
+}

abstract_claude-0.1.0/src/abstract_claude/util.py

@@ -0,0 +1,51 @@
+"""Small shared helpers: JSON IO and subprocess running."""
+import json
+import os
+import subprocess
+
+from .paths import HOME, ROOT
+
+
+def load_json(path, default=None):
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except Exception:
+        return {} if default is None else default
+
+
+def save_json(path, obj):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    tmp = path + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(obj, f, indent=2)
+        f.write("\n")
+    os.replace(tmp, path)
+
+
+def which_claude_auth():
+    for p in (os.path.join(HOME, ".local/bin/claude-auth"),
+              "/usr/local/bin/claude-auth"):
+        if os.path.exists(p):
+            return p
+    return "claude-auth"
+
+
+def real_claude():
+    import shutil
+    return (shutil.which("claude")
+            or os.path.join(HOME, ".local/bin/claude"))
+
+
+def run(cmd, timeout=60, stdin=None):
+    """Run a command; return {ok, code, out, err}."""
+    env = dict(os.environ)
+    env["HOME"] = HOME
+    env["PATH"] = os.path.join(HOME, ".local/bin") + os.pathsep + env.get("PATH", "")
+    try:
+        p = subprocess.run(cmd, capture_output=True, text=True,
+                           timeout=timeout, env=env, input=stdin)
+        return {"ok": p.returncode == 0, "code": p.returncode,
+                "out": p.stdout.strip(), "err": p.stderr.strip()}
+    except Exception as e:
+        return {"ok": False, "code": -1, "out": "", "err": str(e)}

abstract_claude-0.1.0/src/abstract_claude.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: abstract-claude
+Version: 0.1.0
+Summary: Fresh Claude Code session manager: settings-only template, durable OAuth, quota fallback wrapper, and a web console.
+Author: jrputkey
+License: MIT
+Project-URL: Homepage, https://abstractendeavors.com
+Keywords: claude,claude-code,oauth,cli
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# abstract-claude
+
+Fresh **Claude Code** session manager: a settings-only template, durable OAuth,
+automatic quota fallback, and a web console — packaged as one `pip`-installable CLI.
+
+## Install
+
+```bash
+pip install abstract-claude                 # from your index
+# or from the private index:
+pip install -i https://<index>/api/pypi/simple/ abstract-claude
+```
+
+## Quickstart
+
+```bash
+abstract-claude init                        # materialize AC_ROOT (config + template)
+abstract-claude serve                       # web console (default http://127.0.0.1:9111)
+sudo abstract-claude install-service        # install + enable the systemd unit
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `serve [--host --port]` | Run the web console (Model+fallback, OAuth, Template+reset, Session settings). |
+| `init` | Create `AC_ROOT` with `config.json` + `template/` from shipped defaults. |
+| `save-template` | Capture current `~/.claude/settings.json` + minimal flags as the template. |
+| `restore` | Create a fresh `~/.claude` (settings + flags) if it doesn't exist. |
+| `reset [-y]` | Wipe ALL Claude state (transcripts/history/creds) → reseed template → clean session. |
+| `oauth-status` / `oauth-set <token>` | Show / store the durable 1-year `claude-auth` token. |
+| `launch -- <claude args>` | Launch Claude Code, auto-switching to the fallback model when the default is over quota. |
+| `install-service [--user]` | Write + enable `9111_abstract_claude_web.service` (needs sudo). |
+
+## How it works
+
+- **Template = config only.** `template/settings.json` + a minimal `~/.claude.json`
+  (onboarding/trust flags). No credentials, history, or transcripts — a reset gives a
+  genuinely clean session, not a restored snapshot.
+- **OAuth is not templated.** Login rides on the durable 1-year `CLAUDE_CODE_OAUTH_TOKEN`
+  (managed by `claude-auth`), so a fresh session auto-authenticates — no `/login`.
+- **Quota fallback is the wrapper.** Claude Code's `fallbackModel` only fires on
+  *overload*, never on quota; `autoContinueAtUsageLimit` doesn't exist before v2.1.234.
+  `abstract-claude launch` handles the real case: default Fable maxed → run on Opus 4.8.
+  Wire it up with:
+  ```bash
+  alias claude='abstract-claude launch --dangerously-skip-permissions'
+  ```
+
+## Config
+
+`AC_ROOT` (default `/srv/abstract_claude`) holds `config.json`:
+
+```json
+{ "listen_host": "127.0.0.1", "listen_port": 9111,
+  "default_model": "claude-fable-5[1m]", "quota_fallback_model": "claude-opus-4-8",
+  "preflight_quota_check": true }
+```
+
+Override the data root with `AC_ROOT=/path abstract-claude ...`.

abstract_claude-0.1.0/src/abstract_claude.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/abstract_claude/__init__.py
+src/abstract_claude/__main__.py
+src/abstract_claude/actions.py
+src/abstract_claude/cli.py
+src/abstract_claude/launch.py
+src/abstract_claude/paths.py
+src/abstract_claude/server.py
+src/abstract_claude/util.py
+src/abstract_claude.egg-info/PKG-INFO
+src/abstract_claude.egg-info/SOURCES.txt
+src/abstract_claude.egg-info/dependency_links.txt
+src/abstract_claude.egg-info/entry_points.txt
+src/abstract_claude.egg-info/top_level.txt
+src/abstract_claude/templates/dot-claude.json
+src/abstract_claude/templates/settings.json

abstract_claude-0.1.0/src/abstract_claude.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

abstract_claude-0.1.0/src/abstract_claude.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+abstract-claude = abstract_claude.cli:main

abstract_claude-0.1.0/src/abstract_claude.egg-info/top_level.txt

@@ -0,0 +1 @@
+abstract_claude