@ory/argus 0.13.9 → 1.0.0

package/dist/local/seed.js

@@ -2,18 +2,16 @@
 /**
  * Seed the local Ory environment with test data for development.
  *
- * Creates two principals:
+ * Creates the **User** (`user@ory-local.dev`) — a human identity with a
+ * known password (printed by the launcher) and an OAuth2
+ * `authorization_code` + PKCE client registered against the loopback
+ * redirect URIs. The launcher always runs the real PKCE browser flow; the
+ * user types these credentials into the login UI to complete the flow.
  *
- *   1. **Agent** (`agent@ory-local.dev`) — a Kratos identity that the
- *      harness will register a DCR OAuth2 client *for* on first session
- *      start. No OAuth2 client is pre-registered here.
- *
- *   2. **User** (`user@ory-local.dev`) — a human identity with a known
- *      password (printed by the launcher) and an OAuth2
- *      `authorization_code` + PKCE client registered against the
- *      loopback redirect URIs. The launcher always runs the real PKCE
- *      browser flow; the user types these credentials into the login
- *      UI to complete the flow.
+ * No agent principal is seeded: the harness self-registers a DCR OAuth2
+ * client for the agent on first session start (using the user's bearer as
+ * the initial access token), and permission checks are made against the
+ * user subject — so a pre-seeded agent Kratos identity would be unused.
  *
  * Permission tuples are written as SubjectSet `User:<identity.id>` so
  * the Console's *Add relationship* dialog (which always emits SubjectSet
@@ -28,27 +26,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.USER_SUBJECT_NAMESPACE = exports.USER_CLIENT_ID = void 0;
 exports.seedLocalEnvironment = seedLocalEnvironment;
 const auth_js_1 = require("../auth.js");
+const branding_js_1 = require("../branding.js");
 const tool_catalog_js_1 = require("../tool-catalog.js");
+const subject_js_1 = require("../subject.js");
+const opl_js_1 = require("../opl.js");
 const configs_js_1 = require("./configs.js");
-const KRATOS_ADMIN = `http://localhost:${configs_js_1.KRATOS_ADMIN_PORT}`;
-const KETO_WRITE = `http://localhost:${configs_js_1.KETO_WRITE_PORT}`;
-const HYDRA_ADMIN = `http://localhost:${configs_js_1.HYDRA_ADMIN_PORT}`;
-const AGENT_EMAIL = "agent@ory-local.dev";
-const AGENT_PASSWORD = "ory-agent-local-dev-password!";
+const ports_js_1 = require("./ports.js");
+const health_js_1 = require("./health.js");
+const KRATOS_ADMIN = (0, ports_js_1.hostUrl)(configs_js_1.LOCAL_STACK_HOST, configs_js_1.KRATOS_ADMIN_PORT);
+const KETO_WRITE = (0, ports_js_1.hostUrl)(configs_js_1.LOCAL_STACK_HOST, configs_js_1.KETO_WRITE_PORT);
+const HYDRA_ADMIN = (0, ports_js_1.hostUrl)(configs_js_1.LOCAL_STACK_HOST, configs_js_1.HYDRA_ADMIN_PORT);
 const USER_EMAIL = "user@ory-local.dev";
 const USER_PASSWORD = "ory-user-local-dev-password!";
-const USER_CLIENT_NAME = "ory-agent-plugins-local-user";
 /**
- * Stable client id Hydra issues to the seeded user PKCE client. Stable
- * so `local configure` can persist it to the shared config and downstream
- * runs can rely on `ORY_OAUTH2_CLIENT_ID` resolution without first
+ * The client id Hydra issues to the seeded user PKCE client: the same
+ * **reserved** id Ory Network's Agent Security setup uses, so local dev and a
+ * hosted project name the shared login client identically and the id — never a
+ * `client_name` — is what resolves it in both.
+ *
+ * Stable, so `local configure` can persist it to the shared config and
+ * downstream runs can rely on `ORY_OAUTH2_CLIENT_ID` resolution without first
  * dragging the value out of the `local up` banner.
  */
-exports.USER_CLIENT_ID = "ory-user-local";
+exports.USER_CLIENT_ID = branding_js_1.USER_LOGIN_CLIENT_ID;
 /**
- * Tools the dev launcher seeds tuples for. Sourced from the shared
- * per-harness catalog so a single seed grants the local user identity
- * `use` on every harness's built-in tool set.
+ * Tools the explicit local-stack command seeds tuples for. Sourced from the
+ * shared catalog so one seed covers every harness's built-in tool set.
  */
 const COMMON_TOOLS = tool_catalog_js_1.ALL_TOOLS;
 async function jsonFetch(url, opts = {}) {
@@ -85,8 +88,12 @@ async function seedIdentity(email, password, name) {
     }));
     return { id: identity.id, email };
 }
-/** Subject namespace for user identities in seeded permission tuples. */
-exports.USER_SUBJECT_NAMESPACE = "User";
+/**
+ * Subject namespace for user identities in seeded permission tuples. Re-exported
+ * from the core default so the seed, the runtime resolver, and the persisted
+ * install config all address the user under the same namespace.
+ */
+exports.USER_SUBJECT_NAMESPACE = subject_js_1.DEFAULT_USER_SUBJECT_NAMESPACE;
 /**
  * Write permission tuples granting the user identity access to all
  * common tools. The subject is written as a SubjectSet
@@ -94,16 +101,16 @@ exports.USER_SUBJECT_NAMESPACE = "User";
  * dialog — which only emits SubjectSet subjects — can recreate the same
  * tuple by hand during the runbook walkthrough.
  */
-async function seedPermissions(userId, namespace) {
+async function seedPermissions(userId, namespace, objects = COMMON_TOOLS) {
     let created = 0;
-    for (const tool of COMMON_TOOLS) {
+    for (const object of objects) {
         try {
             await jsonFetch(`${KETO_WRITE}/admin/relation-tuples`, {
                 method: "PUT",
                 body: JSON.stringify({
                     namespace,
-                    object: tool,
-                    relation: "use",
+                    object,
+                    relation: opl_js_1.RELATION_USERS,
                     subject_set: {
                         namespace: exports.USER_SUBJECT_NAMESPACE,
                         object: userId,
@@ -116,7 +123,7 @@ async function seedPermissions(userId, namespace) {
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             if (!msg.includes("409")) {
-                process.stderr.write(`  Warning: failed to create permission for ${tool}: ${msg}\n`);
+                process.stderr.write(`  Warning: failed to create permission for ${object}: ${msg}\n`);
             }
             else {
                 created++;
@@ -126,25 +133,29 @@ async function seedPermissions(userId, namespace) {
     return created;
 }
 /**
- * Delete a Hydra OAuth2 client if it exists, then create it with a
- * known client_id/secret. We always recreate so the launcher knows the
- * exact credentials to inject into the harness env.
+ * Delete a Hydra OAuth2 client if it exists, then create it at a known
+ * client_id (with a known secret, for a confidential client). We always
+ * recreate so the launcher knows the exact credentials to inject into the
+ * harness env.
+ *
+ * The client is addressed **by id**, never by `client_name`. That mirrors how
+ * Ory Network resolves the shared login client — the name is a display label
+ * anyone can register a client under, so only the reserved id identifies it
+ * (see `USER_LOGIN_CLIENT_ID`) — so local dev cannot pass with a lookup shape
+ * that would be unsafe against a hosted project.
  */
 async function ensureOAuth2Client(spec) {
-    // Look up by client_name; delete if present so we can recreate with a
-    // deterministic secret.
-    const existing = (await jsonFetch(`${HYDRA_ADMIN}/admin/clients?client_name=${encodeURIComponent(spec.clientName)}`));
-    for (const c of existing) {
-        if (c.client_name !== spec.clientName)
-            continue;
-        try {
-            await jsonFetch(`${HYDRA_ADMIN}/admin/clients/${encodeURIComponent(c.client_id)}`, {
-                method: "DELETE",
-            });
-        }
-        catch {
-            // best-effort cleanup
-        }
+    // Delete the client at this id if one is already there, so the recreate
+    // below lands with the exact grants, scopes, and redirect URIs this seed
+    // declares. A 404 (nothing to delete) is the normal first-run case.
+    try {
+        await jsonFetch(`${HYDRA_ADMIN}/admin/clients/${encodeURIComponent(spec.clientId)}`, {
+            method: "DELETE",
+        });
+    }
+    catch {
+        // best-effort cleanup — absent, or Hydra refused; the create below reports
+        // the real problem if there is one.
     }
     const body = {
         client_id: spec.clientId,
@@ -177,12 +188,24 @@ function loopbackRedirectUris() {
  * Returns a `SeedResult` describing both identities, the user's
  * pre-minted session, and the OAuth2 clients registered for each.
  */
-async function seedLocalEnvironment(namespace = "AgentTools") {
+async function seedLocalEnvironment(namespace = "AgentTool") {
     process.stderr.write("Seeding local Ory environment...\n\n");
-    // 1. Identities
-    process.stderr.write("  Creating agent identity...\n");
-    const agentIdentity = await seedIdentity(AGENT_EMAIL, AGENT_PASSWORD, "Local Agent");
-    process.stderr.write(`  Agent: ${agentIdentity.id} (${agentIdentity.email})\n`);
+    // 0. Readiness barrier. The seed writes directly to Kratos (admin),
+    //    Keto (write), and Hydra (admin). Neither the static nginx gateway
+    //    `/health` nor `docker compose up -d --wait` (the Ory containers
+    //    declare no healthcheck) proves those APIs are actually serving, so
+    //    on a cold start the writes can race ahead of the services and
+    //    silently create no identities or permission tuples. Block until all
+    //    three report ready before touching them.
+    process.stderr.write("  Waiting for backend services to be ready...\n");
+    const readiness = await (0, health_js_1.waitForSeedTargets)();
+    if (!readiness.ready) {
+        throw new Error(`backend services not ready before seed: ${readiness.pending.join(", ")} ` +
+            `did not report ready within the timeout. The stack may still be starting — retry in a moment.`);
+    }
+    // 1. User identity. No agent identity is seeded — the harness
+    //    self-registers a DCR OAuth2 client for the agent on first session
+    //    start, and permission checks target the user subject.
     process.stderr.write("  Creating user identity...\n");
     const userIdentity = await seedIdentity(USER_EMAIL, USER_PASSWORD, "Local User");
     process.stderr.write(`  User: ${userIdentity.id} (${userIdentity.email})\n`);
@@ -194,6 +217,14 @@ async function seedLocalEnvironment(namespace = "AgentTools") {
     process.stderr.write(`  Creating permissions for ${COMMON_TOOLS.length} tools...\n`);
     const tupleCount = await seedPermissions(userIdentity.id, namespace);
     process.stderr.write(`  Permissions: ${tupleCount} entries in '${namespace}' for ${subjectLabel}\n`);
+    // Shell-command sub-tools (issue #76): grant every catalog word in the
+    // ShellTool namespace so a launched harness can run `bash -c "curl …"`
+    // out of the box, and the enforce demo (revoke `ShellTool:curl#users`,
+    // watch it block) works without hand-writing tuples first.
+    const shellWords = (0, tool_catalog_js_1.getShellCommandCatalog)();
+    const shellNamespace = (0, tool_catalog_js_1.resolveShellCommandNamespace)();
+    const shellCount = await seedPermissions(userIdentity.id, shellNamespace, shellWords);
+    process.stderr.write(`  Shell commands: ${shellCount} entries in '${shellNamespace}' for ${subjectLabel}\n`);
     // 3. User OAuth2 client (PKCE) — pre-registered so the user gate's
     //    PKCE flow has somewhere to authenticate against. The agent's
     //    OAuth2 client is intentionally NOT pre-registered; the harness
@@ -202,13 +233,15 @@ async function seedLocalEnvironment(namespace = "AgentTools") {
     let userClient = { clientId: exports.USER_CLIENT_ID };
     try {
         userClient = await ensureOAuth2Client({
-            clientName: USER_CLIENT_NAME,
+            // Display label only, matching what a hosted project shows in the
+            // Console — the client is addressed by its id.
+            clientName: branding_js_1.USER_LOGIN_CLIENT_NAME,
             clientId: exports.USER_CLIENT_ID,
             // Public PKCE client — no secret. Hydra accepts an empty string
             // for `token_endpoint_auth_method=none`.
             grantTypes: ["authorization_code", "refresh_token"],
             responseTypes: ["code"],
-            scope: "openid offline_access",
+            scope: branding_js_1.USER_LOGIN_SCOPE_OAUTH,
             tokenEndpointAuthMethod: "none",
             redirectUris: loopbackRedirectUris(),
         });
@@ -219,7 +252,6 @@ async function seedLocalEnvironment(namespace = "AgentTools") {
         process.stderr.write(`  Warning: user OAuth2 client registration failed: ${msg}\n`);
     }
     return {
-        agent: { identity: agentIdentity },
         user: { identity: userIdentity, password: USER_PASSWORD, client: userClient },
         permissions: { namespace, subject: subjectLabel, tuples: tupleCount },
     };

package/dist/logger.d.ts

@@ -1,4 +1,5 @@
 export type LogLevel = "debug" | "info" | "warn" | "error";
+export type ActivityStatus = "ok" | "error" | "denied" | "skipped";
 export interface LogEntry {
     timestamp: string;
     level: LogLevel;
@@ -6,45 +7,73 @@ export interface LogEntry {
     harness: string;
     data?: Record<string, unknown>;
 }
-/**
- * Recursively redact sensitive values from a structured log payload.
- * The original object is not modified.
- */
+export interface ActivityEntry {
+    timestamp: string;
+    level: "activity";
+    event: string;
+    harness: string;
+    status: ActivityStatus;
+    durationMs: number;
+    sessionId?: string;
+    attributes?: Record<string, unknown>;
+}
+export type UnifiedLogEntry = LogEntry | ActivityEntry;
+export type ActivityEnricher = () => Record<string, unknown> | undefined;
+export type ActivitySink = (entry: ActivityEntry) => void;
 export declare function redactLogData(value: unknown): unknown;
+export declare function activityValueHash(value: string): string;
+/** Convert arbitrary strings to correlation-safe summaries for always-on activity. */
+export declare function sanitizeActivityAttributes(attributes: Record<string, unknown>): Record<string, unknown>;
+export declare class ActiveActivity {
+    private readonly logger;
+    private readonly event;
+    private readonly baseAttributes?;
+    private readonly sessionId?;
+    private readonly startedAt;
+    private readonly timestamp;
+    private endedEntry;
+    constructor(logger: DebugLogger, event: string, baseAttributes?: Record<string, unknown> | undefined, sessionId?: string | undefined);
+    get ended(): boolean;
+    end(status: ActivityStatus, attributes?: Record<string, unknown>): ActivityEntry;
+}
 export declare class DebugLogger {
-    /**
-     * Process-global switch to suppress the stderr firehose while still writing
-     * to the log file. The interactive installer sets this so structured debug
-     * JSON (`[ory-agent] {...}`) doesn't interleave with the wizard's
-     * human-facing UI when a session runs with `ORY_AGENT_DEBUG=true` (the dev
-     * launcher, for one, always sets it). File logging — the real observability
-     * channel — is unaffected.
-     */
     static stderrSuppressed: boolean;
     enabled: boolean;
-    harness: string;
-    logFile: string | null;
+    readonly harness: string;
+    readonly logFile: string | null;
+    private readonly activityEntries;
+    private activityEnricher;
+    private activitySink;
     constructor(harness: string, opts?: {
         logFile?: string;
     });
     get isEnabled(): boolean;
     enable(): void;
     disable(): void;
+    setActivityEnricher(enricher: ActivityEnricher | null): void;
+    setActivitySink(sink: ActivitySink | null): void;
+    activities(): ReadonlyArray<ActivityEntry>;
+    startActivity(event: string, attributes?: Record<string, unknown>, sessionId?: string): ActiveActivity;
+    activity(event: string, status: ActivityStatus, options?: {
+        attributes?: Record<string, unknown>;
+        durationMs?: number;
+        sessionId?: string;
+        timestamp?: string;
+    }): ActivityEntry;
     log(level: LogLevel, event: string, data?: Record<string, unknown>): void;
     debug(event: string, data?: Record<string, unknown>): void;
     info(event: string, data?: Record<string, unknown>): void;
     warn(event: string, data?: Record<string, unknown>): void;
     error(event: string, data?: Record<string, unknown>): void;
+    private writeToStderr;
+    private writeToFile;
+}
+export interface FormattedLogEntryParts {
+    time: string;
+    event: string;
+    marker: string;
+    details: string[];
 }
-/**
- * Run `fn` with the structured stderr firehose suppressed, restoring the
- * previous state afterward (even on throw). File logging is unaffected.
- *
- * Human-facing CLI commands (the interactive installer, `status`,
- * `permissions status`/`bootstrap`) spin up a client and emit debug/info
- * events; when the process runs with `ORY_AGENT_DEBUG=true` (the dev launcher
- * always sets it) those `[ory-agent] {...}` lines would interleave with the
- * command's polished output. Wrapping the command body in this keeps the
- * terminal clean while the log file still captures everything.
- */
+export declare function formatLogEntryParts(entry: UnifiedLogEntry): FormattedLogEntryParts;
+export declare function formatLogEntry(entry: UnifiedLogEntry): string;
 export declare function withQuietStderr<T>(fn: () => Promise<T> | T): Promise<T>;