@happyvertical/smrt-cli 0.53.3 → 0.53.5

package/AGENTS.md

@@ -42,8 +42,11 @@ smrt config:export           # Export agent config for SSG
 smrt init                    # Init new project
 smrt gnode                   # Scaffold gnode site
 smrt dispatch:*              # Dispatch management (list/process/retry/cleanup)
+smrt app <op>                # App install/setup/start/migrate/worker…: agents/app-commands.md
 ```
 
+DB target: config `database.url` > `DATABASE_URL` > `:memory:` (README).
+
 File-backed SQL/TypeScript migration generation is not supported. SMRT schema
 migrations are manifest-driven through registered objects and project manifests.
 

package/README.md

@@ -208,6 +208,13 @@ Run the project's package-manager install command after initialization. Existing
 versions are preserved; s-m-r-t workspace projects receive `workspace:*` ranges and
 consumer projects receive the CLI's published release line.
 
+The generated `src/lib/server/smrt.ts` exports only `runtime` (`classOptions()`
+and `getCollection()` over `DATABASE_URL`/`DATABASE_TYPE`), which generated API
+routes call per request; it no longer exports the deprecated
+`getCollection`/`getSmrtConfig` accessors. To adopt the full application
+runtime, replace that object with `createSmrtSvelteKitRuntime()` from
+`@happyvertical/smrt-app-runtime/sveltekit` and mount its `handle`/`init`.
+
 ### Dispatch
 
 | Command | Description |
@@ -242,6 +249,45 @@ consumer projects receive the CLI's published release line.
 | `smrt playground dev` | Run the shared workspace host or local app playground |
 | `smrt playground list` | Show discovered playground modules and preview entries |
 
+### Application operations (`smrt app`)
+
+Operational commands for a generated s-m-r-t application, run from the
+application root. They replace the template's copied `scripts/*.mjs`, so an
+app's `package.json` scripts are one-liners:
+
+```json
+{
+  "dev": "smrt app dev",
+  "build": "smrt app build",
+  "preview": "smrt app start",
+  "db:migrate": "vite build && smrt app migrate",
+  "app:setup": "smrt app setup",
+  "app:doctor": "smrt app doctor",
+  "worker": "smrt app worker task",
+  "worker:schedule": "smrt app worker schedule"
+}
+```
+
+| Command | Description |
+|---------|------------|
+| `smrt app install` | Local: setup, start, and open owner onboarding under one operation lock |
+| `smrt app setup` | Build, run `smrt db:migrate` explicitly, and prepare the private owner-onboarding handoff |
+| `smrt app recover` | Local: rotate the single-use owner onboarding invitation |
+| `smrt app start` / `stop` | Local: run the production build on loopback; readiness is proven by app id, process instance, and configuration fingerprint |
+| `smrt app doctor` | Secret-free findings (`invalid-runtime-profile`, `unsafe-local-bind`, `runtime-path-unavailable`, `migration-required`, …); exits 1 on any error (default operation) |
+| `smrt app open` | Open the app, or the pending onboarding launch file |
+| `smrt app backup [destination]` | Local: copy the validated data root to a new private directory outside the checkout |
+| `smrt app export [path]` / `import <path>` | Logical, asset-aware bundle; import requires an empty target (deployed: `SMRT_MAINTENANCE_MODE=true`) |
+| `smrt app migrate` | Establish local storage custody, then `smrt db:migrate`, under the operation lock |
+| `smrt app worker [task\|schedule]` | Deployed: imports `.smrt/runtime/register.js`, then runs the jobs runner until SIGTERM. The kind defaults to `task`; any other value is a usage error before anything starts |
+| `smrt app dev\|build\|vite [args]` | Run the app's installed Vite with `.env` loaded (shell wins); `build` validates `./mcp-apps` first |
+
+Success output is JSON on stdout; a failure is one JSON envelope on stderr with
+exit code 1 and never contains secret values. The same primitives (operation
+lock, writer lease, state root, artifact-path custody, portability) are
+importable without side effects from `@happyvertical/smrt-cli/app`. Contract
+details: [agents/app-commands.md](agents/app-commands.md).
+
 ### Auto-Generated Object Commands
 
 For each registered s-m-r-t object, the CLI generates:
@@ -325,6 +371,23 @@ export default {
 };
 ```
 
+### Database precedence
+
+Every `db:*` command resolves its database once, at startup:
+
+1. `packages.cli.database.url` from any config layer — an explicit project
+   setting always wins, so a stray shell `DATABASE_URL` never retargets it.
+2. `DATABASE_URL`, with the engine from the config's `database.type`, else
+   `DATABASE_TYPE` (`sqlite` | `postgres`), else the URL scheme
+   (`postgres://` / `postgresql://` → postgres, anything else sqlite). An
+   unsupported `DATABASE_TYPE` disables this step with a warning.
+3. The `:memory:` default, which schema commands refuse.
+
+`smrt app setup` and `smrt app migrate` hand `smrt db:migrate` the profile's
+database through step 2, so an application does not forward
+`DATABASE_URL` in its own config. The rule is smrt-config's
+`resolveCliDatabaseConfig()`, which `smrt-dev-mcp` uses too.
+
 ### Entry Point Discovery
 
 The CLI loads s-m-r-t objects from your project entry point:
@@ -345,4 +408,5 @@ If compiled classes cannot be loaded, the CLI falls back to manifest-only mode (
 
 - `@happyvertical/smrt-core` -- ORM, manifest, code generation
 - `@happyvertical/smrt-config` -- configuration loading
+- `@happyvertical/smrt-app-runtime` -- local storage custody and runtime composition for `smrt app`
 - `@happyvertical/smrt-scanner` -- AST scanning for metadata extraction

package/agents/app-commands.md

@@ -0,0 +1,118 @@
+# `smrt app` — application operator commands (#3371)
+
+`smrt app <operation>` is the CLI home of the operations a generated SMRT app
+used to ship as copied `scripts/*.mjs`. It is a port, not a redesign: state
+files, JSON output, exit codes, environment variables, and messages match the
+template's scripts so an app's `package.json` scripts become one-liners.
+
+| Template script | Command |
+|---|---|
+| `scripts/smrt-app.mjs <op>` | `smrt app install\|setup\|recover\|start\|stop\|doctor\|open\|backup\|export\|import` |
+| `scripts/smrt-prepare-migration.mjs` | `smrt app migrate` |
+| `scripts/smrt-worker.mjs [task\|schedule]` | `smrt app worker [task\|schedule]` |
+| `node --env-file-if-exists=.env scripts/smrt-vite.mjs <args>` | `smrt app vite <args>` (`smrt app dev …` = `vite dev …` plus `--host 127.0.0.1` / `--port $PORT` unless given: `devServerArguments`) |
+| `smrt-mcp-apps.mjs validate-if-present && …smrt-vite.mjs build` | `smrt app build [vite args]` |
+| `scripts/smrt-web.mjs` | `bin/smrt-web.mjs` (spawned by `start`) |
+| — (new, #3413) | `smrt app token [create] --scopes … [--expires 30d] [--label …]`, `token list`, `token revoke <id>` |
+| helper modules | `@happyvertical/smrt-cli/app` (side-effect-free subpath) |
+
+## Source
+
+`src/app/`: `cli.ts` (dispatch, help, error envelope), `operations.ts`,
+`launchers.ts` (migrate/worker/vite), `identity.ts` (artifact-path custody;
+re-exports identity and state root), `process-record.ts`, `portability.ts`,
+`portability-assets.ts`, `runtime.ts` (context, runners, profile-aware child
+environment). Application ID, configuration fingerprint, state root,
+operation lock, writer lease, stale reclaim, and provider readiness are
+`@happyvertical/smrt-app-runtime`'s (the web process takes the same lease
+without depending on the CLI); `./app` re-exports them unchanged. `main()` dispatches `app` before manifest or
+config loading; `bin/smrt.js` imports `dist/` in-process so SIGTERM reaches
+`smrt app worker`.
+
+## Contracts that must not drift
+
+- **Profile**: `resolveConfiguredRuntime` and app-runtime's SvelteKit entry
+  both call smrt-config's `resolveEffectiveApplicationRuntime(loaded)` (#3446),
+  so operator and web process agree: no `runtime` block (or no config) is
+  `local`; any present value other than `undefined` (including
+  `null`/`false`/`0`/`''`) is validated and fails closed when it is not a
+  valid block.
+- **State root** `<XDG_STATE_HOME|~/.local/state|~/Library/Application Support|%LOCALAPPDATA%>/.<appId>-<sha256(dataRoot)[:12]>-state`,
+  mode 0700, every ancestor user/root-owned and not group/world-writable,
+  app-bound empty 0600 marker `.smrt-state-<appId>`. Shared with the running
+  web server (`writer.lease`), so record formats are byte-compatible.
+- **Locks**: `operation.lock` (one operator op; dead owner reclaimed;
+  unparsable fails closed; never unlinks a replaced lock) and `writer.lease`
+  (one writer; a live op blocks a writer unless it presents that op's
+  `instance`, which `start` passes as `SMRT_OPERATION_INSTANCE`). Stale
+  records are removed only under an exclusive SQLite transaction on
+  `<state>/.smrt-lock-reclaim.sqlite` (kernel lock, released on death), after
+  re-reading that the file still holds the exact dead record
+  (app-runtime `stale-reclaim.ts`); a contender waits up to 2 s, then fails. Acquisition
+  is still a plain `O_EXCL` create, so formats are unchanged.
+- **Storage custody** belongs to `@happyvertical/smrt-app-runtime`: `setup`
+  goes through `initializeLocalApplicationRuntime` with an explicit
+  `prepareDatabase` that runs `smrt db:migrate`; `migrate` calls
+  `prepareLocalDatabaseStorage`; `doctor`/`backup`/`export`/`import` call
+  `validateLocalDatabaseStorage`, which never creates or repairs storage.
+- **No runtime schema**: migrations run only through `smrt db:migrate`.
+- **Output**: success JSON on stdout; failure is one stderr line
+  `{schemaVersion:1,status:'error',code:'operation-failed',message,recovery,secretValuesIncluded:false}`
+  plus `runtimeCode` when a `LocalRuntimeError` carries one
+  (`migration_failed` + `MIGRATION_FAILED_MESSAGE`). Messages pass through
+  `redactSecrets()` (secret-named env values, URL userinfo, `token=`, Bearer;
+  every span is found on the raw text and the union masked at once, so a
+  literal value never splits a structural match; existing `[redacted]`
+  markers are opaque, so a second pass neither corrupts nor grows text).
+  `start` sends the detached web process's stdout/stderr to a fresh 0600
+  `<state>/app.log` per start (removed, then created `wx`; a pipe would EPIPE
+  once the CLI exits); a start that never proves readiness adds `output` (the
+  last ≤ 8 KiB, redacted against the child env before the cut with
+  `{ strict: true }`: no 8-character floor for env values or Bearer tokens) and `logFile`
+  (`ApplicationStartError`).
+  The bootstrap token is written only to mode-0600 `onboarding.json` /
+  `onboarding-launch.html`; `open` passes the launch file URL, never the token. `setup`/`recover` print the one-time
+  `/setup?token=` URL only to an interactive terminal (`io.operatorTerminal`,
+  stderr when both stdio are TTYs), never to stdout/stderr logs or pipes. The
+  web runtime deletes the files after a successful owner claim.
+- **`token`** (`tokens.ts`, local only): parses every argument before touching
+  state, opens `openLocalMcpTokenStore` (validated custody, uncached
+  connection, no writer lease, so it runs beside `app:start`), and serializes
+  create/revoke under `operation.lock`. Only the `issued` document carries
+  the token (`secretValuesIncluded: true`); list/revoke/error output never
+  does.
+- **Artifacts**: backup/export/import paths go through
+  `assertExternalArtifactPath` (real path of nearest existing ancestor, never
+  in or over the checkout). Backup refuses an existing destination; export
+  publishes via `link()` (never replaces); import requires a 0600 regular
+  bundle for the same app, an exactly matching manifest schema, and an empty
+  target; deployed import requires `SMRT_MAINTENANCE_MODE=true`.
+- **Process identity**: `app.pid` is trusted only when the live command
+  line's last two tokens are a path with basename `smrt-web.mjs` and exactly
+  `--smrt-instance=<record instance>` (an app started by the template's former
+  `scripts/smrt-web.mjs` still matches); `stop` re-reads it immediately before SIGTERM
+  (`checkOwnedProcess`: only `gone`/`mismatched` drop `app.pid`; an
+  `unverifiable` query keeps it, sends nothing, and fails naming the pid). A `start`
+  whose launcher never proves readiness is sent SIGTERM, then SIGKILL; only a
+  confirmed exit removes `app.pid`, otherwise the record stays and the error
+  names the pid.
+- **Application resolution**: Vite and bare readiness-module specifiers
+  resolve from the app's own `node_modules` chain (never `NODE_PATH`).
+  Readiness specifiers go through Node's own ESM resolver re-parented to the
+  app root (a temporary `module.registerHooks` resolve hook, because the
+  `import.meta.resolve` parent argument is still flagged), so `exports`
+  precedence, condition order, `null` targets, and invalid targets follow
+  Node exactly; the result must stay inside the installed package. Relative
+  readiness specifiers resolve against the app root.
+- **Import recovery**: after the database commit the asset journal gains an
+  additive `committedAt`. A leftover journal with matching table counts is
+  accepted as complete only with that marker for the same bundle digest, or
+  when every table's rows equal the bundle's; otherwise recovery refuses
+  (`asset-recovery-target-mismatch`) and keeps the journal.
+- `scripts/smrt-portability.mjs`, when an app provides it, still overrides
+  the built-in export/import adapter (the documented extension point).
+
+Tests: `src/app/__tests__/` (primitives, operations in-process, real CLI
+process, and the template's portability-asset suite ported verbatim); lock,
+lease, state-custody, and readiness cases (including review findings R1, R3,
+T2) live in app-runtime's `src/operator-primitives.test.ts`.

package/bin/smrt-web.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// Web launcher spawned by `smrt app start` (cwd = application root).
+//
+// The file name and the `--smrt-instance=<32 hex>` argument are the process
+// identity `smrt app stop` verifies before signalling a recorded pid, so a
+// recycled pid is never terminated. Ported from the template's
+// `scripts/smrt-web.mjs`.
+
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const instance = process.argv
+  .find((value) => value.startsWith('--smrt-instance='))
+  ?.slice('--smrt-instance='.length);
+if (!instance || !/^[a-f0-9]{32}$/.test(instance)) {
+  throw new Error('A valid application process identity is required.');
+}
+
+await import(pathToFileURL(resolve(process.cwd(), 'build', 'index.js')).href);

package/bin/smrt.js

@@ -3,24 +3,30 @@
 import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const distEntry = resolve(packageRoot, 'dist/index.js');
 const sourceEntry = resolve(packageRoot, 'src/index.ts');
 
-const command = existsSync(distEntry)
-  ? [distEntry, ...process.argv.slice(2)]
-  : ['--import', 'tsx', sourceEntry, ...process.argv.slice(2)];
+if (existsSync(distEntry)) {
+  // Run the built CLI in this process so signals reach long-running commands
+  // (a container's SIGTERM to `smrt app worker`), and exit codes are its own.
+  await import(pathToFileURL(distEntry).href);
+} else {
+  const result = spawnSync(
+    process.execPath,
+    ['--import', 'tsx', sourceEntry, ...process.argv.slice(2)],
+    { stdio: 'inherit' },
+  );
 
-const result = spawnSync(process.execPath, command, { stdio: 'inherit' });
+  if (result.error) {
+    throw result.error;
+  }
 
-if (result.error) {
-  throw result.error;
-}
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+  }
 
-if (result.signal) {
-  process.kill(process.pid, result.signal);
+  process.exit(result.status ?? 1);
 }
-
-process.exit(result.status ?? 1);

package/dist/{ApiKey-BZmbOTnL-DchyhIPA.js → ApiKey-BZmbOTnL-BbZupUZ3.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { n as __exportAll$1 } from "./NostrIdentity-n70E0vck-CLGPdJ1W.js";
+import { n as __exportAll$1 } from "./NostrIdentity-n70E0vck-Di3_eNCq.js";
 import { SmrtObject, field, foreignKey, smrt } from "@happyvertical/smrt-core";
 import { createHash, randomBytes } from "node:crypto";
 //#region ../profiles/dist/chunks/ApiKey-BZmbOTnL.js
@@ -127,7 +127,7 @@ var ApiKey = class extends SmrtObject {
 	*/
 	static async verify(key, options = {}) {
 		const keyHash = ApiKey.hashKey(key);
-		const { ApiKeyCollection } = await import("./ApiKeyCollection-Bfb_nw81-DR5XF_SZ.js").then((n) => n.n);
+		const { ApiKeyCollection } = await import("./ApiKeyCollection-Bfb_nw81-DYAZwx0O.js").then((n) => n.n).then((n) => n.n);
 		const apiKey = await (await ApiKeyCollection.create(options)).findOne({ where: { keyHash } });
 		if (!apiKey) return null;
 		if (!apiKey.isValid()) return null;

package/dist/ApiKeyCollection-Bfb_nw81-DYAZwx0O.js

@@ -0,0 +1,87 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { n as __exportAll$1 } from "./NostrIdentity-n70E0vck-Di3_eNCq.js";
+import { t as ApiKey } from "./ApiKey-BZmbOTnL-BbZupUZ3.js";
+import { SmrtCollection } from "@happyvertical/smrt-core";
+//#region ../profiles/dist/chunks/ApiKeyCollection-Bfb_nw81.js
+var ApiKeyCollection_Bfb_nw81_exports = /* @__PURE__ */ __exportAll({
+	n: () => ApiKeyCollection_exports,
+	t: () => ApiKeyCollection
+});
+var ApiKeyCollection_exports = /* @__PURE__ */ __exportAll$1({ ApiKeyCollection: () => ApiKeyCollection });
+var ApiKeyCollection = class extends SmrtCollection {
+	static _itemClass = ApiKey;
+	/**
+	* Find all keys for a profile
+	*/
+	async findByProfile(profileId) {
+		return await this.list({ where: { profileId } });
+	}
+	/**
+	* Find active (non-revoked, non-expired) keys for a profile
+	*/
+	async findActiveByProfile(profileId) {
+		return (await this.findByProfile(profileId)).filter((key) => key.isValid());
+	}
+	/**
+	* Find key by hash
+	*/
+	async findByHash(keyHash) {
+		return await this.findOne({ where: { keyHash } });
+	}
+	/**
+	* Verify an API key string and return the record if valid
+	*/
+	async verify(key) {
+		const keyHash = ApiKey.hashKey(key);
+		const apiKey = await this.findByHash(keyHash);
+		if (!apiKey) return null;
+		if (!apiKey.isValid()) return null;
+		await apiKey.recordUsage();
+		if (!apiKey.isValid()) return null;
+		return apiKey;
+	}
+	/**
+	* Generate a new key for a profile
+	*/
+	async generateForProfile(profile, options) {
+		return await ApiKey.generate(profile, {
+			...options,
+			db: this.options.db
+		});
+	}
+	/**
+	* Revoke all keys for a profile
+	*/
+	async revokeAllForProfile(profileId) {
+		const keys = await this.findActiveByProfile(profileId);
+		for (const key of keys) await key.revoke();
+		return keys.length;
+	}
+	/**
+	* Revoke a specific key by prefix
+	*/
+	async revokeByPrefix(keyPrefix) {
+		const key = await this.findOne({ where: { keyPrefix } });
+		if (key?.isValid()) {
+			await key.revoke();
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Clean up expired keys (soft delete by setting revokedAt)
+	*/
+	async cleanupExpired() {
+		const now = /* @__PURE__ */ new Date();
+		const allKeys = await this.list({});
+		let cleaned = 0;
+		for (const key of allKeys) if (key.expiresAt && key.expiresAt < now && !key.revokedAt) {
+			key.revokedAt = now;
+			await key.save();
+			cleaned++;
+		}
+		return cleaned;
+	}
+};
+//#endregion
+export { ApiKeyCollection_Bfb_nw81_exports as n, ApiKeyCollection as t };

package/dist/AuditLogCollection-B1YonCAP-Bkj2Ezon.js

@@ -0,0 +1,193 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { i as tenantId, r as TenantScoped } from "./dist-C87Ib9Vx.js";
+import { n as __exportAll$1 } from "./NostrIdentity-n70E0vck-Di3_eNCq.js";
+import { SmrtCollection, SmrtObject, foreignKey, smrt } from "@happyvertical/smrt-core";
+//#region ../profiles/dist/chunks/AuditLogCollection-B1YonCAP.js
+var AuditLogCollection_B1YonCAP_exports = /* @__PURE__ */ __exportAll({
+	n: () => AuditLogCollection_exports,
+	r: () => AuditLog,
+	t: () => AuditLogCollection
+});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var AuditLog = class extends SmrtObject {
+	tenantId = null;
+	profileId;
+	/**
+	* Action performed (e.g., 'issue.update', 'feedback.incorporate')
+	*/
+	action = "";
+	/**
+	* Type of resource affected (e.g., 'Issue', 'Repository')
+	*/
+	resourceType = "";
+	/**
+	* ID of the affected resource
+	*/
+	resourceId = "";
+	/**
+	* Source of the action
+	*/
+	source = "web";
+	/**
+	* Additional context (CI run ID, request ID, etc.)
+	*/
+	metadata = {};
+	onBehalfOfId;
+	constructor(options = {}) {
+		super(options);
+		if (options.profileId) this.profileId = options.profileId;
+		if (options.action) this.action = options.action;
+		if (options.resourceType) this.resourceType = options.resourceType;
+		if (options.resourceId) this.resourceId = options.resourceId;
+		if (options.source) this.source = options.source;
+		if (options.metadata) this.metadata = options.metadata;
+		if (options.onBehalfOfId !== void 0) this.onBehalfOfId = options.onBehalfOfId;
+	}
+	/**
+	* Get the profile who performed the action
+	*/
+	async getProfile() {
+		return await this.getRelated("profileId");
+	}
+	/**
+	* Get the profile on whose behalf the action was performed (if any)
+	*/
+	async getOnBehalfOf() {
+		if (!this.onBehalfOfId) return null;
+		return await this.getRelated("onBehalfOfId");
+	}
+	/**
+	* Get the effective actor (onBehalfOf if set, otherwise profile)
+	*/
+	async getEffectiveActor() {
+		const onBehalfOf = await this.getOnBehalfOf();
+		if (onBehalfOf) return onBehalfOf;
+		return await this.getProfile();
+	}
+	/**
+	* Create an audit log entry
+	*/
+	static async record(options) {
+		const log = new AuditLog({
+			...options,
+			profileId: options.profile.id,
+			onBehalfOfId: options.onBehalfOf?.id
+		});
+		await log.initialize();
+		await log.save();
+		return log;
+	}
+};
+__decorateClass([tenantId({ nullable: true })], AuditLog.prototype, "tenantId", 2);
+__decorateClass([foreignKey("Profile", { required: true })], AuditLog.prototype, "profileId", 2);
+__decorateClass([foreignKey("Profile", { nullable: true })], AuditLog.prototype, "onBehalfOfId", 2);
+AuditLog = __decorateClass([TenantScoped({
+	mode: "optional",
+	allowSuperAdminBypass: true
+}), smrt({
+	tableName: "audit_logs",
+	api: { include: ["list", "get"] },
+	mcp: { include: ["list", "get"] },
+	cli: { include: ["list"] }
+})], AuditLog);
+var AuditLogCollection_exports = /* @__PURE__ */ __exportAll$1({ AuditLogCollection: () => AuditLogCollection });
+var AuditLogCollection = class extends SmrtCollection {
+	static _itemClass = AuditLog;
+	/**
+	* Find logs for a profile (actions they performed)
+	*/
+	async findByProfile(profileId) {
+		return await this.list({
+			where: { profileId },
+			orderBy: "createdAt DESC"
+		});
+	}
+	/**
+	* Find logs for a resource
+	*/
+	async findByResource(resourceType, resourceId) {
+		return await this.list({
+			where: {
+				resourceType,
+				resourceId
+			},
+			orderBy: "createdAt DESC"
+		});
+	}
+	/**
+	* Find logs by action type
+	*/
+	async findByAction(action) {
+		return await this.list({
+			where: { action },
+			orderBy: "createdAt DESC"
+		});
+	}
+	/**
+	* Find logs by source
+	*/
+	async findBySource(source) {
+		return await this.list({
+			where: { source },
+			orderBy: "createdAt DESC"
+		});
+	}
+	/**
+	* Find logs where actions were performed on behalf of someone
+	*/
+	async findOnBehalfOf(profileId) {
+		return await this.list({
+			where: { onBehalfOfId: profileId },
+			orderBy: "createdAt DESC"
+		});
+	}
+	/**
+	* Record a new audit log entry
+	*/
+	async record(options) {
+		const log = new AuditLog({
+			...this.options,
+			profileId: options.profile.id,
+			action: options.action,
+			resourceType: options.resourceType,
+			resourceId: options.resourceId,
+			source: options.source || "web",
+			metadata: options.metadata || {},
+			onBehalfOfId: options.onBehalfOf?.id
+		});
+		await log.initialize();
+		await log.save();
+		return log;
+	}
+	/**
+	* Get recent activity for a profile
+	*/
+	async getRecentActivity(profileId, limit = 50) {
+		return await this.list({
+			where: { profileId },
+			orderBy: "createdAt DESC",
+			limit
+		});
+	}
+	/**
+	* Get activity timeline for a resource
+	*/
+	async getResourceTimeline(resourceType, resourceId) {
+		return await this.list({
+			where: {
+				resourceType,
+				resourceId
+			},
+			orderBy: "createdAt ASC"
+		});
+	}
+};
+//#endregion
+export { AuditLogCollection as n, AuditLogCollection_B1YonCAP_exports as r, AuditLog as t };

package/dist/{NostrIdentity-n70E0vck-CLGPdJ1W.js → NostrIdentity-n70E0vck-Di3_eNCq.js}

@@ -4097,21 +4097,21 @@ var NostrIdentity = class extends SmrtObject {
 	* Find identity by public key
 	*/
 	static async findByPubkey(pubkey, options = {}) {
-		const { NostrIdentityCollection } = await import("./NostrIdentityCollection-Ca74dkaL-C2r-uDlC.js").then((n) => n.n);
+		const { NostrIdentityCollection } = await import("./NostrIdentityCollection-Ca74dkaL-DvjOg9Xy.js").then((n) => n.n).then((n) => n.n);
 		return await (await NostrIdentityCollection.create(options)).findOne({ where: { pubkey } });
 	}
 	/**
 	* Find identity by email
 	*/
 	static async findByEmail(email, options = {}) {
-		const { NostrIdentityCollection } = await import("./NostrIdentityCollection-Ca74dkaL-C2r-uDlC.js").then((n) => n.n);
+		const { NostrIdentityCollection } = await import("./NostrIdentityCollection-Ca74dkaL-DvjOg9Xy.js").then((n) => n.n).then((n) => n.n);
 		return await (await NostrIdentityCollection.create(options)).findOne({ where: { email: email.toLowerCase() } });
 	}
 	/**
 	* Find identity by NIP-05 username
 	*/
 	static async findByNip05(username, options = {}) {
-		const { NostrIdentityCollection } = await import("./NostrIdentityCollection-Ca74dkaL-C2r-uDlC.js").then((n) => n.n);
+		const { NostrIdentityCollection } = await import("./NostrIdentityCollection-Ca74dkaL-DvjOg9Xy.js").then((n) => n.n).then((n) => n.n);
 		return await (await NostrIdentityCollection.create(options)).findOne({ where: { nip05Username: username.toLowerCase() } });
 	}
 	/**
@@ -4186,4 +4186,4 @@ NostrIdentity = __decorateClass([smrt({
 	cli: { include: ["list", "get"] }
 })], NostrIdentity);
 //#endregion
-export { verifyAuthEvent as a, generateNostrKeypair as i, __exportAll as n, encryptPrivkey as r, NostrIdentity as t };
+export { deriveEncryptionKey as a, privkeyToNsec as c, verifyNostrSignature as d, decryptPrivkey as i, pubkeyToNpub as l, __exportAll as n, encryptPrivkey as o, computeEventId as r, generateNostrKeypair as s, NostrIdentity as t, verifyAuthEvent as u };