omega-code 0.4.0__py3-none-any.whl

omega/onboarding.py

@@ -0,0 +1,242 @@
+"""First-run setup: get `~/.omega/config.json` into a working state without
+the full browser flow (`omega setup`). `run()` picks the Textual wizard on a
+real terminal and falls back to `run_plain()` (the original `input()` flow)
+otherwise; both share the provider presets, catalog, and config-merge logic
+in this module. No Textual imports here -- `omega/ui/tui/onboarding.py` is the
+only place that knows about widgets."""
+import asyncio
+import getpass
+import sys
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from . import config, loop
+from .setup_server import PROBE_PROMPT as PROBE_PROMPT
+from .setup_server import _save
+
+Body = dict[str, Any]
+
+
+@dataclass
+class _Choice:
+    provider_key: str
+    provider: Body
+    catalog: dict[str, Body]  # alias -> model entry, this provider only
+    default_alias: str
+    cheap_alias: str
+
+
+_ANTHROPIC = _Choice(
+    provider_key="anthropic",
+    provider={"type": "anthropic", "apiKey": ""},
+    catalog={
+        "fable": {"model": "claude-fable-5-1", "provider": "anthropic", "context": 1048576, "effort": "xhigh"},
+        "opus": {"model": "claude-opus-5", "provider": "anthropic", "context": 1048576, "effort": "high"},
+        "sonnet": {"model": "claude-sonnet-5", "provider": "anthropic", "context": 1048576, "effort": "high"},
+        "haiku": {"model": "claude-haiku-4-5", "provider": "anthropic", "context": 200000},
+    },
+    default_alias="opus", cheap_alias="haiku",
+)
+_OPENROUTER = _Choice(
+    provider_key="openrouter",
+    provider={"type": "openai", "baseUrl": "https://openrouter.ai/api/v1", "apiKey": ""},
+    catalog={
+        "spark": {"model": "meta/muse-spark-1.3", "provider": "openrouter", "context": 1048576},
+        "kimi": {"model": "moonshotai/kimi-k3", "provider": "openrouter", "context": 1048576},
+        "glm": {"model": "z-ai/glm-5.3-flash", "provider": "openrouter", "context": 128000},
+        "sol": {"model": "openai/gpt-5.6-sol", "provider": "openrouter", "context": 1050000},
+        "terra": {"model": "openai/gpt-5.6-terra", "provider": "openrouter", "context": 1050000},
+        "luna": {"model": "openai/gpt-5.6-luna", "provider": "openrouter", "context": 1050000},
+        "codex": {"model": "openai/gpt-5.3-codex", "provider": "openrouter", "context": 400000},
+        "grok": {"model": "x-ai/grok-4.6", "provider": "openrouter", "context": 500000},
+        "grok-build": {"model": "x-ai/grok-build-0.1", "provider": "openrouter", "context": 256000},
+    },
+    default_alias="spark", cheap_alias="glm",
+)
+_OPENAI = _Choice(
+    provider_key="openai",
+    provider={"type": "openai", "baseUrl": "https://api.openai.com/v1", "apiKey": ""},
+    catalog={
+        "astra": {"model": "gpt-6-astra", "provider": "openai", "context": 1050000},
+        "sol": {"model": "gpt-5.6-sol", "provider": "openai", "context": 1050000},
+        "terra": {"model": "gpt-5.6-terra", "provider": "openai", "context": 1050000},
+        "luna": {"model": "gpt-5.6-luna", "provider": "openai", "context": 1050000},
+        "codex": {"model": "gpt-5.3-codex", "provider": "openai", "context": 400000},
+    },
+    default_alias="sol", cheap_alias="luna",
+)
+
+# USD per million tokens, (input, output) -- shown in the model picker.
+PRICES: dict[str, tuple[float, float]] = {
+    "fable": (10, 50), "opus": (5, 25), "sonnet": (2, 10), "haiku": (1, 5),
+    "spark": (1.25, 4.25), "kimi": (3, 15), "glm": (0.6, 2.2),
+    "astra": (10, 50), "sol": (2, 10), "terra": (2, 12), "luna": (0.2, 1.2), "codex": (1.75, 14),
+    "grok": (2, 6), "grok-build": (1, 2),
+}
+
+PURPOSES: dict[str, str] = {
+    "fable": "hardest problems, deepest reasoning",
+    "opus": "best for coding (recommended)",
+    "sonnet": "fast and strong",
+    "haiku": "cheapest, quick tasks",
+    "spark": "Meta's frontier — strong at agentic coding, cheap",
+    "kimi": "strong open-weights, 1M context",
+    "glm": "cheap and fast",
+    "astra": "OpenAI's flagship GPT-6 — limited rollout, priciest",
+    "sol": "GPT-5.6 top tier — strong reasoning and coding",
+    "terra": "GPT-5.6 mid tier — balanced cost and capability",
+    "luna": "GPT-5.6 fast tier — high volume, cheap",
+    "codex": "OpenAI's agentic coding model",
+    "grok": "SpaceX's Grok 4.6 — frontier agentic coding, 500k context",
+    "grok-build": "Grok's fast coding model — cheap",
+}
+
+# provider_key -> (label, one-liner, env var checked for "key found in environment")
+PROVIDER_INFO: list[tuple[str, str, str, str]] = [
+    ("anthropic", "Anthropic  — Claude (recommended)",
+     "Native Anthropic API access -- fable, opus, sonnet, haiku.", "ANTHROPIC_API_KEY"),
+    ("openrouter", "OpenRouter  — Claude, GPT, Grok, Kimi, GLM, Gemini and 200+ more",
+     "One key, hundreds of models, pay-as-you-go.", "OPENROUTER_API_KEY"),
+    ("openai", "OpenAI  — GPT-6 Astra, GPT-5.6, Codex",
+     "Native OpenAI API access -- the only route to GPT-6 Astra for now.", "OPENAI_API_KEY"),
+    ("other", "Other OpenAI-compatible  — any /chat/completions endpoint",
+     "Bring your own base URL: local models, other clouds, self-hosted.", ""),
+]
+
+
+def env_var_for(provider_key: str) -> str:
+    for key, _label, _desc, env in PROVIDER_INFO:
+        if key == provider_key or (key == "other" and provider_key == "custom"):
+            return env
+    return ""
+
+
+def choice_for(provider_key: str, base_url: str = "") -> _Choice:
+    if provider_key == "anthropic":
+        return _ANTHROPIC
+    if provider_key == "openrouter":
+        return _OPENROUTER
+    if provider_key == "openai":
+        return _OPENAI
+    return _Choice(provider_key="custom", provider={"type": "openai", "baseUrl": base_url, "apiKey": ""},
+                  catalog={}, default_alias="", cheap_alias="")
+
+
+def build_config(choice: _Choice, main_alias: str, cheap_alias: str, models: dict[str, Body]) -> Body:
+    """Merge this choice into whatever config already exists on disk --
+    onboarding's own six roles win, everything else in the file is untouched."""
+    raw = config._json_or_default()
+    raw.setdefault("providers", {})[choice.provider_key] = choice.provider
+    raw.setdefault("models", {}).update(models)
+    roles = raw.setdefault("roles", {})
+    roles["main"] = {"alias": main_alias}
+    roles["plan"] = {"alias": main_alias}
+    roles["subagent_mid"] = {"alias": main_alias}
+    roles["subagent_fast"] = {"alias": cheap_alias}
+    roles["compact"] = {"alias": cheap_alias}
+    roles["memory"] = {"alias": cheap_alias}
+    return raw
+
+
+def save_config(raw: Body) -> None:
+    _save(raw)
+
+
+async def validate_key(choice: _Choice, key: str) -> tuple[bool, str]:
+    """Probe that `key` actually works for `choice`'s provider. Returns
+    (ok, message) -- message is "connected" on success or a short error."""
+    if choice.provider.get("type") == "anthropic":
+        from anthropic import AsyncAnthropic
+        try:
+            client = AsyncAnthropic(api_key=key)
+            await client.models.list(limit=1)
+            return True, "connected"
+        except Exception as e:
+            return False, f"{type(e).__name__}: {e}"[:120]
+
+    base = (choice.provider.get("baseUrl") or "").rstrip("/")
+    try:
+        async with httpx.AsyncClient(timeout=15) as http_client:
+            r = await http_client.get(f"{base}/models", headers={"Authorization": f"Bearer {key}"})
+        if r.status_code != 200:
+            return False, f"HTTP {r.status_code}: {r.text[:100]}"
+        return True, "connected"
+    except Exception as e:
+        return False, f"{type(e).__name__}: {e}"[:120]
+
+
+async def run() -> bool:
+    """Entry point for both `omega onboard` and the first-run gate: the
+    Textual wizard on a real terminal, the original `input()` flow otherwise
+    (piped/scripted invocations, or a dumb terminal)."""
+    if sys.stdin.isatty() and sys.stdout.isatty():
+        from .ui.tui.onboarding import OnboardingApp
+        return bool(await OnboardingApp().run_async())
+    await run_plain()
+    return config.CONFIG_PATH.exists()
+
+
+async def _ask(prompt: str) -> str:
+    return (await asyncio.to_thread(input, prompt)).strip()
+
+
+async def _ask_choice(prompt: str, options: list[str], default: int = 1) -> int:
+    print(prompt)
+    for i, opt in enumerate(options, 1):
+        print(f"  {i}. {opt}")
+    raw = await _ask(f"choice [{default}]: ")
+    if not raw:
+        return default
+    if raw.isdigit() and 1 <= int(raw) <= len(options):
+        return int(raw)
+    return default
+
+
+async def run_plain() -> None:
+    print("omega needs a model to drive it -- let's set one up (`omega setup` opens the full browser flow).")
+    pick = await _ask_choice("Pick a provider:",
+                             ["Anthropic (native)", "OpenRouter", "OpenAI (native)", "Other OpenAI-compatible"])
+
+    if pick == 1:
+        choice = _ANTHROPIC
+    elif pick == 2:
+        choice = _OPENROUTER
+    elif pick == 3:
+        choice = _OPENAI
+    else:
+        base_url = await _ask("Base URL (e.g. https://api.example.com/v1): ")
+        choice = choice_for("other", base_url)
+
+    key = await asyncio.to_thread(getpass.getpass, "API key (hidden): ")
+    choice.provider["apiKey"] = key
+
+    if choice.catalog:
+        aliases = sorted(choice.catalog)
+        default_idx = aliases.index(choice.default_alias) + 1
+        labels = [f"{a}  {choice.catalog[a]['model']}" for a in aliases]
+        picked = await _ask_choice("Default model for `main`:", labels, default=default_idx)
+        main_alias = aliases[picked - 1]
+        cheap_alias = choice.cheap_alias
+        models = dict(choice.catalog)
+    else:
+        model_id = await _ask("Model id served by this endpoint: ")
+        main_alias = cheap_alias = "main-model"
+        models = {main_alias: {"model": model_id, "provider": choice.provider_key, "context": 128000}}
+
+    save_config(build_config(choice, main_alias, cheap_alias, models))
+    print(f"wrote {config.CONFIG_PATH}")
+
+    print("\nrunning a test turn...")
+    try:
+        cfg = config.load()
+        text = await loop.run_agent(cfg, "main", loop.BUILD_SYSTEM,
+                                    [{"role": "user", "content": PROBE_PROMPT}])
+        print(text)
+    except Exception as e:
+        print(f"test turn failed ({type(e).__name__}: {e}) -- config is saved; check the key and retry.")
+
+    print("\nomega                    interactive TUI\n"
+          "omega \"do the thing\"     one-shot\n"
+          "omega setup              full browser setup, more providers/roles/MCP")

omega/permissions.py

@@ -0,0 +1,137 @@
+import json
+import os
+import re
+import shlex
+from pathlib import Path
+from typing import Any
+
+STORE = Path.home() / ".omega" / "permissions.json"
+
+ALLOW, ASK, DENY = "allow", "ask", "deny"
+
+# Never askable: no confirmation prompt makes these safe, and a model that has
+# ingested untrusted content is exactly what would propose them. This floor
+# stays in place even with everything below relaxed to ALLOW -- it guards
+# against catastrophic, irreversible harm (credential theft, wiping the
+# filesystem, running as root), not routine workflow friction, so "drop all
+# permissions" doesn't extend to it without a separate, explicit ask.
+# Both `.omega/config.json` and the pre-rename `.rig/config.json` stay
+# protected -- the old file may still exist (with a key in it) after migration.
+FORBIDDEN_PATHS = ("/.ssh", "/.aws", "/.gnupg", "/.omega/config.json", "/.rig/config.json",
+                   "/.claude.json", "/.claude/", "/.mcp-auth", "/.netrc",
+                   "/.config/gh", "/.kube")
+FORBIDDEN_PATTERNS = [
+    (re.compile(r"\b(curl|wget)\b[^|;&]*\|\s*(sudo\s+)?(ba)?sh"), "pipes a download into a shell"),
+    (re.compile(r"\brm\s+(-[a-zA-Z]*\s+)*-?[a-zA-Z]*[rf][a-zA-Z]*\s+(/|~|\$HOME)\s*$"), "recursive delete of / or ~"),
+    (re.compile(r"\bsudo\b"), "runs as root"),
+    (re.compile(r"\bgit\s+push\b.*--force(?!-with-lease)"), "force-push"),
+    (re.compile(r":\(\)\s*\{.*\};\s*:"), "fork bomb"),
+    (re.compile(r"\b(shutdown|reboot|mkfs|diskutil\s+erase)\b"), "destructive system command"),
+]
+
+
+def _load() -> dict[str, list[str]]:
+    if STORE.exists():
+        try:
+            return dict(json.loads(STORE.read_text()))
+        except json.JSONDecodeError:
+            pass
+    return {"allow": [], "deny": []}
+
+
+def remember(rule: str, verdict: str) -> None:
+    data = _load()
+    key = "allow" if verdict == ALLOW else "deny"
+    if rule not in data[key]:
+        data[key].append(rule)
+    STORE.parent.mkdir(parents=True, exist_ok=True)
+    STORE.write_text(json.dumps(data, indent=1))
+    STORE.chmod(0o600)
+
+
+def rule_for(name: str, args: dict[str, Any]) -> str:
+    if name == "bash":
+        return f"bash:{_first_token(args.get('command', ''))}"
+    if name == "call_tool":
+        tool = str(args.get("name", ""))
+        # One "always" per connected server, not per tool: the user authorised
+        # the integration, and a server with 40 tools would otherwise prompt
+        # 40 times.
+        m = re.match(r"(mcp__[^_]+(?:_[^_]+)*?)__", tool)
+        return f"call_tool:{m.group(1)}__*" if m else f"call_tool:{tool}"
+    return name
+
+
+def _first_token(command: str) -> str:
+    try:
+        parts = shlex.split(command)
+    except ValueError:
+        return command.strip().split(" ")[0] if command else ""
+    if not parts:
+        return ""
+    # `cd <dir> && real-command …`: the rule should name the real command,
+    # otherwise every command run from a worktree is classified as "cd".
+    if parts[0] == "cd" and "&&" in parts:
+        parts = parts[parts.index("&&") + 1:] or parts
+    if parts[0] == "git" and len(parts) > 1:
+        return f"git {parts[1]}"
+    return parts[0]
+
+
+def _touches_forbidden(text: str) -> str | None:
+    expanded = os.path.expanduser(text)
+    home = str(Path.home())
+    for frag in FORBIDDEN_PATHS:
+        if frag in expanded or (home + frag) in expanded:
+            return f"touches protected path {frag}"
+    return None
+
+
+def decide(name: str, args: dict[str, Any], cwd: str | None = None,
+          tainted: bool = False) -> tuple[str, str]:
+    """Returns (verdict, reason). Pure -- no I/O beyond the rules file.
+
+    Everything the model can do to the local filesystem/shell -- write, edit,
+    bash, the git subcommand it runs, whether a path is inside `cwd` -- is
+    ALLOW by default now; only the FORBIDDEN_PATHS/FORBIDDEN_PATTERNS floor
+    above and prompt-injection taint still gate. `call_tool` (any external
+    MCP server, database writes included) is deliberately left unclassified
+    below so it still falls through to ASK -- that's the one category this
+    relaxation does not cover."""
+    stored = _load()
+    rule = rule_for(name, args)
+
+    if name in ("write", "edit", "bash", "call_tool", "remember", "supersede", "link"):
+        blob = " ".join(str(v) for v in args.values())
+        why = _touches_forbidden(blob)
+        if why:
+            return DENY, why
+
+    if name == "bash":
+        command = args.get("command", "")
+        for pattern, why in FORBIDDEN_PATTERNS:
+            if pattern.search(command):
+                return DENY, why
+
+    if rule in stored["deny"]:
+        return DENY, "denied by a saved rule"
+    if rule in stored["allow"]:
+        return ALLOW, "allowed by a saved rule"
+
+    if name in ("read", "grep", "glob", "recall", "find_tools", "subagent",
+                "fetch_result", "list_artifacts", "ask_user", "skill", "bash_status"):
+        return ALLOW, "read-only"
+
+    if name in ("save_artifact", "update_artifact", "remember", "supersede", "link"):
+        return ALLOW, "writes to omega's own store (~/.omega or .omega/), not project files"
+
+    if name in ("write", "edit"):
+        return ALLOW, "writes always allowed (permissions relaxed to the filesystem/shell)"
+
+    if name == "bash":
+        # The user chose zero prompts over the prompt-injection guard: the
+        # FORBIDDEN floor above is the only thing between untrusted content
+        # and the shell.
+        return ALLOW, "bash always allowed (permissions relaxed to the filesystem/shell)"
+
+    return ASK, "not classified"

omega/secrets.py

@@ -0,0 +1,173 @@
+"""Where provider API keys actually live.
+
+A key written into `config.json` is a key that leaks: into a screenshot, into
+`cat` output pasted in a bug report, into every backup that copies the file,
+into the `.bak` written beside it. The file being mode 0600 stops another
+*user* reading it and nothing else -- most of the ways a key escapes a laptop
+run as you.
+
+So the config holds a *reference* to a secret rather than the secret. Three
+kinds, in the order `config.Provider` tries them:
+
+  apiKeyEnv  "OPENROUTER_API_KEY"          -- an environment variable
+  apiKeyCmd  "op read op://dev/or/key"     -- anything that prints it to stdout
+  (keychain) looked up automatically       -- the OS store, service "omega"
+
+The keychain is the default target rather than an encrypted file of our own
+making. It is already encrypted at rest, already unlocked by your login, and
+already access-controlled per application; a passphrase-encrypted file would
+either prompt on every single invocation or cache its derived key on disk,
+which just moves the plaintext somewhere less examined. `apiKeyCmd` is the
+escape hatch for anyone who keeps secrets in 1Password, pass, or a cloud
+secret manager and wants omega to never store one at all.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+SERVICE = "omega"
+
+# Resolving a secret costs a keychain round-trip or a whole subprocess, and
+# `Provider.api_key` is read on every request. Cached for the life of the
+# process; a rotated key takes effect on the next run, same as a config edit.
+_cache: dict[str, str] = {}
+
+
+def clear_cache() -> None:
+    _cache.clear()
+
+
+# ---- the OS keychain --------------------------------------------------------
+
+def keychain_available() -> bool:
+    """macOS only for now. Linux's Secret Service and Windows' Credential
+    Locker have no equivalent single binary to shell out to, so those
+    platforms get `apiKeyEnv`/`apiKeyCmd`, which reach every secret manager
+    worth using anyway."""
+    return sys.platform == "darwin" and shutil.which("security") is not None
+
+
+def keychain_get(account: str) -> str | None:
+    if not keychain_available():
+        return None
+    key = f"keychain:{account}"
+    if key in _cache:
+        return _cache[key]
+    proc = subprocess.run(
+        ["security", "find-generic-password", "-s", SERVICE, "-a", account, "-w"],
+        capture_output=True, text=True)
+    if proc.returncode != 0:
+        return None
+    secret = proc.stdout.strip()
+    if secret:
+        _cache[key] = secret
+    return secret or None
+
+
+def keychain_set(account: str, secret: str) -> None:
+    """Store (or replace) a key.
+
+    The secret goes through `security`'s argv, which is visible to `ps` for
+    the instant the process lives -- the CLI's own `-w` prompt cannot be
+    piped (it demands an interactive retype), and the alternative is a ctypes
+    binding to the Security framework whose memory handling is easy to get
+    subtly wrong. This runs at most once per key, on `omega keys set`, versus
+    reads that happen constantly and expose nothing. Anyone who considers
+    even that moment too much should use `apiKeyCmd` and keep the secret in a
+    manager omega never writes to."""
+    if not keychain_available():
+        raise RuntimeError("no OS keychain available on this platform")
+    proc = subprocess.run(
+        ["security", "add-generic-password", "-U", "-s", SERVICE, "-a", account,
+         "-w", secret, "-D", "omega provider key",
+         "-j", f"API key for omega provider {account!r}"],
+        capture_output=True, text=True)
+    if proc.returncode != 0:
+        raise RuntimeError(proc.stderr.strip() or "keychain write failed")
+    _cache.pop(f"keychain:{account}", None)
+
+
+def keychain_delete(account: str) -> bool:
+    if not keychain_available():
+        return False
+    proc = subprocess.run(
+        ["security", "delete-generic-password", "-s", SERVICE, "-a", account],
+        capture_output=True, text=True)
+    _cache.pop(f"keychain:{account}", None)
+    return proc.returncode == 0
+
+
+def keychain_accounts(names: list[str]) -> list[str]:
+    """Which of `names` the keychain holds. Probed one at a time rather than
+    by dumping the service: `security dump-keychain` prompts for permission
+    per item and is the kind of thing that trains people to click Allow."""
+    return [n for n in names if keychain_get(n) is not None]
+
+
+# ---- an external command ----------------------------------------------------
+
+def from_command(cmd: str, *, timeout: int = 20) -> str:
+    """Run `cmd` and take its stdout as the secret.
+
+    Deliberately a shell string, not an argv list: the point is to paste in
+    whatever incantation a secret manager already documents (`op read ...`,
+    `pass show ...`, `gcloud secrets versions access ...`) without translating
+    it. It only ever runs commands the config's owner wrote there themselves.
+    """
+    key = f"cmd:{cmd}"
+    if key in _cache:
+        return _cache[key]
+    try:
+        proc = subprocess.run(cmd, shell=True, capture_output=True, text=True,
+                              timeout=timeout)
+    except subprocess.TimeoutExpired:
+        raise RuntimeError(f"apiKeyCmd timed out after {timeout}s: {cmd}") from None
+    if proc.returncode != 0:
+        detail = proc.stderr.strip().splitlines()
+        raise RuntimeError(f"apiKeyCmd failed (exit {proc.returncode}): "
+                           f"{detail[0] if detail else cmd}")
+    secret = proc.stdout.strip()
+    if not secret:
+        raise RuntimeError(f"apiKeyCmd printed nothing: {cmd}")
+    _cache[key] = secret
+    return secret
+
+
+# ---- redaction --------------------------------------------------------------
+
+# Provider key shapes, longest-prefix first so `sk-ant-` is not eaten by the
+# shorter `sk-` alternative before it can match.
+_KEY_RE = re.compile(r"\b(sk-ant-[A-Za-z0-9_\-]{8,}|sk-or-[A-Za-z0-9_\-]{8,}"
+                     r"|sk-proj-[A-Za-z0-9_\-]{8,}|sk-[A-Za-z0-9_\-]{16,}"
+                     r"|ghp_[A-Za-z0-9]{16,}|xox[baprs]-[A-Za-z0-9\-]{10,})")
+
+
+def redact(text: str) -> str:
+    """Mask anything key-shaped, keeping enough of the head to tell two keys
+    apart. For error messages and any diagnostic a user might paste back."""
+    def mask(m: re.Match[str]) -> str:
+        raw = m.group(0)
+        return f"{raw[:11]}…{raw[-4:]} [redacted]" if len(raw) > 20 else "[redacted]"
+    return _KEY_RE.sub(mask, text)
+
+
+def looks_like_key(value: str) -> bool:
+    return bool(_KEY_RE.fullmatch(value.strip()))
+
+
+def describe_source(env: str, cmd: str, literal: str, account: str) -> str:
+    """Where a provider's key is coming from, for `omega keys` and `doctor`.
+    Never the value."""
+    if literal:
+        return "config.json (plaintext)"
+    if cmd:
+        return f"command: {cmd}"
+    if env and os.environ.get(env):
+        return f"env: {env}"
+    if keychain_get(account) is not None:
+        return "keychain"
+    return "missing"

omega/server/__init__.py

@@ -0,0 +1,7 @@
+"""D1 daemon: a FastAPI + uvicorn server exposing omega's agent loop over
+REST/WebSocket for the Omega.app SwiftUI client -- see Phase 9 of the plan.
+`omega serve` (wired up separately in omega/__main__.py) and
+`python -m omega.server` both call `main()`."""
+from .app import create_app, main
+
+__all__ = ["create_app", "main"]

omega/server/__main__.py

@@ -0,0 +1,18 @@
+"""`python -m omega.server --port 7777` -- a manual entrypoint for the D1
+daemon, ahead of the `omega serve` subcommand (wired up separately)."""
+from __future__ import annotations
+
+import argparse
+
+from .app import main
+
+
+def _cli() -> None:
+    parser = argparse.ArgumentParser(prog="python -m omega.server")
+    parser.add_argument("--port", type=int, default=7777)
+    args = parser.parse_args()
+    main(port=args.port)
+
+
+if __name__ == "__main__":
+    _cli()

omega/server/app.py

@@ -0,0 +1,71 @@
+"""FastAPI app factory and process entrypoint for the D1 daemon: binds
+127.0.0.1 only, no CORS, bearer-token auth (see auth.py) -- `omega serve`
+(wired up separately in omega/__main__.py) and `python -m omega.server` both
+end up calling `main()`."""
+from __future__ import annotations
+
+import contextlib
+import importlib.metadata
+import logging
+import os
+from collections.abc import AsyncIterator
+
+from fastapi import FastAPI
+
+from . import auth, tasks_api, terminals
+from .manager import TaskManager, WorkerArgv, default_worker_argv
+
+LOG_PATH = auth.SERVE_PATH.parent / "serve.log"
+
+
+def _version() -> str:
+    try:
+        return importlib.metadata.version("omega-code")
+    except importlib.metadata.PackageNotFoundError:
+        return "0.0.0"
+
+
+def create_app(port: int, worker_argv: WorkerArgv | None = None) -> FastAPI:
+    """`worker_argv` overrides how a task's child worker process is launched
+    -- the real daemon never passes it (defaults to spawning
+    `python -m omega.server.worker`); tests point it at a scripted stub."""
+    token = auth.generate_token()
+
+    @contextlib.asynccontextmanager
+    async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+        auth.write_serve_info(auth.ServeInfo(port=port, token=token, pid=os.getpid()))
+        try:
+            yield
+        finally:
+            await app.state.tasks_manager.shutdown_all()
+            app.state.terminals.kill_all()
+            auth.remove_serve_info()
+
+    app = FastAPI(title="omega D1 daemon", lifespan=lifespan)
+    app.state.token = token
+    app.state.version = _version()
+    app.state.tasks_manager = TaskManager(worker_argv or default_worker_argv)
+    app.state.terminals = terminals.TerminalManager()
+    app.include_router(tasks_api.router)
+    app.include_router(terminals.router)
+    return app
+
+
+def _configure_logging() -> None:
+    LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    handler = logging.FileHandler(LOG_PATH)
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
+    # "uvicorn.error"/"uvicorn.access" propagate up to "uvicorn" by default --
+    # attaching the handler to all three would log every line twice.
+    for name in ("uvicorn", "omega.server"):
+        logger = logging.getLogger(name)
+        logger.addHandler(handler)
+        logger.setLevel(logging.INFO)
+
+
+def main(port: int = 7777) -> None:
+    import uvicorn
+
+    _configure_logging()
+    app = create_app(port)
+    uvicorn.run(app, host="127.0.0.1", port=port, log_config=None)