pythia-plsql 0.2.0__tar.gz → 0.2.2__tar.gz

{pythia_plsql-0.2.0/scripts/pythia_plsql.egg-info → pythia_plsql-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.2.0
+Version: 0.2.2
 Summary: PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback.
 License: MIT
 Project-URL: Homepage, https://github.com/thaildhe172591/pythia
@@ -121,12 +121,18 @@ every agent read them first (`pythia conventions` shows both).
 
 **The account is the real security layer** — the policy file is an application-side
 fence. Give the agent its own revocable credential with proxy authentication
-(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared).
-`pythia agent-user` generates that SQL for your current connection — password
-included, `--save` drops the credential into `connections.json` — but it is
-optional convenience: running
+(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared):
+
+```bash
+pythia agent-user --save   # SQL for the DBA + matching credential saved as <conn>_agent
+pythia check               # after the DBA ran it: proxy session, warning gone
+```
+
+One run does both — the password is regenerated each run, so the SQL and the
+saved config must come from the same run. Optional convenience: doing it by
+hand with
 [`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql)
-by hand works just as well.
+works just as well.
 `pythia check` warns when the session runs with more power than the task needs.
 
 Per-group write policy, `.pythia/policy.json` (defaults shown):

{pythia_plsql-0.2.0 → pythia_plsql-0.2.2}/README.md

@@ -107,12 +107,18 @@ every agent read them first (`pythia conventions` shows both).
 
 **The account is the real security layer** — the policy file is an application-side
 fence. Give the agent its own revocable credential with proxy authentication
-(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared).
-`pythia agent-user` generates that SQL for your current connection — password
-included, `--save` drops the credential into `connections.json` — but it is
-optional convenience: running
+(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared):
+
+```bash
+pythia agent-user --save   # SQL for the DBA + matching credential saved as <conn>_agent
+pythia check               # after the DBA ran it: proxy session, warning gone
+```
+
+One run does both — the password is regenerated each run, so the SQL and the
+saved config must come from the same run. Optional convenience: doing it by
+hand with
 [`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql)
-by hand works just as well.
+works just as well.
 `pythia check` warns when the session runs with more power than the task needs.
 
 Per-group write policy, `.pythia/policy.json` (defaults shown):

{pythia_plsql-0.2.0 → pythia_plsql-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythia-plsql"
-version = "0.2.0"
+version = "0.2.2"
 description = "PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback."
 readme = "README.md"
 license = { text = "MIT" }

{pythia_plsql-0.2.0 → pythia_plsql-0.2.2}/scripts/pythia.py

@@ -1355,7 +1355,7 @@ AGENT_USER_SQL = """\
 -- privileges, utility grants — the agent needs none of them to develop
 -- PL/SQL, and every extra grant widens the blast radius.
 
-CREATE USER {agent} IDENTIFIED BY "{password}";
+{create_line}
 GRANT CREATE SESSION TO {agent};
 ALTER USER {owner} GRANT CONNECT THROUGH {agent};
 
@@ -1365,6 +1365,23 @@ ALTER USER {owner} GRANT CONNECT THROUGH {agent};
 """
 
 
+def agent_user_sql(owner, agent, password, exists):
+    """exists True: the user is already there — CREATE would be ORA-01920,
+    so reset the password and unlock in one statement (harmless if it was
+    never locked). exists None: no database to ask — emit CREATE plus the
+    fallback as a comment so the DBA can pick."""
+    if exists:
+        line = (f'ALTER USER {agent} IDENTIFIED BY "{password}" ACCOUNT '
+                f"UNLOCK;  -- user already exists; CREATE would be ORA-01920")
+    else:
+        line = f'CREATE USER {agent} IDENTIFIED BY "{password}";'
+        if exists is None:
+            line += ("\n-- (if the user already exists — ORA-01920 — run "
+                     "instead:\n--  ALTER USER "
+                     f'{agent} IDENTIFIED BY "{password}" ACCOUNT UNLOCK;)')
+    return AGENT_USER_SQL.format(owner=owner, agent=agent, create_line=line)
+
+
 def agent_password():
     """Random password satisfying common Oracle verify functions: letter
     first, upper+lower+digit+special, 16+ chars. Always quoted in SQL."""
@@ -1403,18 +1420,51 @@ def cmd_agent_user(conn, schema, ns):
                  f"({base['user']}) — nothing to set up.")
     agent = (ns.name or f"{owner}_AGENT").upper()
     password = agent_password()
-    print(AGENT_USER_SQL.format(owner=owner, agent=agent, password=password))
+    exists, dangerous = None, None
+    if conn is not None:
+        _, rows = run_query(conn, "select username from all_users "
+                                  "where username = :n", {"n": agent})
+        exists = bool(rows)
+        _, prows = run_query(conn, load_query("session-privileges.sql"))
+        dangerous = [r[0] for r in prows]
+    sql = agent_user_sql(owner, agent, password, exists)
+    saved = None
     if ns.save:
-        name = save_agent_connection(root, base_name, base, agent, password)
-        print(f"Saved connection '{name}' (now the default) in "
-              f"{pathlib.Path(root) / CONFIG_DIR / CONFIG_NAME};\n"
+        saved = save_agent_connection(root, base_name, base, agent, password)
+    if ns.json:
+        print(json.dumps({
+            "owner": owner, "agent": agent, "password": password, "sql": sql,
+            "agent_user_exists": exists, "saved_connection": saved,
+            "owner_connection": base_name,
+            "check_will_warn": bool(dangerous) if dangerous is not None else None,
+            "owner_dangerous_privs": dangerous,
+            "next": ["have a DBA run the sql", f"{invocation()} check"]}))
+        return
+    print(sql)
+    print("-- The password is regenerated on EVERY run — only the SQL from")
+    print("-- this exact run matches what --save writes. One run, not two.")
+    if dangerous:
+        print(f"\n! Even after this, {invocation()} check will STILL warn: "
+              f"the owner {owner} holds\n  {', '.join(dangerous[:3])}"
+              + ("…" if len(dangerous) > 3 else "")
+              + " — every proxy session inherits it.\n"
+              "  Trim the owner's grants to reach the no-warning goal state "
+              "(see README, Security).")
+    elif dangerous is not None:
+        print(f"\nOwner grants look clean: after the DBA runs this, "
+              f"{invocation()} check should pass with no warning.")
+    if saved:
+        print(f"\nSaved connection '{saved}' (now the default) in "
+              f"{pathlib.Path(root) / CONFIG_DIR / CONFIG_NAME} — its "
+              f"password matches the SQL above;\n"
               f"the owner entry '{base_name}' is untouched — switch back "
               f"any time with --conn {base_name}.")
-        print(f"\nNext: run the SQL above as a DBA, then: {invocation()} check")
+        print(f"\nNext: relay the SQL above to the developer verbatim for a "
+              f"DBA to run, then: {invocation()} check")
     else:
-        print(f"-- Rerun with --save to add this credential to "
-              f"connections.json as '{base_name}_agent' and make it the "
-              f"default once the DBA has run it.")
+        print(f"-- Nothing was saved. Use --save to also write this "
+              f"credential to connections.json as '{base_name}_agent' in "
+              f"the same run.")
 
 
 # unistr escapes. Single quote doubles to '' per SQL (a \' is ORA-01756 for
@@ -1559,8 +1609,7 @@ COMMANDS = {"check": cmd_check, "ls": cmd_ls, "src": cmd_src, "args": cmd_args,
             "conventions": cmd_conventions, "install": cmd_install,
             "unistr": cmd_unistr, "agent-user": cmd_agent_user}
 
-NO_DB_COMMANDS = {"policy", "journal", "conventions", "install", "unistr",
-                  "agent-user"}
+NO_DB_COMMANDS = {"policy", "journal", "conventions", "install", "unistr"}
 
 
 # --- CLI ---------------------------------------------------------------------

{pythia_plsql-0.2.0 → pythia_plsql-0.2.2/scripts/pythia_plsql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.2.0
+Version: 0.2.2
 Summary: PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback.
 License: MIT
 Project-URL: Homepage, https://github.com/thaildhe172591/pythia
@@ -121,12 +121,18 @@ every agent read them first (`pythia conventions` shows both).
 
 **The account is the real security layer** — the policy file is an application-side
 fence. Give the agent its own revocable credential with proxy authentication
-(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared).
-`pythia agent-user` generates that SQL for your current connection — password
-included, `--save` drops the credential into `connections.json` — but it is
-optional convenience: running
+(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared):
+
+```bash
+pythia agent-user --save   # SQL for the DBA + matching credential saved as <conn>_agent
+pythia check               # after the DBA ran it: proxy session, warning gone
+```
+
+One run does both — the password is regenerated each run, so the SQL and the
+saved config must come from the same run. Optional convenience: doing it by
+hand with
 [`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql)
-by hand works just as well.
+works just as well.
 `pythia check` warns when the session runs with more power than the task needs.
 
 Per-group write policy, `.pythia/policy.json` (defaults shown):

{pythia_plsql-0.2.0 → pythia_plsql-0.2.2}/skills/pythia-setup/SKILL.md

@@ -41,8 +41,15 @@ connects *through* the schema owner. The agent never learns the owner's
 password, revocation is one statement, the audit trail shows who really
 connected, and the blast radius is the one development schema.
 
-Run `examples/agent-user-setup.example.sql` (as a DBA, names adapted), then
-set the connection's user to `"agent_user[schema_owner]"`.
+Run `pythia agent-user --save` — ONE run, in the project directory. It
+prints the three-statement proxy SQL with a generated password and saves
+the matching credential as connection `<conn>_agent` (the new default; the
+owner entry stays untouched). The password is regenerated on every run, so
+never preview first and save later — the SQL and the saved config must
+come from the same run. Relay the SQL to the developer verbatim for a DBA
+to execute, then verify with `pythia check`. `--json` gives the same
+result machine-readable. Manual alternative:
+`examples/agent-user-setup.example.sql`, names adapted.
 
 Oracle's own guidance for LLM access, follow it: grant minimum privileges,
 never point an LLM at a production database, audit its activity regularly.

{pythia_plsql-0.2.0 → pythia_plsql-0.2.2}/tests/test_install.py

@@ -87,6 +87,38 @@ def test_pack_dirs_resolve_in_the_source_layout():
     assert (pythia.SKILLS_DIR / "pythia-apply" / "SKILL.md").is_file()
 
 
+def test_agent_user_json_saves_the_same_password_it_prints():
+    """The agent flow: one --json --save run must be self-consistent — the
+    password inside the SQL is the password written to connections.json."""
+    import argparse
+    import contextlib
+    import io
+    import os
+    with tempfile.TemporaryDirectory() as td:
+        root = pathlib.Path(td)
+        (root / ".pythia").mkdir()
+        (root / ".pythia" / "connections.json").write_text(json.dumps(
+            {"dev": {"host": "h", "port": 1521, "service_name": "s",
+                     "user": "OWNER", "password": "p", "schema": "OWNER"}}),
+            encoding="utf-8")
+        cwd = os.getcwd()
+        os.chdir(td)
+        try:
+            ns = argparse.Namespace(conn=None, json=True, save=True, name=None)
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                pythia.cmd_agent_user(None, None, ns)
+            d = json.loads(buf.getvalue())
+            assert d["saved_connection"] == "dev_agent"
+            assert d["password"] in d["sql"]
+            cfg = json.loads((root / ".pythia" / "connections.json")
+                             .read_text(encoding="utf-8"))
+            assert cfg["dev_agent"]["password"] == d["password"]
+            assert cfg["dev"]["password"] == "p"        # owner untouched
+        finally:
+            os.chdir(cwd)
+
+
 def test_one_version_across_every_manifest():
     """pyproject, plugin.json, marketplace.json and npm/package.json must all
     carry the same version — the release workflow publishes from one tag."""

{pythia_plsql-0.2.0 → pythia_plsql-0.2.2}/tests/test_phase1.py

@@ -254,8 +254,7 @@ def test_to_unistr():
 
 
 def test_agent_user_sql_is_least_privilege():
-    sql = pythia.AGENT_USER_SQL.format(owner="APP", agent="APP_AGENT",
-                                       password="x")
+    sql = pythia.agent_user_sql("APP", "APP_AGENT", "x", exists=False)
     assert "CREATE USER APP_AGENT" in sql
     assert "GRANT CREATE SESSION TO APP_AGENT" in sql
     assert "GRANT CONNECT THROUGH APP_AGENT" in sql

{pythia_plsql-0.2.0 → pythia_plsql-0.2.2}/tests/test_phase3.py

@@ -558,6 +558,39 @@ def test_journal_prune_keeps_applied_entries():
         assert pythia.list_journal_entries(td) == [kept]
 
 
+def test_agent_user_alter_form_and_warning_prediction():
+    """DB-aware agent-user: an existing agent user gets the ALTER+UNLOCK
+    form (CREATE would be ORA-01920), and a dirty owner is called out —
+    check will STILL warn — before the DBA runs anything."""
+    import argparse
+    import contextlib
+    import io
+    import os
+    script = {"from all_users": ([("USERNAME",)], [("APP_AGENT",)]),
+              "from session_privs": ([("PRIVILEGE",)], [("DROP ANY TABLE",)])}
+    with tempfile.TemporaryDirectory() as td:
+        (pathlib.Path(td) / ".pythia").mkdir()
+        (pathlib.Path(td) / ".pythia" / "connections.json").write_text(
+            json.dumps({"dev": {"host": "h", "user": "APP", "password": "p",
+                                "schema": "APP"}}), encoding="utf-8")
+        cwd = os.getcwd()
+        os.chdir(td)
+        try:
+            ns = argparse.Namespace(conn=None, json=True, save=False, name=None)
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                pythia.cmd_agent_user(FakeConn(script), "APP", ns)
+            d = json.loads(buf.getvalue())
+        finally:
+            os.chdir(cwd)
+        assert d["agent_user_exists"] is True
+        assert "ALTER USER APP_AGENT IDENTIFIED BY" in d["sql"]
+        assert "ACCOUNT UNLOCK" in d["sql"]
+        assert "CREATE USER" not in d["sql"]
+        assert d["check_will_warn"] is True
+        assert d["owner_dangerous_privs"] == ["DROP ANY TABLE"]
+
+
 def main():
     failed = 0
     for name, fn in sorted(globals().items()):