@mysten-incubation/memwal-mcp 0.0.14-dev.0 → 0.0.14-dev.10

package/README.md

@@ -23,6 +23,86 @@ Add Walrus Memory MCP to your MCP client config:
 }
 ```
 
+## How the plugin launches the server
+
+The [MemWal plugin](https://memory.walrus.xyz/mcp/claude-code) does **not** use the
+`npx` form above. `npx` resolves a package *name* against the directory the MCP
+client was started in — your project — so a project that contains an installed
+`@mysten-incubation/memwal-mcp` claiming the pinned version would be run instead of
+the published one. Pinning the version in the `npx` command does not prevent that:
+the planted package simply claims the pinned version.
+
+Instead, every plugin launch config runs the plugin's launcher:
+
+```json
+{
+  "mcpServers": {
+    "memwal": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/scripts/launch_mcp.mjs"]
+    }
+  }
+}
+```
+
+The launcher installs the pinned version once into a directory it owns and then
+runs that absolute entry point with the current `node` binary:
+
+```
+~/.memwal/runtime/memwal-mcp@<version>/node_modules/@mysten-incubation/memwal-mcp/dist/bin/memwal-mcp.js
+```
+
+It never consults your project's `node_modules` or a `PATH`-relative bin shim, and
+it fails rather than falling back to the package name if the pinned version cannot
+be installed. Everything after the script path is forwarded to the server
+unchanged, so flags such as `--namespace work` or `--relayer <url>` work exactly as
+they do above.
+
+The runtime directory is trusted because of what it is, not how it is spelled:
+
+- It must be outside the project the client started in. An absolute path is not
+  enough on its own — a client expands `${workspaceFolder}` to an absolute path
+  inside the repository, and a repository can commit a whole fake install there.
+- It must be a real directory (not a symlink), owned by you, and not group- or
+  world-writable. The launcher creates it with mode `0700` and refuses to run code
+  out of it otherwise. If you see a refusal, `chmod 700 ~/.memwal ~/.memwal/runtime`.
+- `MEMWAL_MCP_RUNTIME_DIR` moves it, subject to exactly the same rules.
+
+The one-off install is run with `--ignore-scripts` (so no `preinstall` or
+`postinstall` from the package or its dependencies executes), against an explicitly
+pinned public registry, with the `npm_config_*` and `NODE_OPTIONS` environment
+scrubbed for that spawn — npm ranks environment variables above every `.npmrc`, so
+a client `env` block would otherwise choose the registry. npm itself is run as
+`node <npm-cli.js>` resolved from the running node binary where that layout exists.
+
+What that does **not** give you is an integrity check of the package contents: it
+establishes where the code came from and that nobody else can write it, not that
+the registry served the bytes a reviewer read. If you install from a private
+registry, pre-populate the directory yourself (below) — the launcher then finds the
+install and never runs npm at all.
+
+If you configure MemWal without the plugin and want the same property, install the
+version you intend to run into a directory outside any project and point your
+client at its absolute path:
+
+```sh
+mkdir -p ~/.memwal/runtime/memwal-mcp@0.0.14
+chmod 700 ~/.memwal ~/.memwal/runtime
+npm install --ignore-scripts --prefix ~/.memwal/runtime/memwal-mcp@0.0.14 \
+  @mysten-incubation/memwal-mcp@0.0.14
+```
+
+```json
+{
+  "mcpServers": {
+    "memwal": {
+      "command": "node",
+      "args": ["/absolute/path/to/home/.memwal/runtime/memwal-mcp@0.0.14/node_modules/@mysten-incubation/memwal-mcp/dist/bin/memwal-mcp.js"]
+    }
+  }
+}
+```
+
 ## Login
 
 Run the login flow manually:
@@ -38,6 +118,7 @@ The command opens your browser, asks you to connect your Sui wallet, and saves c
 ```sh
 memwal-mcp
 memwal-mcp login
+memwal-mcp auto-save on|off
 memwal-mcp --logout
 memwal-mcp --help
 ```
@@ -52,9 +133,111 @@ Use CLI flags or environment variables to override the default Walrus Memory end
 | `--web-url <url>` | `MEMWAL_WEB_URL` | Override the web app URL used during login. |
 | `--label <text>` | `MEMWAL_CLIENT_LABEL` | Friendly delegate-key label shown in Walrus Memory. |
 | `--namespace <name>` (alias `--ns`) | `MEMWAL_NAMESPACE` | Default memory namespace applied when the agent omits one. |
+| `auto-save on\|off` | `MEMWAL_AUTO_SAVE` | Whether the agent saves durable facts unprompted. On once you agree at login; see [Automatic Memory](#automatic-memory). |
 
 Enable verbose stderr logging with `MEMWAL_MCP_DEBUG=1`.
 
+Set `MEMWAL_MCP_TRANSPORT=http` to dial the relayer's Streamable HTTP endpoint instead of the default SSE pair. Opt-in: reconnect replay is not transport-aware yet, so a write interrupted mid-send may be retried and duplicated.
+
+## Automatic Memory
+
+MemWal saves durable facts — preferences, decisions, constraints, recurring
+workflows — as you state them, without asking each time. That is what it is for,
+so it is on. It asks you once first.
+
+The question comes up in your terminal the first time you run `login`:
+
+```
+MemWal can save things about you automatically.
+
+What that means: when you state a preference, a decision, or a setting in
+chat — "I prefer pnpm", "we deploy from dev", "the relayer is at X" —
+MemWal writes it to your memory without asking each time, so it is there
+in your next session and in every other client you use.
+
+Before you choose:
+
+  - Saved memories are permanent. They go to Walrus, which is immutable
+    storage. You can stop saving new ones at any time, but you cannot
+    delete one that is already saved.
+  - They are encrypted to your account. Only your delegate key reads them.
+  - MemWal strips obvious credentials — API keys, tokens, passwords,
+    private keys — before saving. Treat that as a safety net, not a
+    guarantee: do not paste secrets into a session with this on.
+
+  [1] Save automatically      recommended, this is what MemWal is for
+  [2] Only save when I ask    nothing is saved unless you say "remember this"
+
+Your choice [1/2]:
+```
+
+**Saved memories are permanent.** Walrus is immutable storage: you can stop
+saving new ones at any time, but you cannot delete one already saved — which is
+why you are asked before it starts rather than after.
+
+Until you answer, nothing is saved unprompted on a new install; "remember this"
+and recall work throughout. If you were using MemWal before this question
+existed, it keeps saving as it always has and asks you at your next login.
+
+The question is only ever asked in a terminal. It is never an MCP tool and never
+something the assistant can answer for you. Change it any time:
+
+```sh
+npx -y @mysten-incubation/memwal-mcp auto-save on
+npx -y @mysten-incubation/memwal-mcp auto-save off
+npx -y @mysten-incubation/memwal-mcp auto-save        # report the current setting
+```
+
+The answer is stored as `{"autoSave": true}` in `settings.json` next to your
+credentials file, so it follows the same project-local-beats-global resolution.
+To pin one MCP client instead, set the environment variable — it overrides the
+file and skips the question:
+
+```json
+{
+  "mcpServers": {
+    "memwal": {
+      "command": "npx",
+      "args": ["-y", "@mysten-incubation/memwal-mcp"],
+      "env": { "MEMWAL_AUTO_SAVE": "1" }
+    }
+  }
+}
+```
+
+Recall is never gated, and neither is an explicit "remember this" — the setting
+only decides whether the agent saves things you did not ask it to save. Saying
+no costs nothing and is not asked about again.
+
+### What is never saved
+
+Walrus storage is append-only and encrypted: a memory that lands **cannot be
+edited or deleted**. So credentials are excluded whichever way you answer, by the same
+rules stated in the server instructions, the tool descriptions and the plugin
+hooks — and enforced by a check that runs before any text is sent:
+
+- passwords, API keys, access and refresh tokens, private keys, seed and
+  recovery phrases, authorization headers, session cookies, and connection
+  strings or URLs with an embedded `user:password`;
+- anything you say not to save ("don't save this", "off the record");
+- pasted third-party content — a fenced block, a quoted passage — which is not
+  a fact about you.
+
+When a message mixes a preference with a credential, the **preference is kept**
+and only the credential is removed: "I prefer dark mode, db is
+`postgres://admin:hunter2@db.internal/app`" is stored with the password gone and
+the host intact. The agent is told which kinds were removed; the secret itself
+is never stored, logged, or echoed back.
+
+Detection targets specific credential shapes rather than "looks random", so
+identifiers you *do* want remembered — blob ids, Sui object ids, commit SHAs,
+digests — pass through untouched. Where a secret is indistinguishable from an
+identifier, the **label** decides: pasting your `credentials.json` has its
+`delegatePrivateKey` removed, while the same 64 hex characters with nothing
+calling them a key are stored as the digest they look like. The trade-off is
+that a secret in no recognisable shape, and with no label near it, can still
+slip past the check — which is why the model-facing rules exist alongside it.
+
 ## Default Namespace
 
 By default the MCP tool schemas expose an optional `namespace` argument and the
@@ -146,12 +329,66 @@ You can also pass explicit URLs:
 
 ## Credential Storage
 
-Credentials are stored locally in `~/.memwal/credentials.json`. To remove them:
+Credentials are stored locally in `~/.memwal/credentials.json`, and the
+automatic-memory setting in `settings.json` beside it. To remove the
+credentials:
 
 ```sh
 npx -y @mysten-incubation/memwal-mcp --logout
 ```
 
+A sign-in that is still in flight also writes a `login-pending.json`
+write-ahead record, beside `credentials.json` in `~/.memwal`. It holds the
+delegate keypair minted for that sign-in, written before the browser can
+register the public half on-chain so an interrupted login can be reclaimed
+instead of paid for a second time. Same owner-only mode `0600` as
+`credentials.json`.
+
+It is removed once the sign-in completes, on `--logout`, and on a successful
+recovery at the next start. A record older than 24 hours is discarded rather
+than reused.
+
+### Per-project credentials
+
+A project can keep its own `.memwal/credentials.json` so memory written from it
+goes to a separate account. That file lives inside the repository, where anyone
+who can commit to it — or who can get you to open a clone — could otherwise
+choose the account and relayer your memories go to. So it is **ignored until you
+approve it**, once per machine:
+
+```sh
+cd path/to/project
+npx -y @mysten-incubation/memwal-mcp approve-project
+```
+
+Until then the global credentials are used, and a line on stderr names the file
+that was skipped and the destination it wanted. An approval covers one exact
+project path, account, delegate key and relayer: if any of those change, it has
+to be approved again. The record is kept in `~/.memwal/project-approvals.json`,
+outside the repository, so a repository cannot carry its own approval.
+`revoke-project` withdraws it.
+
+Approving also picks the file that is **written**: a later sign-in from that
+project saves a delegate private key into `.memwal/credentials.json` in plain
+text, inside the repository. `approve-project` says so, and so does the sign-in
+warning. Add `.memwal/` to your `.gitignore`. The write-ahead record is the one
+thing that stays out: a project sign-in keeps it in `~/.memwal/login-pending/`,
+one file per approved project, so no key material lands in the checkout and a
+sign-in is still reclaimable only by the project that started it.
+
+`MEMWAL_CREDS_DIR` points the credentials, the approval record and the
+write-ahead record at a directory of your choosing and overrides project
+resolution entirely, with no approval. Because it skips the gate, it must be an
+**absolute path outside the current project**: a relative value would resolve
+against the working directory and put the approval record inside the
+repository, and an MCP client passes on the `env` block it reads from
+`.cursor/mcp.json` / `.vscode/mcp.json` / `.claude/settings.json` in the
+checkout — where `${workspaceFolder}` is expanded, so an in-project absolute
+path is not proof you chose it. Anything else is refused with an error naming
+the value, rather than quietly ignored. An empty value means unset.
+
+`memwal_health` reports the destination in use as `account=… relayer=…`.
+
 ## License
 
 Apache-2.0

package/dist/auth-required.d.ts

@@ -22,6 +22,261 @@
  * and coexist.
  */
 import { type MemWalCredentials } from "./auth.js";
+/** Tool names the OLDEST relayer this bridge still talks to serves.
+ *
+ * The bridge ships on npm and updates itself; a relayer ships per environment
+ * and does not, so the bridge is routinely NEWER than the relayer it dials —
+ * 0.0.14-dev.0 against prod and staging on 0.0.13, which is GH #928. The
+ * cold-start list is served before any relayer capability is known, so every
+ * name in it that the dialled relayer does not serve is a tool the agent can
+ * be told about and then cannot call.
+ *
+ * Cold start is therefore a FLOOR, not a forecast: add a name here only once
+ * the tool has shipped to prod, never when it lands on dev. Newer tools reach
+ * the client a beat later anyway — the relayer's own `tools/list` replaces
+ * this one and `notifications/tools/list_changed` tells the client to re-read
+ * it. `memwal_remember_status` is the worked example: it exists on dev, not on
+ * prod/staging, and belongs here only after a prod release carries it. */
+export declare const BASELINE_RELAYER_TOOLS: ReadonlySet<string>;
+/** Every tool this bridge can describe, baseline or not. Only the baseline
+ * subset is advertised at cold start; this is what the schema tests pin, so a
+ * newer tool's shape stays reviewed while it waits for a prod release. */
+export declare const ALL_TOOL_DEFINITIONS: ({
+    name: string;
+    title: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            text: {
+                type: string;
+                minLength: number;
+            };
+            namespace: {
+                type: string;
+                minLength?: undefined;
+            };
+            facts?: undefined;
+            job_id?: undefined;
+            job_ids?: undefined;
+            waitMs?: undefined;
+            query?: undefined;
+            limit?: undefined;
+            maxDistance?: undefined;
+            freshKey?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    title: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            facts: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+                minItems: number;
+                maxItems: number;
+            };
+            namespace: {
+                type: string;
+                minLength?: undefined;
+            };
+            text?: undefined;
+            job_id?: undefined;
+            job_ids?: undefined;
+            waitMs?: undefined;
+            query?: undefined;
+            limit?: undefined;
+            maxDistance?: undefined;
+            freshKey?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    title: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            job_id: {
+                type: string;
+                minLength: number;
+            };
+            job_ids: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+                minItems: number;
+                maxItems: number;
+            };
+            waitMs: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+            };
+            text?: undefined;
+            namespace?: undefined;
+            facts?: undefined;
+            query?: undefined;
+            limit?: undefined;
+            maxDistance?: undefined;
+            freshKey?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+} | {
+    name: string;
+    title: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                minLength: number;
+            };
+            limit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+            };
+            namespace: {
+                type: string;
+                minLength?: undefined;
+            };
+            maxDistance: {
+                type: string;
+                minimum: number;
+                description: string;
+            };
+            text?: undefined;
+            facts?: undefined;
+            job_id?: undefined;
+            job_ids?: undefined;
+            waitMs?: undefined;
+            freshKey?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    title: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            namespace: {
+                type: string;
+                minLength: number;
+            };
+            limit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+            };
+            text?: undefined;
+            facts?: undefined;
+            job_id?: undefined;
+            job_ids?: undefined;
+            waitMs?: undefined;
+            query?: undefined;
+            maxDistance?: undefined;
+            freshKey?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    title: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            text?: undefined;
+            namespace?: undefined;
+            facts?: undefined;
+            job_id?: undefined;
+            job_ids?: undefined;
+            waitMs?: undefined;
+            query?: undefined;
+            limit?: undefined;
+            maxDistance?: undefined;
+            freshKey?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+} | {
+    name: string;
+    title: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            freshKey: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+            text?: undefined;
+            namespace?: undefined;
+            facts?: undefined;
+            job_id?: undefined;
+            job_ids?: undefined;
+            waitMs?: undefined;
+            query?: undefined;
+            limit?: undefined;
+            maxDistance?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+})[];
 /** Signed-in cold-start list (bridge). Credentials exist; the relayer session
  * is not up yet. Proactive wording so clients that keep the first tools/list
  * still save/recall without being asked. */
@@ -51,6 +306,7 @@ export declare const TOOL_DEFINITIONS: ({
             query?: undefined;
             limit?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -86,6 +342,7 @@ export declare const TOOL_DEFINITIONS: ({
             query?: undefined;
             limit?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -126,6 +383,7 @@ export declare const TOOL_DEFINITIONS: ({
             query?: undefined;
             limit?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
         };
         additionalProperties: boolean;
         required?: undefined;
@@ -165,6 +423,7 @@ export declare const TOOL_DEFINITIONS: ({
             job_id?: undefined;
             job_ids?: undefined;
             waitMs?: undefined;
+            freshKey?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -197,6 +456,7 @@ export declare const TOOL_DEFINITIONS: ({
             waitMs?: undefined;
             query?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -221,6 +481,36 @@ export declare const TOOL_DEFINITIONS: ({
             query?: undefined;
             limit?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+} | {
+    name: string;
+    title: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            freshKey: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+            text?: undefined;
+            namespace?: undefined;
+            facts?: undefined;
+            job_id?: undefined;
+            job_ids?: undefined;
+            waitMs?: undefined;
+            query?: undefined;
+            limit?: undefined;
+            maxDistance?: undefined;
         };
         additionalProperties: boolean;
         required?: undefined;
@@ -255,6 +545,7 @@ export declare const SIGNED_OUT_TOOL_DEFINITIONS: ({
             query?: undefined;
             limit?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -290,6 +581,7 @@ export declare const SIGNED_OUT_TOOL_DEFINITIONS: ({
             query?: undefined;
             limit?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -330,6 +622,7 @@ export declare const SIGNED_OUT_TOOL_DEFINITIONS: ({
             query?: undefined;
             limit?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
         };
         additionalProperties: boolean;
         required?: undefined;
@@ -369,6 +662,7 @@ export declare const SIGNED_OUT_TOOL_DEFINITIONS: ({
             job_id?: undefined;
             job_ids?: undefined;
             waitMs?: undefined;
+            freshKey?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -401,6 +695,7 @@ export declare const SIGNED_OUT_TOOL_DEFINITIONS: ({
             waitMs?: undefined;
             query?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -425,6 +720,36 @@ export declare const SIGNED_OUT_TOOL_DEFINITIONS: ({
             query?: undefined;
             limit?: undefined;
             maxDistance?: undefined;
+            freshKey?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+} | {
+    name: string;
+    title: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            freshKey: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+            text?: undefined;
+            namespace?: undefined;
+            facts?: undefined;
+            job_id?: undefined;
+            job_ids?: undefined;
+            waitMs?: undefined;
+            query?: undefined;
+            limit?: undefined;
+            maxDistance?: undefined;
         };
         additionalProperties: boolean;
         required?: undefined;

package/dist/auth-required.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-required.d.ts","sourceRoot":"","sources":["../src/auth-required.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAwB,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAiLzE;;4CAE4C;AAC5C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA6B,CAAC;AAE3D;;8BAE8B;AAC9B,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA8B,CAAC;AA2CvE;;;mCAGmC;AACnC,MAAM,WAAW,kBAAkB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd;;;;4DAIwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAmID;;yCAEyC;AACzC,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,iBAAiB,CAAC;IACzB;;sCAEkC;IAClC,YAAY,EAAE,MAAM,EAAE,CAAC;CAC1B;AAwID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,qBAAqB,CACvC,MAAM,EAAE,kBAAkB,GAC3B,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAgE7B"}
+{"version":3,"file":"auth-required.d.ts","sourceRoot":"","sources":["../src/auth-required.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAwB,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AA2MzE;;;;;;;;;;;;;;0EAc0E;AAC1E,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,MAAM,CAOrD,CAAC;AAMH;;0EAE0E;AAC1E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA6B,CAAC;AAS/D;;4CAE4C;AAC5C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAuB,CAAC;AAErD;;8BAE8B;AAC9B,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAwB,CAAC;AA+CjE;;;mCAGmC;AACnC,MAAM,WAAW,kBAAkB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd;;;;4DAIwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AA6ID;;yCAEyC;AACzC,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,iBAAiB,CAAC;IACzB;;sCAEkC;IAClC,YAAY,EAAE,MAAM,EAAE,CAAC;CAC1B;AA4ID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,qBAAqB,CACvC,MAAM,EAAE,kBAAkB,GAC3B,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAgE7B"}