@slates/profiles 1.0.0-rc.2

package/dist/index.module.js

@@ -0,0 +1,403 @@
+// 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 resolveSlatesCliDir = (cwd = process.cwd()) => path.join(resolveSlatesCliRoot(cwd), CLI_DIR_NAME);
+var resolveSlatesCliProfilesDir = (cwd = process.cwd()) => path.join(resolveSlatesCliDir(cwd), PROFILES_DIR_NAME);
+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(resolveSlatesCliProfilesDir(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 = resolveSlatesCliProfilesDir(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(resolveSlatesCliDir(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, dirPath, storePath, scope, data) {
+    this.rootDir = rootDir;
+    this.dirPath = dirPath;
+    this.storePath = storePath;
+    this.scope = scope;
+    this.data = data;
+  }
+  rootDir;
+  dirPath;
+  storePath;
+  scope;
+  data;
+  static async open(opts = {}) {
+    let rootDir = opts.storePath ? inferRootDirFromStorePath(opts.storePath) : resolveSlatesCliRoot(opts.cwd);
+    let cliDir = resolveSlatesCliDir(rootDir);
+    let scopeKey = opts.storePath ? resolveScopeKeyFromStorePath(rootDir, 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 ?? {}
+    } : scopeKey ? await loadMigratedLegacyStore(rootDir, scopeKey) : createEmptyStore();
+    if (!parsed) {
+      await writeFile(storePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    }
+    return new _SlatesCliStore(
+      rootDir,
+      dirPath,
+      storePath,
+      scopeKey ? { key: scopeKey, name: opts.scope?.name } : null,
+      data
+    );
+  }
+  async save() {
+    await ensureDir(this.dirPath);
+    await ensureDir(resolveSlatesCliDir(this.rootDir));
+    await ensureGitIgnore(resolveSlatesCliDir(this.rootDir));
+    await writeFile(this.storePath, JSON.stringify(this.data, null, 2) + "\n", "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, cwd) => {
+  if (path2.isAbsolute(entry)) return entry;
+  return path2.resolve(resolveSlatesCliRoot(cwd), entry);
+};
+var loadSlateFromProfile = async (profile, cwd) => {
+  if (profile.target.type !== "local") {
+    throw new Error(`Unsupported profile target type: ${profile.target.type}`);
+  }
+  let modulePath = resolveEntryPath(profile.target.entry, cwd);
+  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.cwd);
+  let client = createSlatesClient({
+    transport: createLocalSlateTransport({ slate }),
+    state: {
+      config: profile.config,
+      session: profile.session,
+      auth: firstAuth ? {
+        authenticationMethodId: firstAuth.authMethodId,
+        output: firstAuth.output
+      } : null
+    }
+  });
+  if (firstAuth) {
+    attachAutoRefresh(client, profile, firstAuth, opts.store);
+  }
+  return client;
+};
+var EXPIRY_BUFFER_MS = 60 * 1e3;
+var shouldRefreshOAuthAuth = (auth) => {
+  if (auth.authType !== "auth.oauth") return false;
+  if (!auth.clientId || !auth.clientSecret) return false;
+  if (typeof auth.output?.refreshToken !== "string" || !auth.output.refreshToken) return false;
+  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 attachAutoRefresh = (client, profile, storedAuth, store) => {
+  let baseRequest = client.request.bind(client);
+  let inflightRefresh = null;
+  let refreshIfNeeded = async () => {
+    if (inflightRefresh) {
+      await inflightRefresh;
+      return;
+    }
+    if (!shouldRefreshOAuthAuth(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.2",
+  "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",
+    "lint": "prettier src/**/*.ts --check",
+    "build": "tsup --config ../../tsup.packages.config.ts --external async_hooks",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@slates/client": "1.0.0-rc.2",
+    "@slates/proto": "1.0.0-rc.7"
+  },
+  "devDependencies": {
+    "@slates/provider": "1.0.0-rc.8",
+    "@slates/tsconfig": "1.0.0-rc.1",
+    "typescript": "5.8.2",
+    "vitest": "^3.1.2",
+    "zod": "^4.2.1"
+  }
+}

package/src/client.ts

@@ -0,0 +1,143 @@
+import { createLocalSlateTransport, createSlatesClient } from '@slates/client';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { resolveSlatesCliRoot, SlatesCliStore } from './store';
+import { SlatesProfileRecord, SlatesStoredAuth } from './types';
+
+let resolveEntryPath = (entry: string, cwd?: string) => {
+  if (path.isAbsolute(entry)) return entry;
+  return path.resolve(resolveSlatesCliRoot(cwd), entry);
+};
+
+let loadSlateFromProfile = async (profile: SlatesProfileRecord, cwd?: string) => {
+  if (profile.target.type !== 'local') {
+    throw new Error(`Unsupported profile target type: ${(profile.target as any).type}`);
+  }
+
+  let modulePath = resolveEntryPath(profile.target.entry, cwd);
+  let loaded = await import(pathToFileURL(modulePath).href);
+  let exportName = profile.target.exportName;
+
+  let slate =
+    (exportName ? loaded[exportName] : undefined) ??
+    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;
+};
+
+export let createSlatesClientFromProfile = async (
+  profile: SlatesProfileRecord,
+  opts: { cwd?: string; store?: SlatesCliStore } = {}
+) => {
+  let firstAuth = Object.values(profile.auth)[0];
+  let slate = await loadSlateFromProfile(profile, opts.cwd);
+  let client = createSlatesClient({
+    transport: createLocalSlateTransport({ slate }),
+    state: {
+      config: profile.config,
+      session: profile.session,
+      auth: firstAuth
+        ? {
+            authenticationMethodId: firstAuth.authMethodId,
+            output: firstAuth.output
+          }
+        : null
+    }
+  });
+
+  if (firstAuth) {
+    attachAutoRefresh(client, profile, firstAuth, opts.store);
+  }
+
+  return client;
+};
+
+let EXPIRY_BUFFER_MS = 60 * 1000;
+
+let shouldRefreshOAuthAuth = (auth: SlatesStoredAuth) => {
+  if (auth.authType !== 'auth.oauth') return false;
+  if (!auth.clientId || !auth.clientSecret) return false;
+  if (typeof auth.output?.refreshToken !== 'string' || !auth.output.refreshToken) return false;
+  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;
+};
+
+let attachAutoRefresh = (
+  client: ReturnType<typeof createSlatesClient>,
+  profile: SlatesProfileRecord,
+  storedAuth: SlatesStoredAuth,
+  store?: SlatesCliStore
+) => {
+  let baseRequest = client.request.bind(client);
+  let inflightRefresh: Promise<void> | null = null;
+
+  let refreshIfNeeded = async () => {
+    if (inflightRefresh) {
+      await inflightRefresh;
+      return;
+    }
+
+    if (!shouldRefreshOAuthAuth(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 = 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 as never, params as never);
+  }) as typeof client.request;
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './store';
+export * from './types';