@agentikos/omega-os 0.1.0 → 0.2.0

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -1,7 +1,9 @@
 """The `omega` command-line interface.
 
 A thin entry point. The installer's doctor step calls `omega doctor`; operators
-use `omega status` to see every task's derived state.
+use `omega status` to see every task's derived state. `omega account ...` and
+`omega billing` give visibility into the Claude Code Max account pool — see
+`docs/ACCOUNT-AND-BILLING.md` for the design.
 """
 from __future__ import annotations
 
@@ -62,43 +64,237 @@ def cmd_status(_args: argparse.Namespace) -> int:
     return 0
 
 
-def cmd_account(_args: argparse.Namespace) -> int:
-    """Show the Claude Code Max account pool and the selection strategy.
+# ──── account subcommands ─────────────────────────────────────────────────
 
-    Omega OS runs one engine, not N tmux sessions — so an account is not
-    "switched" globally. The Claude provider holds a POOL and distributes agent
-    calls across accounts. Add one with `omega account login`.
-    See docs/ACCOUNT-AND-BILLING.md.
+
+def _print_pool(pool) -> None:
+    print(f"Claude Max account pool — selection: {pool.selection}")
+    if not pool.accounts:
+        print("  (empty)")
+        print("  add an account:  omega account login")
+        return
+    for a in pool.accounts:
+        used = f"{a.tokens_used:>9,d} tok" if a.tokens_used else "         -"
+        print(f"  [{a.status:<9}] {a.id:<16} {used}  {a.label}")
+    print("  add an account:  omega account login")
+
+
+def cmd_account_list(_args: argparse.Namespace) -> int:
+    """Show the Claude Code Max account pool and the selection strategy."""
+    from omega_engine.account import AccountPool
+
+    pool = AccountPool.load(_omega_home())
+    _print_pool(pool)
+    return 0
+
+
+def cmd_account_login(args: argparse.Namespace) -> int:
+    """Add an account: run the OAuth flow, store the token in the vault,
+    and add a pool entry.
+
+    Strategy: try the RFC 8628 device-code flow first; if it's unavailable
+    (Anthropic does not currently publish those endpoints), fall back to a
+    manual paste flow — the user logs in via browser elsewhere, copies the
+    token, and pastes it. Either way ends with the token in the vault and
+    a new account in `accounts.yaml`.
     """
-    cfg = _omega_home() / "Agentik_Providers" / "claude" / "accounts.yaml"
-    if not cfg.exists():
-        cfg = cfg.with_name("accounts.example.yaml")
-    if not cfg.exists():
-        print("no Claude Max account pool configured — see docs/ACCOUNT-AND-BILLING.md")
-        return 0
+    from omega_engine.account import (
+        AccountPool,
+        ClaudeAccount,
+        claude_device_code_flow,
+        claude_oauth_login_url,
+        write_token,
+    )
+
+    account_id = (args.id or "").strip()
+    if not account_id:
+        account_id = input("account id (e.g. max-primary): ").strip()
+    if not account_id:
+        print("account id is required — aborting")
+        return 2
+    label = (args.label or "").strip() or f"Claude Max account ({account_id})"
+    secret_ref = f"CLAUDE_OAUTH_{account_id}"
+
+    token: str | None = None
+    if not args.manual:
+        print("attempting OAuth device-code flow...")
+        try:
+            result = claude_device_code_flow()
+            instruction = result.get("raw", {}).get("_human_instruction") \
+                or result.get("_human_instruction") or ""
+            if instruction:
+                print(instruction)
+            token = result.get("access_token")
+        except RuntimeError as exc:
+            print(f"device-code flow unavailable: {exc}")
+            print("falling back to manual paste...")
+
+    if not token:
+        # manual fallback — this is the path that always works
+        print()
+        print("MANUAL LOGIN")
+        print(f"  1. open in a browser:  {claude_oauth_login_url()}")
+        print("  2. complete login on the Claude account you want to add")
+        print("  3. copy the OAuth token from the dashboard or developer panel")
+        print()
+        try:
+            token = input("paste the OAuth token here: ").strip()
+        except EOFError:
+            token = ""
+    if not token:
+        print("no token provided — aborting (vault not modified)")
+        return 2
+
+    home = _omega_home()
+    path = write_token(home, secret_ref, token)
+    pool = AccountPool.load(home)
+    pool.add(ClaudeAccount(
+        id=account_id, label=label, secret_ref=secret_ref,
+        weight=1, status="active",
+    ))
+    cfg = pool.save(home)
+    print(f"  vault:  {path}  (chmod 600)")
+    print(f"  pool:   {cfg}")
+    _print_pool(pool)
+    return 0
+
+
+def cmd_account_use(args: argparse.Namespace) -> int:
+    """Set an account's status: active | resting | disabled."""
+    from omega_engine.account import AccountPool
+
+    home = _omega_home()
+    pool = AccountPool.load(home)
+    if pool.get(args.id) is None:
+        print(f"no account '{args.id}' in the pool")
+        return 2
     try:
-        import yaml
-    except ImportError:
-        print(f"account pool config: {cfg}  (install pyyaml to render it)")
-        return 0
-    data = yaml.safe_load(cfg.read_text()) or {}
-    pool = data.get("pool", [])
-    print(f"Claude Max account pool — selection: {data.get('selection', 'least-used')}")
-    for a in pool or [{"status": "(empty)", "id": "", "label": ""}]:
-        print(f"  [{str(a.get('status', '?')):<9}] {str(a.get('id', '')):<16} {a.get('label', '')}")
-    print("  add an account:  omega account login   (docs/ACCOUNT-AND-BILLING.md)")
+        pool.set_status(args.id, args.status)
+    except ValueError as exc:
+        print(str(exc))
+        return 2
+    pool.save(home)
+    _print_pool(pool)
     return 0
 
 
+def cmd_account_pool(args: argparse.Namespace) -> int:
+    """Edit pool-wide knobs: selection strategy and per-account weights.
+
+    Non-interactive flags drive scripted edits; with no flags, it prints the
+    current pool for inspection.
+    """
+    from omega_engine.account import AccountPool
+
+    home = _omega_home()
+    pool = AccountPool.load(home)
+    changed = False
+    if args.selection:
+        if args.selection not in ("round-robin", "least-used", "by-quota"):
+            print(
+                f"invalid selection '{args.selection}' — "
+                "must be round-robin|least-used|by-quota"
+            )
+            return 2
+        pool.selection = args.selection
+        changed = True
+    if args.weight:
+        # each --weight ID=N — parse and apply
+        for spec in args.weight:
+            if "=" not in spec:
+                print(f"weight spec '{spec}' must be of the form id=N")
+                return 2
+            ident, _, val = spec.partition("=")
+            ident, val = ident.strip(), val.strip()
+            acc = pool.get(ident)
+            if acc is None:
+                print(f"no account '{ident}' — skipping")
+                continue
+            try:
+                acc.weight = max(int(val), 0)
+            except ValueError:
+                print(f"weight for '{ident}' must be an integer, got {val!r}")
+                return 2
+            changed = True
+    if changed:
+        pool.save(home)
+    _print_pool(pool)
+    return 0
+
+
+def cmd_account(args: argparse.Namespace) -> int:
+    """Account dispatcher — keeps `omega account` (no subcommand) working as a
+    list view, matches the original surface area."""
+    sub = getattr(args, "account_cmd", None) or "list"
+    fns = {
+        "list": cmd_account_list,
+        "login": cmd_account_login,
+        "use": cmd_account_use,
+        "pool": cmd_account_pool,
+    }
+    if sub not in fns:
+        print(f"unknown account subcommand: {sub}")
+        return 2
+    return fns[sub](args)
+
+
+# ──── billing ─────────────────────────────────────────────────────────────
+
+
 def cmd_billing(_args: argparse.Namespace) -> int:
     """Show usage and cost per Claude Max account.
 
-    Per-account billing reads token usage recorded on the event log against the
-    provider cost model — so you see which account is near its weekly limit.
+    Sources: token usage on `task.*` events (live aggregation via
+    `BillingAggregator`) plus the cached counter in `accounts.yaml`. The event
+    log is the source of truth; the cached counter is the convenience view.
     """
+    from omega_engine.account import AccountPool, BillingAggregator
+    from omega_engine.store import SQLiteStore
+
+    home = _omega_home()
+    pool = AccountPool.load(home)
     print("omega billing — usage per Claude Max account")
-    print("  source: token usage on task.* events + the provider cost model")
-    print("  build-out: live per-account aggregation — see docs/ACCOUNT-AND-BILLING.md")
+    print()
+    print(f"  pool selection: {pool.selection}")
+    print(f"  accounts in pool: {len(pool.accounts)}")
+    print()
+
+    db = home / "Agentik_Runtime" / "eventlog" / "omega.db"
+    if not db.exists():
+        print("  no event store yet — nothing to aggregate")
+        return 0
+    store = SQLiteStore(db)
+    totals = BillingAggregator.from_event_log(store)
+    if not totals:
+        print("  no per-account usage recorded in the event log yet")
+        print("  (events emit `usage.account_id` once the Claude provider "
+              "is wired)")
+        store.close()
+        return 0
+
+    pool_ids = {a.id for a in pool.accounts}
+    header = f"  {'account':<16} {'calls':>7} {'input_tok':>12} {'output_tok':>12} {'total_tok':>12}"
+    print(header)
+    print(f"  {'-' * 64}")
+    grand_in = grand_out = grand_calls = 0
+    for account_id, t in sorted(totals.items()):
+        marker = "" if account_id in pool_ids else "  (unknown)"
+        total_tok = t["input_tokens"] + t["output_tokens"]
+        print(
+            f"  {account_id:<16} {t['total_calls']:>7,d} "
+            f"{t['input_tokens']:>12,d} {t['output_tokens']:>12,d} "
+            f"{total_tok:>12,d}{marker}"
+        )
+        grand_in += t["input_tokens"]
+        grand_out += t["output_tokens"]
+        grand_calls += t["total_calls"]
+    print(f"  {'-' * 64}")
+    print(
+        f"  {'TOTAL':<16} {grand_calls:>7,d} "
+        f"{grand_in:>12,d} {grand_out:>12,d} "
+        f"{grand_in + grand_out:>12,d}"
+    )
+    store.close()
     return 0
 
 
@@ -134,13 +330,227 @@ def cmd_project(args: argparse.Namespace) -> int:
     return 0
 
 
-def main(argv: list[str] | None = None) -> int:
+# --------------------------------------------------------------------------
+# `omega tool ...` — the registry of third-party tools (incl. installed MCPs).
+# --------------------------------------------------------------------------
+
+
+def _tool_install_npm(name: str, package: str, home: Path) -> dict[str, str]:
+    """Install one npm package into Agentik_Tools/<name>/ and return locator info."""
+    import shutil as _sh
+    import subprocess
+
+    tool_dir = home / "Agentik_Tools" / name
+    tool_dir.mkdir(parents=True, exist_ok=True)
+    npm = _sh.which("npm")
+    if npm is None:
+        raise RuntimeError("npm not found on PATH — install Node.js first")
+    subprocess.run(
+        [npm, "install", "-g", "--prefix", str(tool_dir), package],
+        check=True, capture_output=True, text=True, timeout=600,
+    )
+    bin_dir = tool_dir / "bin"
+    invoke = ""
+    if bin_dir.is_dir():
+        bins = sorted(p for p in bin_dir.iterdir() if p.is_file())
+        if bins:
+            invoke = str(bins[0].relative_to(home))
+    return {"path": f"Agentik_Tools/{name}/", "invoke": invoke}
+
+
+def cmd_tool_list(_args: argparse.Namespace) -> int:
+    from omega_engine.tools import ToolRegistry
+    reg = ToolRegistry.load(_omega_home())
+    tools = reg.list()
+    if not tools:
+        print("(no tools installed)")
+        return 0
+    print(f"{len(tools)} tool(s) installed:")
+    for t in tools:
+        ver = f"@{t.version}" if t.version else ""
+        print(f"  {t.name}{ver}  source={t.source or '-'}  invoke={t.invoke or '-'}")
+    return 0
+
+
+def cmd_tool_install(args: argparse.Namespace) -> int:
+    """Install a tool — either an MCP id from the catalog OR an npm package."""
+    home = _omega_home()
+    name = args.name
+    from omega_engine.tools import (
+        CatalogError,
+        Tool,
+        ToolRegistry,
+        install_from_catalog,
+        load_catalog,
+    )
+
+    if args.npm is None:
+        # Default path: treat <name> as an MCP catalog id.
+        try:
+            catalog = load_catalog(home)
+            tool = install_from_catalog(home, name, catalog=catalog)
+            print(f"installed {tool.name} (source={tool.source})")
+            return 0
+        except CatalogError as exc:
+            print(f"error: {exc}")
+            return 1
+        except Exception as exc:  # noqa: BLE001
+            print(f"error: {exc}")
+            return 1
+
+    # --npm given: install a bare npm package under Agentik_Tools/<name>/.
+    try:
+        loc = _tool_install_npm(name, args.npm, home)
+    except Exception as exc:  # noqa: BLE001
+        print(f"error: {exc}")
+        return 1
+    reg = ToolRegistry.load(home)
+    reg.install(Tool(name=name, path=loc["path"], invoke=loc["invoke"],
+                     source=f"npm:{args.npm}"))
+    reg.save(home)
+    print(f"installed {name} (npm:{args.npm})")
+    return 0
+
+
+def cmd_tool_remove(args: argparse.Namespace) -> int:
+    import shutil as _sh
+    from omega_engine.tools import ToolRegistry
+    home = _omega_home()
+    reg = ToolRegistry.load(home)
+    tool = reg.get(args.name)
+    if tool is None:
+        print(f"not installed: {args.name}")
+        return 1
+    tool_dir = home / tool.path
+    if tool_dir.exists():
+        _sh.rmtree(tool_dir, ignore_errors=True)
+    reg.remove(args.name)
+    reg.save(home)
+    print(f"removed {args.name}")
+    return 0
+
+
+def cmd_tool_update(args: argparse.Namespace) -> int:
+    """Re-install the tool from its recorded source."""
+    from omega_engine.tools import (
+        CatalogError,
+        Tool,
+        ToolRegistry,
+        install_from_catalog,
+        load_catalog,
+    )
+    home = _omega_home()
+    reg = ToolRegistry.load(home)
+    tool = reg.get(args.name)
+    if tool is None:
+        print(f"not installed: {args.name}")
+        return 1
+    if tool.source.startswith("mcp:") or tool.source.startswith("catalog:"):
+        try:
+            catalog = load_catalog(home)
+            install_from_catalog(home, args.name, catalog=catalog, registry=reg)
+            print(f"updated {args.name}")
+            return 0
+        except CatalogError as exc:
+            print(f"error: {exc}")
+            return 1
+    if tool.source.startswith("npm:"):
+        pkg = tool.source.split(":", 1)[1]
+        try:
+            loc = _tool_install_npm(args.name, pkg, home)
+        except Exception as exc:  # noqa: BLE001
+            print(f"error: {exc}")
+            return 1
+        reg.install(Tool(name=args.name, path=loc["path"], invoke=loc["invoke"],
+                         source=tool.source))
+        reg.save(home)
+        print(f"updated {args.name}")
+        return 0
+    print(f"cannot update — unknown source: {tool.source}")
+    return 1
+
+
+def cmd_tool(args: argparse.Namespace) -> int:
+    """`omega tool` dispatcher."""
+    sub = getattr(args, "tool_cmd", None) or "list"
+    fns = {
+        "list":    cmd_tool_list,
+        "install": cmd_tool_install,
+        "remove":  cmd_tool_remove,
+        "update":  cmd_tool_update,
+    }
+    if sub not in fns:
+        print(f"unknown tool subcommand: {sub}")
+        return 2
+    return fns[sub](args)
+
+
+def cmd_sync(_args: argparse.Namespace) -> int:
+    """Project the SSOT into every active provider's native shape."""
+    from omega_engine.sync import SyncEngine
+    outcomes = SyncEngine().sync_all(_omega_home())
+    for o in outcomes:
+        if o.get("projected"):
+            print(
+                f"  [ok] {o['provider']}: skills={o['skills_written']} "
+                f"commands={o['commands_written']} "
+                f"agents={o.get('agents_written', 0)} "
+                f"mcp={o['mcp_servers']} hooks={len(o.get('hooks', []))}"
+            )
+        else:
+            print(f"  [-]  {o['provider']}: {o.get('reason', 'skipped')}")
+    return 0
+
+
+def cmd_daemon(args: argparse.Namespace) -> int:
+    """Run one of the 24/7 service daemons.
+
+    ``omega daemon engine``      — the event-store keeper + local HTTP API.
+    ``omega daemon telegram``    — long-polls Telegram, routes inbound messages.
+    ``omega daemon autonomous``  — runs the autonomous-agent supervisor.
+
+    The installer's systemd user units invoke these.
+    """
+    name = args.name
+    if name == "engine":
+        from omega_engine.daemons import engine as d
+        return d.main()
+    if name == "telegram":
+        from omega_engine.daemons import telegram as d
+        return d.main()
+    if name == "autonomous":
+        from omega_engine.daemons import autonomous as d
+        return d.main()
+    print(f"unknown daemon: {name!r} — expected engine|telegram|autonomous")
+    return 2
+
+
+def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="omega", description="Omega OS control CLI")
     sub = parser.add_subparsers(dest="cmd", required=True)
     sub.add_parser("version", help="print the engine version").set_defaults(fn=cmd_version)
     sub.add_parser("doctor", help="validate the deployment").set_defaults(fn=cmd_doctor)
     sub.add_parser("status", help="show all tasks and their derived state").set_defaults(fn=cmd_status)
-    sub.add_parser("account", help="show the Claude Max account pool").set_defaults(fn=cmd_account)
+
+    p_acc = sub.add_parser("account", help="manage the Claude Max account pool")
+    p_acc.set_defaults(fn=cmd_account)
+    acc_sub = p_acc.add_subparsers(dest="account_cmd")
+    acc_sub.add_parser("list", help="show the pool (default)")
+    p_login = acc_sub.add_parser("login", help="add an account via OAuth (or manual paste)")
+    p_login.add_argument("--id", help="account id (e.g. max-primary)", default=None)
+    p_login.add_argument("--label", help="human label", default=None)
+    p_login.add_argument("--manual", action="store_true",
+                         help="skip the device-code attempt; paste a token directly")
+    p_use = acc_sub.add_parser("use", help="set an account's status")
+    p_use.add_argument("id", help="account id")
+    p_use.add_argument("status", choices=["active", "resting", "disabled"])
+    p_pool = acc_sub.add_parser("pool", help="edit weights and selection strategy")
+    p_pool.add_argument("--selection", choices=["round-robin", "least-used", "by-quota"],
+                        help="set the pool-wide selection strategy")
+    p_pool.add_argument("--weight", action="append", default=[],
+                        metavar="ID=N",
+                        help="set an account weight; repeatable")
+
     sub.add_parser("billing", help="show usage/cost per Claude Max account").set_defaults(fn=cmd_billing)
     p_run = sub.add_parser("run", help="run a mission end-to-end")
     p_run.add_argument("intent", help="the mission, in natural language")
@@ -150,6 +560,34 @@ def main(argv: list[str] | None = None) -> int:
     p_proj.add_argument("--no-telegram", action="store_true",
                         help="skip Telegram topic creation")
     p_proj.set_defaults(fn=cmd_project)
+
+    p_dae = sub.add_parser("daemon", help="run a 24/7 service daemon")
+    p_dae.add_argument("name", choices=["engine", "telegram", "autonomous"],
+                       help="which daemon to run")
+    p_dae.set_defaults(fn=cmd_daemon)
+
+    p_tool = sub.add_parser("tool", help="manage installed tools (incl. MCP servers)")
+    p_tool.set_defaults(fn=cmd_tool)
+    tool_sub = p_tool.add_subparsers(dest="tool_cmd")
+    tool_sub.add_parser("list", help="list installed tools (default)")
+    p_tinst = tool_sub.add_parser("install", help="install from the MCP catalog (default) or via --npm")
+    p_tinst.add_argument("name", help="tool name (an MCP catalog id, or a free name when --npm is given)")
+    p_tinst.add_argument("--npm", default=None, metavar="PACKAGE",
+                         help="install a bare npm package under Agentik_Tools/<name>/")
+    p_trm = tool_sub.add_parser("remove", help="remove a tool + unregister")
+    p_trm.add_argument("name", help="tool name")
+    p_tup = tool_sub.add_parser("update", help="re-install a tool from its recorded source")
+    p_tup.add_argument("name", help="tool name")
+
+    sub.add_parser(
+        "sync",
+        help="project Agentik_SSOT/ into each provider's native shape",
+    ).set_defaults(fn=cmd_sync)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
     args = parser.parse_args(argv)
     return args.fn(args)
 

package/omega/Agentik_Engine/omega_engine/daemons/__init__.py

@@ -0,0 +1,14 @@
+"""24/7 service layer for Omega OS.
+
+Three long-running daemons backed by systemd user units:
+
+* :mod:`omega_engine.daemons.engine`      — the event-store keeper + heartbeat
+* :mod:`omega_engine.daemons.telegram`    — long-polls Telegram, routes inbound
+  messages to either the autonomous supervisor or :func:`run_mission`
+* :mod:`omega_engine.daemons.autonomous`  — runs the autonomous-agent
+  supervisor
+
+Each daemon exposes a ``main()`` entry point invoked by ``omega daemon <name>``.
+"""
+
+__all__ = ["engine", "telegram", "autonomous"]

package/omega/Agentik_Engine/omega_engine/daemons/autonomous.py

@@ -0,0 +1,56 @@
+"""The autonomous-agent daemon.
+
+Loads every charter under
+``$OMEGA_HOME/Agentik_Orchestration/autonomous/``, builds an
+:class:`omega_engine.autonomous.AutonomousSupervisor`, and runs it until
+SIGTERM/SIGINT.
+
+This daemon owns the cron + event triggers. Channel triggers are routed in
+from the Telegram daemon; webhook triggers are awakened by whatever HTTP shim
+your operator put in front (the supervisor exposes ``wake_webhook`` for them).
+"""
+from __future__ import annotations
+
+import logging
+import os
+
+from omega_engine.autonomous import build_supervisor_from_home
+
+logger = logging.getLogger("omega.daemon.autonomous")
+
+
+def main() -> int:
+    logging.basicConfig(
+        level=os.environ.get("OMEGA_LOG_LEVEL", "INFO"),
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+    )
+    # Optional outbound Telegram bridge — used by the supervisor to deliver
+    # progress + reports for missions it spawns. Best-effort: missing vault
+    # token means "no Telegram", not "abort".
+    telegram = None
+    try:
+        from omega_engine.telegram import TelegramBridge
+        telegram = TelegramBridge.from_vault()
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("autonomous daemon: no outbound Telegram (%s)", exc)
+
+    supervisor = build_supervisor_from_home(telegram=telegram)
+    charters = supervisor.charters()
+    if not charters:
+        logger.warning(
+            "autonomous daemon: no charters found — idling. Drop a YAML in "
+            "Agentik_Orchestration/autonomous/ and restart."
+        )
+    else:
+        for c in charters:
+            logger.info("autonomous: loaded charter %s (%s, trigger=%s)",
+                        c.id, c.role, c.trigger_type)
+
+    # blocks until SIGTERM / SIGINT (the supervisor wires both)
+    supervisor.run()
+    logger.info("autonomous daemon stopped")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())