@agentproto/providers-store 0.2.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,51 @@
+# @agentproto/providers-store
+
+The `~/.agentproto/providers.json` LLM provider API-key store (mode 0600),
+written by `agentproto auth provider set`, and the `injectProviderKeysIntoEnv`
+helper that lets a process boot with those keys in its environment.
+
+Before this store existed, the only way to give a process a provider key was
+an ambient `export FOO_API_KEY=…` in whatever shell launched it — invisible,
+easy to forget, per-shell. Set once via the CLI, every process that calls
+`injectProviderKeysIntoEnv` at boot picks it up.
+
+This package is a **leaf**: node builtins + `@agentproto/model-catalog` only,
+so any standalone process (not just the `@agentproto/runtime` daemon) can
+depend on it without dragging in a full gateway.
+
+## Usage
+
+```ts
+import { injectProviderKeysIntoEnv } from "@agentproto/providers-store"
+
+// Call once at process boot, before anything reads provider env vars.
+// Explicit env always wins — a var already set is never overwritten.
+const injected = await injectProviderKeysIntoEnv(process.env)
+if (injected.length > 0) {
+  console.error(`loaded ${injected.length} provider key(s) from store: ${injected.join(", ")}`)
+}
+```
+
+Keys never leave the store except into the caller's own process env; they are
+never logged — only provider *names*, never values, should reach output.
+
+## API
+
+- `loadProviders()` / `setProviderKey(provider, apiKey, baseUrl?)` /
+  `removeProviderKey(provider)` / `getProviderKey(provider)` — read/write
+  `providers.json`.
+- `injectProviderKeysIntoEnv(env?)` — injects stored keys into `env`
+  (default `process.env`), skipping any name already set. Returns the list of
+  provider names actually injected.
+- `providerEnvVar(provider)` / `PROVIDER_ENV_VARS` — canonical provider →
+  env-var-name mapping (derived from `@agentproto/model-catalog`'s
+  `PROVIDER_KEY_ENV`, plus the non-catalog gateway providers this store also
+  fronts).
+- `providersPath()` — resolves `~/.agentproto/providers.json`.
+
+`@agentproto/runtime` re-exports this package's surface unchanged (including
+the `@agentproto/runtime/providers-store` subpath) for existing consumers.
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `~/.agentproto/providers.json` — the provider API-key store (mode 0600).
+ *
+ * Distinct from `credentials.json` (host-binding OAuth tokens for
+ * `serve --connect`) and from per-adapter `setup[]` tokens. This file holds
+ * the LLM/model **provider** keys (anthropic, openrouter, openai, …) that the
+ * model gateways in spawned agents read from the environment.
+ *
+ * Why a store at all: before this, the only way to give the daemon a provider
+ * key was an ambient `export FOO_API_KEY=…` in whatever shell launched
+ * `serve`. That's invisible, easy to forget, and per-shell. Storing the keys
+ * here (0600, same-user-only) lets `serve` inject them at boot — set once,
+ * works for every daemon. Explicit env still wins (see injectProviderKeysIntoEnv).
+ *
+ * Keys never leave this file except into the daemon's own process env; they
+ * are never logged. A browser-loaded localhost page can't read a 0600 file —
+ * the same defence the runtime.json bearer token relies on.
+ */
+/**
+ * Canonical provider → environment-variable name. The spawned model gateways
+ * (Mastra in mastra-agent, hermes/opencode's routers) read the provider key
+ * from these env names. Aligned with the adapter manifests' `models.env`
+ * maps + the common SDK conventions.
+ *
+ * DERIVED from `@agentproto/model-catalog`'s {@link PROVIDER_KEY_ENV} (the
+ * single source of truth, co-located with the provider enum — DECISION 1) so
+ * the two maps that used to restate the same fact can't drift, plus the few
+ * NON-catalog gateway providers this store also fronts (`groq`,
+ * `vercel-ai-gateway`) which aren't LLM-catalog `provider` values but still
+ * carry a key here. Adding a catalog provider forces adding its key env in the
+ * catalog (the `Record<CatalogProvider, string>` is exhaustive), and it flows
+ * through to here for free.
+ */
+declare const PROVIDER_ENV_VARS: Readonly<Record<string, string>>;
+type KnownProvider = keyof typeof PROVIDER_ENV_VARS;
+interface ProviderEntry {
+    /** The provider API key (or gateway key). */
+    apiKey: string;
+    /** Optional custom base URL (self-hosted / proxy). */
+    baseUrl?: string;
+    /** Wall-clock ISO timestamp the key was last set. */
+    updatedAt: string;
+}
+interface ProvidersFile {
+    version: 1;
+    providers: Record<string, ProviderEntry>;
+}
+declare function providersPath(): string;
+/** Resolve the env-var name for a provider (canonical map, else
+ *  `<PROVIDER>_API_KEY` upper-snake fallback so new providers still work). */
+declare function providerEnvVar(provider: string): string;
+declare function loadProviders(): Promise<ProvidersFile>;
+/**
+ * Read a single provider's stored api key from `providers.json`, or undefined
+ * when the provider has no entry (or the file doesn't exist). The EXPLICIT,
+ * verifiable credential source for the billing-auth resolver's api-key mode
+ * (`agentproto auth provider set <provider> <key>` writes it) — distinct from
+ * the ambient shell env, which the resolver never reads. Returns the raw key;
+ * only a non-secret fingerprint of it is ever surfaced back to a caller.
+ */
+declare function getProviderKey(provider: string): Promise<string | undefined>;
+/** Set (or replace) a provider's key. Returns the env-var it maps to. */
+declare function setProviderKey(provider: string, apiKey: string, baseUrl?: string): Promise<string>;
+/** Remove a provider's key. Returns true if it existed. */
+declare function removeProviderKey(provider: string): Promise<boolean>;
+/**
+ * Inject stored provider keys into a target env (default `process.env`).
+ * **Explicit env always wins** — a var already set is never overwritten, so a
+ * one-off `FOO_API_KEY=… serve` or a CI secret takes precedence over the
+ * store. Returns the list of provider names actually injected (for a boot log
+ * that names providers, never values).
+ */
+declare function injectProviderKeysIntoEnv(env?: NodeJS.ProcessEnv): Promise<string[]>;
+
+export { type KnownProvider, PROVIDER_ENV_VARS, type ProviderEntry, type ProvidersFile, getProviderKey, injectProviderKeysIntoEnv, loadProviders, providerEnvVar, providersPath, removeProviderKey, setProviderKey };

package/dist/index.mjs

@@ -0,0 +1,91 @@
+import { readFile, mkdir, writeFile } from 'fs/promises';
+import { homedir } from 'os';
+import { resolve, join } from 'path';
+import { PROVIDER_KEY_ENV } from '@agentproto/model-catalog';
+
+/**
+ * @agentproto/providers-store v0.1.0
+ * The ~/.agentproto/providers.json LLM provider API-key store + env injection.
+ */
+
+var PROVIDER_ENV_VARS = {
+  ...PROVIDER_KEY_ENV,
+  // ── Non-catalog gateway providers (not LLM-catalog `provider` enum values,
+  //    so absent from PROVIDER_KEY_ENV, but still keyed through this store) ──
+  groq: "GROQ_API_KEY",
+  xai: "XAI_API_KEY",
+  // Vercel AI Gateway — a gateway provider, like openrouter, that fronts many
+  // upstream model families behind one key.
+  "vercel-ai-gateway": "AI_GATEWAY_API_KEY"
+};
+function emptyFile() {
+  return { version: 1, providers: {} };
+}
+function providersPath() {
+  return resolve(homedir(), ".agentproto", "providers.json");
+}
+function providerEnvVar(provider) {
+  return PROVIDER_ENV_VARS[provider] ?? `${provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`;
+}
+async function loadProviders() {
+  try {
+    const raw = await readFile(providersPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || !("providers" in parsed) || typeof parsed.providers !== "object" || parsed.providers === null) {
+      return emptyFile();
+    }
+    return {
+      version: 1,
+      providers: parsed.providers
+    };
+  } catch {
+    return emptyFile();
+  }
+}
+async function getProviderKey(provider) {
+  const file = await loadProviders();
+  const entry = file.providers[provider];
+  return entry?.apiKey || void 0;
+}
+async function writeProviders(file) {
+  const dir = join(homedir(), ".agentproto");
+  await mkdir(dir, { recursive: true });
+  await writeFile(providersPath(), JSON.stringify(file, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+async function setProviderKey(provider, apiKey, baseUrl) {
+  const file = await loadProviders();
+  file.providers[provider] = {
+    apiKey,
+    ...baseUrl ? { baseUrl } : {},
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeProviders(file);
+  return providerEnvVar(provider);
+}
+async function removeProviderKey(provider) {
+  const file = await loadProviders();
+  if (!(provider in file.providers)) return false;
+  delete file.providers[provider];
+  await writeProviders(file);
+  return true;
+}
+async function injectProviderKeysIntoEnv(env = process.env) {
+  const file = await loadProviders();
+  const injected = [];
+  for (const [provider, entry] of Object.entries(file.providers)) {
+    if (!entry?.apiKey) continue;
+    const name = providerEnvVar(provider);
+    if (env[name]) continue;
+    env[name] = entry.apiKey;
+    if (entry.baseUrl) env[`${provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_BASE_URL`] = entry.baseUrl;
+    injected.push(provider);
+  }
+  return injected;
+}
+
+export { PROVIDER_ENV_VARS, getProviderKey, injectProviderKeysIntoEnv, loadProviders, providerEnvVar, providersPath, removeProviderKey, setProviderKey };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;AAuCO,IAAM,iBAAA,GAAsD;AAAA,EACjE,GAAG,gBAAA;AAAA;AAAA;AAAA,EAGH,IAAA,EAAM,cAAA;AAAA,EACN,GAAA,EAAK,aAAA;AAAA;AAAA;AAAA,EAGL,mBAAA,EAAqB;AACvB;AAoBA,SAAS,SAAA,GAA2B;AAClC,EAAA,OAAO,EAAE,OAAA,EAAS,CAAA,EAAG,SAAA,EAAW,EAAC,EAAE;AACrC;AAEO,SAAS,aAAA,GAAwB;AACtC,EAAA,OAAO,OAAA,CAAQ,OAAA,EAAQ,EAAG,aAAA,EAAe,gBAAgB,CAAA;AAC3D;AAIO,SAAS,eAAe,QAAA,EAA0B;AACvD,EAAA,OACE,iBAAA,CAAkB,QAAQ,CAAA,IAC1B,CAAA,EAAG,QAAA,CAAS,aAAY,CAAE,OAAA,CAAQ,aAAA,EAAe,GAAG,CAAC,CAAA,QAAA,CAAA;AAEzD;AAEA,eAAsB,aAAA,GAAwC;AAC5D,EAAA,IAAI;AACF,IAAA,MAAM,GAAA,GAAM,MAAM,QAAA,CAAS,aAAA,IAAiB,MAAM,CAAA;AAClD,IAAA,MAAM,MAAA,GAAS,IAAA,CAAK,KAAA,CAAM,GAAG,CAAA;AAC7B,IAAA,IACE,CAAC,MAAA,IACD,OAAO,MAAA,KAAW,YAClB,EAAE,WAAA,IAAe,MAAA,CAAA,IACjB,OAAQ,MAAA,CAAmC,SAAA,KAAc,QAAA,IACxD,MAAA,CAAmC,cAAc,IAAA,EAClD;AACA,MAAA,OAAO,SAAA,EAAU;AAAA,IACnB;AACA,IAAA,OAAO;AAAA,MACL,OAAA,EAAS,CAAA;AAAA,MACT,WAAY,MAAA,CAAyB;AAAA,KACvC;AAAA,EACF,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,SAAA,EAAU;AAAA,EACnB;AACF;AAUA,eAAsB,eAAe,QAAA,EAA+C;AAClF,EAAA,MAAM,IAAA,GAAO,MAAM,aAAA,EAAc;AACjC,EAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,SAAA,CAAU,QAAQ,CAAA;AACrC,EAAA,OAAO,OAAO,MAAA,IAAU,MAAA;AAC1B;AAEA,eAAe,eAAe,IAAA,EAAoC;AAChE,EAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,EAAQ,EAAG,aAAa,CAAA;AACzC,EAAA,MAAM,KAAA,CAAM,GAAA,EAAK,EAAE,SAAA,EAAW,MAAM,CAAA;AAEpC,EAAA,MAAM,SAAA,CAAU,eAAc,EAAG,IAAA,CAAK,UAAU,IAAA,EAAM,IAAA,EAAM,CAAC,CAAA,GAAI,IAAA,EAAM;AAAA,IACrE,QAAA,EAAU,MAAA;AAAA,IACV,IAAA,EAAM;AAAA,GACP,CAAA;AACH;AAGA,eAAsB,cAAA,CACpB,QAAA,EACA,MAAA,EACA,OAAA,EACiB;AACjB,EAAA,MAAM,IAAA,GAAO,MAAM,aAAA,EAAc;AACjC,EAAA,IAAA,CAAK,SAAA,CAAU,QAAQ,CAAA,GAAI;AAAA,IACzB,MAAA;AAAA,IACA,GAAI,OAAA,GAAU,EAAE,OAAA,KAAY,EAAC;AAAA,IAC7B,SAAA,EAAA,iBAAW,IAAI,IAAA,EAAK,EAAE,WAAA;AAAY,GACpC;AACA,EAAA,MAAM,eAAe,IAAI,CAAA;AACzB,EAAA,OAAO,eAAe,QAAQ,CAAA;AAChC;AAGA,eAAsB,kBAAkB,QAAA,EAAoC;AAC1E,EAAA,MAAM,IAAA,GAAO,MAAM,aAAA,EAAc;AACjC,EAAA,IAAI,EAAE,QAAA,IAAY,IAAA,CAAK,SAAA,CAAA,EAAY,OAAO,KAAA;AAC1C,EAAA,OAAO,IAAA,CAAK,UAAU,QAAQ,CAAA;AAC9B,EAAA,MAAM,eAAe,IAAI,CAAA;AACzB,EAAA,OAAO,IAAA;AACT;AASA,eAAsB,yBAAA,CACpB,GAAA,GAAyB,OAAA,CAAQ,GAAA,EACd;AACnB,EAAA,MAAM,IAAA,GAAO,MAAM,aAAA,EAAc;AACjC,EAAA,MAAM,WAAqB,EAAC;AAC5B,EAAA,KAAA,MAAW,CAAC,UAAU,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,SAAS,CAAA,EAAG;AAC9D,IAAA,IAAI,CAAC,OAAO,MAAA,EAAQ;AACpB,IAAA,MAAM,IAAA,GAAO,eAAe,QAAQ,CAAA;AACpC,IAAA,IAAI,GAAA,CAAI,IAAI,CAAA,EAAG;AACf,IAAA,GAAA,CAAI,IAAI,IAAI,KAAA,CAAM,MAAA;AAClB,IAAA,IAAI,KAAA,CAAM,OAAA,EAAS,GAAA,CAAI,CAAA,EAAG,QAAA,CAAS,WAAA,EAAY,CAAE,OAAA,CAAQ,aAAA,EAAe,GAAG,CAAC,CAAA,SAAA,CAAW,IAAI,KAAA,CAAM,OAAA;AACjG,IAAA,QAAA,CAAS,KAAK,QAAQ,CAAA;AAAA,EACxB;AACA,EAAA,OAAO,QAAA;AACT","file":"index.mjs","sourcesContent":["/**\n * `~/.agentproto/providers.json` — the provider API-key store (mode 0600).\n *\n * Distinct from `credentials.json` (host-binding OAuth tokens for\n * `serve --connect`) and from per-adapter `setup[]` tokens. This file holds\n * the LLM/model **provider** keys (anthropic, openrouter, openai, …) that the\n * model gateways in spawned agents read from the environment.\n *\n * Why a store at all: before this, the only way to give the daemon a provider\n * key was an ambient `export FOO_API_KEY=…` in whatever shell launched\n * `serve`. That's invisible, easy to forget, and per-shell. Storing the keys\n * here (0600, same-user-only) lets `serve` inject them at boot — set once,\n * works for every daemon. Explicit env still wins (see injectProviderKeysIntoEnv).\n *\n * Keys never leave this file except into the daemon's own process env; they\n * are never logged. A browser-loaded localhost page can't read a 0600 file —\n * the same defence the runtime.json bearer token relies on.\n */\n\nimport { mkdir, readFile, writeFile } from \"node:fs/promises\"\nimport { homedir } from \"node:os\"\nimport { join, resolve } from \"node:path\"\nimport { PROVIDER_KEY_ENV } from \"@agentproto/model-catalog\"\n\n/**\n * Canonical provider → environment-variable name. The spawned model gateways\n * (Mastra in mastra-agent, hermes/opencode's routers) read the provider key\n * from these env names. Aligned with the adapter manifests' `models.env`\n * maps + the common SDK conventions.\n *\n * DERIVED from `@agentproto/model-catalog`'s {@link PROVIDER_KEY_ENV} (the\n * single source of truth, co-located with the provider enum — DECISION 1) so\n * the two maps that used to restate the same fact can't drift, plus the few\n * NON-catalog gateway providers this store also fronts (`groq`,\n * `vercel-ai-gateway`) which aren't LLM-catalog `provider` values but still\n * carry a key here. Adding a catalog provider forces adding its key env in the\n * catalog (the `Record<CatalogProvider, string>` is exhaustive), and it flows\n * through to here for free.\n */\nexport const PROVIDER_ENV_VARS: Readonly<Record<string, string>> = {\n  ...PROVIDER_KEY_ENV,\n  // ── Non-catalog gateway providers (not LLM-catalog `provider` enum values,\n  //    so absent from PROVIDER_KEY_ENV, but still keyed through this store) ──\n  groq: \"GROQ_API_KEY\",\n  xai: \"XAI_API_KEY\",\n  // Vercel AI Gateway — a gateway provider, like openrouter, that fronts many\n  // upstream model families behind one key.\n  \"vercel-ai-gateway\": \"AI_GATEWAY_API_KEY\",\n}\n\nexport type KnownProvider = keyof typeof PROVIDER_ENV_VARS\n\nexport interface ProviderEntry {\n  /** The provider API key (or gateway key). */\n  apiKey: string\n  /** Optional custom base URL (self-hosted / proxy). */\n  baseUrl?: string\n  /** Wall-clock ISO timestamp the key was last set. */\n  updatedAt: string\n}\n\nexport interface ProvidersFile {\n  version: 1\n  providers: Record<string, ProviderEntry>\n}\n\n/** Fresh empty file each call — never share the `providers` object, or a\n *  later `setProviderKey` mutation leaks into every other load in-process. */\nfunction emptyFile(): ProvidersFile {\n  return { version: 1, providers: {} }\n}\n\nexport function providersPath(): string {\n  return resolve(homedir(), \".agentproto\", \"providers.json\")\n}\n\n/** Resolve the env-var name for a provider (canonical map, else\n *  `<PROVIDER>_API_KEY` upper-snake fallback so new providers still work). */\nexport function providerEnvVar(provider: string): string {\n  return (\n    PROVIDER_ENV_VARS[provider] ??\n    `${provider.toUpperCase().replace(/[^A-Z0-9]+/g, \"_\")}_API_KEY`\n  )\n}\n\nexport async function loadProviders(): Promise<ProvidersFile> {\n  try {\n    const raw = await readFile(providersPath(), \"utf8\")\n    const parsed = JSON.parse(raw) as unknown\n    if (\n      !parsed ||\n      typeof parsed !== \"object\" ||\n      !(\"providers\" in parsed) ||\n      typeof (parsed as Record<string, unknown>).providers !== \"object\" ||\n      (parsed as Record<string, unknown>).providers === null\n    ) {\n      return emptyFile()\n    }\n    return {\n      version: 1,\n      providers: (parsed as ProvidersFile).providers,\n    }\n  } catch {\n    return emptyFile() // ENOENT / malformed → empty\n  }\n}\n\n/**\n * Read a single provider's stored api key from `providers.json`, or undefined\n * when the provider has no entry (or the file doesn't exist). The EXPLICIT,\n * verifiable credential source for the billing-auth resolver's api-key mode\n * (`agentproto auth provider set <provider> <key>` writes it) — distinct from\n * the ambient shell env, which the resolver never reads. Returns the raw key;\n * only a non-secret fingerprint of it is ever surfaced back to a caller.\n */\nexport async function getProviderKey(provider: string): Promise<string | undefined> {\n  const file = await loadProviders()\n  const entry = file.providers[provider]\n  return entry?.apiKey || undefined\n}\n\nasync function writeProviders(file: ProvidersFile): Promise<void> {\n  const dir = join(homedir(), \".agentproto\")\n  await mkdir(dir, { recursive: true })\n  // mode 0600 so other local users can't read the keys.\n  await writeFile(providersPath(), JSON.stringify(file, null, 2) + \"\\n\", {\n    encoding: \"utf8\",\n    mode: 0o600,\n  })\n}\n\n/** Set (or replace) a provider's key. Returns the env-var it maps to. */\nexport async function setProviderKey(\n  provider: string,\n  apiKey: string,\n  baseUrl?: string,\n): Promise<string> {\n  const file = await loadProviders()\n  file.providers[provider] = {\n    apiKey,\n    ...(baseUrl ? { baseUrl } : {}),\n    updatedAt: new Date().toISOString(),\n  }\n  await writeProviders(file)\n  return providerEnvVar(provider)\n}\n\n/** Remove a provider's key. Returns true if it existed. */\nexport async function removeProviderKey(provider: string): Promise<boolean> {\n  const file = await loadProviders()\n  if (!(provider in file.providers)) return false\n  delete file.providers[provider]\n  await writeProviders(file)\n  return true\n}\n\n/**\n * Inject stored provider keys into a target env (default `process.env`).\n * **Explicit env always wins** — a var already set is never overwritten, so a\n * one-off `FOO_API_KEY=… serve` or a CI secret takes precedence over the\n * store. Returns the list of provider names actually injected (for a boot log\n * that names providers, never values).\n */\nexport async function injectProviderKeysIntoEnv(\n  env: NodeJS.ProcessEnv = process.env,\n): Promise<string[]> {\n  const file = await loadProviders()\n  const injected: string[] = []\n  for (const [provider, entry] of Object.entries(file.providers)) {\n    if (!entry?.apiKey) continue\n    const name = providerEnvVar(provider)\n    if (env[name]) continue // explicit env wins\n    env[name] = entry.apiKey\n    if (entry.baseUrl) env[`${provider.toUpperCase().replace(/[^A-Z0-9]+/g, \"_\")}_BASE_URL`] = entry.baseUrl\n    injected.push(provider)\n  }\n  return injected\n}\n"]}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@agentproto/providers-store",
+  "version": "0.2.0",
+  "description": "@agentproto/providers-store — the `~/.agentproto/providers.json` LLM provider API-key store (mode 0600) and the `injectProviderKeysIntoEnv` helper that lets any process (daemon or standalone gateway) boot with keys set via `agentproto auth provider set`, without ever logging a value. Explicit env always wins.",
+  "keywords": [
+    "agentproto",
+    "providers",
+    "api-key",
+    "secrets",
+    "llm",
+    "open-standard"
+  ],
+  "homepage": "https://agentproto.sh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts",
+    "directory": "packages/providers-store"
+  },
+  "bugs": {
+    "url": "https://github.com/agentproto/ts/issues"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@agentproto/model-catalog": "0.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "@agentproto/tooling": "0.1.0-alpha.0"
+  },
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest"
+  }
+}