@ory/argus 0.14.0 → 1.0.1

package/dist/post-install.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The shared post-install step every harness's `install` command runs.
+ *
+ * Every install wires the same **developer-experience** surface: the Ory
+ * skills and commands, the local Ory stack, the MCP server, and local activity logging.
+ * None of that needs an Ory project, so none of it is optional or configurable
+ * here — it is simply what installing the plugin gives you.
+ *
+ * On top of that sits **Ory Agent Security** — user sign-in, permission checks
+ * on every tool call, and delegation recording. It runs only when the install
+ * has an Ory project URL. The broker and public OAuth2 client id default to the
+ * production Agent Security origin and reserved login client; explicit flags
+ * select staging, local, or custom deployments. Pass the project URL to
+ * `install` (or `configure` later) and the next session signs in and starts
+ * checking; leave it out and the
+ * plugin logs activity locally and gates nothing. Nothing else changes either way.
+ *
+ * Everything *else* an Ory project needs to serve Agent Security — the login
+ * OAuth2 client, the permission model, the per-tool grants, explicit blocks,
+ * and the observe/enforce posture — is provisioned in the **Ory Console**
+ * (Agent Security), by someone with access to the project. The plugin never
+ * writes project configuration, which is why installing it needs only a
+ * project URL and no workspace privilege at all.
+ */
+/**
+ * Apply the install's connection intent and print the closing summary.
+ *
+ * With no connection flags the plugin installs with Agent Security simply not
+ * connected. With any of them it delegates to {@link runConfigureCommand},
+ * which validates the project URL and any explicit broker override exactly as
+ * a bare `configure` would.
+ */
+export declare function runPostInstall(binName: string, _harness: string, args?: string[]): Promise<void>;

package/dist/post-install.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * The shared post-install step every harness's `install` command runs.
+ *
+ * Every install wires the same **developer-experience** surface: the Ory
+ * skills and commands, the local Ory stack, the MCP server, and local activity logging.
+ * None of that needs an Ory project, so none of it is optional or configurable
+ * here — it is simply what installing the plugin gives you.
+ *
+ * On top of that sits **Ory Agent Security** — user sign-in, permission checks
+ * on every tool call, and delegation recording. It runs only when the install
+ * has an Ory project URL. The broker and public OAuth2 client id default to the
+ * production Agent Security origin and reserved login client; explicit flags
+ * select staging, local, or custom deployments. Pass the project URL to
+ * `install` (or `configure` later) and the next session signs in and starts
+ * checking; leave it out and the
+ * plugin logs activity locally and gates nothing. Nothing else changes either way.
+ *
+ * Everything *else* an Ory project needs to serve Agent Security — the login
+ * OAuth2 client, the permission model, the per-tool grants, explicit blocks,
+ * and the observe/enforce posture — is provisioned in the **Ory Console**
+ * (Agent Security), by someone with access to the project. The plugin never
+ * writes project configuration, which is why installing it needs only a
+ * project URL and no workspace privilege at all.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPostInstall = runPostInstall;
+const config_js_1 = require("./config.js");
+const cli_js_1 = require("./cli.js");
+const setup_js_1 = require("./setup.js");
+const version_cli_js_1 = require("./version-cli.js");
+const ui = __importStar(require("./ui.js"));
+/**
+ * The `configure` connection flags `install` also accepts, so a single
+ * `install --project-url … --agent-security-url …` both registers the plugin and
+ * connects it to Ory Agent Security. Presence of any of these hands the
+ * post-install step off to `configure`, which owns the validation.
+ */
+const CONFIGURE_FLAGS = [
+    "--project-url",
+    "--sdk-url",
+    "--project-id",
+    "--agent-security-url",
+    "--oauth2-client-id",
+    "--disconnect",
+    "--user-subject-namespace",
+    "--no-user-subject-namespace",
+];
+function hasConfigureFlag(args) {
+    return args.some((a) => CONFIGURE_FLAGS.includes(a));
+}
+/**
+ * Apply the install's connection intent and print the closing summary.
+ *
+ * With no connection flags the plugin installs with Agent Security simply not
+ * connected. With any of them it delegates to {@link runConfigureCommand},
+ * which validates the project URL and any explicit broker override exactly as
+ * a bare `configure` would.
+ */
+async function runPostInstall(binName, _harness, args = []) {
+    // Surface the running CLI version up front. `npx -p @ory/<harness>` (no
+    // version pin) will happily reuse a previously-cached install rather than
+    // re-resolve to latest, so a user can silently be running an old CLI while
+    // believing they're on the current release. Printing the version makes that
+    // mismatch visible at a glance; the README's troubleshooting note explains
+    // how to clear a stale npx cache.
+    const cliVersion = (0, version_cli_js_1.resolveCoreVersion)();
+    if (cliVersion !== "unknown") {
+        ui.info(`${binName} v${cliVersion}`);
+    }
+    if (hasConfigureFlag(args)) {
+        (0, cli_js_1.runConfigureCommand)(binName, args);
+    }
+    ui.blank();
+    const security = (0, config_js_1.resolveConfig)().security;
+    ui.success("Installed.");
+    ui.hint("Skills, commands, the local Ory stack, the MCP server, and activity logging are ready to use.");
+    ui.blank();
+    if (security.connected) {
+        ui.success("Ory Agent Security is connected.");
+        ui.hint("Sign-in and permission checks run on the next session.");
+        ui.hint("Tool grants, explicit blocks, and the observe/enforce posture are managed in the Ory Console (Agent Security).");
+        ui.hint(`Inspect what this machine resolves with \`${binName} permissions status\`.`);
+    }
+    else {
+        ui.hint(`Ory Agent Security is not connected (${(0, config_js_1.describeSecurityGap)(security)}) — no sign-in, no permission checks.`);
+        ui.hint(`Connect it any time with \`${binName} configure --project-url <URL>\`.`);
+        ui.hint("Get the project URL from the Ory Console; pass --agent-security-url to override the production broker.");
+    }
+    // Flush the harness's deferred next-steps as the closing summary. `true`
+    // selects the short "you're set — start the harness" renderer (which reads
+    // the resolved mode) rather than the manual Ory env-var wall.
+    (0, setup_js_1.emitDeferredNextSteps)(true);
+}

package/dist/read-credential.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Make sure the client holds the agent credential required by the canonical
+ * permission broker before a read goes out.
+ *
+ * ## Why this exists
+ *
+ * Permission, mode, and event reads require a noninteractive runtime
+ * credential. This helper resolves only the process-local/injected credential
+ * path and never starts user interaction or falls back to OAuth/DCR state. It
+ * remains cheap to call for every read and preserves existing fail-open error
+ * classification when no credential is available.
+ */
+import { OryAgentClient } from "./client.js";
+import { ensureAgentIdentity } from "./agent-auth.js";
+export interface EnsureReadCredentialOptions {
+    /** Harness whose install credential to resolve. Defaults to `client.harness`. */
+    harness?: string;
+    /** Inject the agent gate for tests. */
+    agentGate?: typeof ensureAgentIdentity;
+    /** Injectable clock for the failed-attempt backoff (tests). */
+    now?: number;
+    /** Abort network work when the caller's latency budget expires. */
+    signal?: AbortSignal;
+    /** Retained for call-site compatibility; runtime resolution never uses DCR. */
+    allowRegistration?: boolean;
+}
+/**
+ * How long a *failed* resolution suppresses another attempt on the same client.
+ *
+ * A success needs no backoff — the token is on the client and every later call
+ * returns at the `present` check. A failure would otherwise be retried by each
+ * read path of each gate (the mode probe and the tool check, at least), so one
+ * unreachable token endpoint would mean several grant attempts per tool call.
+ * Short enough that a long-lived in-process session still recovers on its own
+ * once the endpoint comes back.
+ */
+export declare const READ_CREDENTIAL_RETRY_MS = 30000;
+/** Drop the failed-attempt backoff. Test-only (reassigns the WeakMap). */
+export declare function resetReadCredentialBackoff(): void;
+export type ReadCredentialOutcome = 
+/** Agent Security isn't connected; there is nothing to authenticate against. */
+{
+    kind: "not_connected";
+}
+/** The agent credential was already in hand. */
+ | {
+    kind: "present";
+    principal: "agent";
+}
+/** The agent identity was resolved for this read. */
+ | {
+    kind: "resolved";
+}
+/** No agent credential could be resolved; the read will classify locally. */
+ | {
+    kind: "unavailable";
+    reason?: string;
+};
+/**
+ * Resolve an Agent Security broker credential onto `client` if needed.
+ *
+ * Idempotent and cheap to call repeatedly: the first call in a process resolves,
+ * the rest see the principal already populated and return immediately.
+ */
+export declare function ensureReadCredential(client: OryAgentClient, options?: EnsureReadCredentialOptions): Promise<ReadCredentialOutcome>;

package/dist/read-credential.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Make sure the client holds the agent credential required by the canonical
+ * permission broker before a read goes out.
+ *
+ * ## Why this exists
+ *
+ * Permission, mode, and event reads require a noninteractive runtime
+ * credential. This helper resolves only the process-local/injected credential
+ * path and never starts user interaction or falls back to OAuth/DCR state. It
+ * remains cheap to call for every read and preserves existing fail-open error
+ * classification when no credential is available.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.READ_CREDENTIAL_RETRY_MS = void 0;
+exports.resetReadCredentialBackoff = resetReadCredentialBackoff;
+exports.ensureReadCredential = ensureReadCredential;
+const config_js_1 = require("./config.js");
+const agent_auth_js_1 = require("./agent-auth.js");
+/**
+ * How long a *failed* resolution suppresses another attempt on the same client.
+ *
+ * A success needs no backoff — the token is on the client and every later call
+ * returns at the `present` check. A failure would otherwise be retried by each
+ * read path of each gate (the mode probe and the tool check, at least), so one
+ * unreachable token endpoint would mean several grant attempts per tool call.
+ * Short enough that a long-lived in-process session still recovers on its own
+ * once the endpoint comes back.
+ */
+exports.READ_CREDENTIAL_RETRY_MS = 30_000;
+/** Last failed attempt per client and session. WeakMap keeps finished clients collectable. */
+let lastFailure = new WeakMap();
+/** Drop the failed-attempt backoff. Test-only (reassigns the WeakMap). */
+function resetReadCredentialBackoff() {
+    lastFailure = new WeakMap();
+}
+/**
+ * Resolve an Agent Security broker credential onto `client` if needed.
+ *
+ * Idempotent and cheap to call repeatedly: the first call in a process resolves,
+ * the rest see the principal already populated and return immediately.
+ */
+async function ensureReadCredential(client, options = {}) {
+    // Nothing is connected, so nothing is read and there is nothing to
+    // authenticate. Mirrors the gates' own not_connected short-circuit.
+    const resolved = (0, config_js_1.resolveConfig)();
+    if (!resolved.security.connected)
+        return { kind: "not_connected" };
+    // The broker requires the machine bearer, so this is the whole goal.
+    if (client.hasRuntimeCredential)
+        return { kind: "present", principal: "agent" };
+    const now = options.now ?? Date.now();
+    const sessionId = client.sessionId;
+    const sessionKey = sessionId?.trim() || "sessionless";
+    const failures = lastFailure.get(client);
+    const failedAt = failures?.get(sessionKey);
+    if (failedAt !== undefined && now - failedAt < exports.READ_CREDENTIAL_RETRY_MS) {
+        return { kind: "unavailable", reason: "a recent resolution attempt failed" };
+    }
+    const gate = options.agentGate ?? agent_auth_js_1.ensureAgentIdentity;
+    const creds = await gate(client, {
+        projectUrl: resolved.projectUrl,
+        harness: options.harness ?? client.harness,
+        sessionId,
+        // Tool-path call: skip the migration revoke queue (session start owns it —
+        // a queue of RFC 7592 deletes must not add latency to a gate) and label the
+        // activity so an auditor can tell this resolution from the session-start one.
+        drainRetired: false,
+        trigger: "read_credential",
+        signal: options.signal,
+        allowRegistration: options.allowRegistration,
+    }).catch((err) => {
+        // `ensureAgentIdentity` already swallows its own failures; this is only for
+        // a caller-injected gate that throws.
+        client.logger.warn("read_credential.failed", {
+            message: err instanceof Error ? err.message : String(err),
+        });
+        return undefined;
+    });
+    if (creds?.runtimeCredential || creds?.token)
+        return { kind: "resolved" };
+    const updatedFailures = failures ?? new Map();
+    updatedFailures.set(sessionKey, now);
+    lastFailure.set(client, updatedFailures);
+    return { kind: "unavailable", ...(creds?.reason ? { reason: creds.reason } : {}) };
+}

package/dist/registry/cli.js

@@ -16,6 +16,9 @@ const manager_js_1 = require("./manager.js");
 async function runRegistryCommand(binName, args) {
     const [subcommand] = args;
     switch (subcommand) {
+        case "dev":
+            await (0, manager_js_1.registryDev)();
+            break;
         case "start":
             await (0, manager_js_1.registryStart)();
             break;
@@ -54,6 +57,7 @@ Usage:
   ${binName} registry <command>
 
 Commands:
+  dev         Start the registry and publish all workspace packages
   start       Start the local Verdaccio npm registry (Docker container)
   stop        Stop the running registry
   status      Show registry status and published packages
@@ -67,8 +71,7 @@ on the host, bind-mounted into the container. Everything is ephemeral —
 'clean' removes both the container and the on-disk data.
 
 Workflow:
-  ${binName} registry start          # Start the registry
-  ${binName} registry publish        # Build and publish all packages
+  ${binName} registry dev            # Start and publish all packages
   npm install --registry http://localhost:4873 @ory/claude-code
   ${binName} registry stop           # Stop when done
   ${binName} registry clean          # Remove all data

package/dist/registry/config.d.ts

@@ -21,20 +21,3 @@ export declare const REGISTRY_CONTAINER_STORAGE = "/verdaccio/storage";
 export declare const REGISTRY_CONTAINER_CONFIG = "/verdaccio/conf/config.yaml";
 export declare function verdaccioConfigYaml(): string;
 export declare function npmrcContent(): string;
-/**
- * Userconfig file used by the dev launcher's npm/npx subprocesses.
- *
- * The scope-specific `@ory:registry=…` line is the critical bit. If a
- * developer has ever run `npm login --scope=@ory` (or otherwise pinned
- * `@ory:registry` in their `~/.npmrc`) to publish or fetch from npmjs.org,
- * that pin takes precedence over `--registry` / `npm_config_registry` for
- * scoped packages — so the launcher's `npm install @ory/<harness>` and the
- * harness's own runtime `npx -y -p @ory/<harness>` calls silently hit
- * npmjs.org instead of localhost, producing either `ENOVERSIONS` (because
- * npmjs's manifest doesn't list the just-bumped local version) or a tarball
- * sha512 mismatch (when the local manifest is consulted but npmjs serves
- * the bytes). We expose this file as `npm_config_userconfig` so it
- * displaces `~/.npmrc` entirely for subprocesses the launcher spawns,
- * without modifying any global config or polluting the sandbox.
- */
-export declare function launcherNpmrcContent(): string;

package/dist/registry/config.js

@@ -13,7 +13,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.REGISTRY_CONTAINER_CONFIG = exports.REGISTRY_CONTAINER_STORAGE = exports.REGISTRY_CONTAINER = exports.REGISTRY_IMAGE = exports.REGISTRY_DIR_NAME = exports.REGISTRY_URL = exports.REGISTRY_PORT = void 0;
 exports.verdaccioConfigYaml = verdaccioConfigYaml;
 exports.npmrcContent = npmrcContent;
-exports.launcherNpmrcContent = launcherNpmrcContent;
 exports.REGISTRY_PORT = 4873;
 exports.REGISTRY_URL = `http://localhost:${exports.REGISTRY_PORT}`;
 exports.REGISTRY_DIR_NAME = ".ory-dev/registry";
@@ -90,29 +89,7 @@ log:
 }
 function npmrcContent() {
     return `registry=${exports.REGISTRY_URL}/
-//localhost:${exports.REGISTRY_PORT}/:_authToken=local-dev-token
-`;
-}
-/**
- * Userconfig file used by the dev launcher's npm/npx subprocesses.
- *
- * The scope-specific `@ory:registry=…` line is the critical bit. If a
- * developer has ever run `npm login --scope=@ory` (or otherwise pinned
- * `@ory:registry` in their `~/.npmrc`) to publish or fetch from npmjs.org,
- * that pin takes precedence over `--registry` / `npm_config_registry` for
- * scoped packages — so the launcher's `npm install @ory/<harness>` and the
- * harness's own runtime `npx -y -p @ory/<harness>` calls silently hit
- * npmjs.org instead of localhost, producing either `ENOVERSIONS` (because
- * npmjs's manifest doesn't list the just-bumped local version) or a tarball
- * sha512 mismatch (when the local manifest is consulted but npmjs serves
- * the bytes). We expose this file as `npm_config_userconfig` so it
- * displaces `~/.npmrc` entirely for subprocesses the launcher spawns,
- * without modifying any global config or polluting the sandbox.
- */
-function launcherNpmrcContent() {
-    return `registry=${exports.REGISTRY_URL}/
 @ory:registry=${exports.REGISTRY_URL}/
-//localhost:${exports.REGISTRY_PORT}/:_authToken=local-dev-token
 min-release-age=0
 `;
 }

package/dist/registry/index.d.ts

@@ -1,3 +1,3 @@
 export { runRegistryCommand } from "./cli.js";
-export { registryStart, registryStop, registryStatus, registryPublish, registryClean, registryNpmrc, ensureRegistryRunning, publishHarnessToLocal, getLocalRegistryNpmCacheDir, } from "./manager.js";
+export { registryStart, registryStop, registryStatus, registryPublish, registryDev, registryClean, registryNpmrc, ensureRegistryRunning, getLocalRegistryNpmCacheDir, } from "./manager.js";
 export { REGISTRY_PORT, REGISTRY_URL, REGISTRY_DIR_NAME, REGISTRY_IMAGE, REGISTRY_CONTAINER, } from "./config.js";

package/dist/registry/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REGISTRY_CONTAINER = exports.REGISTRY_IMAGE = exports.REGISTRY_DIR_NAME = exports.REGISTRY_URL = exports.REGISTRY_PORT = exports.getLocalRegistryNpmCacheDir = exports.publishHarnessToLocal = exports.ensureRegistryRunning = exports.registryNpmrc = exports.registryClean = exports.registryPublish = exports.registryStatus = exports.registryStop = exports.registryStart = exports.runRegistryCommand = void 0;
+exports.REGISTRY_CONTAINER = exports.REGISTRY_IMAGE = exports.REGISTRY_DIR_NAME = exports.REGISTRY_URL = exports.REGISTRY_PORT = exports.getLocalRegistryNpmCacheDir = exports.ensureRegistryRunning = exports.registryNpmrc = exports.registryClean = exports.registryDev = exports.registryPublish = exports.registryStatus = exports.registryStop = exports.registryStart = exports.runRegistryCommand = void 0;
 var cli_js_1 = require("./cli.js");
 Object.defineProperty(exports, "runRegistryCommand", { enumerable: true, get: function () { return cli_js_1.runRegistryCommand; } });
 var manager_js_1 = require("./manager.js");
@@ -8,10 +8,10 @@ Object.defineProperty(exports, "registryStart", { enumerable: true, get: functio
 Object.defineProperty(exports, "registryStop", { enumerable: true, get: function () { return manager_js_1.registryStop; } });
 Object.defineProperty(exports, "registryStatus", { enumerable: true, get: function () { return manager_js_1.registryStatus; } });
 Object.defineProperty(exports, "registryPublish", { enumerable: true, get: function () { return manager_js_1.registryPublish; } });
+Object.defineProperty(exports, "registryDev", { enumerable: true, get: function () { return manager_js_1.registryDev; } });
 Object.defineProperty(exports, "registryClean", { enumerable: true, get: function () { return manager_js_1.registryClean; } });
 Object.defineProperty(exports, "registryNpmrc", { enumerable: true, get: function () { return manager_js_1.registryNpmrc; } });
 Object.defineProperty(exports, "ensureRegistryRunning", { enumerable: true, get: function () { return manager_js_1.ensureRegistryRunning; } });
-Object.defineProperty(exports, "publishHarnessToLocal", { enumerable: true, get: function () { return manager_js_1.publishHarnessToLocal; } });
 Object.defineProperty(exports, "getLocalRegistryNpmCacheDir", { enumerable: true, get: function () { return manager_js_1.getLocalRegistryNpmCacheDir; } });
 var config_js_1 = require("./config.js");
 Object.defineProperty(exports, "REGISTRY_PORT", { enumerable: true, get: function () { return config_js_1.REGISTRY_PORT; } });

package/dist/registry/manager.d.ts

@@ -6,9 +6,8 @@
  * container is started with `--rm` and all state lives under
  * `.ory-dev/registry/` on the host, bind-mounted into the container.
  *
- * Mirrors the lifecycle model used by the standalone Jaeger container
- * (see `local/jaeger.ts`): single `docker run -d --rm --name <name>`,
- * idempotent start, removal via `docker rm -f`.
+ * Uses one detached, auto-removed container with idempotent startup and
+ * removal via `docker rm -f`.
  */
 /**
  * Per-registry npm cache directory.
@@ -19,31 +18,15 @@
  * pnpm publish/npm install even after we drop the version from Verdaccio.
  */
 export declare function getLocalRegistryNpmCacheDir(): string;
-/**
- * Path to the userconfig npmrc the dev launcher hands to its subprocesses.
- * See `launcherNpmrcContent` in `./config.ts` for why this exists.
- */
-export declare function getLauncherNpmrcPath(): string;
-/**
- * Materialize the launcher userconfig npmrc on disk and return its path.
- * Idempotent: rewrites the file every call so any drift in the rendered
- * content (e.g. registry URL change) lands without a clean-and-restart.
- */
-export declare function ensureLauncherNpmrc(): string;
 /**
  * Start the local registry if it isn't already running.
  */
 export declare function ensureRegistryRunning(): Promise<void>;
-/**
- * Publish all `@ory/*` packages to the local registry — entrypoint used by
- * the dev launcher. The `harnessName` arg is retained for call-site
- * compatibility; we publish the whole scope every time so any harness gets
- * a coherent registry state without needing to compute its dep closure.
- */
-export declare function publishHarnessToLocal(_harnessName: string): Promise<void>;
 export declare function registryStart(): Promise<void>;
 export declare function registryStop(): Promise<void>;
 export declare function registryStatus(): Promise<void>;
 export declare function registryPublish(): Promise<void>;
+/** Start the local registry and publish a coherent development package set. */
+export declare function registryDev(): Promise<void>;
 export declare function registryClean(): Promise<void>;
 export declare function registryNpmrc(): Promise<void>;

package/dist/registry/manager.js

@@ -7,9 +7,8 @@
  * container is started with `--rm` and all state lives under
  * `.ory-dev/registry/` on the host, bind-mounted into the container.
  *
- * Mirrors the lifecycle model used by the standalone Jaeger container
- * (see `local/jaeger.ts`): single `docker run -d --rm --name <name>`,
- * idempotent start, removal via `docker rm -f`.
+ * Uses one detached, auto-removed container with idempotent startup and
+ * removal via `docker rm -f`.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -46,14 +45,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalRegistryNpmCacheDir = getLocalRegistryNpmCacheDir;
-exports.getLauncherNpmrcPath = getLauncherNpmrcPath;
-exports.ensureLauncherNpmrc = ensureLauncherNpmrc;
 exports.ensureRegistryRunning = ensureRegistryRunning;
-exports.publishHarnessToLocal = publishHarnessToLocal;
 exports.registryStart = registryStart;
 exports.registryStop = registryStop;
 exports.registryStatus = registryStatus;
 exports.registryPublish = registryPublish;
+exports.registryDev = registryDev;
 exports.registryClean = registryClean;
 exports.registryNpmrc = registryNpmrc;
 const fs = __importStar(require("node:fs"));
@@ -86,29 +83,15 @@ function getRegistryDir() {
 function getLocalRegistryNpmCacheDir() {
     return path.join(getRegistryDir(), "npm-cache");
 }
-/**
- * Path to the userconfig npmrc the dev launcher hands to its subprocesses.
- * See `launcherNpmrcContent` in `./config.ts` for why this exists.
- */
-function getLauncherNpmrcPath() {
-    return path.join(getRegistryDir(), "launcher.npmrc");
-}
-/**
- * Materialize the launcher userconfig npmrc on disk and return its path.
- * Idempotent: rewrites the file every call so any drift in the rendered
- * content (e.g. registry URL change) lands without a clean-and-restart.
- */
-function ensureLauncherNpmrc() {
-    const npmrcPath = getLauncherNpmrcPath();
-    ensureDir(path.dirname(npmrcPath));
-    fs.writeFileSync(npmrcPath, (0, config_js_1.launcherNpmrcContent)());
-    return npmrcPath;
-}
 function ensureDir(dir) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
 }
+function writeRegistryNpmrc(registryDir) {
+    ensureDir(registryDir);
+    fs.writeFileSync(path.join(registryDir, ".npmrc"), (0, config_js_1.npmrcContent)());
+}
 function listWorkspaceScopedPackages(workspaceRoot) {
     return listWorkspaceScopedPackageJsons(workspaceRoot)
         .map((file) => readPackageName(file))
@@ -412,9 +395,10 @@ async function ensureConfigInSync(quiet) {
  * Start the local registry if it isn't already running.
  */
 async function ensureRegistryRunning() {
-    if (isRegistryRunning())
-        return;
-    await registryStart();
+    if (!isRegistryRunning()) {
+        await registryStart();
+    }
+    writeRegistryNpmrc(getRegistryDir());
 }
 /**
  * Env vars stripped before invoking the per-package publish, mirroring the
@@ -597,20 +581,12 @@ function emitCapturedOutput(quiet, label, result) {
 function stripScheme(url) {
     return url.replace(/^https?:\/\//, "");
 }
-/**
- * Publish all `@ory/*` packages to the local registry — entrypoint used by
- * the dev launcher. The `harnessName` arg is retained for call-site
- * compatibility; we publish the whole scope every time so any harness gets
- * a coherent registry state without needing to compute its dep closure.
- */
-async function publishHarnessToLocal(_harnessName) {
-    await publishAllOryToLocal({ quiet: true });
-}
 // ─── Commands ──────────────────────────────────────────────────────
 async function registryStart() {
     const registryDir = getRegistryDir();
     const storageDir = path.join(registryDir, "storage");
     if (isRegistryRunning()) {
+        writeRegistryNpmrc(registryDir);
         console.log(`Local registry is already running (container ${config_js_1.REGISTRY_CONTAINER}).`);
         console.log(`  URL: ${config_js_1.REGISTRY_URL}`);
         return;
@@ -642,7 +618,7 @@ async function registryStart() {
     const configPath = path.join(registryDir, "config.yaml");
     fs.writeFileSync(configPath, (0, config_js_1.verdaccioConfigYaml)());
     // .npmrc is consumed by host-side npm/pnpm tooling, not by the container.
-    fs.writeFileSync(path.join(registryDir, ".npmrc"), (0, config_js_1.npmrcContent)());
+    writeRegistryNpmrc(registryDir);
     // Stale --rm container could only exist if Docker died mid-run; clean it up
     // so the new `docker run --rm` doesn't collide on the container name.
     const state = inspectContainer(config_js_1.REGISTRY_CONTAINER);
@@ -798,6 +774,14 @@ async function registryPublish() {
     console.log("");
     console.log("Published.");
 }
+/** Start the local registry and publish a coherent development package set. */
+async function registryDev() {
+    await ensureRegistryRunning();
+    await registryPublish();
+    console.log("");
+    console.log(`Plugin packages are available from ${config_js_1.REGISTRY_URL} at the latest tag.`);
+    console.log("Local Lite and Ory Agent Security are expected to be running separately.");
+}
 async function registryClean() {
     // Stop first if running
     await registryStop();