@gaia-ai/addon-dropsh 0.11.1 → 0.11.3

package/dist/src/index.d.ts

@@ -1,6 +1,10 @@
-import { type GaiaCommandPlugin } from '@gaia-ai/core';
-/** Actionable hint when a `gaia dropsh` command runs with no loadable connection. */
+import { type GaiaCommandHost, type GaiaCommandPlugin, type WorkspaceRecoveryOptions } from '@gaia-ai/core';
 export declare function dropshConfigHint(resolvedPath?: string): string;
-/** The `dropsh` command plugin the host mounts (`gaia dropsh …`). */
+export interface DropshDispatchOptions extends WorkspaceRecoveryOptions {
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+}
+/** Build the actual plugin registrations after the final connection is ready. */
+export declare function dispatchGaiaDropsh(host: GaiaCommandHost, argv: string[], options?: DropshDispatchOptions): Promise<void>;
 declare const dropshCommandPlugin: GaiaCommandPlugin;
 export default dropshCommandPlugin;

package/dist/src/index.js

@@ -1,82 +1,112 @@
-import { loadGaiaConfig, } from '@gaia-ai/core';
+import { createGaiaConnectionContext, discoverGaiaWorkspaces, loadGaiaConnectionBootstrap, loadReadyGaiaConnection, } from '@gaia-ai/core';
 import { buildProgram as buildDropshProgram } from 'dropsh';
-// GAIA-201: the `gaia dropsh` command PLUGIN. It builds the inherited dropsh
-// JSON:API shell from the CONNECTION config (`loadGaiaConfig`) — NEVER
-// `loadConductorConfig`. That is the deepest AC-2 fix: the old `gaia dropsh`
-// went through `loadConductorConfig`, which eagerly constructed the whole engine
-// plugin farm (remote/executor/agent/workspace) just to read the auth `plugins`.
-// This package has no `@gaia-ai/conductor` edge and imports no engine plugin, so
-// a `gaia dropsh read …` instantiates nothing but the dropsh auth plugins.
-//
-// Connection precedence (AC-4, resolved in core `resolveGaiaConfigPath`):
-// explicit `--config` / `$DROPSH_CONFIG` → project `./.gaia/gaia.config.js`
-// walk-up (legacy `conductor.config.js` accepted) → home `~/.gaia/gaia.config.js`
-// → shipped fallback. `$DROPSH_CONFIG` is set to the resolved path so dropsh's
-// own subcommands (`auth login`) reload the same connection.
-/** Actionable hint when a `gaia dropsh` command runs with no loadable connection. */
 export function dropshConfigHint(resolvedPath) {
-    const where = resolvedPath ? ` (looked at ${resolvedPath})` : '';
-    return (`gaia dropsh: no connection config could be loaded${where}.\n` +
-        'Point at one with --config <path>, set $DROPSH_CONFIG, run from a directory ' +
-        'containing .gaia/gaia.config.js, or onboard this machine with ' +
-        '`gaia conductor init --base-url <url>` (home fallback).');
+    return `gaia dropsh: no connection config at ${resolvedPath ?? '~/.gaia/gaia.config.js'}. Use --config <path> or run gaia config init --scope connection.`;
 }
-/**
- * Build the `dropsh` command from a resolved connection. Sets `$DROPSH_CONFIG`
- * to the connection path (unless already set) so dropsh's own subcommands reload
- * the same site + plugins.
- */
-async function buildDropshCommand(host) {
-    let connection;
-    try {
-        connection = await loadGaiaConfig(host, {});
+/** Consume only wrapper flags; forward all actual dropsh arguments unchanged. */
+function invocation(argv) {
+    const forwarded = [];
+    let explicit;
+    let format;
+    let yes = false;
+    let profile;
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === '--yes') {
+            yes = true;
+            continue;
+        }
+        if (token === '--config' ||
+            token === '--format' ||
+            token === '--auth-profile') {
+            const value = argv[i + 1];
+            if (value !== undefined) {
+                if (token === '--config')
+                    explicit = value;
+                else if (token === '--format')
+                    format = value;
+                else
+                    profile = value;
+                forwarded.push(token, value);
+                i++;
+                continue;
+            }
+        }
+        if (token.startsWith('--config='))
+            explicit = token.slice(9);
+        if (token.startsWith('--format='))
+            format = token.slice(9);
+        forwarded.push(token);
     }
-    catch {
-        connection = undefined;
+    // Global options can appear late, after the command's positional arguments.
+    const positional = forwarded.filter((token, i) => !['--config', '--format', '--auth-profile', '--view-mode'].includes(token) &&
+        !/^--(?:config|format|auth-profile|view-mode)=/.test(token) &&
+        !['--config', '--format', '--auth-profile', '--view-mode'].includes(forwarded[i - 1] ?? ''));
+    return { forwarded, explicit, format, yes, profile, positional };
+}
+/** Build the actual plugin registrations after the final connection is ready. */
+export async function dispatchGaiaDropsh(host, argv, options = {}) {
+    const args = invocation(argv);
+    const opts = {
+        ...options,
+        ...(args.explicit ? { explicit: args.explicit } : {}),
+        ...(args.format ? { format: args.format } : {}),
+        yes: options.yes || args.yes,
+    };
+    const help = argv.includes('--help') || argv.includes('-h') || argv.length === 0;
+    const auth = args.positional[0] === 'auth';
+    const search = args.positional[0] === 'search' &&
+        args.positional[1] === 'gaia_workspace' &&
+        args.positional.length === 2 &&
+        (!args.format || ['md', 'json'].includes(args.format));
+    if (search) {
+        const connection = await loadGaiaConnectionBootstrap(host, opts);
+        const rows = await discoverGaiaWorkspaces(connection, opts);
+        const stdout = options.stdout ?? ((s) => process.stdout.write(s));
+        if (args.format === 'md')
+            stdout(`| Workspace | UUID |\n| --- | --- |\n${rows.map((r) => `| ${r.name.replace(/[|\r\n]/g, ' ')} | ${r.id} |`).join('\n')}\n`);
+        else
+            stdout(`${JSON.stringify(rows, null, 2)}\n`);
+        return;
     }
-    const dropsh = buildDropshProgram({
+    const connection = help
+        ? undefined
+        : auth
+            ? await loadGaiaConnectionBootstrap(host, opts)
+            : await loadReadyGaiaConnection(host, opts);
+    const program = buildDropshProgram({
         plugins: connection?.plugins ?? [],
-    });
-    if (connection && !process.env.DROPSH_CONFIG) {
-        process.env.DROPSH_CONFIG = connection.config_path;
-    }
-    if (!connection) {
-        // Registration is unconditional; a config problem must surface WHEN a dropsh
-        // command runs, not make the command vanish. The hook fires only on a real
-        // subcommand dispatch — never for `--help` — so discoverability holds. It
-        // honours a late `--config` (AC-4 explicit leg).
-        dropsh.hook('preSubcommand', async (thisCommand) => {
-            const override = thisCommand.opts().config ??
-                process.env.DROPSH_CONFIG;
-            let resolvedPath;
-            try {
-                const c = await loadGaiaConfig(host, { explicit: override });
-                resolvedPath = c.config_path;
-            }
-            catch (cause) {
-                // A config that was FOUND and then REJECTED (no `site.base_url`, no
-                // `workspace_id`) must not be reported as "no config could be loaded":
-                // that sends the reader hunting for a file which is right there and
-                // names its own problem. Only a genuine resolution failure gets the hint.
-                if (cause?.name === 'GaiaConnectionConfigError') {
-                    throw cause;
-                }
-                throw new Error(dropshConfigHint(override));
+        ...(options.stdout ? { stdout: options.stdout } : {}),
+        ...(options.stderr ? { stderr: options.stderr } : {}),
+        ...(connection
+            ? {
+                contextFactory: () => createGaiaConnectionContext(connection, {
+                    ...opts,
+                    ...(args.profile ? { profile: args.profile } : {}),
+                }),
             }
-            if (!process.env.DROPSH_CONFIG) {
-                process.env.DROPSH_CONFIG = resolvedPath;
-            }
-        });
-    }
-    return dropsh;
+            : {}),
+    });
+    // Auth commands perform their own reload; bind it explicitly to the same path.
+    const forwarded = connection
+        ? ['--config', connection.config_path, ...args.forwarded]
+        : args.forwarded;
+    await program.parseAsync(forwarded, { from: 'user' });
 }
-/** The `dropsh` command plugin the host mounts (`gaia dropsh …`). */
 const dropshCommandPlugin = {
     kind: 'command',
     name: 'dropsh',
     describe: 'JSON:API shell (dropsh) bound to the GAIA connection config',
-    async register(program, host) {
-        program.addCommand(await buildDropshCommand(host));
+    register(program, host) {
+        program
+            .command('dropsh')
+            .description('JSON:API shell bound to the GAIA connection')
+            .helpOption(false)
+            .allowUnknownOption()
+            .argument('[args...]')
+            .action(async (args) => {
+            await dispatchGaiaDropsh(host, args);
+        });
     },
 };
 export default dropshCommandPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/addon-dropsh",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "GAIA dropsh command plugin: the `gaia dropsh` JSON:API shell bound to the split connection config.",
   "type": "module",
   "license": "MIT",
@@ -26,6 +26,6 @@
     "dropsh": "^0.6.1"
   },
   "peerDependencies": {
-    "@gaia-ai/core": "^0.11.1"
+    "@gaia-ai/core": "^0.11.3"
   }
 }