npm - @ory/cline - Versions diffs - 0.14.0 → 1.0.1 - Mend

@ory/cline 0.14.0 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md CHANGED Viewed

@@ -2,9 +2,12 @@
 Security and developer experience for [Cline](https://github.com/cline/cline), powered by [Ory](https://ory.com).
-**Security.** Cline 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; Cline 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.
+Cline runs real actions on your machine — editing files, running shell commands, calling APIs. This plugin gives those actions an identity, a permission check, and an audit trail.
-**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.
+One command installs two independent halves:
+- **Developer experience** — the Ory skill catalog, the local Ory dev stack, and activity logging. No account, no keys, nothing to configure: it works the moment it's installed.
+- **Ory Agent Security** — browser sign-in, brokered permission checks before tool calls, and the delegation trail. Opt-in connection details from the [Ory Console](https://console.ory.sh) switch it on, and it takes nothing away from the half above. See [Connect to Ory Agent Security](#connect-to-ory-agent-security).
 ## What you'll need
@@ -15,110 +18,119 @@ Security and developer experience for [Cline](https://github.com/cline/cline), p
 ## Get started
-Run one command. It installs the plugin and walks you through connecting:
+Run one command:
 ```bash
 npx -y -p @ory/cline ory-cline install
 ```
-It opens a guided setup **in your browser** where you pick how to connect — the default takes just a click:
-- **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 Cline does.
-> No browser available (CI, SSH, headless)? The same walkthrough runs right in your terminal instead — or force it with `--no-web`.
-That's it. Confirm everything landed with:
+Add `--global` to install for every project (`~/.cline/hooks/`) instead of just this one. Confirm everything landed with:
 ```bash
 npx -y -p @ory/cline ory-cline status
 ```
-`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)`.
+`status` is your one-stop check: what's configured, who's signed in, which tools are covered by permissions, and recent activity. Until you connect Agent Security, the identity and permission rows say so and name what's missing.
+## Skills and commands
+Installing the plugin drops the full Ory playbook catalog into Cline. **Skills** are model-invoked — just say what you want in plain language and the matching one takes over.
+| Skill | What it does for you |
+|---|---|
+| `ory-auth-setup` | Adds a complete auth system to your app — login, registration, recovery, verification, settings — on [Ory Elements](https://github.com/ory/elements) |
+| `ory-login-flow` | Builds just the pages, wired to Ory's self-service flows |
+| `ory-social-login` | "Sign in with…" for Google, GitHub, Apple, Microsoft, Discord, Slack, GitLab, Facebook |
+| `ory-local-dev` | Develops and tests login/permission flows against a local Ory — no project, no account, offline |
+| `ory-permissions-onboarding` | Walks a fresh install from observe mode to enforced per-tool permissions without getting blocked |
+| `ory-build-agent` | Drops `@ory/argus` into an agent *you* own — Claude Agent SDK, OpenAI Agents, Mastra, Vercel AI, LangGraph/PydanticAI |
+| `ory-build-integration` | Wires Ory into your app: Action webhooks, JWT validation at a gateway, live event streams |
+| `ory-contribute-integration` | Authors and submits an integration to the public `ory/integrates` registry |
+| `ory-e2b-sandbox` | Scaffolds an E2B sandbox template that boots with this plugin preinstalled |
+| `ory-temporal-worker` | Scaffolds a Temporal TypeScript worker where every Activity is authenticated, authorized, and audited |
+The local stack has its own playbooks — ask for them by name:
-> Re-run install with `--reconfigure` to change your connection later, or `--no-configure` to skip the wizard and configure by hand. Add `--global` to install for every project (`~/.cline/hooks/`) instead of just this one.
+| Command | What it does |
+|---|---|
+| `ory-local-up` | Starts a local Ory (Identities, OAuth2, Permissions) in Docker and seeds a test user — it prints the email + password to sign in with |
+| `ory-local-down` | Stops it, keeping your data volumes |
+| `ory-temporal-up` | Starts a local Temporal dev server for the `ory-temporal-worker` scaffold |
+The local stack runs entirely on your laptop: Ory APIs at `http://localhost:4000`, a login UI on `:4455` (not `:3000`, to dodge Next.js port clashes), and the Ory Console on `:4100`.
+So: ask Cline *"add Ory login to this app"* and it scaffolds the pages, starts a local Ory, and wires them together.
 ## What you get
-Once connected, every task and tool call Cline runs is governed by Ory — three things happen automatically:
+Out of the box, every tool Cline runs produces a privacy-safe structured activity event in the unified local log.
-- **Who's driving.** You sign in once in your browser; Cline gets its own identity too, and registers it automatically on first run — no tokens to copy around. 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.
+Once you connect to Ory Agent Security, two more things happen automatically:
+- **Who's driving.** You sign in once in your browser; each Cline session gets its own identity and registers it automatically on first use — no tokens to copy around. 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 **observe mode** — nothing is blocked, you just *see* what would be — so it never gets in your way on day one.
 If Ory is ever unreachable, the plugin gets out of the way and lets Cline keep working — so it can't lock you out.
 ### See what's happening
-Everything the plugin does is observable out of the box — no configuration required:
+Everything the plugin does is observable out of the box:
-- **Status at a glance.** `npx -y -p @ory/cline ory-cline 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 dashboard.** `npx -y -p @ory/cline ory-cline dashboard` opens the same picture in your browser — configuration, identities, permission coverage, Ory service health, and the latest tool-call activity, all refreshing live. From there you can flip **enforcement** on or off, toggle **user login**, and use **Change stack** to reconnect to a different Ory — no CLI required.
-- **Live traces.** Every tool call is recorded as an OpenTelemetry-style span. Watch them stream as the agent works:
+- **Activity log.** Privacy-safe activity is always appended to `~/.config/ory-agent-plugins/cline/ory-agent-debug.log`. View events, decisions, and errors live with:
   ```bash
   npx -y -p @ory/cline ory-cline watch
   ```
-  Spans are also written to `~/.config/ory-agent-plugins/cline/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/cline/ory-agent-debug.log`.
+  Set `ORY_AGENT_LOG_FILE` to override the path; set it empty to disable file persistence.
+- **Live debug.** Launch Cline with `ORY_AGENT_DEBUG=true` to add verbose local diagnostics, including raw shell commands, to the watched log and stderr. Secrets are recursively redacted; pass `watch --json` for NDJSON.
 ### Ready to enforce?
-When the watch-mode logs look right, turn on blocking with one command (setup already granted you the built-in tools):
+Once connected, the deny posture lives on the Ory project: when the observe-mode activity looks right, an admin promotes it to **enforce** in the **Ory Console** (Agent Security). Every session reads that posture live, so nothing has to be reinstalled.
 ```bash
-npx -y -p @ory/cline ory-cline permissions enforce
+npx -y -p @ory/cline ory-cline permissions   # what the project grants, and the live mode
 ```
-Now a denied tool is actually blocked and Cline shows why. Go back to watch mode anytime with `permissions observe`. Prefer clicking? The dashboard has the same **Enforce** switch — flip it on, or back to watch mode, without touching the CLI. 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
+Then a denied tool is actually blocked and Cline shows why.
-Beyond securing Cline, the plugin helps you build Ory into whatever you're working on. Ask Cline *"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. These are **skills**: just ask in plain language and the matching one takes over.
+## Connect to Ory Agent Security
-Start that local Ory with the `ory-local-up` skill (it prints a test email + password to sign in with) and tear it down with `ory-local-down`. It runs the Ory APIs at `http://localhost:4000`, a login UI on `:4455` (not :3000, to avoid Next.js port conflicts), the Ory Console on `:4100`, and Jaeger on `:16686`. More bundled skills cover login flows, social sign-in (Google, GitHub, Apple…), permissions onboarding, and playbooks for wiring Ory into your own agents, E2B sandboxes, or Temporal workers.
+Copy the connection details from the [Ory Console](https://console.ory.sh) under **Agent Security**:
-## 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.
+| Value | Flag | Environment variable |
+|---|---|---|
+| Project URL | `--project-url` | `ORY_PROJECT_URL` |
+| Agent Security URL | `--agent-security-url` | `ORY_AGENT_SECURITY_URL` |
+| Sign-in client id override (default `ory-agent-security-login`) | `--oauth2-client-id` | `ORY_OAUTH2_CLIENT_ID` |
 ```bash
 npx -y -p @ory/cline ory-cline configure \
   --project-url https://<slug>.projects.oryapis.com \
-  --oauth2-client-id <sign-in client id>
+  --agent-security-url https://agents.console.ory.com
 ```
-Cline's own identity registers itself automatically on first run — nothing to create. The `--oauth2-client-id` is the one piece browser sign-in needs (a **public sign-in client** registered with the loopback URLs `http://127.0.0.1:47823..47826/callback`); the guided setup makes it for you. For logging-only with no checks, use `--audit-only`. The interactive user login runs every session (always on, non-blocking) and only needs `ORY_OAUTH2_CLIENT_ID` to complete the browser flow.
-With nothing configured, the plugin still loads and runs in **pass-through mode**: skills and logging work, but no checks run and nothing is blocked. Perfectly fine if you only want the app-building features.
-<details>
-<summary>How the integration works</summary>
-Cline discovers hooks by directory — the presence of an executable script named after the event *is* the registration. `install` writes one thin shell shim per event into the workspace hooks directory `<project>/.clinerules/hooks/` (or `~/.cline/hooks/` with `--global`), makes each executable, and materializes the Ory skills. Each shim execs the published hook binary via `npx`. Install and uninstall respect hook scripts you authored: if an event name is already taken by a script Ory didn't write, install skips it and prints a warning; uninstall removes only the scripts Ory wrote.
+`install` accepts the same flags, so you can register the plugin **and** connect in one shot (`install --project-url <URL> --agent-security-url <URL>`). The login client defaults to `ory-agent-security-login`; custom deployments can override it with `--oauth2-client-id`. Existing configurations fall back to the project URL when the Agent Security URL is unset. To turn sign-in and checks back off later, use `configure --disconnect`.
-Cline runs each hook as a **subprocess**, passing the event as JSON on stdin and reading a JSON decision on stdout. A hook blocks a tool call by returning `{"cancel":true}`. Cline does **not** expose a separate approval-ask hook, so the plugin gates at the tool-call event. Hooks have a 30-second timeout.
+**Ory Network or OEL.** Either works. For an Ory Network project the URL is `https://<slug>.projects.oryapis.com`; for a self-hosted **Ory Enterprise License** deployment, point `--project-url` at that deployment's base URL and use the sign-in client id from its Agent Security configuration. Everything downstream — sign-in, checks, delegation — is identical.
-The hook filenames are PascalCase (`TaskStart`, `PreToolUse`, …); the payload Cline delivers carries the matching snake_case event name (`agent_start`, `tool_call`, …) the plugin acts on. The shims wire into these phases:
+**There is nothing else for you to create.** The sign-in client, the permission model, the per-tool grants and blocks, and the observe/enforce posture are all provisioned in the Console by someone with project access. At runtime the plugin only *reads* permissions — it has no write path into your project, which is why installing it needs no workspace privilege. Each Cline session registers its own identity automatically on first use.
-- **TaskStart** (`agent_start`) — signs the user in and gives Cline its identity.
-- **PreToolUse** (`tool_call`) — checks the tool against your permissions; a deny blocks the call in enforce mode.
-- **PostToolUse / TaskComplete / TaskCancel / TaskError / UserPromptSubmit / PreCompact / SessionShutdown** — audit-only trace spans.
+Sign-in runs at the start of every session and never blocks — a declined, skipped, or timed-out login simply leaves that session without a user identity.
-</details>
+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. Running headless with an OAuth2 access token already? Set `ORY_USER_OAUTH2_TOKEN` and the browser step is skipped entirely.
 ## Commands
 ```
-ory-cline install | uninstall        Install/remove; --reconfigure re-runs setup, --no-web forces the terminal wizard, --no-configure skips it
+ory-cline install | uninstall        Install (add --project-url to also connect Agent Security) / remove; --global installs for every project
 ory-cline status                     Show configuration, identities, permission coverage, recent activity
-ory-cline dashboard                  Open the live browser dashboard (status + service health + Change stack)
-ory-cline watch                      Tail the live trace stream (OTel spans)
-ory-cline permissions <cmd>          status | bootstrap | observe (watch) | enforce (block)
-ory-cline configure <flags>          Point at a project by hand (--project-url, --oauth2-client-id, --audit-only)
+ory-cline permissions <cmd>          status  (read-only; grants + posture live in the Ory Console)
+ory-cline configure <flags>          Connect a project (--project-url) or --disconnect
 ory-cline agent <status|unregister>  Manage Cline's own auto-created identity
+ory-cline local <up|down|status|…>   Run / manage a local Ory in Docker
+ory-cline version                    Print plugin, core, and Node versions (--json for machine-readable)
 ```
 All prefixed with `npx -y -p @ory/cline`.
@@ -126,16 +138,14 @@ All prefixed with `npx -y -p @ory/cline`.
 ## Troubleshooting
 - **Local Ory fails to start** — make sure Docker is running and ports `4000`, `4100`, `4455`, and `16686` are free.
-- **Browser sign-in loops** — reset with `ory-cline agent unregister` and try again.
-- **Install ran but never asked how to connect** — you're almost certainly on a stale `npx` cache. `npx -p @ory/cline` (no version pin) reuses a previously-downloaded copy instead of re-resolving to the latest, so an older CLI whose install predates the setup wizard can run while you believe you're on the current release. The install banner prints the running version; confirm it with `npx -y -p @ory/cline ory-cline version`. To force the current release, clear the cache and reinstall: `rm -rf ~/.npm/_npx` then `npx -y -p @ory/cline ory-cline install`. Pinning an exact version (`@ory/cline@<version>`) also bypasses the cached copy.
+- **Browser sign-in loops** (after connecting) — reset with `ory-cline agent unregister` and try again.
+- **Running an older CLI than expected** — `npx -p @ory/cline` (no version pin) reuses a previously-downloaded copy instead of re-resolving to the latest. The install banner prints the running version; confirm it with `npx -y -p @ory/cline ory-cline version`. To force the current release, clear the cache and reinstall: `rm -rf ~/.npm/_npx` then `npx -y -p @ory/cline ory-cline install`. Pinning an exact version (`@ory/cline@<version>`) also bypasses the cached copy.
 - **A hook didn't install** — check the install output for a skipped-event warning; move or remove your own script at that event name and re-run install.
-- **Want to see what's happening** — `npx -y -p @ory/cline ory-cline status` for a snapshot, `npx -y -p @ory/cline ory-cline 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/cline/` (see [See what's happening](#see-whats-happening)).
 ## Learn more
 - [Ory documentation](https://www.ory.com/docs/) · [Ory Console](https://console.ory.sh) · [Ory Elements](https://github.com/ory/elements)
 - [Cline repository](https://github.com/cline/cline)
-- [Repo README](../../README.md) and [AGENTS.md](../../AGENTS.md) — full env-var and permission-mode reference
 ## License

package/dist/cli/main.d.ts CHANGED Viewed

@@ -7,7 +7,7 @@
  *   npx ory-cline uninstall [--global]   Remove the Ory hook scripts
  *   npx ory-cline configure              Set or view Ory credentials
  *   npx ory-cline agent <cmd>            Manage the agent's OAuth2 (DCR) identity
- *   npx ory-cline permissions <cmd>      Manage permission mode and tool permissions
+ *   npx ory-cline permissions           Show permission mode and per-tool coverage
  *   npx ory-cline setup [options]        Write hook scripts directly (fallback)
  *   npx ory-cline status                 Show plugin status
  *   npx ory-cline local <cmd>            Manage the local Ory dev environment

package/dist/cli/main.js CHANGED Viewed

@@ -8,7 +8,7 @@
  *   npx ory-cline uninstall [--global]   Remove the Ory hook scripts
  *   npx ory-cline configure              Set or view Ory credentials
  *   npx ory-cline agent <cmd>            Manage the agent's OAuth2 (DCR) identity
- *   npx ory-cline permissions <cmd>      Manage permission mode and tool permissions
+ *   npx ory-cline permissions           Show permission mode and per-tool coverage
  *   npx ory-cline setup [options]        Write hook scripts directly (fallback)
  *   npx ory-cline status                 Show plugin status
  *   npx ory-cline local <cmd>            Manage the local Ory dev environment
@@ -54,6 +54,11 @@ const argus_1 = require("@ory/argus");
 const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
 function main() {
     const [command, ...args] = process.argv.slice(2);
+    // `--help` after a matched subcommand: print usage, do nothing else.
+    // Without this the switch below ignores the flag and `install --help`
+    // performs a real install (#221).
+    if ((0, argus_1.shouldPrintHelp)(command, args))
+        return help();
     switch (command) {
         case "install":
             (0, argus_1.beginDeferNextSteps)();
@@ -65,7 +70,10 @@ function main() {
             break;
         case "uninstall":
             uninstall(args);
-            (0, argus_1.clearCredentialsForUninstall)().then(() => process.exit(0), (err) => {
+            (0, argus_1.clearCredentialsForUninstall)({
+                harness: "cline",
+                purge: args.includes("--purge"),
+            }).then(() => process.exit(0), (err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
@@ -74,7 +82,7 @@ function main() {
             (0, argus_1.runConfigureCommand)("ory-cline", args);
             break;
         case "agent":
-            (0, argus_1.runAgentCommand)("ory-cline", args).then((code) => process.exit(code), (err) => {
+            (0, argus_1.runAgentCommand)("ory-cline", "cline", args).then((code) => process.exit(code), (err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
@@ -94,17 +102,11 @@ function main() {
                 process.exit(1);
             });
             break;
-        case "local":
-            (0, argus_1.runLocalCommand)("ory-cline", args).catch((err) => {
-                console.error(err.message ?? err);
-                process.exit(1);
-            });
-            break;
         case "watch":
-            (0, argus_1.runWatchCommand)("cline", args);
+            (0, argus_1.runWatchCommand)("ory-cline", "cline", args).then((code) => process.exit(code), (err) => { console.error(err.message ?? err); process.exit(1); });
             break;
-        case "dashboard":
-            (0, argus_1.runDashboardCommand)("ory-cline", "cline", args).then((code) => process.exit(code), (err) => {
+        case "local":
+            (0, argus_1.runLocalCommand)("ory-cline", args).catch((err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
@@ -169,11 +171,11 @@ Commands:
   uninstall [--global]   Remove the Ory hook scripts from Cline
   configure              Set or view Ory project URL and API key
   agent <cmd>            Manage the agent's OAuth2 (DCR) identity (status, unregister)
-  permissions <cmd>      Manage permission mode and tool permissions (status, bootstrap, observe, enforce)
+  permissions            Show the live permission mode and per-tool coverage
   setup [options]        Write hook scripts directly to the hooks directory (fallback)
   status                 Show plugin status and configuration
-  dashboard            Open the Ory Agent dashboard (system health + configuration)
-  watch [trace-file]     Tail the trace stream (OTel spans) live
+  watch [--json] [--lines <count>]
+                         Follow the live activity/debug log
   version                Show version and the ory-agent-plugins build commit
   local <cmd>            Manage local Ory dev environment (up, down, status, seed, ...)

package/dist/cli/setup.d.ts CHANGED Viewed

@@ -6,8 +6,8 @@
  * filename matches the event name, found in a hooks directory. There is no
  * per-hook config file — presence of the script IS the registration. We
  * therefore write one thin shell shim per event into the hooks directory and
- * `chmod 0755` it. Each shim execs the published hook binary via npx,
- * forwarding stdin so the JSON payload reaches the Node entry point.
+ * `chmod 0755` it. Each shim execs the Ory runtime shim resolved at install
+ * time, forwarding stdin so the JSON payload reaches the Node entry point.
  *
  * Hooks directory (verified against cline@3.0.29):
  *   workspace : <projectDir>/.clinerules/hooks/

package/dist/cli/setup.js CHANGED Viewed

@@ -7,8 +7,8 @@
  * filename matches the event name, found in a hooks directory. There is no
  * per-hook config file — presence of the script IS the registration. We
  * therefore write one thin shell shim per event into the hooks directory and
- * `chmod 0755` it. Each shim execs the published hook binary via npx,
- * forwarding stdin so the JSON payload reaches the Node entry point.
+ * `chmod 0755` it. Each shim execs the Ory runtime shim resolved at install
+ * time, forwarding stdin so the JSON payload reaches the Node entry point.
  *
  * Hooks directory (verified against cline@3.0.29):
  *   workspace : <projectDir>/.clinerules/hooks/
@@ -61,37 +61,22 @@ const path = __importStar(require("node:path"));
 const argus_1 = require("@ory/argus");
 const assets_js_1 = require("./assets.js");
 const shims_js_1 = require("./shims.js");
-const HOOK_BIN = "ory-cline-hook";
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
 /**
- * The version-pinned npx command that each shim execs. Resolving via npx
- * keeps the binary off the PATH requirement and pins the version the shim was
- * generated with (read from this package's own package.json).
- */
-function hookCommand() {
-    return (0, argus_1.pinHookToLocalRegistry)(`npx -y -p ${shims_js_1.PACKAGE_NAME}@${readPackageVersion()} ${HOOK_BIN}`);
-}
-function readPackageVersion() {
-    // dist/cli/setup.js -> package root is two levels up.
-    const pkgPath = path.resolve(__dirname, "..", "..", "package.json");
-    try {
-        const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        return parsed.version ?? "latest";
-    }
-    catch {
-        return "latest";
-    }
-}
-/**
- * Body of a per-event shim. A POSIX shell script that execs the hook binary,
- * forwarding stdin/stdout transparently. `exec` replaces the shell so the
- * hook's exit status and stdout flow straight back to Cline.
+ * Body of a per-event shim. A POSIX shell script that execs the Ory runtime
+ * entry, forwarding stdin/stdout transparently. `exec` replaces the shell so
+ * the hook's exit status and stdout flow straight back to Cline.
+ *
+ * The `${PACKAGE_NAME}` line is load-bearing beyond documentation: install and
+ * uninstall use it to tell our shims apart from hook scripts the user authored
+ * under the same event name (see `isOryShim`).
  */
-function shimBody() {
+function shimBody(hookCommand) {
     return `#!/bin/sh
 # Ory plugin hook shim for Cline. Generated by ${shims_js_1.PACKAGE_NAME} — do not edit.
 # Forwards the event payload (stdin JSON) to the Ory hook and returns its
 # JSON decision on stdout.
-exec ${hookCommand()}
+exec ${hookCommand}
 `;
 }
 /**
@@ -128,8 +113,9 @@ function main() {
         process.exit(0);
     }
     const args = (0, argus_1.parseSetupArgs)({ supportsGlobal: true });
-    const body = shimBody();
     if (args.print) {
+        // Nothing is resolved or written on a --print run.
+        const body = shimBody('node "<runtime shim>"');
         for (const event of shims_js_1.HOOK_EVENTS) {
             console.log(`# ── ${event} ───────────────────────────────`);
             console.log(body);
@@ -155,12 +141,29 @@ function main() {
         }
         (0, assets_js_1.uninstallClineOryAssets)(rulesRoot);
         console.log(`Removed Ory skills from ${path.join(rulesRoot, "skills")}`);
+        (0, argus_1.removeRuntimeWiring)("cline");
+        for (const pruned of (0, argus_1.pruneRuntimeStores)()) {
+            console.log(`  Removed runtime: ${pruned}`);
+        }
         return;
     }
+    const runtime = (0, argus_1.wireRuntime)({
+        harness: "cline",
+        packageName: shims_js_1.PACKAGE_NAME,
+        packageRoot: PACKAGE_ROOT,
+        installCommand: "npx -y -p @ory/cline ory-cline install",
+        args: process.argv.slice(2),
+    });
+    console.log(runtime.target.kind === "linked"
+        ? `Runtime: linked to ${runtime.target.packageDir} (dev)`
+        : `Runtime: ${runtime.target.packageName}@${runtime.target.version} in ${runtime.target.storeDir}`);
+    for (const pruned of runtime.prunedStores) {
+        console.log(`  Removed stale runtime: ${pruned}`);
+    }
     // Write the per-event shims, skipping any event whose script the user
     // authored (i.e. it exists but is not an Ory shim). Existing Ory shims
     // are refreshed.
-    const { written, skipped } = (0, shims_js_1.writeHookShims)(hooksDir, body);
+    const { written, skipped } = (0, shims_js_1.writeHookShims)(hooksDir, shimBody((0, argus_1.requireHookCommand)(runtime)));
     (0, assets_js_1.installClineOryAssets)(rulesRoot);
     console.log(`Ory hook scripts installed to ${hooksDir}`);
     console.log(`  Scripts: ${written.length > 0 ? written.join(", ") : "(none)"}`);
@@ -180,7 +183,10 @@ main();
 // 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) => {
+    (0, argus_1.clearCredentialsForUninstall)({
+        harness: "cline",
+        purge: process.argv.includes("--purge"),
+    }).then(() => process.exit(0), (err) => {
         console.error(err.message ?? err);
         process.exit(1);
     });

package/dist/cli/shims.d.ts CHANGED Viewed

@@ -16,15 +16,15 @@ export declare const PACKAGE_NAME = "@ory/cline";
  * carries the snake_case `hookName` the handler switches on:
  *
  *   TaskStart        → agent_start       (auth gates)
- *   TaskResume       → agent_resume      (trace-only)
- *   TaskCancel       → agent_abort       (trace-only)
- *   TaskComplete     → agent_end         (trace-only)
- *   TaskError        → agent_error       (trace-only)
+ *   TaskResume       → agent_resume      (activity-only)
+ *   TaskCancel       → agent_abort       (activity-only)
+ *   TaskComplete     → agent_end         (activity-only)
+ *   TaskError        → agent_error       (activity-only)
  *   PreToolUse       → tool_call         (permission gate, blocking)
- *   PostToolUse      → tool_result       (trace-only)
- *   UserPromptSubmit → prompt_submit     (trace-only)
- *   PreCompact       → pre_compact       (trace-only)
- *   SessionShutdown  → session_shutdown  (trace-only)
+ *   PostToolUse      → tool_result       (activity-only)
+ *   UserPromptSubmit → prompt_submit     (activity-only)
+ *   PreCompact       → pre_compact       (activity-only)
+ *   SessionShutdown  → session_shutdown  (activity-only)
  */
 export declare const HOOK_EVENTS: readonly ["TaskStart", "TaskResume", "TaskCancel", "TaskComplete", "TaskError", "PreToolUse", "PostToolUse", "UserPromptSubmit", "PreCompact", "SessionShutdown"];
 export declare function isOryShim(file: string): boolean;

package/dist/cli/shims.js CHANGED Viewed

@@ -57,15 +57,15 @@ exports.PACKAGE_NAME = "@ory/cline";
  * carries the snake_case `hookName` the handler switches on:
  *
  *   TaskStart        → agent_start       (auth gates)
- *   TaskResume       → agent_resume      (trace-only)
- *   TaskCancel       → agent_abort       (trace-only)
- *   TaskComplete     → agent_end         (trace-only)
- *   TaskError        → agent_error       (trace-only)
+ *   TaskResume       → agent_resume      (activity-only)
+ *   TaskCancel       → agent_abort       (activity-only)
+ *   TaskComplete     → agent_end         (activity-only)
+ *   TaskError        → agent_error       (activity-only)
  *   PreToolUse       → tool_call         (permission gate, blocking)
- *   PostToolUse      → tool_result       (trace-only)
- *   UserPromptSubmit → prompt_submit     (trace-only)
- *   PreCompact       → pre_compact       (trace-only)
- *   SessionShutdown  → session_shutdown  (trace-only)
+ *   PostToolUse      → tool_result       (activity-only)
+ *   UserPromptSubmit → prompt_submit     (activity-only)
+ *   PreCompact       → pre_compact       (activity-only)
+ *   SessionShutdown  → session_shutdown  (activity-only)
  */
 exports.HOOK_EVENTS = [
     "TaskStart",

package/dist/handlers.d.ts CHANGED Viewed

@@ -1,20 +1,12 @@
-import { OryAgentClient, ensureUserAuthenticated, ensureAgentIdentity } from "@ory/argus";
+import { OryAgentClient, ensureAgentIdentity, ensureSubAgentIdentity, ensureUserAuthenticated } from "@ory/argus";
 import type { ClineHookInput, ClineHookOutput } from "./types.js";
 export interface HandleHookEventDeps {
-    /** Test injection point for the user login flow. */
     userLogin?: typeof ensureUserAuthenticated;
-    /** Test injection point for the agent identity gate. */
     agentGate?: typeof ensureAgentIdentity;
+    subAgentGate?: typeof ensureSubAgentIdentity;
 }
 /**
- * Route a Cline file-hook event to the appropriate Ory integration.
- *
- * Cline has no dedicated approval-ask hook, so authorization is enforced at
- * the `tool_call` event. A deny becomes `{ cancel: true, errorMessage }`, which
- * prevents the tool from running.
- *
- * The on-disk script filenames are PascalCase (TaskStart, PreToolUse, …) but
- * the `hookName` field inside the stdin payload is the snake_case
- * `HookEventName` enum (verified against cline@3.0.29) — we switch on that.
+ * Route a Cline file-hook event to Ory. Cline blocks a `tool_call` with
+ * `{ cancel: true, errorMessage }`.
  */
 export declare function handleHookEvent(input: ClineHookInput, client: OryAgentClient, deps?: HandleHookEventDeps): Promise<ClineHookOutput>;

package/dist/handlers.js CHANGED Viewed

@@ -2,16 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleHookEvent = handleHookEvent;
 const argus_1 = require("@ory/argus");
+const HARNESS = "cline";
 /**
- * Route a Cline file-hook event to the appropriate Ory integration.
- *
- * Cline has no dedicated approval-ask hook, so authorization is enforced at
- * the `tool_call` event. A deny becomes `{ cancel: true, errorMessage }`, which
- * prevents the tool from running.
- *
- * The on-disk script filenames are PascalCase (TaskStart, PreToolUse, …) but
- * the `hookName` field inside the stdin payload is the snake_case
- * `HookEventName` enum (verified against cline@3.0.29) — we switch on that.
+ * Route a Cline file-hook event to Ory. Cline blocks a `tool_call` with
+ * `{ cancel: true, errorMessage }`.
  */
 async function handleHookEvent(input, client, deps = {}) {
     const event = input.hookName;
@@ -20,245 +14,116 @@ async function handleHookEvent(input, client, deps = {}) {
         taskId: input.taskId,
         toolName: input.preToolUse?.toolName ?? input.postToolUse?.toolName,
     });
-    // Set trace context so all spans within this hook invocation correlate.
-    client.tracer.setContext({
-        traceId: (0, argus_1.deriveTraceId)(input.taskId),
-        sessionId: input.taskId,
-    });
-    try {
+    return (0, argus_1.withHookContext)(client, { sessionId: input.taskId }, async () => {
         switch (event) {
             case "agent_start":
-                return await handleTaskStart(input, client, deps);
+                client.logger.info("lifecycle.task_start", {
+                    taskId: input.taskId,
+                    workspaceRoots: input.workspaceRoots,
+                });
+                await startTask(input, client, deps);
+                return {};
             case "agent_resume":
-                return await handleTaskResume(input, client);
+                client.logger.info("lifecycle.task_resume", { taskId: input.taskId });
+                await startTask(input, client, deps);
+                return {};
+            case "tool_call": {
+                const toolName = input.preToolUse?.toolName ?? "unknown";
+                const toolArgs = input.preToolUse?.parameters;
+                client.logger.info("lifecycle.pre_tool_use", {
+                    taskId: input.taskId,
+                    toolName,
+                    toolInput: toolArgs,
+                });
+                const result = await (0, argus_1.gate)(client, {
+                    harness: HARNESS,
+                    toolName,
+                    toolArgs,
+                    subjectFallback: `session:${input.taskId}`,
+                    principals: actingSubagentPrincipals(input),
+                });
+                return result.blocked
+                    ? { cancel: true, errorMessage: result.denialMessage }
+                    : {};
+            }
+            case "tool_result": {
+                const toolName = input.postToolUse?.toolName ?? "unknown";
+                client.logger.info("lifecycle.post_tool_use", {
+                    taskId: input.taskId,
+                    toolName,
+                    success: input.postToolUse?.success,
+                });
+                const terminal = {
+                    toolName,
+                    input: input.postToolUse?.parameters,
+                    extraActivityAttributes: {
+                        success: input.postToolUse?.success,
+                        executionTimeMs: input.postToolUse?.executionTimeMs,
+                    },
+                };
+                if (input.postToolUse?.success === false) {
+                    (0, argus_1.fail)(client, { ...terminal, error: input.postToolUse.result });
+                }
+                else {
+                    (0, argus_1.complete)(client, { ...terminal, output: input.postToolUse?.result });
+                }
+                return {};
+            }
             case "agent_abort":
-                return await handleTaskCancel(input, client);
+                return endTask(client, input, "ok", { reasonCode: "abort" }, "lifecycle.task_cancel");
             case "agent_end":
-                return await handleTaskComplete(input, client);
+                return endTask(client, input, "ok", { reasonCode: "complete" }, "lifecycle.task_complete");
             case "agent_error":
-                return await handleTaskError(input, client);
-            case "tool_call":
-                return await handlePreToolUse(input, client);
-            case "tool_result":
-                return await handlePostToolUse(input, client);
+                return endTask(client, input, "error", { reasonCode: "error" }, "lifecycle.task_error");
+            case "session_shutdown":
+                return endTask(client, input, "ok", { stage: "session_shutdown" }, "lifecycle.session_shutdown");
             case "prompt_submit":
-                return await handleUserPromptSubmit(input, client);
+                client.logger.info("lifecycle.user_prompt_submit", { taskId: input.taskId });
+                client.logger.activity("user.prompt", "ok", {
+                    attributes: { stage: "user_prompt_submit" },
+                });
+                return {};
             case "pre_compact":
-                return await handlePreCompact(input, client);
-            case "session_shutdown":
-                return await handleSessionShutdown(input, client);
+                client.logger.info("lifecycle.pre_compact", { taskId: input.taskId });
+                client.logger.activity("compaction", "ok", { attributes: { stage: "pre_compact" } });
+                return {};
             default:
                 client.logger.debug("hook.passthrough", { event });
-                client.tracer.record("hook.passthrough", "skipped", {
-                    attributes: { event },
-                });
+                client.logger.activity("hook.passthrough", "skipped", { attributes: { event } });
                 return {};
         }
-    }
-    finally {
-        client.tracer.clearContext();
-    }
-}
-// ─── agent_start (session.start) ───────────────────────────────────
-async function handleTaskStart(input, client, deps) {
-    client.logger.info("lifecycle.task_start", {
-        taskId: input.taskId,
-        workspaceRoots: input.workspaceRoots,
-    });
-    client.tracer.record("session.start", "ok", {
-        attributes: { clineVersion: input.clineVersion },
-    });
-    // 1. User gate. The user login runs every session and never blocks;
-    // enforcement is governed solely by permissionMode at tool-call time.
-    const userGate = deps.userLogin ?? argus_1.ensureUserAuthenticated;
-    await userGate(client, {
-        binName: "ory-cline",
-        harness: "cline",
-    });
-    // 2. Agent gate. Never blocks; attaches the agent's bearer token to
-    // outgoing Ory API calls.
-    const agentGate = deps.agentGate ?? argus_1.ensureAgentIdentity;
-    await agentGate(client, {
-        projectUrl: (0, argus_1.resolveConfig)().projectUrl,
-        harness: "cline",
     });
-    // 3. User → agent delegation tuple. Best-effort; never blocks. Written at
-    // most once per install.
-    await (0, argus_1.writeUserDelegatesAgent)(client);
-    return {};
 }
-// ─── tool_call (tool.before, blocking) ─────────────────────────────
-async function handlePreToolUse(input, client) {
-    const toolName = input.preToolUse?.toolName ?? "unknown";
-    const toolInput = input.preToolUse?.parameters;
-    client.logger.info("lifecycle.pre_tool_use", {
-        taskId: input.taskId,
-        toolName,
-        toolInput,
-    });
-    const inputSummary = (0, argus_1.summarizeToolInput)(toolName, toolInput);
-    // In audit-only mode, log the invocation but skip permission checks.
-    if ((0, argus_1.resolveConfig)().auditOnly) {
-        client.tracer.record("tool.invoke", "ok", {
-            attributes: { toolName, ...inputSummary },
-        });
-        return {};
-    }
-    const subject = (0, argus_1.resolveUserSubject)(client, `session:${input.taskId}`);
-    const subjectId = (0, argus_1.subjectLabel)(subject);
-    const namespace = resolveNamespace();
-    try {
-        const outcome = await (0, argus_1.gateToolCall)(client, {
-            harness: "cline",
-            toolName,
-            check: { namespace, object: toolName, relation: "use", ...subject },
-            spanAttributes: { toolName },
-        });
-        // Interactive tools (operator-extensible via ORY_INTERACTIVE_TOOLS):
-        // user.interaction span is already recorded; pass through.
-        if (outcome.kind === "interactive") {
-            return {};
-        }
-        const decision = outcome;
-        if (decision.kind === "fail_open") {
-            return handlePermissionError(decision.error, toolName, client);
-        }
-        const attrs = { toolName, ...inputSummary };
-        const decisionAttrs = decision.spanAttributes;
-        if (decision.kind === "allow") {
-            client.tracer.record("tool.invoke", "ok", {
-                attributes: { ...attrs, ...decisionAttrs, allowed: true },
-            });
-            return {};
-        }
-        if (decision.kind === "observe") {
-            client.tracer.record("tool.block", "denied", {
-                attributes: {
-                    ...attrs,
-                    ...decisionAttrs,
-                    allowed: false,
-                    ...(0, argus_1.alertAttributes)(false),
-                },
-            });
-            client.tracer.record("tool.invoke", "ok", {
-                attributes: { ...attrs, ...decisionAttrs, allowed: false, observed: true },
-            });
-            return {};
-        }
-        // deny → cancel the tool.
-        client.tracer.record("tool.block", "denied", {
-            attributes: {
-                ...attrs,
-                ...decisionAttrs,
-                allowed: false,
-                ...(0, argus_1.alertAttributes)(true),
-            },
-        });
-        return {
-            cancel: true,
-            errorMessage: (0, argus_1.formatDenialMessage)({ tool: toolName, subjectId, namespace }),
-        };
-    }
-    catch (err) {
-        return handlePermissionError(err, toolName, client);
-    }
-}
-// ─── tool_result (tool.after) ──────────────────────────────────────
-async function handlePostToolUse(input, client) {
-    const toolName = input.postToolUse?.toolName ?? "unknown";
-    const toolInput = input.postToolUse?.parameters;
-    const toolResult = input.postToolUse?.result;
-    client.logger.info("lifecycle.post_tool_use", {
-        taskId: input.taskId,
-        toolName,
-        success: input.postToolUse?.success,
-    });
-    client.tracer.record("tool.complete", "ok", {
-        attributes: {
-            toolName,
-            success: input.postToolUse?.success,
-            executionTimeMs: input.postToolUse?.executionTimeMs,
-            ...(0, argus_1.summarizeToolInput)(toolName, toolInput),
-            ...(0, argus_1.summarizeToolOutput)(toolName, toolResult),
-        },
-    });
-    return {};
-}
-// ─── Trace-only lifecycle events ───────────────────────────────────
-async function handleTaskResume(input, client) {
-    client.logger.info("lifecycle.task_resume", { taskId: input.taskId });
-    client.tracer.record("session.start", "ok", {
-        attributes: { resumed: true, clineVersion: input.clineVersion },
-    });
-    return {};
-}
-async function handleTaskCancel(input, client) {
-    client.logger.info("lifecycle.task_cancel", { taskId: input.taskId });
-    client.tracer.record("session.end", "ok", {
-        attributes: { reason: "abort" },
-    });
-    return {};
-}
-async function handleTaskComplete(input, client) {
-    client.logger.info("lifecycle.task_complete", { taskId: input.taskId });
-    client.tracer.record("session.end", "ok", {
-        attributes: { reason: "complete" },
-    });
-    return {};
-}
-async function handleTaskError(input, client) {
-    client.logger.info("lifecycle.task_error", { taskId: input.taskId });
-    client.tracer.record("session.end", "error", {
-        attributes: { reason: "error" },
-    });
-    return {};
-}
-async function handleSessionShutdown(input, client) {
-    client.logger.info("lifecycle.session_shutdown", { taskId: input.taskId });
-    client.tracer.record("session.end", "ok", {
-        attributes: { stage: "session_shutdown" },
-    });
-    return {};
-}
-async function handleUserPromptSubmit(input, client) {
-    client.logger.info("lifecycle.user_prompt_submit", { taskId: input.taskId });
-    // User-facing phase: the human is the decision-maker. Audit span only.
-    client.tracer.record("user.prompt", "ok", {
-        attributes: { stage: "user_prompt_submit" },
-    });
-    return {};
-}
-async function handlePreCompact(input, client) {
-    client.logger.info("lifecycle.pre_compact", { taskId: input.taskId });
-    client.tracer.record("compaction", "ok", {
-        attributes: { stage: "pre_compact" },
-    });
-    return {};
-}
-// ─── Helpers ────────────────────────────────────────────────────────
-function resolveNamespace() {
-    return process.env.ORY_PERMISSION_NAMESPACE ?? "AgentTools";
+function actingSubagentPrincipals(input) {
+    if (!input.parent_agent_id || !input.agent_id)
+        return undefined;
+    const credential = (0, argus_1.loadSubAgentDynamicCredentials)(HARNESS, input.taskId, HARNESS);
+    if (!credential)
+        return undefined;
+    return {
+        subAgentClientId: credential.clientId,
+        subAgentType: HARNESS,
+        perSpawnId: input.agent_id,
+        sessionId: input.taskId,
+    };
 }
-function handlePermissionError(oryErr, toolName, client) {
-    if (oryErr.code === "network_error") {
-        client.logger.warn("permission.network_error", {
-            toolName,
-            message: "Ory unreachable, failing open",
+async function startTask(input, client, deps) {
+    await (0, argus_1.sessionStart)(client, {
+        harness: HARNESS,
+        userLogin: deps.userLogin,
+        agentGate: deps.agentGate,
+    });
+    if (input.parent_agent_id && input.agent_id) {
+        await (0, argus_1.registerSubagent)(client, {
+            harness: HARNESS,
+            subAgentType: HARNESS,
+            perSpawnId: input.agent_id,
+            subAgentGate: deps.subAgentGate,
         });
-        return {};
     }
-    if (oryErr.code === "rate_limited") {
-        client.logger.warn("permission.rate_limited", {
-            toolName,
-            message: "Ory rate limited, failing open",
-        });
-        return {};
-    }
-    // For other errors, also fail open but log prominently.
-    client.logger.error("permission.check.error", {
-        toolName,
-        code: oryErr.code,
-        message: oryErr.message,
-    });
+}
+function endTask(client, input, status, attributes, logEvent) {
+    client.logger.info(logEvent, { taskId: input.taskId });
+    client.logger.activity("session.end", status, { attributes });
     return {};
 }

package/dist/hook.js CHANGED Viewed

@@ -18,6 +18,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const argus_1 = require("@ory/argus");
 const handlers_js_1 = require("./handlers.js");
+const EVENT_FLUSH_TIMEOUT_MS = 750;
+let client;
+async function flushEvents() {
+    try {
+        await client?.flushEvents(EVENT_FLUSH_TIMEOUT_MS);
+    }
+    catch {
+        // The hook decision must not depend on activity delivery.
+    }
+}
 /**
  * Read all of stdin as a string.
  *
@@ -53,7 +63,7 @@ function readStdin() {
     });
 }
 async function main() {
-    const client = argus_1.OryAgentClient.fromEnv("cline");
+    client = argus_1.OryAgentClient.fromEnv("cline");
     const raw = await readStdin();
     let input;
     try {
@@ -61,7 +71,6 @@ async function main() {
     }
     catch {
         client.logger.error("hook.stdin.parse_failed", { raw: raw.slice(0, 200) });
-        await client.tracer.shutdown();
         process.exit(0); // Don't block on parse errors
     }
     const output = await (0, handlers_js_1.handleHookEvent)(input, client);
@@ -70,10 +79,11 @@ async function main() {
     if (output.cancel || output.contextModification || output.errorMessage) {
         process.stdout.write(JSON.stringify(output));
     }
-    await client.tracer.shutdown();
+    await flushEvents();
     process.exit(0);
 }
-main().catch((err) => {
+main().catch(async (err) => {
     process.stderr.write(`[ory-agent] fatal: ${err}\n`);
+    await flushEvents();
     process.exit(0); // Fail open
 });

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ory/cline",
-  "version": "0.14.0",
+  "version": "1.0.1",
   "description": "Ory plugin for Cline: scaffolding skills, a local Ory instance, and authentication, authorization, and audit for every tool call",
   "license": "Apache-2.0",
   "homepage": "https://ory.com",
@@ -35,8 +35,7 @@
     "agent-security",
     "guardrails",
     "llm",
-    "tracing",
-    "distributed-tracing",
+    "activity-auditing",
     "observability",
     "kratos",
     "keto",
@@ -47,6 +46,10 @@
     "registry": "https://registry.npmjs.org/",
     "provenance": true
   },
+  "reova": {
+    "enabled": true,
+    "endpoint": "https://telemetry.reo.dev/data"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -62,12 +65,11 @@
   },
   "files": [
     "dist",
-    "!dist/dev",
     "!dist/**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "reo-census": "^1.2.8",
-    "@ory/argus": "0.14.0"
+    "reova": "^0.7.0",
+    "@ory/argus": "1.0.1"
   },
   "devDependencies": {
     "typescript": "^6.0.2",
@@ -81,7 +83,6 @@
     "clean": "rm -rf dist *.tsbuildinfo",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "dev": "node dist/dev/launcher.js"
+    "typecheck": "tsc --noEmit"
   }
 }