@byok-sdk/keys 0.1.0 → 0.2.1

package/dist/bin/pi-provider-launcher.js

@@ -0,0 +1,1137 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import { promises, mkdirSync, existsSync, chmodSync } from 'fs';
+import os from 'os';
+import path, { dirname } from 'path';
+import { z } from 'zod';
+import { createRequire } from 'module';
+
+// src/errors.ts
+var ByokKeysError = class extends Error {
+  code;
+  httpStatus;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "ByokKeysError";
+    this.code = code;
+    this.httpStatus = options?.httpStatus;
+  }
+};
+async function runCommand(executable, args, stdin) {
+  return new Promise((resolveResult) => {
+    const child = spawn(executable, args, {
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", () => {
+      resolveResult({
+        exitCode: 127,
+        stderr: "command unavailable",
+        stdout: ""
+      });
+    });
+    child.on("close", (code) => {
+      resolveResult({ exitCode: code ?? 1, stderr, stdout });
+    });
+    if (stdin === void 0) child.stdin.end();
+    else child.stdin.end(stdin);
+  });
+}
+
+// src/secret-name.ts
+var SECRET_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{2,95}$/u;
+var SECRET_NAMESPACE_PATTERN = /^[a-z0-9][a-z0-9_-]{7,95}$/u;
+function assertSecretName(name) {
+  if (!SECRET_NAME_PATTERN.test(name)) {
+    throw new ByokKeysError(
+      "SECRET_NAME_INVALID",
+      "Secret name must be 3 to 96 characters of [a-z0-9_-] starting with a letter or digit"
+    );
+  }
+  return name;
+}
+function assertSecretNamespace(value) {
+  const normalized = value.trim();
+  if (!SECRET_NAMESPACE_PATTERN.test(normalized)) {
+    throw new ByokKeysError(
+      "SECRET_NAMESPACE_INVALID",
+      "Secret namespace must be 8 to 96 characters of [a-z0-9_-] starting with a letter or digit"
+    );
+  }
+  return normalized;
+}
+
+// src/secret-store.ts
+var DEFAULT_SECRET_SERVICE_PREFIX = "com.byok.keys";
+var MODEL_PROVIDER_SECRET_NAMES = {
+  anthropic: "model-anthropic-api-key",
+  custom: "model-custom-api-key",
+  deepseek: "model-deepseek-api-key",
+  openai: "model-openai-api-key"
+};
+function modelProviderSecretName(providerId) {
+  return MODEL_PROVIDER_SECRET_NAMES[providerId];
+}
+function decodeStrictBase64Utf8(encoded) {
+  if (encoded.length % 4 !== 0) return void 0;
+  if (!/^[A-Za-z0-9+/]*={0,2}$/u.test(encoded)) return void 0;
+  const bytes = Buffer.from(encoded, "base64");
+  if (bytes.toString("base64") !== encoded) return void 0;
+  const text = bytes.toString("utf8");
+  if (!Buffer.from(text, "utf8").equals(bytes)) return void 0;
+  return text;
+}
+
+// src/macos-keychain.ts
+var DEFAULT_KEYCHAIN_SECRET_STORAGE_PREFIX = "byok-b64-v1:";
+var SECURITY_ITEM_NOT_FOUND = 44;
+var MacOsKeychainSecretStore = class _MacOsKeychainSecretStore {
+  providerLabel = "macOS Keychain";
+  #account;
+  #allowUnprefixedRead;
+  #commandRunner;
+  #platform;
+  #servicePrefix;
+  #storagePrefix;
+  constructor(options = {}) {
+    this.#account = options.account ?? "local-device";
+    this.#allowUnprefixedRead = options.allowUnprefixedRead ?? false;
+    this.#commandRunner = options.commandRunner ?? runCommand;
+    this.#platform = options.platform ?? process.platform;
+    this.#servicePrefix = options.servicePrefix ?? DEFAULT_SECRET_SERVICE_PREFIX;
+    this.#storagePrefix = options.storagePrefix ?? DEFAULT_KEYCHAIN_SECRET_STORAGE_PREFIX;
+  }
+  async available() {
+    if (this.#platform !== "darwin") return false;
+    const result = await this.#commandRunner("/usr/bin/security", [
+      "default-keychain",
+      "-d",
+      "user"
+    ]);
+    return result.exitCode === 0;
+  }
+  async delete(name) {
+    const service = this.#service(name);
+    this.#assertMacOs();
+    const result = await this.#commandRunner("/usr/bin/security", [
+      "delete-generic-password",
+      "-a",
+      this.#account,
+      "-s",
+      service
+    ]);
+    if (result.exitCode === SECURITY_ITEM_NOT_FOUND) return false;
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "KEYCHAIN_DELETE_FAILED",
+        "macOS Keychain could not delete the requested secret"
+      );
+    }
+    return true;
+  }
+  async get(name) {
+    const service = this.#service(name);
+    this.#assertMacOs();
+    const result = await this.#commandRunner("/usr/bin/security", [
+      "find-generic-password",
+      "-a",
+      this.#account,
+      "-s",
+      service,
+      "-w"
+    ]);
+    if (result.exitCode === SECURITY_ITEM_NOT_FOUND) return void 0;
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "KEYCHAIN_READ_FAILED",
+        "macOS Keychain could not read the requested secret"
+      );
+    }
+    return this.#decode(result.stdout.replace(/\r?\n$/u, ""));
+  }
+  async has(name) {
+    return await this.get(name) !== void 0;
+  }
+  scope(namespace) {
+    return new _MacOsKeychainSecretStore({
+      account: this.#account,
+      allowUnprefixedRead: this.#allowUnprefixedRead,
+      commandRunner: this.#commandRunner,
+      platform: this.#platform,
+      servicePrefix: `${this.#servicePrefix}.scope.${assertSecretNamespace(namespace)}`,
+      storagePrefix: this.#storagePrefix
+    });
+  }
+  async set(name, secret) {
+    const service = this.#service(name);
+    this.#assertMacOs();
+    if (secret.length === 0 || secret.length > 16384 || /[\u0000\r\n]/u.test(secret)) {
+      throw new ByokKeysError(
+        "KEYCHAIN_SECRET_INVALID",
+        "Secret must contain 1 to 16384 non-newline characters"
+      );
+    }
+    const storedSecret = `${this.#storagePrefix}${Buffer.from(secret, "utf8").toString("base64")}`;
+    const command = [
+      "add-generic-password",
+      "-U",
+      "-a",
+      quoteSecurityInteractiveArgument(this.#account),
+      "-s",
+      quoteSecurityInteractiveArgument(service),
+      "-w",
+      quoteSecurityInteractiveArgument(storedSecret)
+    ].join(" ");
+    const result = await this.#commandRunner(
+      "/usr/bin/security",
+      ["-i"],
+      `${command}
+`
+    );
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "KEYCHAIN_WRITE_FAILED",
+        "macOS Keychain could not store the requested secret"
+      );
+    }
+  }
+  #assertMacOs() {
+    if (this.#platform !== "darwin") {
+      throw new ByokKeysError(
+        "KEYCHAIN_UNAVAILABLE",
+        "macOS Keychain is required; plaintext fallback is disabled"
+      );
+    }
+  }
+  /**
+   * Fail-closed inverse of the storage encoding. The error message never
+   * echoes the undecodable value — it may still be somebody's live credential.
+   */
+  #decode(storedSecret) {
+    if (!storedSecret.startsWith(this.#storagePrefix)) {
+      if (this.#allowUnprefixedRead) return storedSecret;
+      throw new ByokKeysError(
+        "KEYCHAIN_SECRET_DECODE_FAILED",
+        "macOS Keychain returned a value without this store's storage prefix"
+      );
+    }
+    const decoded = decodeStrictBase64Utf8(
+      storedSecret.slice(this.#storagePrefix.length)
+    );
+    if (decoded === void 0 || decoded.length === 0) {
+      throw new ByokKeysError(
+        "KEYCHAIN_SECRET_DECODE_FAILED",
+        "macOS Keychain returned a secret that is not valid base64-encoded UTF-8"
+      );
+    }
+    return decoded;
+  }
+  #service(name) {
+    return `${this.#servicePrefix}.${assertSecretName(name)}`;
+  }
+};
+function quoteSecurityInteractiveArgument(value) {
+  if (/[\u0000\r\n]/u.test(value)) {
+    throw new ByokKeysError(
+      "KEYCHAIN_ARGUMENT_INVALID",
+      "macOS Keychain arguments cannot contain null or newline characters"
+    );
+  }
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+// src/pi-provider-projection.ts
+var PI_PROJECTED_KEY_ENV = "PI_PROVIDER_API_KEY";
+function piProjectionProviderId(profileProviderId) {
+  return `byok-sdk-${profileProviderId}`;
+}
+function buildPiProviderProjection(profile) {
+  const projectedProviderId = piProjectionProviderId(profile.provider_id);
+  return {
+    providers: {
+      [projectedProviderId]: {
+        baseUrl: profile.base_url,
+        api: profile.adapter === "anthropic" ? "anthropic-messages" : "openai-completions",
+        ...profile.auth_mode === "none" ? {} : { apiKey: `$${PI_PROJECTED_KEY_ENV}` },
+        ...profile.auth_mode === "bearer" ? { authHeader: true } : {},
+        models: [
+          {
+            id: profile.model,
+            name: profile.display_name
+          }
+        ]
+      }
+    }
+  };
+}
+function buildPiProviderArgs(profile, delegatedArgs) {
+  let modeCount = 0;
+  for (let index = 0; index < delegatedArgs.length; index += 1) {
+    const flag = delegatedArgs[index];
+    if (flag === "--no-tools") continue;
+    if (flag === "--mode") {
+      modeCount += 1;
+      const value = delegatedArgs[index + 1];
+      if (value !== "rpc") throw new Error("Pi launcher requires --mode rpc");
+      index += 1;
+      continue;
+    }
+    if (flag === "--session" || flag === "--tools" || flag === "--exclude-tools") {
+      const value = delegatedArgs[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error(`${flag} requires a value`);
+      }
+      index += 1;
+      continue;
+    }
+    throw new Error(`Pi launcher does not allow delegated argument ${flag ?? "<missing>"}`);
+  }
+  if (modeCount !== 1) throw new Error("Pi launcher requires exactly one --mode rpc");
+  return [
+    ...delegatedArgs,
+    "--provider",
+    piProjectionProviderId(profile.provider_id),
+    "--model",
+    profile.model
+  ];
+}
+
+// src/url.ts
+function normalizeProviderUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ByokKeysError(
+      "PROVIDER_URL_INVALID",
+      "Provider base URL must be absolute"
+    );
+  }
+  if (url.username || url.password || url.hash || url.search || url.protocol !== "https:" && !(url.protocol === "http:" && isLoopbackHost(url.hostname))) {
+    throw new ByokKeysError(
+      "PROVIDER_URL_INVALID",
+      "Provider URL requires HTTPS; HTTP is allowed only for localhost"
+    );
+  }
+  if (isPrivateNetworkLiteral(url.hostname) && !isLoopbackHost(url.hostname)) {
+    throw new ByokKeysError(
+      "PROVIDER_URL_INVALID",
+      "Private-network provider IPs are not allowed"
+    );
+  }
+  return url.toString().replace(/\/$/u, "");
+}
+function isLoopbackHost(hostname) {
+  const value = hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+  return value === "localhost" || value === "127.0.0.1" || value === "::1";
+}
+function isPrivateNetworkLiteral(hostname) {
+  const value = hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+  if (value.includes(":")) return true;
+  const parts = value.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+    return false;
+  }
+  return parts[0] === 10 || parts[0] === 127 || parts[0] === 169 && parts[1] === 254 || parts[0] === 172 && (parts[1] ?? 0) >= 16 && (parts[1] ?? 0) <= 31 || parts[0] === 192 && parts[1] === 168;
+}
+
+// src/provider-profile.ts
+var MODEL_PROVIDER_IDS = [
+  "openai",
+  "deepseek",
+  "anthropic",
+  "custom"
+];
+var PROVIDER_AUTH_MODES = ["bearer", "x_api_key", "none"];
+var MODEL_PROVIDER_ADAPTERS = ["openai_compatible", "anthropic"];
+function boundedString(field, maximumLength) {
+  return z.string().superRefine((value, ctx) => {
+    if (value.trim().length === 0 || value.length > maximumLength || /[\u0000\r\n]/u.test(value)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Provider ${field} is invalid`
+      });
+    }
+  }).transform((value) => value.trim());
+}
+function isoTimestamp(field) {
+  return boundedString(field, 64).superRefine((value, ctx) => {
+    if (!Number.isFinite(Date.parse(value))) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Provider ${field} must be an ISO timestamp`
+      });
+    }
+  });
+}
+var providerBaseUrl = z.string().superRefine((value, ctx) => {
+  try {
+    normalizeProviderUrl(value);
+  } catch (error) {
+    ctx.addIssue({
+      code: "custom",
+      message: error instanceof Error ? error.message : "Provider base URL is invalid",
+      params: {
+        byokCode: error instanceof ByokKeysError ? error.code : "PROVIDER_URL_INVALID"
+      }
+    });
+  }
+}).transform((value) => normalizeProviderUrl(value));
+var ModelProviderProfileSchema = z.object({
+  adapter: z.enum(MODEL_PROVIDER_ADAPTERS),
+  auth_mode: z.enum(PROVIDER_AUTH_MODES),
+  base_url: providerBaseUrl,
+  created_at: isoTimestamp("created_at"),
+  display_name: boundedString("display_name", 100),
+  enabled: z.boolean(),
+  kind: z.literal("model"),
+  model: boundedString("model", 160),
+  provider_id: z.enum(MODEL_PROVIDER_IDS),
+  updated_at: isoTimestamp("updated_at")
+}).superRefine((profile, ctx) => {
+  if (profile.adapter === "anthropic" && profile.auth_mode !== "x_api_key") {
+    ctx.addIssue({
+      code: "custom",
+      message: "Anthropic requires x_api_key authentication",
+      path: ["auth_mode"]
+    });
+  }
+  if (profile.adapter === "openai_compatible" && profile.auth_mode === "x_api_key") {
+    ctx.addIssue({
+      code: "custom",
+      message: "OpenAI-compatible providers support bearer or no authentication",
+      path: ["auth_mode"]
+    });
+  }
+  if (Date.parse(profile.updated_at) < Date.parse(profile.created_at)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Provider updated_at cannot precede created_at",
+      path: ["updated_at"]
+    });
+  }
+});
+function parseModelProviderProfile(value) {
+  const result = ModelProviderProfileSchema.safeParse(value);
+  if (result.success) return result.data;
+  const issue = result.error.issues[0];
+  const params = issue?.params;
+  throw new ByokKeysError(
+    params?.byokCode ?? "PROVIDER_PROFILE_INVALID",
+    issue?.message ?? "Provider profile is invalid",
+    { cause: result.error }
+  );
+}
+
+// src/pi-provider-launcher-core.ts
+var PI_CHILD_BASE_ENV_NAMES = [
+  "PATH",
+  "HOME",
+  "USERPROFILE",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "LANG",
+  "TZ",
+  "TERM",
+  "SHELL",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "ALL_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  "all_proxy"
+];
+var PI_CHILD_WINDOWS_ENV_NAMES = [
+  "SystemRoot",
+  "COMSPEC",
+  "PATHEXT",
+  "windir",
+  "SYSTEMDRIVE",
+  "PROGRAMFILES",
+  "APPDATA",
+  "LOCALAPPDATA"
+];
+function parsePiProviderLauncherOptions(args) {
+  const separator = args.indexOf("--");
+  if (separator < 0) throw new Error("launcher arguments must end with -- <pi args>");
+  const ownArgs = args.slice(0, separator);
+  const piArgs = args.slice(separator + 1);
+  if (piArgs.length === 0) throw new Error("launcher requires Pi arguments after --");
+  const allowedFlags = /* @__PURE__ */ new Set([
+    "--pi-bin",
+    "--profile-db",
+    "--provider",
+    "--model",
+    "--session-dir",
+    "--secret-service-prefix"
+  ]);
+  const values = /* @__PURE__ */ new Map();
+  for (let index = 0; index < ownArgs.length; index += 2) {
+    const flag = ownArgs[index];
+    const value = ownArgs[index + 1];
+    if (!flag || !allowedFlags.has(flag)) {
+      throw new Error(`unknown launcher argument ${flag ?? "<missing>"}`);
+    }
+    if (values.has(flag)) throw new Error(`launcher argument ${flag} may only be provided once`);
+    if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value`);
+    if (/[\u0000\r\n]/u.test(value)) {
+      throw new Error(`${flag} must be a single-line value`);
+    }
+    values.set(flag, value);
+  }
+  const required = (flag) => {
+    const value = values.get(flag);
+    if (value === void 0) throw new Error(`${flag} requires a value`);
+    return value;
+  };
+  const rawProviderId = required("--provider");
+  if (!MODEL_PROVIDER_IDS.includes(rawProviderId)) {
+    throw new Error(`provider ${rawProviderId} is not configured by @byok-sdk/keys`);
+  }
+  const modelId = required("--model");
+  if (modelId.length > 160) throw new Error("--model exceeds 160 characters");
+  const profileDbPath = required("--profile-db");
+  const sessionDir = required("--session-dir");
+  if (!path.isAbsolute(profileDbPath) || !path.isAbsolute(sessionDir)) {
+    throw new Error("launcher profile database and session directory must be absolute paths");
+  }
+  const secretServicePrefix = values.get("--secret-service-prefix");
+  return {
+    piBin: required("--pi-bin"),
+    profileDbPath,
+    providerId: rawProviderId,
+    modelId,
+    sessionDir,
+    ...secretServicePrefix ? { secretServicePrefix } : {},
+    piArgs
+  };
+}
+async function resolvePiProviderSecret(profile, createStore) {
+  if (profile.auth_mode === "none") return void 0;
+  const secrets = createStore();
+  if (!await secrets.available()) {
+    throw new ByokKeysError(
+      "KEYCHAIN_UNAVAILABLE",
+      `${secrets.providerLabel} is unavailable`
+    );
+  }
+  const secret = await secrets.get(modelProviderSecretName(profile.provider_id));
+  if (!secret) {
+    throw new ByokKeysError(
+      "PROVIDER_SECRET_MISSING",
+      `${profile.provider_id} provider requires a secret in ${secrets.providerLabel}`
+    );
+  }
+  return secret;
+}
+function buildPiProviderChildEnvironment(options) {
+  const platform = options.platform ?? process.platform;
+  const exactNames = new Set([
+    ...PI_CHILD_BASE_ENV_NAMES,
+    ...platform === "win32" ? PI_CHILD_WINDOWS_ENV_NAMES : []
+  ].map((name) => platform === "win32" ? name.toUpperCase() : name));
+  const result = {};
+  for (const [name, value] of Object.entries(options.ambient)) {
+    if (value === void 0) continue;
+    const platformName = platform === "win32" ? name.toUpperCase() : name;
+    const isExact = exactNames.has(platformName);
+    const isPrefixed = platform === "win32" ? platformName.startsWith("LC_") || platformName.startsWith("XDG_") : name.startsWith("LC_") || name.startsWith("XDG_");
+    if (isExact || isPrefixed) result[name] = value;
+  }
+  result.PI_CODING_AGENT_DIR = options.projectionDir;
+  result.PI_CODING_AGENT_SESSION_DIR = options.sessionDir;
+  if (options.secret !== void 0) {
+    result[PI_PROJECTED_KEY_ENV] = options.secret;
+  }
+  return result;
+}
+async function ensurePiSessionDirectory(sessionDir) {
+  const firstCreated = await promises.mkdir(sessionDir, { recursive: true, mode: 448 });
+  if (firstCreated !== void 0) {
+    await promises.chmod(sessionDir, 448).catch(() => {
+    });
+  }
+  const stat = await promises.stat(sessionDir);
+  if (!stat.isDirectory()) {
+    throw new Error("Pi session path must be a directory");
+  }
+  if (process.platform !== "win32" && (stat.mode & 63) !== 0) {
+    throw new Error(
+      "existing Pi session directory must already be owner-only; refusing to change host-owned permissions"
+    );
+  }
+}
+
+// src/profile-store.ts
+function providerNotConfigured(providerId) {
+  return new ByokKeysError(
+    "PROVIDER_NOT_CONFIGURED",
+    `${providerId} model provider is not configured`
+  );
+}
+function closeSqliteDatabaseAfterInitializationFailure(database, initializationError, message, close = (handle) => handle.close()) {
+  try {
+    close(database);
+  } catch (closeError) {
+    throw new AggregateError([initializationError, closeError], message);
+  }
+  throw initializationError;
+}
+var SECURE_DIR_MODE = 448;
+var SECURE_FILE_MODE = 384;
+var DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+function loadSqliteModule() {
+  try {
+    return createRequire(import.meta.url)("node:sqlite");
+  } catch (error) {
+    throw new ByokKeysError(
+      "PROVIDER_STORE_UNAVAILABLE",
+      "node:sqlite is unavailable in this Node.js runtime. SqliteProviderProfileStore requires Node.js 22.5+ with the built-in `node:sqlite` module (no native dependency is used or allowed here). Upgrade Node.js, or use InMemoryProviderProfileStore instead.",
+      { cause: error }
+    );
+  }
+}
+function openSqliteDatabase(path3, options, faults) {
+  const { DatabaseSync } = loadSqliteModule();
+  const readOnly = options?.readOnly === true;
+  if (path3 !== ":memory:" && !readOnly) {
+    mkdirSync(dirname(path3), { mode: SECURE_DIR_MODE, recursive: true });
+  }
+  const database = new DatabaseSync(path3, {
+    timeout: DEFAULT_BUSY_TIMEOUT_MS,
+    ...options
+  });
+  try {
+    faults?.onStep?.("after-open");
+    if (path3 !== ":memory:" && !readOnly) {
+      database.exec("PRAGMA journal_mode = WAL");
+      faults?.onStep?.("after-wal");
+      database.exec("PRAGMA synchronous = FULL");
+      faults?.onStep?.("after-synchronous");
+    }
+    return database;
+  } catch (error) {
+    closeSqliteDatabaseAfterInitializationFailure(
+      database,
+      error,
+      "provider profile SQLite open initialization failed and its native handle could not be closed",
+      faults?.close
+    );
+  }
+}
+function secureSqliteFilePermissions(databasePath) {
+  if (databasePath === ":memory:") return;
+  for (const candidate of [
+    databasePath,
+    `${databasePath}-wal`,
+    `${databasePath}-shm`
+  ]) {
+    if (existsSync(candidate)) {
+      chmodSync(candidate, SECURE_FILE_MODE);
+    }
+  }
+}
+
+// src/sqlite-profile-store.ts
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS provider_profile (
+  provider_id  TEXT PRIMARY KEY CHECK (provider_id IN ('openai', 'deepseek', 'anthropic', 'custom')),
+  kind         TEXT NOT NULL CHECK (kind = 'model'),
+  adapter      TEXT NOT NULL CHECK (adapter IN ('openai_compatible', 'anthropic')),
+  display_name TEXT NOT NULL,
+  base_url     TEXT NOT NULL,
+  auth_mode    TEXT NOT NULL CHECK (auth_mode IN ('bearer', 'x_api_key', 'none')),
+  model        TEXT NOT NULL,
+  enabled      INTEGER NOT NULL CHECK (enabled IN (0, 1)),
+  created_at   TEXT NOT NULL,
+  updated_at   TEXT NOT NULL
+);
+`;
+var ENABLED_INDEX = `
+CREATE UNIQUE INDEX IF NOT EXISTS provider_profile_one_enabled
+ON provider_profile(kind)
+WHERE enabled = 1;
+`;
+var SqliteProviderProfileStore = class {
+  #database;
+  #closed = false;
+  constructor(options) {
+    this.#database = openSqliteDatabase(options.path, {
+      readOnly: options.readOnly ?? false
+    });
+    if (!options.readOnly) {
+      try {
+        this.#database.exec(SCHEMA);
+        this.#database.exec(ENABLED_INDEX);
+        secureSqliteFilePermissions(options.path);
+      } catch (error) {
+        closeSqliteDatabaseAfterInitializationFailure(
+          this.#database,
+          error,
+          "SqliteProviderProfileStore initialization failed and its native handle could not be closed"
+        );
+      }
+    }
+  }
+  /**
+   * Idempotent, as {@link ProviderProfileStore.close} requires: `node:sqlite`
+   * throws "database is not open" on a second `close()`, and a store is
+   * routinely closed both by the code that finished with it and by a test's
+   * teardown.
+   */
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#database.close();
+  }
+  async delete(providerId) {
+    const result = this.#database.prepare("DELETE FROM provider_profile WHERE provider_id = ?").run(providerId);
+    return Number(result.changes) === 1;
+  }
+  async get(providerId) {
+    const row = this.#database.prepare("SELECT * FROM provider_profile WHERE provider_id = ?").get(providerId);
+    return row === void 0 ? void 0 : parseRow(row);
+  }
+  async getEnabled() {
+    const row = this.#database.prepare("SELECT * FROM provider_profile WHERE enabled = 1").get();
+    return row === void 0 ? void 0 : parseRow(row);
+  }
+  async list() {
+    const rows = this.#database.prepare("SELECT * FROM provider_profile ORDER BY provider_id ASC").all();
+    return rows.map(parseRow);
+  }
+  async save(profile) {
+    const existing = await this.get(profile.provider_id);
+    const validated = parseModelProviderProfile({
+      ...profile,
+      created_at: existing?.created_at ?? profile.created_at
+    });
+    this.#transaction(() => {
+      if (validated.enabled) {
+        this.#database.prepare(
+          "UPDATE provider_profile SET enabled = 0 WHERE provider_id <> ?"
+        ).run(validated.provider_id);
+      }
+      this.#database.prepare(
+        `INSERT INTO provider_profile (
+             provider_id, kind, adapter, display_name, base_url,
+             auth_mode, model, enabled, created_at, updated_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(provider_id) DO UPDATE SET
+             adapter = excluded.adapter,
+             display_name = excluded.display_name,
+             base_url = excluded.base_url,
+             auth_mode = excluded.auth_mode,
+             model = excluded.model,
+             enabled = excluded.enabled,
+             updated_at = excluded.updated_at`
+      ).run(
+        validated.provider_id,
+        validated.kind,
+        validated.adapter,
+        validated.display_name,
+        validated.base_url,
+        validated.auth_mode,
+        validated.model,
+        validated.enabled ? 1 : 0,
+        validated.created_at,
+        validated.updated_at
+      );
+    });
+    return await this.get(validated.provider_id);
+  }
+  async setEnabled(providerId) {
+    const existing = await this.get(providerId);
+    if (existing === void 0) throw providerNotConfigured(providerId);
+    return this.save({ ...existing, enabled: true });
+  }
+  /** `BEGIN IMMEDIATE` / `COMMIT` / `ROLLBACK`, per `providers.ts:1252-1263`. */
+  #transaction(body) {
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      body();
+      this.#database.exec("COMMIT");
+    } catch (error) {
+      this.#database.exec("ROLLBACK");
+      throw error;
+    }
+  }
+};
+function parseRow(row) {
+  return parseModelProviderProfile({
+    ...row,
+    enabled: row.enabled === 1
+  });
+}
+
+// src/windows-credential-manager.ts
+var CREDENTIAL_NOT_FOUND = 44;
+var WINDOWS_CREDENTIAL_MANAGER_SCRIPT_BASE64 = Buffer.from(
+  String.raw`
+Add-Type -TypeDefinition @"
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
+
+namespace Byok {
+  public static class CredentialManager {
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct Credential {
+      public UInt32 Flags;
+      public UInt32 Type;
+      [MarshalAs(UnmanagedType.LPWStr)] public string TargetName;
+      [MarshalAs(UnmanagedType.LPWStr)] public string Comment;
+      public FILETIME LastWritten;
+      public UInt32 CredentialBlobSize;
+      public IntPtr CredentialBlob;
+      public UInt32 Persist;
+      public UInt32 AttributeCount;
+      public IntPtr Attributes;
+      [MarshalAs(UnmanagedType.LPWStr)] public string TargetAlias;
+      [MarshalAs(UnmanagedType.LPWStr)] public string UserName;
+    }
+
+    [DllImport("Advapi32.dll", EntryPoint = "CredWriteW", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern bool CredWrite([In] ref Credential credential, UInt32 flags);
+
+    [DllImport("Advapi32.dll", EntryPoint = "CredReadW", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern bool CredRead(string target, UInt32 type, UInt32 flags, out IntPtr credential);
+
+    [DllImport("Advapi32.dll", EntryPoint = "CredDeleteW", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern bool CredDelete(string target, UInt32 type, UInt32 flags);
+
+    [DllImport("Advapi32.dll", SetLastError = false)]
+    private static extern void CredFree(IntPtr buffer);
+
+    public static void Write(string target, string username, byte[] secret) {
+      IntPtr blob = IntPtr.Zero;
+      try {
+        blob = Marshal.AllocHGlobal(secret.Length);
+        Marshal.Copy(secret, 0, blob, secret.Length);
+        Credential credential = new Credential {
+          Type = 1,
+          TargetName = target,
+          CredentialBlobSize = (UInt32)secret.Length,
+          CredentialBlob = blob,
+          Persist = 2,
+          UserName = username
+        };
+        if (!CredWrite(ref credential, 0)) {
+          throw new Win32Exception(Marshal.GetLastWin32Error());
+        }
+      } finally {
+        if (blob != IntPtr.Zero) {
+          Marshal.Copy(new byte[secret.Length], 0, blob, secret.Length);
+          Marshal.FreeHGlobal(blob);
+        }
+      }
+    }
+
+    public static byte[] Read(string target) {
+      IntPtr pointer;
+      if (!CredRead(target, 1, 0, out pointer)) {
+        int error = Marshal.GetLastWin32Error();
+        if (error == 1168) return null;
+        throw new Win32Exception(error);
+      }
+      try {
+        Credential credential = (Credential)Marshal.PtrToStructure(pointer, typeof(Credential));
+        byte[] secret = new byte[credential.CredentialBlobSize];
+        if (secret.Length > 0) Marshal.Copy(credential.CredentialBlob, secret, 0, secret.Length);
+        return secret;
+      } finally {
+        CredFree(pointer);
+      }
+    }
+
+    public static bool Delete(string target) {
+      if (CredDelete(target, 1, 0)) return true;
+      int error = Marshal.GetLastWin32Error();
+      if (error == 1168) return false;
+      throw new Win32Exception(error);
+    }
+  }
+}
+"@
+
+try {
+  $request = ([Console]::In.ReadToEnd() | ConvertFrom-Json)
+  if ($request.operation -eq "set") {
+    [Byok.CredentialManager]::Write(
+      [string]$request.target,
+      [string]$request.username,
+      [Convert]::FromBase64String([string]$request.secret_base64)
+    )
+    exit 0
+  }
+  if ($request.operation -eq "get") {
+    $secret = [Byok.CredentialManager]::Read([string]$request.target)
+    if ($null -eq $secret) { exit 44 }
+    [Console]::Out.Write([Convert]::ToBase64String($secret))
+    exit 0
+  }
+  if ($request.operation -eq "delete") {
+    if ([Byok.CredentialManager]::Delete([string]$request.target)) { exit 0 }
+    exit 44
+  }
+  exit 2
+} catch {
+  [Console]::Error.Write("credential operation failed")
+  exit 1
+}
+`,
+  "utf16le"
+).toString("base64");
+var WindowsCredentialManagerSecretStore = class _WindowsCredentialManagerSecretStore {
+  providerLabel = "Windows Credential Manager";
+  #account;
+  #commandRunner;
+  #platform;
+  #servicePrefix;
+  constructor(options = {}) {
+    this.#account = options.account ?? "local-device";
+    this.#commandRunner = options.commandRunner ?? runCommand;
+    this.#platform = options.platform ?? process.platform;
+    this.#servicePrefix = options.servicePrefix ?? DEFAULT_SECRET_SERVICE_PREFIX;
+  }
+  async available() {
+    if (this.#platform !== "win32") return false;
+    const result = await this.#commandRunner("powershell.exe", [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      "$PSVersionTable.PSVersion.Major"
+    ]);
+    return result.exitCode === 0;
+  }
+  /**
+   * Delete, then read back. The source verifies rather than trusting the
+   * delete's exit code (`index.ts:651-679`): a credential that survives a
+   * "successful" delete is a security failure, so it is reported as one instead
+   * of being returned as `true`.
+   */
+  async delete(name) {
+    const target = this.#service(name);
+    this.#assertWindows();
+    const result = await this.#invoke({
+      operation: "delete",
+      target,
+      username: this.#account
+    });
+    if (result.exitCode === CREDENTIAL_NOT_FOUND) return false;
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_DELETE_FAILED",
+        "Windows Credential Manager could not delete the requested secret"
+      );
+    }
+    const verification = await this.#invoke({
+      operation: "get",
+      target,
+      username: this.#account
+    });
+    if (verification.exitCode === CREDENTIAL_NOT_FOUND) return true;
+    if (verification.exitCode !== 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_DELETE_FAILED",
+        "Windows Credential Manager could not verify secret deletion"
+      );
+    }
+    throw new ByokKeysError(
+      "CREDENTIAL_MANAGER_DELETE_FAILED",
+      "Windows Credential Manager reported deletion but the secret remains"
+    );
+  }
+  async get(name) {
+    const target = this.#service(name);
+    this.#assertWindows();
+    const result = await this.#invoke({
+      operation: "get",
+      target,
+      username: this.#account
+    });
+    if (result.exitCode === CREDENTIAL_NOT_FOUND) return void 0;
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_READ_FAILED",
+        "Windows Credential Manager could not read the requested secret"
+      );
+    }
+    const secret = decodeStrictBase64Utf8(result.stdout.trim());
+    if (secret === void 0 || secret.length === 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_READ_FAILED",
+        "Windows Credential Manager returned an invalid secret"
+      );
+    }
+    return secret;
+  }
+  async has(name) {
+    return await this.get(name) !== void 0;
+  }
+  scope(namespace) {
+    return new _WindowsCredentialManagerSecretStore({
+      account: this.#account,
+      commandRunner: this.#commandRunner,
+      platform: this.#platform,
+      servicePrefix: `${this.#servicePrefix}.scope.${assertSecretNamespace(namespace)}`
+    });
+  }
+  async set(name, secret) {
+    const target = this.#service(name);
+    this.#assertWindows();
+    assertWindowsCredentialSecret(secret);
+    const result = await this.#invoke({
+      operation: "set",
+      secret_base64: Buffer.from(secret, "utf8").toString("base64"),
+      target,
+      username: this.#account
+    });
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_WRITE_FAILED",
+        "Windows Credential Manager could not store the requested secret"
+      );
+    }
+  }
+  #assertWindows() {
+    if (this.#platform !== "win32") {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_UNAVAILABLE",
+        "Windows Credential Manager is required; plaintext fallback is disabled"
+      );
+    }
+  }
+  async #invoke(request) {
+    return this.#commandRunner(
+      "powershell.exe",
+      [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        WINDOWS_CREDENTIAL_MANAGER_SCRIPT_BASE64
+      ],
+      JSON.stringify(request)
+    );
+  }
+  #service(name) {
+    return `${this.#servicePrefix}.${assertSecretName(name)}`;
+  }
+};
+function assertWindowsCredentialSecret(secret) {
+  const bytes = Buffer.byteLength(secret, "utf8");
+  if (secret.length === 0 || bytes > 2560 || /[\u0000\r\n]/u.test(secret)) {
+    throw new ByokKeysError(
+      "CREDENTIAL_MANAGER_SECRET_INVALID",
+      "Secret must contain 1 to 2560 UTF-8 bytes without newline characters"
+    );
+  }
+}
+
+// src/bin/pi-provider-launcher.ts
+function createSecretStore(servicePrefix) {
+  switch (process.platform) {
+    case "darwin":
+      return new MacOsKeychainSecretStore({ servicePrefix });
+    case "win32":
+      return new WindowsCredentialManagerSecretStore({ servicePrefix });
+    default:
+      throw new ByokKeysError(
+        "KEYCHAIN_UNAVAILABLE",
+        `Pi BYOK credential launcher has no plaintext fallback on ${process.platform}`
+      );
+  }
+}
+async function run(options) {
+  const profiles = new SqliteProviderProfileStore({
+    path: options.profileDbPath,
+    readOnly: true
+  });
+  let projectionDir;
+  try {
+    const profile = await profiles.get(options.providerId);
+    if (profile === void 0) {
+      throw new Error(`provider ${options.providerId} is not configured`);
+    }
+    if (profile.model !== options.modelId) {
+      throw new Error(
+        `selected model ${options.modelId} does not match configured provider model ${profile.model}`
+      );
+    }
+    const secret = await resolvePiProviderSecret(
+      profile,
+      () => createSecretStore(options.secretServicePrefix)
+    );
+    projectionDir = await promises.mkdtemp(path.join(os.tmpdir(), "byok-pi-provider-"));
+    await promises.chmod(projectionDir, 448).catch(() => {
+    });
+    await ensurePiSessionDirectory(options.sessionDir);
+    await promises.writeFile(
+      path.join(projectionDir, "models.json"),
+      `${JSON.stringify(buildPiProviderProjection(profile))}
+`,
+      { mode: 384 }
+    );
+    const child = spawn(options.piBin, buildPiProviderArgs(profile, options.piArgs), {
+      env: buildPiProviderChildEnvironment({
+        ambient: process.env,
+        projectionDir,
+        sessionDir: options.sessionDir,
+        secret
+      }),
+      stdio: "inherit"
+    });
+    const forward = (signal) => {
+      if (!child.killed) child.kill(signal);
+    };
+    const onSigint = () => forward("SIGINT");
+    const onSigterm = () => forward("SIGTERM");
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    try {
+      return await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code, signal) => {
+          resolve(code ?? (signal ? 1 : 0));
+        });
+      });
+    } finally {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+    }
+  } finally {
+    await profiles.close();
+    if (projectionDir) {
+      await promises.rm(projectionDir, { recursive: true, force: true });
+    }
+  }
+}
+async function main() {
+  try {
+    process.exitCode = await run(parsePiProviderLauncherOptions(process.argv.slice(2)));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`pi provider launcher: ${message}
+`);
+    process.exitCode = 1;
+  }
+}
+void main();
+//# sourceMappingURL=pi-provider-launcher.js.map
+//# sourceMappingURL=pi-provider-launcher.js.map