@ory/continue 0.11.1 → 0.12.0

package/README.md

@@ -1,119 +1,150 @@
 # Ory Agent Plugin: Continue CLI
 
-[Ory](https://ory.com) bundled into [Continue](https://continue.dev)'s `cn` CLI: skills and slash commands that scaffold Ory authentication into your codebase, a local Ory stack you can spin up in one command, and (when pointed at an Ory project) authentication, authorization, and audit for every tool Continue runs.
+Security and developer experience for [Continue](https://continue.dev)'s `cn` CLI, powered by [Ory](https://ory.com).
 
-You don't need an Ory account or any prior Ory experience to start.
+**Security.** Continue runs real actions on your machine — editing files, running shell commands, calling APIs. The plugin gives every session a verifiable identity (you sign in once; Continue and any sub-agents it spawns each get their own), checks every tool call against permissions you control, and records each decision as an audit trace you can ship to your observability stack. It starts in watch mode so nothing is blocked on day one, and if Ory is ever unreachable it steps aside rather than locking you out.
 
-This integration targets the **`cn` CLI** (not the Continue IDE extension) and is verified against `@continuedev/cli`.
+**Developer experience.** A single command installs the plugin and walks you through connecting — choose Ory Network, a local Docker stack, or audit-only, and it wires up the project, sign-in client, login, and permissions for you. It also helps you build Ory into your own app: ask in plain language to scaffold login, registration, and recovery pages, run a local Ory, or manage identities and permissions through the bundled MCP server.
 
-## New to Ory?
+This targets the **`cn` CLI** (not the Continue IDE extension), verified against `@continuedev/cli`.
 
-[Ory](https://www.ory.com/docs/) is an open-source identity and access platform — login, registration, sessions, social sign-in, multi-factor auth, and fine-grained permissions, so you don't have to build any of that yourself. Two things make it easy to try with no prior experience:
+## What you'll need
 
-- **Ory Elements** are prebuilt, themeable UI components for the auth pages. The scaffolding skills wire them into your app for you.
-- **The local Ory stack** is a complete Ory running on your laptop in Docker — no account, no signup, no API key.
+- [Continue](https://continue.dev)'s `cn` CLI, installed
+- Node.js **22 or newer**
+- [Docker](https://docs.docker.com/get-docker/) — only if you want to run Ory locally
+- macOS or Linux (Windows works via WSL2)
 
-## What this plugin does
+## Get started
 
-Two independent things, and you can use either on its own:
-
-1. **Build auth into your app.** Have Continue scaffold Ory login, registration, social sign-in, and permissions into the project you're working on, backed by the local stack. This needs nothing but Docker.
-2. **Govern the agent itself.** Authenticate Continue's own session and authorize every tool it runs against Ory Permissions, with a full audit trail. See [Agent security](#agent-security).
-
-## Prerequisites
-
-- [Continue](https://continue.dev) `cn` CLI installed
-- Node.js **≥ 22**
-- [Docker](https://docs.docker.com/get-docker/) (only needed for the local Ory stack)
-- macOS or Linux. Windows works via WSL2.
-
-## Install
+Run one command. It installs the plugin and walks you through connecting:
 
 ```bash
 npx -y -p @ory/continue ory-continue install
 ```
 
-Continue has no native extension-install command, so `install` writes the Ory hooks directly into `<project>/.continue/settings.json` and materializes the Ory skills under `<project>/.continue/skills/`. Continue surfaces each skill as a slash command automatically, so the local-stack commands ship as skills too and surface as `/ory-local-up`, `/ory-local-down`, and `/ory-temporal-up`. Confirm everything landed:
+Continue has no native install command, so this writes the Ory hooks into your project settings and drops the Ory skills into your project — Continue turns each skill into a slash command automatically (so the local Ory commands show up as `/ory-local-up`, `/ory-local-down`, and `/ory-temporal-up`).
 
-```bash
-npx -y -p @ory/continue ory-continue status
-```
+You'll be asked how you want to connect — **press Enter for the default**:
 
-`status` prints configuration, user and agent identity, per-tool permission coverage, hook/skill registration, and a tail of recent debug logs. Unconfigured fields show inline as `(unset)`.
+- **Ory Network** *(default)* — sign in, or create a free account, in your browser. The project, keys, permissions, and login are all set up for you. Nothing to configure by hand.
+- **Local** — run a complete Ory on your laptop with Docker. No account, no signup, no keys. Great for trying it out.
+- **Audit-only** — skip Ory entirely and just log what Continue does.
 
-Uninstall removes only the Ory hooks and skills, leaving the rest of your settings intact:
+That's it. Confirm everything landed with:
 
 ```bash
-npx -y -p @ory/continue ory-continue uninstall
+npx -y -p @ory/continue ory-continue status
 ```
 
-## Quickstart (≈ 3 minutes)
+`status` is your one-stop check: what's configured, who's signed in, which tools are covered by permissions, and recent activity. Anything not set up yet shows as `(unset)`.
 
-From any project where you'd like Ory authentication, inside Continue:
+> Re-run install with `--reconfigure` to change your connection later, or `--no-configure` to skip the wizard and configure by hand.
 
-1. **Start a local Ory instance.** Ask Continue *"start the local Ory stack"* or run `/ory-local-up`. A banner prints the seeded test user's email and password — note them.
-2. **Scaffold Ory into your project.** Ask Continue *"add Ory auth to this app"* (the `ory-auth-setup` skill). It installs Ory Elements, wires the SDK, and generates the login / registration / recovery / settings pages, all targeting the local stack.
-3. **Sign in.** Start your app, visit the login page, and sign in with the seeded credentials. You now have a real Ory session backed by a real Ory stack — locally, offline, zero configuration.
+## What you get
 
-That's the full Ory DX path. Continue to [Agent security](#agent-security) when you're ready to enforce.
+Once connected, every tool Continue runs is governed by Ory — three things happen automatically:
 
-## How the integration works
+- **Who's driving.** You sign in once in your browser (a quick, secure handoff — no passwords or tokens to copy around). Continue itself registers its own identity automatically the first time it runs, and any sub-agents get their own too. The "who acted on whose behalf" trail stays queryable later.
+- **What it's allowed to do.** Before a tool runs, Ory checks whether it's permitted. It starts in **watch mode** — nothing is blocked, you just *see* what would be — so it never gets in your way on day one.
+- **A record of everything.** Every decision (allowed, denied, skipped) is logged as a trace you can send to Jaeger, Honeycomb, Grafana, or just a file.
 
-Continue runs the Ory plugin as a **subprocess hook**, the same way [Claude Code](https://github.com/anthropics/claude-code) does — and Continue reads hooks from both `.continue/settings.json` and `.claude/settings.json`. Each lifecycle event launches the hook binary with the event payload as JSON on stdin; the hook replies on stdout and signals a hard block with **exit code 2**.
+If Ory is ever unreachable, the plugin gets out of the way and lets Continue keep working — so it can't lock you out.
 
-The hooks wire into these phases:
+Under the hood, Continue runs the plugin the same way [Claude Code](https://github.com/anthropics/claude-code) does — as a small subprocess for each event — and it reads hooks from both `.continue/` and `.claude/` settings. When a tool is blocked, the plugin signals it with exit code 2 and Continue shows why.
 
-- **SessionStart** — run the user and agent auth gates.
-- **PreToolUse / PermissionRequest** — check the tool against Ory Permissions. In enforce mode a `PreToolUse` deny blocks the call with exit code 2, while a `PermissionRequest` deny is returned as a structured deny decision in the hook output. In observe mode a permission-request deny is recorded as an audit span and falls through to Continue's native user prompt — it is never pre-approved on the user's behalf.
-- **SubagentStart / SubagentStop** — resolve a distinct identity for typed sub-agents and record their lifecycle.
-- **PostToolUse / Stop / SessionEnd** — trace-only audit spans.
+### See what's happening
 
-The plugin is **fail-open** on its own infrastructure failures (network errors, rate limits, missing config): the agent always starts, and enforcement is only as strong as your permission grants.
+Everything the plugin does is observable out of the box — no configuration required:
 
-## Agent security
+- **Status at a glance.** `npx -y -p @ory/continue ory-continue status` shows what's configured, who's signed in, how many built-in tools your permissions cover, and the most recent tool-call activity.
+- **Live traces.** Every tool call is recorded as an OpenTelemetry-style span. Watch them stream as the agent works:
 
-Once pointed at an Ory project (local or hosted), Continue's session and every tool call can be governed by Ory.
+  ```bash
+  npx -y -p @ory/continue ory-continue watch
+  ```
 
-- **Authentication.** The human at the keyboard (the **user**) authenticates interactively via Ory Identities when user login is on (`ORY_USER_LOGIN=true`, off by default — browser PKCE flow on first session, persisted token thereafter). The Continue process (the **agent**) gets its own OAuth2 identity, self-registered via [Dynamic Client Registration (RFC 7591)](https://datatracker.ietf.org/doc/html/rfc7591) on first run.
-- **Authorization.** Before any tool runs, the plugin checks [Ory Permissions](https://www.ory.com/docs/keto) (Zanzibar-style relations) against the user's subject and blocks on `deny`.
-- **Audit.** Every decision is recorded as a structured trace span (NDJSON file and/or OTLP export).
+  Spans are also written to `~/.config/ory-agent-plugins/continue/ory-agent-trace.ndjson` (NDJSON, one span per line) — tail that file, or point `OTEL_EXPORTER_OTLP_ENDPOINT` at a collector to ship them straight to Jaeger, Honeycomb, or Grafana.
+- **Debug log.** For a verbose play-by-play, set `ORY_AGENT_DEBUG=true`; structured logs land in `~/.config/ory-agent-plugins/continue/ory-agent-debug.log`.
 
-### Permission modes: observe → enforce
+### Ready to enforce?
 
-After install the plugin runs in **observe mode**: every tool call is checked, but a deny is recorded as a `permission.observe_deny` audit span and the tool runs anyway. This lets you see what *would* be blocked first.
+When the watch-mode logs look right, turn on blocking with one command (setup already granted you the built-in tools):
 
 ```bash
-# Grant the current user `use` on every built-in tool (idempotent):
-npx -y -p @ory/continue ory-continue permissions bootstrap
-
-# See allowed/denied per tool:
-npx -y -p @ory/continue ory-continue permissions status
-
-# Turn on hard blocking once the observe-mode logs look right:
 npx -y -p @ory/continue ory-continue permissions enforce
 ```
 
-Switch back any time with `permissions observe`. To disable Ory entirely (audit logging only, no auth or checks), run `ory-continue configure --audit-only`.
+Now a denied tool is actually blocked. Go back to watch mode anytime with `permissions observe`. Use `permissions status` to see what's covered and `permissions bootstrap` to (re-)grant the built-in tools.
+
+## Also: add login to your own app
 
-## Pointing at a real Ory project
+Beyond securing Continue, the plugin helps you build Ory into whatever you're working on. Ask Continue *"add Ory login to this app"* and it scaffolds the login, registration, recovery, and settings pages (using [Ory Elements](https://github.com/ory/elements)) wired to a local Ory — no signup or keys needed. Start that local Ory with `/ory-local-up` (it prints a test email + password to sign in with) and tear it down with `/ory-local-down`.
 
-The Quickstart uses the local stack. To point at a hosted [Ory Network](https://console.ory.sh) project:
+Bundled **skills** (just ask in plain language, and Continue surfaces each as a slash command) cover more: `ory-auth-setup`, `ory-login-flow`, `ory-social-login` (Google, GitHub, Apple…), `ory-permissions-onboarding`, and playbooks for wiring Ory into your own agents, E2B sandboxes, or Temporal workers.
+
+## Configure by hand (CI / advanced)
+
+The guided setup covers most people. For scripted or CI setups, or to point at an existing Ory Network project, configure directly. Settings are saved to `~/.config/ory-agent-plugins/config.json` and shared across all your Ory agent plugins; environment variables win when both are set.
 
 ```bash
 npx -y -p @ory/continue ory-continue configure \
-  --project-url https://<id>.projects.oryapis.com \
-  --oauth2-client-id <public OAuth2 client id>
+  --project-url https://<slug>.projects.oryapis.com \
+  --oauth2-client-id <login client id> \
+  --user-login
 ```
 
-`--oauth2-client-id` is required whenever `--project-url` is set — the user PKCE flow needs a public OAuth2 client registered with the four loopback redirect URIs (`http://127.0.0.1:47823..47826/callback`). See the [repo README](../../README.md) and [`AGENTS.md`](../../AGENTS.md) for the full environment-variable reference (`ORY_PROJECT_URL`, `ORY_USER_LOGIN`, `ORY_OAUTH2_CLIENT_ID`, agent-identity vars) and permission-mode semantics. Config is shared across every Ory agent plugin at `~/.config/ory-agent-plugins/config.json`.
+Continue's own identity registers itself automatically on first run — nothing to create. The `--oauth2-client-id` is the one piece browser sign-in needs; the guided setup makes it for you, or see below to do it by hand. For logging-only with no checks, use `--audit-only`.
+
+<details>
+<summary>Create the sign-in client by hand</summary>
+
+The guided setup normally does this. To do it yourself, create a **public** OAuth2 client (no secret) listing all four loopback URLs — the plugin tries each in turn so sign-in survives a busy port:
+
+```bash
+ory create oauth2-client --project <project-id> \
+  --name "ory-agent-plugin" \
+  --grant-type authorization_code,refresh_token \
+  --response-type code \
+  --scope openid,offline_access \
+  --token-endpoint-auth-method none \
+  --redirect-uri http://127.0.0.1:47823/callback \
+  --redirect-uri http://127.0.0.1:47824/callback \
+  --redirect-uri http://127.0.0.1:47825/callback \
+  --redirect-uri http://127.0.0.1:47826/callback
+```
+
+Pass the resulting id to `configure --oauth2-client-id`. Running headless with a session token already? Set `ORY_USER_SESSION_TOKEN` and skip the browser step entirely.
+
+</details>
+
+With nothing configured, the plugin still loads and runs in **pass-through mode**: skills and their slash commands work, but no checks run and nothing is blocked. Perfectly fine if you only want the app-building features.
+
+## Commands
+
+```
+ory-continue install | uninstall        Install/remove; --reconfigure re-runs setup, --no-configure skips it
+ory-continue status                      Show configuration, identities, permission coverage, recent activity
+ory-continue watch                       Tail the live trace stream (OTel spans)
+ory-continue permissions <cmd>           status | bootstrap | observe (watch) | enforce (block)
+ory-continue configure <flags>           Point at a project by hand (--project-url, --oauth2-client-id, --user-login, --audit-only)
+ory-continue agent <status|unregister>   Manage Continue's own auto-created identity
+```
+
+All prefixed with `npx -y -p @ory/continue`.
+
+## Troubleshooting
 
-Without configuration the plugin still loads cleanly and runs in **pass-through mode**: skills and their slash commands work, but nothing is blocked.
+- **`/ory-local-up` fails** — make sure Docker is running and ports `4000`, `4100`, `4455`, and `16686` are free.
+- **Browser sign-in loops** — reset with `ory-continue agent unregister` and try again.
+- **`npx` grabbed an old version** — force the latest: `npx -y -p @ory/continue@latest ory-continue …`.
+- **Hooks stuck on an old version** — re-run the installer.
+- **Want to see what's happening** — `npx -y -p @ory/continue ory-continue status` for a snapshot, `npx -y -p @ory/continue ory-continue watch` for the live trace stream, or set `ORY_AGENT_DEBUG=true` for a verbose log. Traces and logs live under `~/.config/ory-agent-plugins/continue/` (see [See what's happening](#see-whats-happening)).
 
-## Links
+## Learn more
 
-- [Ory documentation](https://www.ory.com/docs/)
+- [Ory documentation](https://www.ory.com/docs/) · [Ory Console](https://console.ory.sh) · [Ory Elements](https://github.com/ory/elements)
 - [Continue documentation](https://docs.continue.dev/)
-- [Repo README](../../README.md) and [AGENTS.md](../../AGENTS.md) — full env-var and permission-mode reference
 
 ## License
 

package/dist/cli/main.js

@@ -56,14 +56,19 @@ function main() {
     const [command, ...args] = process.argv.slice(2);
     switch (command) {
         case "install":
+            (0, argus_1.beginDeferNextSteps)();
             install(args);
-            postInstallPermissions("ory-continue", "continue").then(() => process.exit(0), (err) => {
+            (0, argus_1.runPostInstall)("ory-continue", "continue", args).then(() => process.exit(0), (err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
             break;
         case "uninstall":
             uninstall(args);
+            (0, argus_1.clearCredentialsForUninstall)().then(() => process.exit(0), (err) => {
+                console.error(err.message ?? err);
+                process.exit(1);
+            });
             break;
         case "configure":
             (0, argus_1.runConfigureCommand)("ory-continue", args);
@@ -95,6 +100,9 @@ function main() {
                 process.exit(1);
             });
             break;
+        case "watch":
+            (0, argus_1.runWatchCommand)("continue", args);
+            break;
         case "help":
         case "--help":
         case "-h":
@@ -124,12 +132,6 @@ function uninstall(args) {
     process.argv = ["node", "setup.js", ...setupArgs];
     require("./setup.js");
 }
-async function postInstallPermissions(binName, harness) {
-    const bootstrapped = await (0, argus_1.maybeAutoBootstrap)(binName, harness);
-    (0, argus_1.printPermissionsOnboardingHelp)(binName, harness, {
-        bootstrappedAutomatically: bootstrapped,
-    });
-}
 /**
  * Print a three-line quickstart so a fresh user sees the happy path
  * before the more detailed credentials and permissions banners scroll by.
@@ -156,7 +158,7 @@ function help() {
 ory-continue — Ory plugin for Continue CLI (cn)
 
 Usage:
-  npx ory-continue <command> [options]
+  npx -y -p @ory/continue ory-continue <command> [options]
 
 Commands:
   install                Write Ory hooks and skills into .continue/
@@ -166,6 +168,7 @@ Commands:
   permissions <cmd>      Manage permission mode and tool permissions (status, bootstrap, observe, enforce)
   setup [--project-dir]  Write hooks directly to .continue/settings.json
   status                 Show plugin status and configuration
+  watch [trace-file]     Tail the trace stream (OTel spans) live
   local <cmd>            Manage local Ory dev environment (up, down, status, seed, ...)
 
 After installing, the plugin hooks into these Continue CLI lifecycle events:
@@ -174,9 +177,9 @@ After installing, the plugin hooks into these Continue CLI lifecycle events:
   PostToolUse            Audit log tool executions
 
 Examples:
-  npx ory-continue install          # Install hooks + assets
-  npx ory-continue status           # Check configuration
-  npx ory-continue uninstall        # Remove hooks + assets
+  npx -y -p @ory/continue ory-continue install          # Install hooks + assets
+  npx -y -p @ory/continue ory-continue status           # Check configuration
+  npx -y -p @ory/continue ory-continue uninstall        # Remove hooks + assets
 `);
 }
 main();

package/dist/cli/setup.js

@@ -109,6 +109,18 @@ function main() {
     (0, assets_js_1.installContinueOryAssets)(continueDir);
     console.log(`Ory hooks and MCP server installed to ${settingsPath}`);
     console.log(`Ory skills installed to ${continueDir}`);
-    (0, argus_1.printNextSteps)("Continue CLI", "npx ory-continue-setup --uninstall");
+    (0, argus_1.printNextSteps)("Continue CLI", "npx -y -p @ory/continue ory-continue-setup --uninstall", {
+        binName: "ory-continue",
+        harness: "continue",
+    });
 }
 main();
+// When invoked directly as the `-setup` bin with `--uninstall`, also clear
+// stored Ory credentials. When required by the plugin's main CLI, that
+// command owns the purge, so the `require.main` guard prevents a double run.
+if (require.main === module && process.argv.includes("--uninstall")) {
+    (0, argus_1.clearCredentialsForUninstall)().then(() => process.exit(0), (err) => {
+        console.error(err.message ?? err);
+        process.exit(1);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ory/continue",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Ory plugin for Continue CLI (cn): scaffolding skills, a local Ory instance, and authentication, authorization, and audit for every tool call",
   "license": "Apache-2.0",
   "homepage": "https://ory.com",
@@ -67,7 +67,7 @@
     "!dist/**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@ory/argus": "0.11.1"
+    "@ory/argus": "0.12.0"
   },
   "engines": {
     "node": ">=22"