@slates/profiles 1.0.0-rc.2 → 1.0.0-rc.20

package/dist/index.cjs

@@ -82,11 +82,13 @@ var resolveSlatesCliRoot = (cwd = process.cwd()) => {
     return cwd;
   }
 };
-var resolveSlatesCliDir = (cwd = process.cwd()) => import_path.default.join(resolveSlatesCliRoot(cwd), CLI_DIR_NAME);
-var resolveSlatesCliProfilesDir = (cwd = process.cwd()) => import_path.default.join(resolveSlatesCliDir(cwd), PROFILES_DIR_NAME);
+var resolveSlatesCliDirFromRoot = (rootDir) => import_path.default.join(rootDir, CLI_DIR_NAME);
+var resolveSlatesCliProfilesDirFromRoot = (rootDir) => import_path.default.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) => import_path.default.posix.normalize(scopeKey.replace(/\\/g, "/")).replace(/^\.?\//, "");
 var splitScopeKey = (scopeKey) => normalizeScopeKey(scopeKey).split("/").filter(Boolean).filter((segment) => segment !== "." && segment !== "..");
-var resolveScopedStoreDir = (rootDir, scopeKey) => import_path.default.join(resolveSlatesCliProfilesDir(rootDir), ...splitScopeKey(scopeKey));
+var resolveScopedStoreDir = (rootDir, scopeKey) => import_path.default.join(resolveSlatesCliProfilesDirFromRoot(rootDir), ...splitScopeKey(scopeKey));
 var resolveScopedStorePath = (rootDir, scopeKey) => import_path.default.join(resolveScopedStoreDir(rootDir, scopeKey), STORE_FILE_NAME);
 var inferRootDirFromStorePath = (storePath) => {
   let normalized = import_path.default.resolve(storePath);
@@ -99,7 +101,7 @@ var inferRootDirFromStorePath = (storePath) => {
   return import_path.default.join(import_path.default.sep, ...rootParts);
 };
 var resolveScopeKeyFromStorePath = (rootDir, storePath) => {
-  let profilesDir = resolveSlatesCliProfilesDir(rootDir);
+  let profilesDir = resolveSlatesCliProfilesDirFromRoot(rootDir);
   let relativeDir = import_path.default.relative(profilesDir, import_path.default.dirname(storePath));
   if (!relativeDir || relativeDir.startsWith("..") || import_path.default.isAbsolute(relativeDir)) {
     return null;
@@ -130,7 +132,7 @@ var isProfileInScope = (rootDir, scopeKey, profile) => {
   return relative !== "" && !relative.startsWith("..") && !import_path.default.isAbsolute(relative);
 };
 var loadMigratedLegacyStore = async (rootDir, scopeKey) => {
-  let legacyStorePath = import_path.default.join(resolveSlatesCliDir(rootDir), STORE_FILE_NAME);
+  let legacyStorePath = import_path.default.join(resolveSlatesCliDirFromRoot(rootDir), STORE_FILE_NAME);
   let legacy = await readStoreData(legacyStorePath);
   if (!legacy) {
     return createEmptyStore();
@@ -149,22 +151,25 @@ var loadMigratedLegacyStore = async (rootDir, scopeKey) => {
   };
 };
 var SlatesCliStore = class _SlatesCliStore {
-  constructor(rootDir, dirPath, storePath, scope, data) {
+  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 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 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 ? import_path.default.dirname(opts.storePath) : scopeKey ? resolveScopedStoreDir(rootDir, scopeKey) : cliDir;
     let storePath = opts.storePath ?? (scopeKey ? resolveScopedStorePath(rootDir, scopeKey) : import_path.default.join(cliDir, STORE_FILE_NAME));
     await ensureDir(cliDir);
@@ -176,12 +181,14 @@ var SlatesCliStore = class _SlatesCliStore {
       currentProfileId: parsed.currentProfileId ?? null,
       profiles: parsed.profiles ?? {},
       oauthCredentials: parsed.oauthCredentials ?? {}
-    } : scopeKey ? await loadMigratedLegacyStore(rootDir, scopeKey) : createEmptyStore();
+    } : opts.storePath ? createEmptyStore() : scopeKey ? await loadMigratedLegacyStore(rootDir, scopeKey) : createEmptyStore();
     if (!parsed) {
-      await (0, import_promises.writeFile)(storePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+      await (0, import_promises.writeFile)(storePath, `${JSON.stringify(data, null, 2)}
+`, "utf-8");
     }
     return new _SlatesCliStore(
       rootDir,
+      cliDir,
       dirPath,
       storePath,
       scopeKey ? { key: scopeKey, name: opts.scope?.name } : null,
@@ -190,9 +197,10 @@ var SlatesCliStore = class _SlatesCliStore {
   }
   async save() {
     await ensureDir(this.dirPath);
-    await ensureDir(resolveSlatesCliDir(this.rootDir));
-    await ensureGitIgnore(resolveSlatesCliDir(this.rootDir));
-    await (0, import_promises.writeFile)(this.storePath, JSON.stringify(this.data, null, 2) + "\n", "utf-8");
+    await ensureDir(this.cliDir);
+    await ensureGitIgnore(this.cliDir);
+    await (0, import_promises.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));
@@ -336,15 +344,18 @@ var SlatesCliStore = class _SlatesCliStore {
 var openSlatesCliStore = async (opts = {}) => SlatesCliStore.open(opts);
 
 // src/client.ts
-var resolveEntryPath = (entry, cwd) => {
+var resolveEntryPath = (entry, opts = {}) => {
   if (import_path2.default.isAbsolute(entry)) return entry;
-  return import_path2.default.resolve(resolveSlatesCliRoot(cwd), entry);
+  return import_path2.default.resolve(opts.rootDir ?? resolveSlatesCliRoot(opts.cwd), entry);
 };
-var loadSlateFromProfile = async (profile, cwd) => {
+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);
+  let modulePath = resolveEntryPath(profile.target.entry, {
+    cwd: opts.cwd,
+    rootDir: opts.store?.rootDir
+  });
   let loaded = await import((0, import_url.pathToFileURL)(modulePath).href);
   let exportName = profile.target.exportName;
   let slate = (exportName ? loaded[exportName] : void 0) ?? loaded.provider ?? loaded.slate ?? loaded.default;
@@ -357,7 +368,7 @@ var loadSlateFromProfile = async (profile, cwd) => {
 };
 var createSlatesClientFromProfile = async (profile, opts = {}) => {
   let firstAuth = Object.values(profile.auth)[0];
-  let slate = await loadSlateFromProfile(profile, opts.cwd);
+  let slate = await loadSlateFromProfile(profile, opts);
   let client = (0, import_client.createSlatesClient)({
     transport: (0, import_client.createLocalSlateTransport)({ slate }),
     state: {
@@ -369,20 +380,26 @@ var createSlatesClientFromProfile = async (profile, opts = {}) => {
       } : null
     }
   });
-  if (firstAuth) {
+  if (firstAuth && opts.autoRefresh !== false) {
     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;
+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;
@@ -391,7 +408,7 @@ var attachAutoRefresh = (client, profile, storedAuth, store) => {
       await inflightRefresh;
       return;
     }
-    if (!shouldRefreshOAuthAuth(storedAuth)) {
+    if (!shouldRefreshAuth(storedAuth)) {
       return;
     }
     inflightRefresh = (async () => {

package/dist/index.d.cts

@@ -66,13 +66,15 @@ 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, dirPath: string, storePath: string, scope: SlatesCliStoreScope | null, 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>;
@@ -110,6 +112,7 @@ declare class SlatesCliStore {
 }
 declare let openSlatesCliStore: (opts?: {
     cwd?: string;
+    rootDir?: string;
     scope?: SlatesCliStoreScope;
     storePath?: string;
 }) => Promise<SlatesCliStore>;
@@ -117,6 +120,7 @@ declare let openSlatesCliStore: (opts?: {
 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.d.ts

@@ -66,13 +66,15 @@ 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, dirPath: string, storePath: string, scope: SlatesCliStoreScope | null, 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>;
@@ -110,6 +112,7 @@ declare class SlatesCliStore {
 }
 declare let openSlatesCliStore: (opts?: {
     cwd?: string;
+    rootDir?: string;
     scope?: SlatesCliStoreScope;
     storePath?: string;
 }) => Promise<SlatesCliStore>;
@@ -117,6 +120,7 @@ declare let openSlatesCliStore: (opts?: {
 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

@@ -41,11 +41,13 @@ var resolveSlatesCliRoot = (cwd = process.cwd()) => {
     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 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(resolveSlatesCliProfilesDir(rootDir), ...splitScopeKey(scopeKey));
+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);
@@ -58,7 +60,7 @@ var inferRootDirFromStorePath = (storePath) => {
   return path.join(path.sep, ...rootParts);
 };
 var resolveScopeKeyFromStorePath = (rootDir, storePath) => {
-  let profilesDir = resolveSlatesCliProfilesDir(rootDir);
+  let profilesDir = resolveSlatesCliProfilesDirFromRoot(rootDir);
   let relativeDir = path.relative(profilesDir, path.dirname(storePath));
   if (!relativeDir || relativeDir.startsWith("..") || path.isAbsolute(relativeDir)) {
     return null;
@@ -89,7 +91,7 @@ var isProfileInScope = (rootDir, scopeKey, profile) => {
   return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
 };
 var loadMigratedLegacyStore = async (rootDir, scopeKey) => {
-  let legacyStorePath = path.join(resolveSlatesCliDir(rootDir), STORE_FILE_NAME);
+  let legacyStorePath = path.join(resolveSlatesCliDirFromRoot(rootDir), STORE_FILE_NAME);
   let legacy = await readStoreData(legacyStorePath);
   if (!legacy) {
     return createEmptyStore();
@@ -108,22 +110,25 @@ var loadMigratedLegacyStore = async (rootDir, scopeKey) => {
   };
 };
 var SlatesCliStore = class _SlatesCliStore {
-  constructor(rootDir, dirPath, storePath, scope, data) {
+  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 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 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);
@@ -135,12 +140,14 @@ var SlatesCliStore = class _SlatesCliStore {
       currentProfileId: parsed.currentProfileId ?? null,
       profiles: parsed.profiles ?? {},
       oauthCredentials: parsed.oauthCredentials ?? {}
-    } : scopeKey ? await loadMigratedLegacyStore(rootDir, scopeKey) : createEmptyStore();
+    } : opts.storePath ? createEmptyStore() : scopeKey ? await loadMigratedLegacyStore(rootDir, scopeKey) : createEmptyStore();
     if (!parsed) {
-      await writeFile(storePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+      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,
@@ -149,9 +156,10 @@ var SlatesCliStore = class _SlatesCliStore {
   }
   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");
+    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));
@@ -295,15 +303,18 @@ var SlatesCliStore = class _SlatesCliStore {
 var openSlatesCliStore = async (opts = {}) => SlatesCliStore.open(opts);
 
 // src/client.ts
-var resolveEntryPath = (entry, cwd) => {
+var resolveEntryPath = (entry, opts = {}) => {
   if (path2.isAbsolute(entry)) return entry;
-  return path2.resolve(resolveSlatesCliRoot(cwd), entry);
+  return path2.resolve(opts.rootDir ?? resolveSlatesCliRoot(opts.cwd), entry);
 };
-var loadSlateFromProfile = async (profile, cwd) => {
+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);
+  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;
@@ -316,7 +327,7 @@ var loadSlateFromProfile = async (profile, cwd) => {
 };
 var createSlatesClientFromProfile = async (profile, opts = {}) => {
   let firstAuth = Object.values(profile.auth)[0];
-  let slate = await loadSlateFromProfile(profile, opts.cwd);
+  let slate = await loadSlateFromProfile(profile, opts);
   let client = createSlatesClient({
     transport: createLocalSlateTransport({ slate }),
     state: {
@@ -328,20 +339,26 @@ var createSlatesClientFromProfile = async (profile, opts = {}) => {
       } : null
     }
   });
-  if (firstAuth) {
+  if (firstAuth && opts.autoRefresh !== false) {
     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;
+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;
@@ -350,7 +367,7 @@ var attachAutoRefresh = (client, profile, storedAuth, store) => {
       await inflightRefresh;
       return;
     }
-    if (!shouldRefreshOAuthAuth(storedAuth)) {
+    if (!shouldRefreshAuth(storedAuth)) {
       return;
     }
     inflightRefresh = (async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/profiles",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.20",
   "publishConfig": {
     "access": "public"
   },
@@ -26,16 +26,16 @@
   "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"
+    "typecheck": "tsc --noEmit",
+    "biome:check": "biome check --write src"
   },
   "dependencies": {
-    "@slates/client": "1.0.0-rc.2",
-    "@slates/proto": "1.0.0-rc.7"
+    "@slates/client": "1.0.0-rc.22",
+    "@slates/proto": "1.0.0-rc.19"
   },
   "devDependencies": {
-    "@slates/provider": "1.0.0-rc.8",
+    "@slates/provider": "1.0.0-rc.23",
     "@slates/tsconfig": "1.0.0-rc.1",
     "typescript": "5.8.2",
     "vitest": "^3.1.2",

package/src/client.ts

@@ -1,20 +1,26 @@
 import { createLocalSlateTransport, createSlatesClient } from '@slates/client';
 import path from 'path';
 import { pathToFileURL } from 'url';
-import { resolveSlatesCliRoot, SlatesCliStore } from './store';
-import { SlatesProfileRecord, SlatesStoredAuth } from './types';
+import { resolveSlatesCliRoot, type SlatesCliStore } from './store';
+import type { SlatesProfileRecord, SlatesStoredAuth } from './types';
 
-let resolveEntryPath = (entry: string, cwd?: string) => {
+let resolveEntryPath = (entry: string, opts: { cwd?: string; rootDir?: string } = {}) => {
   if (path.isAbsolute(entry)) return entry;
-  return path.resolve(resolveSlatesCliRoot(cwd), entry);
+  return path.resolve(opts.rootDir ?? resolveSlatesCliRoot(opts.cwd), entry);
 };
 
-let loadSlateFromProfile = async (profile: SlatesProfileRecord, cwd?: string) => {
+let loadSlateFromProfile = async (
+  profile: SlatesProfileRecord,
+  opts: { cwd?: string; store?: SlatesCliStore } = {}
+) => {
   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 modulePath = resolveEntryPath(profile.target.entry, {
+    cwd: opts.cwd,
+    rootDir: opts.store?.rootDir
+  });
   let loaded = await import(pathToFileURL(modulePath).href);
   let exportName = profile.target.exportName;
 
@@ -37,10 +43,10 @@ let loadSlateFromProfile = async (profile: SlatesProfileRecord, cwd?: string) =>
 
 export let createSlatesClientFromProfile = async (
   profile: SlatesProfileRecord,
-  opts: { cwd?: string; store?: SlatesCliStore } = {}
+  opts: { cwd?: string; store?: SlatesCliStore; autoRefresh?: boolean } = {}
 ) => {
   let firstAuth = Object.values(profile.auth)[0];
-  let slate = await loadSlateFromProfile(profile, opts.cwd);
+  let slate = await loadSlateFromProfile(profile, opts);
   let client = createSlatesClient({
     transport: createLocalSlateTransport({ slate }),
     state: {
@@ -55,7 +61,7 @@ export let createSlatesClientFromProfile = async (
     }
   });
 
-  if (firstAuth) {
+  if (firstAuth && opts.autoRefresh !== false) {
     attachAutoRefresh(client, profile, firstAuth, opts.store);
   }
 
@@ -64,16 +70,25 @@ export let createSlatesClientFromProfile = async (
 
 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;
+let hasExpiredOrExpiringOutput = (auth: SlatesStoredAuth) => {
   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 shouldRefreshAuth = (auth: SlatesStoredAuth) => {
+  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;
+};
+
 let attachAutoRefresh = (
   client: ReturnType<typeof createSlatesClient>,
   profile: SlatesProfileRecord,
@@ -89,7 +104,7 @@ let attachAutoRefresh = (
       return;
     }
 
-    if (!shouldRefreshOAuthAuth(storedAuth)) {
+    if (!shouldRefreshAuth(storedAuth)) {
       return;
     }
 

package/src/store.test.ts

@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'fs/promises';
+import { access, mkdir, mkdtemp, rm, writeFile } from 'fs/promises';
 import { tmpdir } from 'os';
 import path from 'path';
 import { afterEach, describe, expect, it } from 'vitest';
@@ -55,7 +55,56 @@ describe('@slates/profiles store', () => {
     expect(reopenedProfile.config).toEqual({ prefix: 'Hello' });
     expect(reopened.getAuth(profile.id, 'token_auth')?.output).toEqual({ token: 'abc' });
     expect(reopened.scope?.key).toBe('integrations/demo');
-    expect(reopened.storePath).toBe(path.join(cwd, '.slates-cli', 'profiles', 'integrations', 'demo', 'store.json'));
+    expect(reopened.cliDir).toBe(path.join(cwd, '.slates-cli'));
+    expect(reopened.storePath).toBe(
+      path.join(cwd, '.slates-cli', 'profiles', 'integrations', 'demo', 'store.json')
+    );
+  });
+
+  it('opens an external scoped store with a separate logical root', async () => {
+    let workspaceRoot = await createTempDir();
+    let storageRoot = await createTempDir();
+    let storePath = path.join(
+      storageRoot,
+      '.slates-cli',
+      'profiles',
+      'integrations',
+      'demo',
+      'store.json'
+    );
+
+    let store = await SlatesCliStore.open({
+      storePath,
+      rootDir: workspaceRoot
+    });
+
+    let profile = store.upsertProfile({
+      name: 'Demo',
+      target: {
+        type: 'local',
+        entry: 'integrations/demo/src/index.ts',
+        exportName: 'provider'
+      }
+    });
+    store.setCurrentProfile(profile.id);
+    await store.save();
+
+    let reopened = await SlatesCliStore.open({
+      storePath,
+      rootDir: workspaceRoot
+    });
+
+    expect(reopened.rootDir).toBe(workspaceRoot);
+    expect(reopened.cliDir).toBe(path.join(storageRoot, '.slates-cli'));
+    expect(reopened.scope?.key).toBe('integrations/demo');
+    expect(reopened.getProfile()?.target.entry).toBe('integrations/demo/src/index.ts');
+
+    await expect(
+      access(path.join(storageRoot, '.slates-cli', '.gitignore'))
+    ).resolves.toBeUndefined();
+    await expect(access(path.join(workspaceRoot, '.slates-cli'))).rejects.toMatchObject({
+      code: 'ENOENT'
+    });
   });
 
   it('migrates matching legacy profiles into an integration-scoped store', async () => {
@@ -182,6 +231,62 @@ export let provider = Slate.create({
     expect(provider.provider.name).toBe('Demo Slate');
   });
 
+  it('resolves profile entry paths against the store root when the store lives elsewhere', async () => {
+    let workspaceRoot = await createTempDir();
+    let storageRoot = await createTempDir();
+    let entry = path.join(workspaceRoot, 'integrations', 'demo-slate.mjs');
+    await mkdir(path.dirname(entry), { recursive: true });
+    await writeFile(
+      entry,
+      `
+import { Slate, SlateAuth, SlateConfig, SlateSpecification } from '@slates/provider';
+import { z } from 'zod';
+
+let config = SlateConfig.create(z.object({})).getDefaultConfig(() => ({}));
+let auth = SlateAuth.create();
+
+export let provider = Slate.create({
+  spec: SlateSpecification.create({
+    key: 'external-demo',
+    name: 'External Demo',
+    description: 'Store root resolution test',
+    config,
+    auth
+  }),
+  tools: [],
+  triggers: []
+});
+`,
+      'utf-8'
+    );
+
+    let store = await SlatesCliStore.open({
+      storePath: path.join(
+        storageRoot,
+        '.slates-cli',
+        'profiles',
+        'integrations',
+        'demo',
+        'store.json'
+      ),
+      rootDir: workspaceRoot
+    });
+    let profile = store.upsertProfile({
+      name: 'Demo',
+      target: {
+        type: 'local',
+        entry: 'integrations/demo-slate.mjs',
+        exportName: 'provider'
+      }
+    });
+
+    let client = await createSlatesClientFromProfile(profile, { store });
+    let provider = await client.identify();
+
+    expect(provider.provider.id).toBe('external-demo');
+    expect(provider.provider.name).toBe('External Demo');
+  });
+
   it('stores OAuth client credentials per integration', async () => {
     let cwd = await createTempDir();
     let store = await SlatesCliStore.open({
@@ -202,7 +307,9 @@ export let provider = Slate.create({
 
     let reopened = await SlatesCliStore.open({ storePath: store.storePath });
     expect(reopened.getOAuthCredential(credential.id)?.clientId).toBe('client-id');
-    expect(reopened.getOAuthCredential('Primary OAuth App')?.clientSecret).toBe('client-secret');
+    expect(reopened.getOAuthCredential('Primary OAuth App')?.clientSecret).toBe(
+      'client-secret'
+    );
   });
 
   it('refreshes expired OAuth auth automatically in the profile-backed client', async () => {
@@ -312,4 +419,115 @@ export let provider = Slate.create({
       token: 'expired-token-refreshed'
     });
   });
+
+  it('refreshes expired custom auth automatically in the profile-backed client', async () => {
+    let cwd = await createTempDir();
+    let entry = path.join(cwd, 'custom-slate.mjs');
+    await writeFile(
+      entry,
+      `
+import { Slate, SlateAuth, SlateConfig, SlateSpecification, SlateTool } from '@slates/provider';
+import { z } from 'zod';
+
+let config = SlateConfig.create(z.object({})).getDefaultConfig(() => ({}));
+let auth = SlateAuth.create()
+  .output(
+    z.object({
+      token: z.string(),
+      expiresAt: z.string().optional()
+    })
+  )
+  .addCustomAuth({
+    type: 'auth.custom',
+    key: 'custom',
+    name: 'Custom',
+    inputSchema: z.object({
+      tokenPrefix: z.string()
+    }),
+    getOutput: async ctx => ({
+      output: {
+        token: \`\${ctx.input.tokenPrefix}-initial\`,
+        expiresAt: new Date(Date.now() + 60 * 60 * 1000).toISOString()
+      }
+    }),
+    handleTokenRefresh: async ctx => ({
+      output: {
+        token: \`\${ctx.input.tokenPrefix}-refreshed\`,
+        expiresAt: new Date(Date.now() + 60 * 60 * 1000).toISOString()
+      }
+    })
+  });
+
+let spec = SlateSpecification.create({
+  key: 'custom-demo',
+  name: 'Custom Demo',
+  description: 'Custom auth test slate',
+  config,
+  auth
+});
+
+let tool = SlateTool.create(spec, {
+  key: 'whoami',
+  name: 'Who Am I'
+})
+  .input(z.object({}))
+  .output(
+    z.object({
+      token: z.string()
+    })
+  )
+  .handleInvocation(async ctx => ({
+    output: {
+      token: ctx.auth.token
+    }
+  }))
+  .build();
+
+export let provider = Slate.create({
+  spec,
+  tools: [tool],
+  triggers: []
+});
+`,
+      'utf-8'
+    );
+
+    let store = await SlatesCliStore.open({
+      cwd,
+      scope: {
+        key: 'integrations/demo',
+        name: 'demo'
+      }
+    });
+    let profile = store.upsertProfile({
+      name: 'Demo',
+      target: {
+        type: 'local',
+        entry: './custom-slate.mjs',
+        exportName: 'provider'
+      }
+    });
+    store.setProfileConfig(profile.id, {});
+    store.upsertAuth(profile.id, {
+      authMethodId: 'custom',
+      authType: 'auth.custom',
+      input: {
+        tokenPrefix: 'custom-token'
+      },
+      output: {
+        token: 'expired-token',
+        expiresAt: new Date(Date.now() - 60 * 1000).toISOString()
+      },
+      scopes: []
+    });
+    await store.save();
+
+    let client = await createSlatesClientFromProfile(profile, { cwd, store });
+    let result = await client.invokeTool('whoami', {});
+
+    expect(result.output).toEqual({ token: 'custom-token-refreshed' });
+    expect(store.getAuth(profile.id, 'custom')?.output).toMatchObject({
+      token: 'custom-token-refreshed'
+    });
+  });
 });

package/src/store.ts

@@ -2,7 +2,7 @@ import { execFileSync } from 'child_process';
 import { randomUUID } from 'crypto';
 import { mkdir, readFile, writeFile } from 'fs/promises';
 import path from 'path';
-import {
+import type {
   SlatesCliStoreData,
   SlatesCliStoreScope,
   SlatesOAuthCredentialRecord,
@@ -56,11 +56,16 @@ export let resolveSlatesCliRoot = (cwd: string = process.cwd()) => {
   }
 };
 
+let resolveSlatesCliDirFromRoot = (rootDir: string) => path.join(rootDir, CLI_DIR_NAME);
+
+let resolveSlatesCliProfilesDirFromRoot = (rootDir: string) =>
+  path.join(resolveSlatesCliDirFromRoot(rootDir), PROFILES_DIR_NAME);
+
 export let resolveSlatesCliDir = (cwd: string = process.cwd()) =>
-  path.join(resolveSlatesCliRoot(cwd), CLI_DIR_NAME);
+  resolveSlatesCliDirFromRoot(resolveSlatesCliRoot(cwd));
 
 export let resolveSlatesCliProfilesDir = (cwd: string = process.cwd()) =>
-  path.join(resolveSlatesCliDir(cwd), PROFILES_DIR_NAME);
+  resolveSlatesCliProfilesDirFromRoot(resolveSlatesCliRoot(cwd));
 
 let normalizeScopeKey = (scopeKey: string) =>
   path.posix.normalize(scopeKey.replace(/\\/g, '/')).replace(/^\.?\//, '');
@@ -72,7 +77,7 @@ let splitScopeKey = (scopeKey: string) =>
     .filter(segment => segment !== '.' && segment !== '..');
 
 let resolveScopedStoreDir = (rootDir: string, scopeKey: string) =>
-  path.join(resolveSlatesCliProfilesDir(rootDir), ...splitScopeKey(scopeKey));
+  path.join(resolveSlatesCliProfilesDirFromRoot(rootDir), ...splitScopeKey(scopeKey));
 
 let resolveScopedStorePath = (rootDir: string, scopeKey: string) =>
   path.join(resolveScopedStoreDir(rootDir, scopeKey), STORE_FILE_NAME);
@@ -91,7 +96,7 @@ let inferRootDirFromStorePath = (storePath: string) => {
 };
 
 let resolveScopeKeyFromStorePath = (rootDir: string, storePath: string) => {
-  let profilesDir = resolveSlatesCliProfilesDir(rootDir);
+  let profilesDir = resolveSlatesCliProfilesDirFromRoot(rootDir);
   let relativeDir = path.relative(profilesDir, path.dirname(storePath));
   if (!relativeDir || relativeDir.startsWith('..') || path.isAbsolute(relativeDir)) {
     return null;
@@ -138,7 +143,7 @@ let loadMigratedLegacyStore = async (
   rootDir: string,
   scopeKey: string
 ): Promise<SlatesCliStoreData> => {
-  let legacyStorePath = path.join(resolveSlatesCliDir(rootDir), STORE_FILE_NAME);
+  let legacyStorePath = path.join(resolveSlatesCliDirFromRoot(rootDir), STORE_FILE_NAME);
   let legacy = await readStoreData<SlatesLegacyCliStoreData>(legacyStorePath);
   if (!legacy) {
     return createEmptyStore();
@@ -166,6 +171,7 @@ let loadMigratedLegacyStore = async (
 export class SlatesCliStore {
   constructor(
     readonly rootDir: string,
+    readonly cliDir: string,
     readonly dirPath: string,
     readonly storePath: string,
     readonly scope: SlatesCliStoreScope | null,
@@ -173,14 +179,20 @@ export class SlatesCliStore {
   ) {}
 
   static async open(
-    opts: { cwd?: string; scope?: SlatesCliStoreScope; storePath?: string } = {}
+    opts: {
+      cwd?: string;
+      rootDir?: string;
+      scope?: SlatesCliStoreScope;
+      storePath?: string;
+    } = {}
   ) {
-    let rootDir = opts.storePath
+    let storageRootDir = opts.storePath
       ? inferRootDirFromStorePath(opts.storePath)
       : resolveSlatesCliRoot(opts.cwd);
-    let cliDir = resolveSlatesCliDir(rootDir);
+    let rootDir = opts.rootDir ?? storageRootDir;
+    let cliDir = resolveSlatesCliDirFromRoot(storageRootDir);
     let scopeKey = opts.storePath
-      ? resolveScopeKeyFromStorePath(rootDir, opts.storePath)
+      ? resolveScopeKeyFromStorePath(storageRootDir, opts.storePath)
       : opts.scope?.key
         ? normalizeScopeKey(opts.scope.key)
         : null;
@@ -207,16 +219,19 @@ export class SlatesCliStore {
           profiles: parsed.profiles ?? {},
           oauthCredentials: parsed.oauthCredentials ?? {}
         }
-      : scopeKey
-        ? await loadMigratedLegacyStore(rootDir, scopeKey)
-        : createEmptyStore();
+      : opts.storePath
+        ? createEmptyStore()
+        : scopeKey
+          ? await loadMigratedLegacyStore(rootDir, scopeKey)
+          : createEmptyStore();
 
     if (!parsed) {
-      await writeFile(storePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+      await writeFile(storePath, `${JSON.stringify(data, null, 2)}\n`, 'utf-8');
     }
 
     return new SlatesCliStore(
       rootDir,
+      cliDir,
       dirPath,
       storePath,
       scopeKey ? { key: scopeKey, name: opts.scope?.name } : null,
@@ -226,9 +241,9 @@ export class SlatesCliStore {
 
   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');
+    await ensureDir(this.cliDir);
+    await ensureGitIgnore(this.cliDir);
+    await writeFile(this.storePath, `${JSON.stringify(this.data, null, 2)}\n`, 'utf-8');
   }
 
   listProfiles() {
@@ -418,5 +433,10 @@ export class SlatesCliStore {
 }
 
 export let openSlatesCliStore = async (
-  opts: { cwd?: string; scope?: SlatesCliStoreScope; storePath?: string } = {}
+  opts: {
+    cwd?: string;
+    rootDir?: string;
+    scope?: SlatesCliStoreScope;
+    storePath?: string;
+  } = {}
 ) => SlatesCliStore.open(opts);

package/src/types.ts

@@ -1,5 +1,5 @@
-import { SlatesJsonObject } from '@slates/client';
-import { SlateAuthenticationMethod, SlatesAction } from '@slates/proto';
+import type { SlatesJsonObject } from '@slates/client';
+import type { SlateAuthenticationMethod, SlatesAction } from '@slates/proto';
 
 export interface SlatesStoredAuth {
   id: string;