dropsh 0.3.1 → 0.4.1

package/dist/src/commands/auth.js

@@ -1,4 +1,4 @@
-import { loginCapableProviders, providerById } from "../core/auth/registry.js";
+import { defaultProvider, loginCapableProviders, providerById } from "../core/auth/registry.js";
 import { clearAll, clearProfile, readProfiles, setActive, writeProfile, } from "../core/auth/session-store.js";
 import { AuthError, ConfigError } from "../errors.js";
 function authContext(deps) {
@@ -24,6 +24,12 @@ async function pickProvider(deps, requestedId) {
             throw new ConfigError(`unknown provider '${requestedId}'. Available: ${capable.map((p) => p.id).join(", ")}`);
         return found;
     }
+    // No explicit --provider: fall back to the configured default profile
+    // (default: true), or the sole provider. Only then, if still ambiguous and
+    // interactive, prompt; non-interactive with no default stays an error.
+    const fallback = defaultProvider(capable) ?? (capable.length === 1 ? capable[0] : undefined);
+    if (fallback)
+        return fallback;
     if (!deps.isTTY)
         throw new ConfigError("non-interactive: pass --provider <id>");
     deps.stdout("Select an auth provider:\n");

package/dist/src/core/config.js

@@ -1,13 +1,76 @@
+import { createRequire } from "node:module";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { ConfigError } from "../errors.js";
 function isRecord(v) {
     return !!v && typeof v === "object" && !Array.isArray(v);
 }
+/**
+ * A plugin descriptor is plain config data that names a plugin package as a
+ * string (`plugin`). This lets a committed config stay import-free: the config
+ * carries only data, and dropsh resolves + constructs the plugin from its own
+ * install — so nothing has to resolve the plugin package from the config file's
+ * own `import` statements (which resolve relative to the config file, not the CLI).
+ */
+function isPluginDescriptor(e) {
+    return isRecord(e) && typeof e.plugin === "string";
+}
+/**
+ * Resolve a named plugin package the way ESLint resolves plugins: by string
+ * name, relative to the config file first, then the cwd, then dropsh's own
+ * install (so a plugin installed alongside dropsh — a dropsh dep, or globally
+ * next to a global dropsh, or via `npx -p`— is found). The config never imports
+ * the package itself.
+ */
+async function loadNamedPlugin(entry, configPath) {
+    const name = entry.plugin;
+    const bases = [
+        pathToFileURL(configPath).href,
+        pathToFileURL(`${process.cwd()}/`).href,
+        import.meta.url,
+    ];
+    let resolved;
+    for (const base of bases) {
+        try {
+            resolved = createRequire(base).resolve(name);
+            break;
+        }
+        catch {
+            // try the next base
+        }
+    }
+    if (resolved === undefined)
+        throw new ConfigError(`cannot resolve plugin '${name}'. Install it next to dropsh (project dep, dropsh dep, global next to a global dropsh, or 'npx -p dropsh -p ${name}').`);
+    let mod;
+    try {
+        mod = (await import(pathToFileURL(resolved).href));
+    }
+    catch (err) {
+        throw new ConfigError(`cannot load plugin '${name}'`, { cause: String(err) });
+    }
+    const exportName = typeof entry.export === "string" ? entry.export : "default";
+    const factory = mod[exportName];
+    if (typeof factory !== "function")
+        throw new ConfigError(`plugin '${name}' has no callable export '${exportName}'`);
+    return factory(entry.with ?? entry.options);
+}
+/**
+ * Expands `plugins[]` entries: named-package descriptors are resolved + built
+ * into real plugins; already-constructed plugins pass through unchanged
+ * (backward compat).
+ */
+async function resolvePlugins(raw, configPath) {
+    if (!Array.isArray(raw))
+        return [];
+    return Promise.all(raw.map((entry) => isPluginDescriptor(entry)
+        ? loadNamedPlugin(entry, configPath)
+        : Promise.resolve(entry)));
+}
 export async function loadConfig(filePath) {
+    const configPath = resolve(filePath);
     let mod;
     try {
-        mod = await import(pathToFileURL(resolve(filePath)).href);
+        mod = await import(pathToFileURL(configPath).href);
     }
     catch (err) {
         throw new ConfigError(`Cannot load config file: ${filePath}`, { cause: String(err) });
@@ -21,7 +84,7 @@ export async function loadConfig(filePath) {
     if (typeof site.base_url !== "string" || site.base_url.length === 0)
         throw new ConfigError("site.base_url required");
     const defaults = isRecord(raw.defaults) ? raw.defaults : {};
-    const plugins = Array.isArray(raw.plugins) ? raw.plugins : [];
+    const plugins = await resolvePlugins(raw.plugins, configPath);
     return {
         site: {
             base_url: site.base_url,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dropsh",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Entity-agnostic helper CLI for Drupal 11 JSON:API, used by the dropsh Claude skill for editorial publishing workflows.",
   "type": "module",
   "bin": {