@slates/profiles 1.0.0-rc.10

package/dist/index.d.ts

@@ -0,0 +1,126 @@
+import * as _slates_client from '@slates/client';
+import { SlatesJsonObject } from '@slates/client';
+import { SlateAuthenticationMethod, SlatesAction } from '@slates/proto';
+
+interface SlatesStoredAuth {
+    id: string;
+    authMethodId: string;
+    authMethodName?: string;
+    authType: SlateAuthenticationMethod['type'];
+    input: SlatesJsonObject;
+    output: SlatesJsonObject;
+    scopes: string[];
+    oauthCredentialId?: string;
+    clientId?: string;
+    clientSecret?: string;
+    callbackState?: SlatesJsonObject | null;
+    profile?: SlatesJsonObject | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlatesOAuthCredentialRecord {
+    id: string;
+    name: string;
+    authMethodId: string;
+    clientId: string;
+    clientSecret: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlatesLocalProfileTarget {
+    type: 'local';
+    entry: string;
+    exportName?: string;
+}
+type SlatesProfileTarget = SlatesLocalProfileTarget;
+interface SlatesCliStoreScope {
+    key: string;
+    name?: string;
+}
+interface SlatesProfileRecord {
+    id: string;
+    name: string;
+    target: SlatesProfileTarget;
+    config: SlatesJsonObject | null;
+    auth: Record<string, SlatesStoredAuth>;
+    session: {
+        id: string;
+        state: SlatesJsonObject;
+    } | null;
+    metadata: {
+        provider?: SlatesJsonObject | null;
+        actions?: SlatesAction[] | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlatesCliStoreData {
+    version: 3;
+    currentProfileId: string | null;
+    profiles: Record<string, SlatesProfileRecord>;
+    oauthCredentials: Record<string, SlatesOAuthCredentialRecord>;
+}
+
+declare let resolveSlatesCliRoot: (cwd?: string) => string;
+declare let resolveSlatesCliDir: (cwd?: string) => string;
+declare let resolveSlatesCliProfilesDir: (cwd?: string) => string;
+declare class SlatesCliStore {
+    readonly rootDir: string;
+    readonly cliDir: string;
+    readonly dirPath: string;
+    readonly storePath: string;
+    readonly scope: SlatesCliStoreScope | null;
+    readonly data: SlatesCliStoreData;
+    constructor(rootDir: string, cliDir: string, dirPath: string, storePath: string, scope: SlatesCliStoreScope | null, data: SlatesCliStoreData);
+    static open(opts?: {
+        cwd?: string;
+        rootDir?: string;
+        scope?: SlatesCliStoreScope;
+        storePath?: string;
+    }): Promise<SlatesCliStore>;
+    save(): Promise<void>;
+    listProfiles(): SlatesProfileRecord[];
+    listOAuthCredentials(authMethodId?: string): SlatesOAuthCredentialRecord[];
+    getOAuthCredential(credentialId?: string | null, authMethodId?: string | null): SlatesOAuthCredentialRecord;
+    getProfile(profileId?: string | null): SlatesProfileRecord;
+    requireProfile(profileId?: string | null): SlatesProfileRecord;
+    upsertProfile(d: {
+        profileId?: string;
+        name: string;
+        target: SlatesProfileTarget;
+        config?: SlatesProfileRecord['config'];
+        session?: SlatesProfileRecord['session'];
+        metadata?: SlatesProfileRecord['metadata'];
+    }): SlatesProfileRecord;
+    upsertOAuthCredential(d: {
+        credentialId?: string;
+        name: string;
+        authMethodId: string;
+        clientId: string;
+        clientSecret: string;
+    }): SlatesOAuthCredentialRecord;
+    setCurrentProfile(profileId: string): void;
+    removeProfile(profileId: string): void;
+    setProfileConfig(profileId: string, config: SlatesProfileRecord['config']): SlatesProfileRecord;
+    setProfileSession(profileId: string, session: SlatesProfileRecord['session']): SlatesProfileRecord;
+    setProfileMetadata(profileId: string, metadata: Partial<SlatesProfileRecord['metadata']>): SlatesProfileRecord;
+    upsertAuth(profileId: string, auth: Omit<SlatesStoredAuth, 'id' | 'createdAt' | 'updatedAt'> & {
+        id?: string;
+    }): SlatesStoredAuth;
+    getAuth(profileId: string, authMethodId?: string | null): SlatesStoredAuth;
+    listAuth(profileId: string): SlatesStoredAuth[];
+}
+declare let openSlatesCliStore: (opts?: {
+    cwd?: string;
+    rootDir?: string;
+    scope?: SlatesCliStoreScope;
+    storePath?: string;
+}) => Promise<SlatesCliStore>;
+
+declare let createSlatesClientFromProfile: (profile: SlatesProfileRecord, opts?: {
+    cwd?: string;
+    store?: SlatesCliStore;
+    autoRefresh?: boolean;
+}) => Promise<_slates_client.SlatesProtocolClient>;
+
+export { SlatesCliStore, type SlatesCliStoreData, type SlatesCliStoreScope, type SlatesLocalProfileTarget, type SlatesOAuthCredentialRecord, type SlatesProfileRecord, type SlatesProfileTarget, type SlatesStoredAuth, createSlatesClientFromProfile, openSlatesCliStore, resolveSlatesCliDir, resolveSlatesCliProfilesDir, resolveSlatesCliRoot };

package/dist/index.module.js

@@ -0,0 +1,420 @@
+// src/client.ts
+import { createLocalSlateTransport, createSlatesClient } from "@slates/client";
+import path2 from "path";
+import { pathToFileURL } from "url";
+
+// src/store.ts
+import { execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+var STORE_VERSION = 3;
+var CLI_DIR_NAME = ".slates-cli";
+var PROFILES_DIR_NAME = "profiles";
+var STORE_FILE_NAME = "store.json";
+var GITIGNORE_FILE_NAME = ".gitignore";
+var createEmptyStore = () => ({
+  version: STORE_VERSION,
+  currentProfileId: null,
+  profiles: {},
+  oauthCredentials: {}
+});
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var ensureDir = async (dirPath) => {
+  await mkdir(dirPath, { recursive: true });
+};
+var ensureGitIgnore = async (dirPath) => {
+  let filePath = path.join(dirPath, GITIGNORE_FILE_NAME);
+  await writeFile(filePath, "*\n!.gitignore\n", { encoding: "utf-8" }).catch(async (error) => {
+    if (error.code === "EEXIST") return;
+    throw error;
+  });
+};
+var resolveSlatesCliRoot = (cwd = process.cwd()) => {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return cwd;
+  }
+};
+var resolveSlatesCliDirFromRoot = (rootDir) => path.join(rootDir, CLI_DIR_NAME);
+var resolveSlatesCliProfilesDirFromRoot = (rootDir) => path.join(resolveSlatesCliDirFromRoot(rootDir), PROFILES_DIR_NAME);
+var resolveSlatesCliDir = (cwd = process.cwd()) => resolveSlatesCliDirFromRoot(resolveSlatesCliRoot(cwd));
+var resolveSlatesCliProfilesDir = (cwd = process.cwd()) => resolveSlatesCliProfilesDirFromRoot(resolveSlatesCliRoot(cwd));
+var normalizeScopeKey = (scopeKey) => path.posix.normalize(scopeKey.replace(/\\/g, "/")).replace(/^\.?\//, "");
+var splitScopeKey = (scopeKey) => normalizeScopeKey(scopeKey).split("/").filter(Boolean).filter((segment) => segment !== "." && segment !== "..");
+var resolveScopedStoreDir = (rootDir, scopeKey) => path.join(resolveSlatesCliProfilesDirFromRoot(rootDir), ...splitScopeKey(scopeKey));
+var resolveScopedStorePath = (rootDir, scopeKey) => path.join(resolveScopedStoreDir(rootDir, scopeKey), STORE_FILE_NAME);
+var inferRootDirFromStorePath = (storePath) => {
+  let normalized = path.resolve(storePath);
+  let parts = normalized.split(path.sep).filter(Boolean);
+  let cliDirIndex = parts.lastIndexOf(CLI_DIR_NAME);
+  if (cliDirIndex === -1) {
+    throw new Error(`Could not infer Slates CLI root from store path: ${storePath}`);
+  }
+  let rootParts = parts.slice(0, cliDirIndex);
+  return path.join(path.sep, ...rootParts);
+};
+var resolveScopeKeyFromStorePath = (rootDir, storePath) => {
+  let profilesDir = resolveSlatesCliProfilesDirFromRoot(rootDir);
+  let relativeDir = path.relative(profilesDir, path.dirname(storePath));
+  if (!relativeDir || relativeDir.startsWith("..") || path.isAbsolute(relativeDir)) {
+    return null;
+  }
+  return normalizeScopeKey(relativeDir);
+};
+var readStoreData = async (storePath) => {
+  try {
+    let raw = await readFile(storePath, "utf-8");
+    if (!raw.trim()) {
+      return null;
+    }
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+var isProfileInScope = (rootDir, scopeKey, profile) => {
+  if (profile.target.type !== "local") {
+    return false;
+  }
+  let scopeDir = path.resolve(rootDir, ...splitScopeKey(scopeKey));
+  let entryPath = path.isAbsolute(profile.target.entry) ? profile.target.entry : path.resolve(rootDir, profile.target.entry);
+  let relative = path.relative(scopeDir, entryPath);
+  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+};
+var loadMigratedLegacyStore = async (rootDir, scopeKey) => {
+  let legacyStorePath = path.join(resolveSlatesCliDirFromRoot(rootDir), STORE_FILE_NAME);
+  let legacy = await readStoreData(legacyStorePath);
+  if (!legacy) {
+    return createEmptyStore();
+  }
+  let profiles = Object.fromEntries(
+    Object.entries(legacy.profiles ?? {}).filter(
+      ([, profile]) => isProfileInScope(rootDir, scopeKey, profile)
+    )
+  );
+  let currentProfileId = legacy.currentProfileId && profiles[legacy.currentProfileId] ? legacy.currentProfileId : null;
+  return {
+    version: STORE_VERSION,
+    currentProfileId,
+    profiles,
+    oauthCredentials: {}
+  };
+};
+var SlatesCliStore = class _SlatesCliStore {
+  constructor(rootDir, cliDir, dirPath, storePath, scope, data) {
+    this.rootDir = rootDir;
+    this.cliDir = cliDir;
+    this.dirPath = dirPath;
+    this.storePath = storePath;
+    this.scope = scope;
+    this.data = data;
+  }
+  rootDir;
+  cliDir;
+  dirPath;
+  storePath;
+  scope;
+  data;
+  static async open(opts = {}) {
+    let storageRootDir = opts.storePath ? inferRootDirFromStorePath(opts.storePath) : resolveSlatesCliRoot(opts.cwd);
+    let rootDir = opts.rootDir ?? storageRootDir;
+    let cliDir = resolveSlatesCliDirFromRoot(storageRootDir);
+    let scopeKey = opts.storePath ? resolveScopeKeyFromStorePath(storageRootDir, opts.storePath) : opts.scope?.key ? normalizeScopeKey(opts.scope.key) : null;
+    let dirPath = opts.storePath ? path.dirname(opts.storePath) : scopeKey ? resolveScopedStoreDir(rootDir, scopeKey) : cliDir;
+    let storePath = opts.storePath ?? (scopeKey ? resolveScopedStorePath(rootDir, scopeKey) : path.join(cliDir, STORE_FILE_NAME));
+    await ensureDir(cliDir);
+    await ensureGitIgnore(cliDir);
+    await ensureDir(dirPath);
+    let parsed = await readStoreData(storePath);
+    let data = parsed ? {
+      version: STORE_VERSION,
+      currentProfileId: parsed.currentProfileId ?? null,
+      profiles: parsed.profiles ?? {},
+      oauthCredentials: parsed.oauthCredentials ?? {}
+    } : opts.storePath ? createEmptyStore() : scopeKey ? await loadMigratedLegacyStore(rootDir, scopeKey) : createEmptyStore();
+    if (!parsed) {
+      await writeFile(storePath, `${JSON.stringify(data, null, 2)}
+`, "utf-8");
+    }
+    return new _SlatesCliStore(
+      rootDir,
+      cliDir,
+      dirPath,
+      storePath,
+      scopeKey ? { key: scopeKey, name: opts.scope?.name } : null,
+      data
+    );
+  }
+  async save() {
+    await ensureDir(this.dirPath);
+    await ensureDir(this.cliDir);
+    await ensureGitIgnore(this.cliDir);
+    await writeFile(this.storePath, `${JSON.stringify(this.data, null, 2)}
+`, "utf-8");
+  }
+  listProfiles() {
+    return Object.values(this.data.profiles).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  listOAuthCredentials(authMethodId) {
+    return Object.values(this.data.oauthCredentials).filter((credential) => !authMethodId || credential.authMethodId === authMethodId).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  getOAuthCredential(credentialId, authMethodId) {
+    if (credentialId) {
+      let direct = this.data.oauthCredentials[credentialId];
+      if (direct && (!authMethodId || direct.authMethodId === authMethodId)) {
+        return direct;
+      }
+      let matches = this.listOAuthCredentials(authMethodId ?? void 0).filter(
+        (credential) => credential.name === credentialId
+      );
+      if (matches.length === 1) {
+        return matches[0];
+      }
+    }
+    return this.listOAuthCredentials(authMethodId ?? void 0)[0] ?? null;
+  }
+  getProfile(profileId) {
+    if (profileId) {
+      if (this.data.profiles[profileId]) {
+        return this.data.profiles[profileId] ?? null;
+      }
+      let matches = this.listProfiles().filter((profile) => profile.name === profileId);
+      if (matches.length === 1) {
+        return matches[0];
+      }
+    }
+    if (this.data.currentProfileId && this.data.profiles[this.data.currentProfileId]) {
+      return this.data.profiles[this.data.currentProfileId];
+    }
+    return this.listProfiles()[0] ?? null;
+  }
+  requireProfile(profileId) {
+    let profile = this.getProfile(profileId);
+    if (!profile) {
+      throw new Error("No Slates profile found for this integration.");
+    }
+    return profile;
+  }
+  upsertProfile(d) {
+    let existing = d.profileId ? this.data.profiles[d.profileId] : void 0;
+    let id = existing?.id ?? d.profileId ?? randomUUID();
+    let createdAt = existing?.createdAt ?? now();
+    let profile = {
+      id,
+      name: d.name,
+      target: d.target,
+      config: d.config ?? existing?.config ?? null,
+      auth: existing?.auth ?? {},
+      session: d.session ?? existing?.session ?? null,
+      metadata: {
+        provider: d.metadata?.provider ?? existing?.metadata?.provider ?? null,
+        actions: d.metadata?.actions ?? existing?.metadata?.actions ?? null
+      },
+      createdAt,
+      updatedAt: now()
+    };
+    this.data.profiles[id] = profile;
+    if (!this.data.currentProfileId) {
+      this.data.currentProfileId = id;
+    }
+    return profile;
+  }
+  upsertOAuthCredential(d) {
+    let existing = d.credentialId ? this.data.oauthCredentials[d.credentialId] : void 0;
+    let id = existing?.id ?? d.credentialId ?? randomUUID();
+    let credential = {
+      id,
+      name: d.name,
+      authMethodId: d.authMethodId,
+      clientId: d.clientId,
+      clientSecret: d.clientSecret,
+      createdAt: existing?.createdAt ?? now(),
+      updatedAt: now()
+    };
+    this.data.oauthCredentials[id] = credential;
+    return credential;
+  }
+  setCurrentProfile(profileId) {
+    if (!this.data.profiles[profileId]) {
+      throw new Error(`Unknown profile: ${profileId}`);
+    }
+    this.data.currentProfileId = profileId;
+  }
+  removeProfile(profileId) {
+    delete this.data.profiles[profileId];
+    if (this.data.currentProfileId === profileId) {
+      this.data.currentProfileId = this.listProfiles()[0]?.id ?? null;
+    }
+  }
+  setProfileConfig(profileId, config) {
+    let profile = this.requireProfile(profileId);
+    profile.config = config;
+    profile.updatedAt = now();
+    return profile;
+  }
+  setProfileSession(profileId, session) {
+    let profile = this.requireProfile(profileId);
+    profile.session = session;
+    profile.updatedAt = now();
+    return profile;
+  }
+  setProfileMetadata(profileId, metadata) {
+    let profile = this.requireProfile(profileId);
+    profile.metadata = {
+      provider: metadata.provider ?? profile.metadata.provider ?? null,
+      actions: metadata.actions ?? profile.metadata.actions ?? null
+    };
+    profile.updatedAt = now();
+    return profile;
+  }
+  upsertAuth(profileId, auth) {
+    let profile = this.requireProfile(profileId);
+    let existing = profile.auth[auth.authMethodId];
+    profile.auth[auth.authMethodId] = {
+      ...auth,
+      id: auth.id ?? existing?.id ?? randomUUID(),
+      createdAt: existing?.createdAt ?? now(),
+      updatedAt: now()
+    };
+    profile.updatedAt = now();
+    return profile.auth[auth.authMethodId];
+  }
+  getAuth(profileId, authMethodId) {
+    let profile = this.requireProfile(profileId);
+    if (authMethodId) return profile.auth[authMethodId] ?? null;
+    return Object.values(profile.auth)[0] ?? null;
+  }
+  listAuth(profileId) {
+    let profile = this.requireProfile(profileId);
+    return Object.values(profile.auth).sort(
+      (a, b) => a.authMethodId.localeCompare(b.authMethodId)
+    );
+  }
+};
+var openSlatesCliStore = async (opts = {}) => SlatesCliStore.open(opts);
+
+// src/client.ts
+var resolveEntryPath = (entry, opts = {}) => {
+  if (path2.isAbsolute(entry)) return entry;
+  return path2.resolve(opts.rootDir ?? resolveSlatesCliRoot(opts.cwd), entry);
+};
+var loadSlateFromProfile = async (profile, opts = {}) => {
+  if (profile.target.type !== "local") {
+    throw new Error(`Unsupported profile target type: ${profile.target.type}`);
+  }
+  let modulePath = resolveEntryPath(profile.target.entry, {
+    cwd: opts.cwd,
+    rootDir: opts.store?.rootDir
+  });
+  let loaded = await import(pathToFileURL(modulePath).href);
+  let exportName = profile.target.exportName;
+  let slate = (exportName ? loaded[exportName] : void 0) ?? loaded.provider ?? loaded.slate ?? loaded.default;
+  if (!slate) {
+    throw new Error(
+      `Could not find a slate export in ${profile.target.entry}. Tried ${exportName ? `\`${exportName}\`, ` : ""}\`provider\`, \`slate\`, and \`default\`.`
+    );
+  }
+  return slate;
+};
+var createSlatesClientFromProfile = async (profile, opts = {}) => {
+  let firstAuth = Object.values(profile.auth)[0];
+  let slate = await loadSlateFromProfile(profile, opts);
+  let client = createSlatesClient({
+    transport: createLocalSlateTransport({ slate }),
+    state: {
+      config: profile.config,
+      session: profile.session,
+      auth: firstAuth ? {
+        authenticationMethodId: firstAuth.authMethodId,
+        output: firstAuth.output
+      } : null
+    }
+  });
+  if (firstAuth && opts.autoRefresh !== false) {
+    attachAutoRefresh(client, profile, firstAuth, opts.store);
+  }
+  return client;
+};
+var EXPIRY_BUFFER_MS = 60 * 1e3;
+var hasExpiredOrExpiringOutput = (auth) => {
+  if (typeof auth.output?.expiresAt !== "string" || !auth.output.expiresAt) return false;
+  let expiresAt = Date.parse(auth.output.expiresAt);
+  return Number.isFinite(expiresAt) && expiresAt <= Date.now() + EXPIRY_BUFFER_MS;
+};
+var shouldRefreshAuth = (auth) => {
+  if (!hasExpiredOrExpiringOutput(auth)) return false;
+  if (auth.authType === "auth.oauth") {
+    if (!auth.clientId || !auth.clientSecret) return false;
+    if (typeof auth.output?.refreshToken !== "string" || !auth.output.refreshToken)
+      return false;
+  }
+  return true;
+};
+var attachAutoRefresh = (client, profile, storedAuth, store) => {
+  let baseRequest = client.request.bind(client);
+  let inflightRefresh = null;
+  let refreshIfNeeded = async () => {
+    if (inflightRefresh) {
+      await inflightRefresh;
+      return;
+    }
+    if (!shouldRefreshAuth(storedAuth)) {
+      return;
+    }
+    inflightRefresh = (async () => {
+      let authMethod = await baseRequest("slates/auth.method.get", {
+        authenticationMethodId: storedAuth.authMethodId
+      });
+      if (!authMethod.authenticationMethod.capabilities.handleTokenRefresh?.enabled) {
+        return;
+      }
+      let refreshed = await baseRequest("slates/auth.token_refresh.handle", {
+        authenticationMethodId: storedAuth.authMethodId,
+        output: storedAuth.output,
+        input: storedAuth.input,
+        clientId: storedAuth.clientId ?? "",
+        clientSecret: storedAuth.clientSecret ?? "",
+        scopes: storedAuth.scopes
+      });
+      storedAuth.input = refreshed.input ?? storedAuth.input;
+      storedAuth.output = refreshed.output;
+      storedAuth.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      client.setAuth({
+        authenticationMethodId: storedAuth.authMethodId,
+        output: storedAuth.output
+      });
+      if (store) {
+        store.upsertAuth(profile.id, storedAuth);
+        await store.save();
+      }
+    })();
+    try {
+      await inflightRefresh;
+    } finally {
+      inflightRefresh = null;
+    }
+  };
+  client.request = (async (method, params) => {
+    if (method !== "slates/auth.token_refresh.handle") {
+      await refreshIfNeeded();
+    }
+    return baseRequest(method, params);
+  });
+};
+export {
+  SlatesCliStore,
+  createSlatesClientFromProfile,
+  openSlatesCliStore,
+  resolveSlatesCliDir,
+  resolveSlatesCliProfilesDir,
+  resolveSlatesCliRoot
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@slates/profiles",
+  "version": "1.0.0-rc.10",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src/**",
+    "dist/**",
+    "README.md",
+    "package.json"
+  ],
+  "author": "Tobias Herber",
+  "license": "FSL 1.1",
+  "type": "module",
+  "source": "src/index.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "require": "./dist/index.cjs",
+    "import": "./dist/index.module.js",
+    "default": "./dist/index.module.js"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.module.js",
+  "types": "dist/index.d.ts",
+  "unpkg": "./dist/index.module.js",
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "build": "tsup --config ../../tsup.packages.config.ts --external async_hooks",
+    "typecheck": "tsc --noEmit",
+    "biome:check": "biome check --write src"
+  },
+  "dependencies": {
+    "@slates/client": "1.0.0-rc.12",
+    "@slates/proto": "1.0.0-rc.11"
+  },
+  "devDependencies": {
+    "@slates/provider": "1.0.0-rc.15",
+    "@slates/tsconfig": "1.0.0-rc.1",
+    "typescript": "5.8.2",
+    "vitest": "^3.1.2",
+    "zod": "^4.2.1"
+  }
+}