@ory/continue 0.11.1 → 0.12.1

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:
+Run one command. It installs the plugin and walks you through connecting:
 
-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).
+```bash
+npx -y -p @ory/continue ory-cn install
+```
+
+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`).
 
-## Prerequisites
+You'll be asked how you want to connect — **press Enter for the default**:
 
-- [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.
+- **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.
 
-## Install
+That's it. Confirm everything landed with:
 
 ```bash
-npx -y -p @ory/continue ory-continue install
+npx -y -p @ory/continue ory-cn status
 ```
 
-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:
+`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)`.
 
-```bash
-npx -y -p @ory/continue ory-continue status
-```
+> Re-run install with `--reconfigure` to change your connection later, or `--no-configure` to skip the wizard and configure by hand.
 
-`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)`.
+## What you get
 
-Uninstall removes only the Ory hooks and skills, leaving the rest of your settings intact:
+Once connected, every tool Continue runs is governed by Ory — three things happen automatically:
 
-```bash
-npx -y -p @ory/continue ory-continue uninstall
-```
+- **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.
 
-## Quickstart (≈ 3 minutes)
+If Ory is ever unreachable, the plugin gets out of the way and lets Continue keep working — so it can't lock you out.
 
-From any project where you'd like Ory authentication, inside Continue:
+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.
 
-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.
+### See what's happening
 
-That's the full Ory DX path. Continue to [Agent security](#agent-security) when you're ready to enforce.
+Everything the plugin does is observable out of the box — no configuration required:
 
-## How the integration works
+- **Status at a glance.** `npx -y -p @ory/continue ory-cn 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:
 
-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**.
+  ```bash
+  npx -y -p @ory/continue ory-cn watch
+  ```
 
-The hooks wire into these phases:
+  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`.
 
-- **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.
+### Ready to enforce?
 
-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.
+When the watch-mode logs look right, turn on blocking with one command (setup already granted you the built-in tools):
 
-## Agent security
+```bash
+npx -y -p @ory/continue ory-cn permissions enforce
+```
 
-Once pointed at an Ory project (local or hosted), Continue's session and every tool call can be governed by Ory.
+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.
 
-- **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).
+## Also: add login to your own app
 
-### Permission modes: observe → enforce
+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`.
 
-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.
+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.
 
-```bash
-# Grant the current user `use` on every built-in tool (idempotent):
-npx -y -p @ory/continue ory-continue permissions bootstrap
+## Configure by hand (CI / advanced)
 
-# See allowed/denied per tool:
-npx -y -p @ory/continue ory-continue permissions status
+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.
 
-# Turn on hard blocking once the observe-mode logs look right:
-npx -y -p @ory/continue ory-continue permissions enforce
+```bash
+npx -y -p @ory/continue ory-cn configure \
+  --project-url https://<slug>.projects.oryapis.com \
+  --oauth2-client-id <login client id> \
+  --user-login
 ```
 
-Switch back any time with `permissions observe`. To disable Ory entirely (audit logging only, no auth or checks), run `ory-continue configure --audit-only`.
+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`.
 
-## Pointing at a real Ory project
+<details>
+<summary>Create the sign-in client by hand</summary>
 
-The Quickstart uses the local stack. To point at a hosted [Ory Network](https://console.ory.sh) project:
+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
-npx -y -p @ory/continue ory-continue configure \
-  --project-url https://<id>.projects.oryapis.com \
-  --oauth2-client-id <public OAuth2 client id>
+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
 ```
 
-`--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`.
+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-cn install | uninstall        Install/remove; --reconfigure re-runs setup, --no-configure skips it
+ory-cn status                      Show configuration, identities, permission coverage, recent activity
+ory-cn watch                       Tail the live trace stream (OTel spans)
+ory-cn permissions <cmd>           status | bootstrap | observe (watch) | enforce (block)
+ory-cn configure <flags>           Point at a project by hand (--project-url, --oauth2-client-id, --user-login, --audit-only)
+ory-cn 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-cn agent unregister` and try again.
+- **`npx` grabbed an old version** — force the latest: `npx -y -p @ory/continue@latest ory-cn …`.
+- **Hooks stuck on an old version** — re-run the installer.
+- **Want to see what's happening** — `npx -y -p @ory/continue ory-cn status` for a snapshot, `npx -y -p @ory/continue ory-cn 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/assets.js

@@ -56,7 +56,7 @@ const argus_1 = require("@ory/argus");
 const HARNESS = "continue";
 const PACKAGE_NAME = "@ory/continue";
 const RENDER_OPTS = {
-    binName: "ory-continue",
+    binName: "ory-cn",
     packageName: PACKAGE_NAME,
 };
 function safeRmEmpty(dir) {

package/dist/cli/main.d.ts

@@ -3,12 +3,12 @@
  * Main CLI for @ory/continue.
  *
  * Usage:
- *   npx ory-continue install                Write hooks to settings.json + assets
- *   npx ory-continue uninstall              Remove hooks and assets
- *   npx ory-continue configure              Set or view Ory credentials
- *   npx ory-continue setup [--project-dir]  Write hooks to settings.json directly
- *   npx ory-continue status                 Show plugin status
- *   npx ory-continue local <cmd>            Manage local Ory dev environment
+ *   npx ory-cn install                Write hooks to settings.json + assets
+ *   npx ory-cn uninstall              Remove hooks and assets
+ *   npx ory-cn configure              Set or view Ory credentials
+ *   npx ory-cn setup [--project-dir]  Write hooks to settings.json directly
+ *   npx ory-cn status                 Show plugin status
+ *   npx ory-cn local <cmd>            Manage local Ory dev environment
  *
  * Continue (the `cn` CLI) has no extension-install command, so `install` is a
  * thin wrapper over the same settings.json setup path the README documents.

package/dist/cli/main.js

@@ -4,12 +4,12 @@
  * Main CLI for @ory/continue.
  *
  * Usage:
- *   npx ory-continue install                Write hooks to settings.json + assets
- *   npx ory-continue uninstall              Remove hooks and assets
- *   npx ory-continue configure              Set or view Ory credentials
- *   npx ory-continue setup [--project-dir]  Write hooks to settings.json directly
- *   npx ory-continue status                 Show plugin status
- *   npx ory-continue local <cmd>            Manage local Ory dev environment
+ *   npx ory-cn install                Write hooks to settings.json + assets
+ *   npx ory-cn uninstall              Remove hooks and assets
+ *   npx ory-cn configure              Set or view Ory credentials
+ *   npx ory-cn setup [--project-dir]  Write hooks to settings.json directly
+ *   npx ory-cn status                 Show plugin status
+ *   npx ory-cn local <cmd>            Manage local Ory dev environment
  *
  * Continue (the `cn` CLI) has no extension-install command, so `install` is a
  * thin wrapper over the same settings.json setup path the README documents.
@@ -56,26 +56,31 @@ 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-cn", "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);
+            (0, argus_1.runConfigureCommand)("ory-cn", args);
             break;
         case "agent":
-            (0, argus_1.runAgentCommand)("ory-continue", args).then((code) => process.exit(code), (err) => {
+            (0, argus_1.runAgentCommand)("ory-cn", args).then((code) => process.exit(code), (err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
             break;
         case "permissions":
-            (0, argus_1.runPermissionsCommand)("ory-continue", "continue", args).then((code) => process.exit(code), (err) => {
+            (0, argus_1.runPermissionsCommand)("ory-cn", "continue", args).then((code) => process.exit(code), (err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
@@ -90,11 +95,14 @@ function main() {
             });
             break;
         case "local":
-            (0, argus_1.runLocalCommand)("ory-continue", args).catch((err) => {
+            (0, argus_1.runLocalCommand)("ory-cn", args).catch((err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
             break;
+        case "watch":
+            (0, argus_1.runWatchCommand)("continue", args);
+            break;
         case "help":
         case "--help":
         case "-h":
@@ -117,19 +125,13 @@ function install(args) {
     process.argv = ["node", "setup.js", ...args];
     require("./setup.js");
     printQuickstart();
-    (0, argus_1.printEnvHelp)("ory-continue");
+    (0, argus_1.printEnvHelp)("ory-cn");
 }
 function uninstall(args) {
     const setupArgs = ["--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.
@@ -142,7 +144,7 @@ function printQuickstart() {
     console.log("  3. Set ORY_USER_LOGIN=true to enable the interactive PKCE browser login.");
 }
 async function status() {
-    await (0, argus_1.runStatusCommand)("ory-continue", "continue", {
+    await (0, argus_1.runStatusCommand)("ory-cn", "continue", {
         title: "Continue CLI",
         printPluginSection: () => {
             console.log("Hooks & plugin:");
@@ -153,10 +155,10 @@ async function status() {
 }
 function help() {
     console.log(`
-ory-continue — Ory plugin for Continue CLI (cn)
+ory-cn — Ory plugin for Continue CLI (cn)
 
 Usage:
-  npx ory-continue <command> [options]
+  npx -y -p @ory/continue ory-cn <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-cn install          # Install hooks + assets
+  npx -y -p @ory/continue ory-cn status           # Check configuration
+  npx -y -p @ory/continue ory-cn uninstall        # Remove hooks + assets
 `);
 }
 main();

package/dist/cli/setup.d.ts

@@ -6,10 +6,10 @@
  * directly into the harness's settings.json.
  *
  * Usage:
- *   npx ory-continue-setup                    # Auto-detect and configure
- *   npx ory-continue-setup --project-dir /path/to/repo
- *   npx ory-continue-setup --print            # Print config to stdout without writing
- *   npx ory-continue-setup --uninstall        # Remove Ory hooks from settings
+ *   npx ory-cn-setup                    # Auto-detect and configure
+ *   npx ory-cn-setup --project-dir /path/to/repo
+ *   npx ory-cn-setup --print            # Print config to stdout without writing
+ *   npx ory-cn-setup --uninstall        # Remove Ory hooks from settings
  *
  * Verified against @continuedev/cli: Continue reads a top-level `hooks` object
  * from `.continue/settings.json` (also `.claude/settings.json` and home

package/dist/cli/setup.js

@@ -7,10 +7,10 @@
  * directly into the harness's settings.json.
  *
  * Usage:
- *   npx ory-continue-setup                    # Auto-detect and configure
- *   npx ory-continue-setup --project-dir /path/to/repo
- *   npx ory-continue-setup --print            # Print config to stdout without writing
- *   npx ory-continue-setup --uninstall        # Remove Ory hooks from settings
+ *   npx ory-cn-setup                    # Auto-detect and configure
+ *   npx ory-cn-setup --project-dir /path/to/repo
+ *   npx ory-cn-setup --print            # Print config to stdout without writing
+ *   npx ory-cn-setup --uninstall        # Remove Ory hooks from settings
  *
  * Verified against @continuedev/cli: Continue reads a top-level `hooks` object
  * from `.continue/settings.json` (also `.claude/settings.json` and home
@@ -54,7 +54,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const argus_1 = require("@ory/argus");
 const assets_js_1 = require("./assets.js");
-const BIN_NAME = "ory-continue-hook";
+const BIN_NAME = "ory-cn-hook";
 const PACKAGE_NAME = "@ory/continue";
 function getSettingsPath(args) {
     return path.join(args.projectDir, ".continue", "settings.json");
@@ -77,7 +77,7 @@ function generateHooksConfig() {
 }
 function main() {
     if (process.argv.includes("--help") || process.argv.includes("-h")) {
-        (0, argus_1.printSetupHelp)("ory-continue-setup", "Continue CLI");
+        (0, argus_1.printSetupHelp)("ory-cn-setup", "Continue CLI");
         process.exit(0);
     }
     const args = (0, argus_1.parseSetupArgs)();
@@ -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-cn-setup --uninstall", {
+        binName: "ory-cn",
+        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/dist/handlers.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleHookEvent = handleHookEvent;
 const argus_1 = require("@ory/argus");
 const HARNESS = "continue";
-const BIN_NAME = "ory-continue";
+const BIN_NAME = "ory-cn";
 /**
  * Route a Continue CLI hook event to the appropriate Ory integration.
  *
@@ -102,7 +102,7 @@ async function handleSessionStart(input, client, deps) {
     if (!resolved.projectUrl) {
         client.logger.warn("config.not_configured", {
             message: "Ory plugin is not configured. Auth and permission checks are disabled. " +
-                "Run 'npx ory-continue configure' to connect to an Ory project.",
+                "Run 'npx ory-cn configure' to connect to an Ory project.",
         });
         return {};
     }

package/dist/settings.js

@@ -67,7 +67,7 @@ function generateSettings(hookScriptPath) {
  * Generate settings assuming the plugin is installed via npm/pnpm.
  */
 function generateInstalledSettings() {
-    return generateSettings("ory-continue-hook");
+    return generateSettings("ory-cn-hook");
 }
 /**
  * Generate settings pointing to a local dev build.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ory/continue",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "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",
@@ -57,9 +57,9 @@
     }
   },
   "bin": {
-    "ory-continue": "dist/cli/main.js",
-    "ory-continue-hook": "dist/hook.js",
-    "ory-continue-setup": "dist/cli/setup.js"
+    "ory-cn": "dist/cli/main.js",
+    "ory-cn-hook": "dist/hook.js",
+    "ory-cn-setup": "dist/cli/setup.js"
   },
   "files": [
     "dist",
@@ -67,7 +67,8 @@
     "!dist/**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@ory/argus": "0.11.1"
+    "reo-census": "^1.2.8",
+    "@ory/argus": "0.12.1"
   },
   "engines": {
     "node": ">=22"