failproofai 1.0.12-beta.1 → 1.0.12

package/.next/standalone/fp-cloud-cli/fp_cli/commands/fleet_cmds.py

@@ -1,4 +1,4 @@
-"""The fleet: fleet list / show / deploy / jev-mode / diff / history / rollback / rename.
+"""The fleet: fleet list / show / deploy / diff / history / rollback / rename.
 
 What each machine is TOLD to enforce. Authoring the policies is `fp policies`;
 what they actually did is `fp guardrails`.
@@ -26,12 +26,10 @@ from .. import output
 from .._context import GLOBALS_EPILOG, AppState, deny_in_key_mode, require_auth
 from .. import _click_compat as click  # the Click Typer is running; see _click_compat
 from ..enforcement import (
-    JEV_MODES,
     RefError,
     RefUsageError,
     check_race,
     disabled_ids,
-    jev_mode_after,
     latest_versions,
     plan_deploy,
     version_kinds,
@@ -157,7 +155,7 @@ def fleet_deploy(
     add: Optional[List[str]] = typer.Option(
         None, "--add",
         help="Add or update a policy: `id`, `id@version`, `id:effect` or `id@version:effect`. "
-             "`observe` on a `both` policy observes its JavaScript and withholds its Jev checks.",
+             "`observe` records what the policy (its JavaScript and its Jev checks) would decide, and decides nothing.",
     ),
     remove: Optional[List[str]] = typer.Option(None, "--remove", help="Remove a policy by id."),
     replace: Optional[List[str]] = typer.Option(
@@ -176,14 +174,6 @@ def fleet_deploy(
         False, "--create",
         help="Allow deploying to a machine id that has not checked in yet (pre-staging).",
     ),
-    jev_mode: Optional[str] = typer.Option(
-        None, "--jev-mode",
-        help="Set the machine's Jev mode from FailproofAI Cloud: off, observe, enforce (Jev's "
-             "checks BLOCK calls as well as clearing what they review) — or local to stop "
-             "overriding the machine's own. Jev checks run on FailproofAI Cloud; nothing is "
-             "installed on the machine. Machine-wide: installed packs' checks too. "
-             "Omitted: unchanged.",
-    ),
     yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt. The prompt only appears on an interactive terminal: under --json, or with stdin redirected, this command proceeds without asking."),
 ) -> None:
     """Change what a machine enforces, showing the full resulting set first.
@@ -198,20 +188,10 @@ def fleet_deploy(
     Any kind deploys the same way. Jev checks run on FailproofAI Cloud; nothing
     is installed on the machine: a `both` policy sends the machine its
     JavaScript, and the machine asks FailproofAI Cloud about each checked tool
-    call while its Jev mode is `observe` or `enforce`. An effect applies to
-    JavaScript only — an `observe` `both` policy observes its JavaScript and its
-    Jev checks are not asked — and a `jev` policy is watched through the Jev
-    MODE instead: `--jev-mode observe` asks Jev and logs what it says while the
-    regex policies decide; `enforce` lets Jev's checks BLOCK calls (every `jev`
-    policy's deny checks) as well as clear the regex verdicts they review; `off`
-    stops Jev on the machine; `local` hands the choice back to the machine. The
-    mode is the MACHINE's: it also governs the checks of any pack installed
-    there, and it overrides the machine's own mode and `jev.json`, a local
-    `off` included. Without `--jev-mode` it is left as it is.
-
-    `--jev-mode` with no change to the set changes ONLY the mode (the same as
-    `fp fleet jev-mode`): the policy set — disabled policies' assignments
-    included — is not read back and rewritten.
+    call. An `observe` effect applies to every kind: the policy's JavaScript
+    and its Jev checks are evaluated and recorded, and decide nothing. There is
+    no Jev mode to set: FailproofAI Cloud turns Jev on for a machine while any
+    `jev` or `both` policy is deployed to it, and off when none is.
 
     **Concurrency.** The write is a full replace with no server-side lock, so the
     CLI records the generation it read and refuses if the result is not exactly
@@ -224,19 +204,18 @@ def fleet_deploy(
     * `fp fleet deploy ci-runner-01 --add no-force-push`
     * `fp fleet deploy ci-runner-01 --add prod-guard@1:observe --remove old-rule`
     * `fp fleet deploy ci-runner-01 --set no-force-push --set no-secret-echo`
-    * `fp fleet deploy ci-runner-01 --add prod-db-intent --jev-mode observe`
-    * `fp fleet deploy ci-runner-01 --jev-mode local`
+    * `fp fleet deploy ci-runner-01 --add prod-db-intent:observe`
     """
     state: AppState = ctx.obj
     deny_in_key_mode(state, "fleet deploy", _KEY_MODE_REASON)
     cctx = require_auth(state)
 
-    if not add and not remove and replace is None and jev_mode is None and not targets and not all_agents:
+    if not add and not remove and replace is None and not targets and not all_agents:
         # Exit 2 for the same reason `--set` with `--add` is: no flag
         # combination was given that this command can act on. Both are the
         # caller's command line, not the server's answer.
         raise click.UsageError(
-            "nothing to do — pass --add, --remove, --set, --target, --all-agents, or --jev-mode. "
+            "nothing to do — pass --add, --remove, --set, --target, or --all-agents. "
             "`fp fleet show <machine>` prints the current set."
         )
 
@@ -268,8 +247,6 @@ def fleet_deploy(
             replace=replace,
             latest=latest,
             disabled=disabled_ids(published),
-            jev_mode=jev_mode,
-            current_jev_mode=current.jev_mode if current else None,
             kinds=version_kinds(published),
             targets=targets or (),
             all_agents=all_agents or (),
@@ -298,16 +275,6 @@ def fleet_deploy(
         output.deployment_unchanged(machine_id)
         return
 
-    # The mode alone: its own route, which never touches the policy set. A
-    # deploy is a full replace of the set the CLI read, and that set leaves out
-    # disabled policies' assignments — so a mode change sent as a deploy deleted
-    # them, and reverted anything changed since the read (CONTRACT C9.1). A
-    # machine with no deployment yet has nothing to lose and no mode to change:
-    # its first deploy, carrying the mode, is how it gets one.
-    if plan.jev_mode is not None and not plan.set_changes and current is not None:
-        _apply_jev_modes(state, cctx, [(machine_id, current.jev_mode)], plan.jev_mode, yes=yes, plan=plan)
-        return
-
     if not output.is_json():
         output.render_deploy_plan(plan)
     dropped = len(plan.removed)
@@ -323,7 +290,7 @@ def fleet_deploy(
             output.print_cancelled()
         return
 
-    result = api.deploy_policies(cctx, machine_id, plan.result, jev_mode=jev_mode)
+    result = api.deploy_policies(cctx, machine_id, plan.result)
     check_race(plan.base, result.deployment)
 
     if output.is_json():
@@ -336,176 +303,6 @@ def fleet_deploy(
     output.deployment_applied(machine_id, result.deployment, len(result.policies))
 
 
-def _jev_mode_consequence(mode: str, count: int) -> str:
-    what = f"{count} machine{'s' if count != 1 else ''}"
-    tail = {
-        "enforce": "; in enforce Jev's deny checks BLOCK calls, and it covers installed packs' checks too",
-        "observe": "; in observe Jev only records what it would have decided",
-        "off": "; Jev stops on them, a local jev.json included",
-        "local": "; each machine's own jev.json decides again",
-    }.get(mode, "")
-    return f"this sets the Jev mode to {mode} on {what} and leaves their policy sets untouched{tail}"
-
-
-def _apply_jev_modes(
-    state: AppState,
-    cctx,
-    targets: List[tuple],
-    mode: str,
-    *,
-    yes: bool,
-    plan=None,
-) -> None:
-    """Set `mode` on each `(machine_id, current_mode)`, through the mode-only route.
-
-    Shared by `fleet jev-mode` and `fleet deploy --jev-mode` with no set change.
-    A machine already on `mode` is left alone; one that fails is reported and
-    the rest still go ahead (exit 1 at the end, naming them).
-    """
-    after = jev_mode_after(mode)
-    rows = [
-        {"machineId": mid, "from": cur or "local", "to": after or "local", "changed": (cur or None) != after}
-        for mid, cur in targets
-    ]
-    todo = [r for r in rows if r["changed"]]
-    if not todo:
-        if output.is_json():
-            out = {"mode": mode, "machines": rows, "applied": False}
-            if plan is not None:
-                out = {"plan": plan.to_dict(), "deployment": None, "applied": False}
-            output.emit_json(out)
-            return
-        output.jev_mode_unchanged([r["machineId"] for r in rows], mode)
-        return
-
-    if not output.is_json():
-        output.render_jev_mode_plan(rows)
-    if not _write.confirm_destructive(
-        state, "change the Jev mode on",
-        todo[0]["machineId"] if len(todo) == 1 else f"{len(todo)} machines",
-        consequence=_jev_mode_consequence(mode, len(todo)),
-        assume_yes=yes,
-    ):
-        if output.is_json():
-            output.emit_json({"cancelled": True, "applied": False, "machines": rows})
-        else:
-            output.print_cancelled()
-        return
-
-    failed = []
-    last = None
-    for row in todo:
-        try:
-            result, changed = api.set_jev_mode(cctx, row["machineId"], mode)
-        except AuthError:
-            raise
-        except FpCliError as exc:
-            # One machine's refusal (a 404, a 403, a 422) is that machine's;
-            # the rest still go ahead, and the exit code says it was not all.
-            row["error"] = exc.format_message() if hasattr(exc, "format_message") else str(exc)
-            failed.append(row["machineId"])
-            continue
-        last = result
-        row["deployment"] = result.deployment
-        row["changed"] = changed
-
-    if output.is_json():
-        if plan is not None:
-            output.emit_json({
-                "plan": plan.to_dict(),
-                "deployment": last.to_dict() if last is not None else None,
-                "applied": last is not None,
-                "jevModeOnly": True,
-            })
-        else:
-            output.emit_json({"mode": mode, "machines": rows, "applied": not failed})
-    else:
-        output.jev_mode_applied(rows)
-    if failed:
-        raise ApiError(
-            f"the Jev mode could not be changed on {', '.join(failed)}"
-            + ("" if len(failed) == len(todo) else " — the other machines were changed"),
-        )
-
-
-def fleet_jev_mode(
-    ctx: typer.Context,
-    args: Optional[List[str]] = typer.Argument(
-        None, metavar="[MACHINE]... MODE",
-        help="The machines, then the mode: off, observe, enforce or local. With --all, just the mode.",
-    ),
-    all_machines: bool = typer.Option(
-        False, "--all", help="Every machine that has a deployment (machines with none are skipped).",
-    ),
-    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt. The prompt only appears on an interactive terminal: under --json, or with stdin redirected, this command proceeds without asking."),
-) -> None:
-    """Set the Jev mode FailproofAI Cloud gives machines, and nothing else.
-
-    `off`, `observe` or `enforce` override each machine's own mode and
-    `jev.json`, a local `off` included; `local` hands the choice back to the
-    machine. Jev checks run on FailproofAI Cloud; nothing is installed on the
-    machine: under `observe` or `enforce` it sends each checked tool call to
-    FailproofAI Cloud. `observe` asks Jev and records what it says while the
-    regex policies decide. `enforce` lets Jev's checks BLOCK calls — every `jev`
-    policy's deny checks — as well as clear the regex verdicts they review. The
-    mode is the machine's: it also governs the checks of every pack installed
-    there. A machine connected with `--no-transcripts` never asks, and reports
-    `transcripts_disabled`.
-
-    Only the mode changes: each machine's policy set, disabled policies'
-    assignments included, is left exactly as it is, and a machine already on
-    the mode is skipped. Each change is a new generation in `fp fleet history`.
-    A machine with no deployment has no mode to change — `fp fleet deploy
-    <machine> --jev-mode <mode>` gives it its first deployment with one.
-
-    Needs `policies:write`. With `--json`: `{mode, applied, machines:[{machineId,
-    from, to, changed, deployment?, error?}]}`.
-
-    Examples:
-
-    * `fp fleet jev-mode ci-runner-01 observe`
-    * `fp fleet jev-mode ci-runner-01 ci-runner-02 enforce`
-    * `fp fleet jev-mode --all local`
-    """
-    state: AppState = ctx.obj
-    deny_in_key_mode(state, "fleet jev-mode", _KEY_MODE_REASON)
-    words = list(args or [])
-    if not words:
-        raise click.UsageError("pass the mode: off, observe, enforce or local")
-    mode, machine_ids = words[-1], list(dict.fromkeys(words[:-1]))
-    if mode not in JEV_MODES:
-        raise click.UsageError(f"{mode!r} is not a Jev mode — one of {', '.join(JEV_MODES)}")
-    if all_machines and machine_ids:
-        raise click.UsageError("--all sets every machine; do not name machines as well")
-    if not all_machines and not machine_ids:
-        raise click.UsageError("name at least one machine, or pass --all")
-    cctx = require_auth(state)
-
-    deployments = {d.machine_id: d for d in api.list_deployments(cctx)}
-    if all_machines:
-        targets = [(mid, deployments[mid].jev_mode) for mid in sorted(deployments)]
-    else:
-        known = {m.machine_id for m in api.list_machines(cctx)} | set(deployments)
-        unknown = [mid for mid in machine_ids if mid not in known]
-        if unknown:
-            raise NotFoundError(f"no machine {', '.join(repr(u) for u in unknown)} has checked in")
-        bare = [mid for mid in machine_ids if mid not in deployments]
-        if bare:
-            raise ApiError(
-                f"{', '.join(bare)} {'has' if len(bare) == 1 else 'have'} no deployment, so there is no Jev "
-                "mode to change",
-                hint=f"`fp fleet deploy <machine> --jev-mode {mode}` gives a machine its first deployment with the mode",
-            )
-        targets = [(mid, deployments[mid].jev_mode) for mid in machine_ids]
-    if not targets:
-        if output.is_json():
-            output.emit_json({"mode": mode, "machines": [], "applied": False})
-        else:
-            output.info("no machine has a deployment yet — nothing to set")
-        return
-    _apply_jev_modes(state, cctx, targets, mode, yes=yes)
-
-
 def fleet_diff(
     ctx: typer.Context,
     machine_id: Optional[str] = typer.Argument(None, help="Machine id. Omit for the whole fleet."),
@@ -606,7 +403,7 @@ def fleet_rollback(
     _require_machine(cctx, machine_id)
     current = api.get_deployment(cctx, machine_id)
     # The mode that generation carried comes back with it, NULL (`local`)
-    # included — a rollback past an `--jev-mode off` turns enforcement back on.
+    # included, as the server reports it.
     # Read it first, so the prompt says so rather than the fleet finding out.
     target = next(
         (e for e in api.deployment_history(cctx, machine_id) if e.get("deployment") == deployment), None)
@@ -669,12 +466,11 @@ def register(app: typer.Typer) -> None:
         no_args_is_help=True,
         rich_markup_mode="markdown",
         context_settings={"help_option_names": ["-h", "--help"]},
-        help="The fleet and what each machine enforces (list / show / deploy / jev-mode / diff / history / rollback / rename).",
+        help="The fleet and what each machine enforces (list / show / deploy / diff / history / rollback / rename).",
     )
     fleet_app.command("list", epilog=GLOBALS_EPILOG)(fleet_list)
     fleet_app.command("show", epilog=GLOBALS_EPILOG)(fleet_show)
     fleet_app.command("deploy", epilog=GLOBALS_EPILOG)(fleet_deploy)
-    fleet_app.command("jev-mode", epilog=GLOBALS_EPILOG)(fleet_jev_mode)
     fleet_app.command("diff", epilog=GLOBALS_EPILOG)(fleet_diff)
     fleet_app.command("history", epilog=GLOBALS_EPILOG)(fleet_history)
     fleet_app.command("rollback", epilog=GLOBALS_EPILOG)(fleet_rollback)

package/.next/standalone/fp-cloud-cli/fp_cli/commands/incidents_cmds.py

@@ -14,7 +14,8 @@ import typer
 
 from .. import client as api
 from .. import output
-from .._context import GLOBALS_EPILOG, AppState, require_auth, validate_limit
+from .. import _click_compat as click
+from .._context import GLOBALS_EPILOG, AppState, require_auth, resolve_dates, validate_limit
 from ..errors import ApiError, ForbiddenError, NotFoundError
 from . import _write
 
@@ -68,12 +69,40 @@ def _fail(state: AppState, exc: Exception, *, incident_id: str = "") -> None:
     raise exc
 
 
+def _issue_filters(
+    agent_id, env, machine, source, audit_id, assignee, archived, search, since,
+) -> dict:
+    if archived is not None and archived not in ("false", "true", "only", "all"):
+        raise click.UsageError("--archived must be false, only or all")
+    if source is not None:
+        bad = [s for s in source.split(",") if s.strip() and s.strip() not in ("alert", "audit", "manual")]
+        if bad:
+            raise click.UsageError("--source must be alert, audit or manual (CSV)")
+    opened_from = None
+    if since is not None:
+        opened_from, _ = resolve_dates(since, None, None)
+    return {
+        "agent": agent_id, "environment": env, "machine": machine, "source": source,
+        "audit_id": audit_id, "assignee": assignee, "archived": archived, "q": search,
+        "opened_from": opened_from,
+    }
+
+
 def incidents_list(
     ctx: typer.Context,
     state_filter: Optional[str] = typer.Option(None, "--state", help="Filter by state(s): firing, acknowledged, resolved, closed (CSV)."),
     alert_id: Optional[str] = typer.Option(None, "--alert-id", help="Only incidents for this alert."),
     limit: int = typer.Option(50, "--limit", "-n", help="Max incidents to return."),
     show_id: bool = typer.Option(False, "--show-id", help="Show the full incident id instead of the short form (always full in --json)."),
+    agent_id: Optional[str] = typer.Option(None, "--agent-id", help="Only issues touching these agent ids (CSV)."),
+    env: Optional[str] = typer.Option(None, "--env", help="Only these environments (CSV)."),
+    machine: Optional[str] = typer.Option(None, "--machine", help="Only these machine ids (CSV)."),
+    source: Optional[str] = typer.Option(None, "--source", help="alert, audit and/or manual (CSV)."),
+    audit_id: Optional[str] = typer.Option(None, "--audit-id", help="Only issues from these audits (CSV of ids)."),
+    assignee: Optional[str] = typer.Option(None, "--assignee", help="Emails, `me` or `unassigned` (CSV)."),
+    archived: Optional[str] = typer.Option(None, "--archived", help="false (default), only or all."),
+    search: Optional[str] = typer.Option(None, "--search", help="Case-insensitive text in the title or summary."),
+    since: Optional[str] = typer.Option(None, "--since", help="Opened within: 15m 1h 6h 24h 7d."),
 ) -> None:
     """List incidents in a boxed table (newest-opened first).
 
@@ -94,7 +123,8 @@ def incidents_list(
     _validate_states(state_filter)
     validate_limit(limit)
     cctx = require_auth(state)
-    incidents = api.list_incidents(cctx, state=state_filter, alert_id=alert_id, limit=limit)
+    extra = _issue_filters(agent_id, env, machine, source, audit_id, assignee, archived, search, since)
+    incidents = api.list_incidents(cctx, state=state_filter, alert_id=alert_id, limit=limit, filters=extra)
     if state.json:
         output.emit_json({"issues": incidents})
         return
@@ -105,6 +135,16 @@ def incidents_list(
 def incidents_count(
     ctx: typer.Context,
     state_filter: Optional[str] = typer.Option(None, "--state", help="Filter by state(s) (CSV)."),
+    alert_id: Optional[str] = typer.Option(None, "--alert-id", help="Only issues from these alerts (CSV of ids)."),
+    agent_id: Optional[str] = typer.Option(None, "--agent-id", help="Only issues touching these agent ids (CSV)."),
+    env: Optional[str] = typer.Option(None, "--env", help="Only these environments (CSV)."),
+    machine: Optional[str] = typer.Option(None, "--machine", help="Only these machine ids (CSV)."),
+    source: Optional[str] = typer.Option(None, "--source", help="alert, audit and/or manual (CSV)."),
+    audit_id: Optional[str] = typer.Option(None, "--audit-id", help="Only issues from these audits (CSV of ids)."),
+    assignee: Optional[str] = typer.Option(None, "--assignee", help="Emails, `me` or `unassigned` (CSV)."),
+    archived: Optional[str] = typer.Option(None, "--archived", help="false (default), only or all."),
+    search: Optional[str] = typer.Option(None, "--search", help="Case-insensitive text in the title or summary."),
+    since: Optional[str] = typer.Option(None, "--since", help="Opened within: 15m 1h 6h 24h 7d."),
 ) -> None:
     """Count incidents (optionally by state) as a compact stat card.
 
@@ -118,7 +158,10 @@ def incidents_count(
     state: AppState = ctx.obj
     _validate_states(state_filter)
     cctx = require_auth(state)
-    count = api.count_incidents(cctx, state=state_filter)
+    extra = _issue_filters(agent_id, env, machine, source, audit_id, assignee, archived, search, since)
+    if alert_id:
+        extra["alert_id"] = alert_id
+    count = api.count_incidents(cctx, state=state_filter, filters=extra)
     if state.json:
         output.emit_json({"count": count})
     else:
@@ -261,10 +304,11 @@ def incidents_close(
 
     For an issue that came from an audit, this also marks the finding `dismissed`. It does
     NOT write the finding's org-wide suppression: closing one issue never hides that pattern
-    in your other audits. Use `fp audits finding-status <id> --action dismiss` for that.
+    in your other audits. Use `fp audits dismiss <finding-id>` for that.
 
-    Needs `issues:close`. Exits 9 (conflict) if the issue already ended — an issue ends once,
-    and closing must not overwrite the record that someone believed they had fixed it.
+    Needs `issues:close`. Exits 1 (the server answers 409 conflict) if the issue already
+    ended — an issue ends once, and closing must not overwrite the record that someone
+    believed they had fixed it.
 
     With `--json`: `{"closed": true, "id": "<id>"}` (or `{cancelled: true}` on a declined
     prompt).
@@ -666,6 +710,37 @@ def incidents_open(
     output.render_incident_opened(summary=summary, severity=sev, state=st, title=hero)
 
 
+def incidents_facets(
+    ctx: typer.Context,
+    state_filter: Optional[str] = typer.Option(None, "--state", help="Filter by state(s) (CSV)."),
+    alert_id: Optional[str] = typer.Option(None, "--alert-id", help="Only issues from these alerts (CSV of ids)."),
+    agent_id: Optional[str] = typer.Option(None, "--agent-id", help="Only issues touching these agent ids (CSV)."),
+    env: Optional[str] = typer.Option(None, "--env", help="Only these environments (CSV)."),
+    machine: Optional[str] = typer.Option(None, "--machine", help="Only these machine ids (CSV)."),
+    source: Optional[str] = typer.Option(None, "--source", help="alert, audit and/or manual (CSV)."),
+    audit_id: Optional[str] = typer.Option(None, "--audit-id", help="Only issues from these audits (CSV of ids)."),
+    assignee: Optional[str] = typer.Option(None, "--assignee", help="Emails, `me` or `unassigned` (CSV)."),
+    archived: Optional[str] = typer.Option(None, "--archived", help="false (default), only or all."),
+    search: Optional[str] = typer.Option(None, "--search", help="Case-insensitive text in the title or summary."),
+    since: Optional[str] = typer.Option(None, "--since", help="Opened within: 15m 1h 6h 24h 7d."),
+) -> None:
+    """The values the issue filters can take right now (agents, environments, machines,
+    sources, assignees), with counts — the dashboard inbox's filter bar. Needs `issues:read`.
+
+    Example:
+
+    * `fp issues facets --state firing,acknowledged`
+    """
+    from . import _cloud
+    state: AppState = ctx.obj
+    _validate_states(state_filter)
+    extra = _issue_filters(agent_id, env, machine, source, audit_id, assignee, archived, search, since)
+    params = {"state": state_filter, "alert_id": alert_id, **extra}
+    data = api.cloud_request(require_auth(state), "GET", "/api/issues/facets",
+                             params={k: v for k, v in params.items() if v is not None})
+    _cloud.emit(state, data, "Issue facets")
+
+
 def register(app: typer.Typer) -> None:
     inc = typer.Typer(
         no_args_is_help=True,
@@ -675,6 +750,7 @@ def register(app: typer.Typer) -> None:
     )
     inc.command("list", epilog=GLOBALS_EPILOG)(incidents_list)
     inc.command("count", epilog=GLOBALS_EPILOG)(incidents_count)
+    inc.command("facets", epilog=GLOBALS_EPILOG)(incidents_facets)
     inc.command("show", epilog=GLOBALS_EPILOG)(incidents_show)
     inc.command("ack", epilog=GLOBALS_EPILOG)(incidents_ack)
     inc.command("assign", epilog=GLOBALS_EPILOG)(incidents_assign)

package/.next/standalone/fp-cloud-cli/fp_cli/commands/list_cmds.py

@@ -24,6 +24,9 @@ _LIST_KINDS = {
     "hooks": ("hook_names", "events:read", "Hook names seen across events.", "seen across events"),
     "tools": ("tool_names", "events:read", "Tool names seen across events.", "seen across events"),
     "error_types": ("error_types", "events:read", "Error types seen across events.", "seen across events"),
+    "trigger_events": ("trigger_events", "events:read", "Hook trigger events seen across events.", "seen across events"),
+    "eval_envs": ("eval_environments", "evaluations:read", "Environments that have evaluation results.", "with evaluation results"),
+    "metric_keys": ("metric_keys", "evaluations:read", "Evaluation metric keys (metrics, not scores).", "evaluation metric keys"),
 }
 
 def _make_list_cmd(name: str, facet_key: str, perm: str, summary: str, description: str):
@@ -56,7 +59,7 @@ def register(app: typer.Typer) -> None:
         context_settings={"help_option_names": ["-h", "--help"]},
         help="List the distinct values behind the dashboard's filter dropdowns. Subcommands: "
         "**envs**, **agents**, **event_types**, **score_filters**, **models**, **hooks**, "
-        "**tools**, **error_types**.",
+        "**tools**, **error_types**, **trigger_events**, **eval_envs**, **metric_keys**.",
     )
     for name, (facet_key, perm, summary, description) in _LIST_KINDS.items():
         list_app.command(name, epilog=GLOBALS_EPILOG)(_make_list_cmd(name, facet_key, perm, summary, description))

package/.next/standalone/fp-cloud-cli/fp_cli/commands/orgs_cmds.py

@@ -316,4 +316,21 @@ def register(app: typer.Typer) -> None:
     orgs_app.command("switch", epilog=GLOBALS_EPILOG)(org_switch)
     orgs_app.command("current", epilog=GLOBALS_EPILOG)(org_current)
     orgs_app.command("perms", epilog=GLOBALS_EPILOG)(org_perms)
+    orgs_app.command("create", epilog=GLOBALS_EPILOG)(org_create)
     app.add_typer(orgs_app, name="orgs")
+
+
+def org_create(ctx: typer.Context, name: str = typer.Option(..., "--name"),
+               slug: Optional[str] = typer.Option(None, "--slug")) -> None:
+    """Create an organization (session only; does not switch the saved org)."""
+    from . import _cloud
+    from .account_cmds import request
+    from .. import _click_compat as click
+    _cloud.session_only(ctx.obj, "orgs create")
+    if not name.strip():
+        raise click.UsageError("--name cannot be empty")
+    import re
+    slug = slug or re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+    if not re.fullmatch(r"[a-z0-9]+(?:-[a-z0-9]+)*", slug):
+        raise click.UsageError("--slug must be lowercase letters/digits separated by hyphens")
+    request(ctx, "POST", "/api/orgs", {"name": name, "slug": slug})