@griffin-app/griffin-cli 1.0.26 → 1.0.28

package/dist/commands/hub/integrations.js

@@ -1,13 +1,14 @@
 import { loadState, resolveEnvironment } from "../../core/state.js";
-import { terminal } from "../../utils/terminal.js";
 import { createSdkFromState, createSdkWithCredentials, } from "../../core/sdk.js";
-import { withSDKErrorHandling } from "../../utils/sdk-error.js";
-import { withCommandErrorHandler, outputJsonOrContinue, } from "../../utils/command-wrapper.js";
-export const executeIntegrationsList = withCommandErrorHandler(async (options) => {
+import { handleSDKErrorWithOutput } from "../../utils/sdk-error.js";
+import { createCommandHandler } from "../../utils/command-wrapper.js";
+import { terminal } from "../../utils/terminal.js";
+export const executeIntegrationsList = createCommandHandler("integrations list", async (options, output) => {
     const sdk = await createSdkFromState();
     const env = await resolveEnvironment(options.environment);
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.getIntegrations({
+    let response;
+    try {
+        response = await sdk.getIntegrations({
             query: {
                 category: options.category,
                 provider: options.provider,
@@ -15,17 +16,19 @@ export const executeIntegrationsList = withCommandErrorHandler(async (options) =
                 enabled: options.enabled,
             },
         });
-    }, "Failed to list integrations");
-    const list = response?.data?.data ?? [];
-    if (outputJsonOrContinue(list, options.json))
-        return;
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to list integrations");
+    }
+    const list = response.data?.data ?? [];
+    output.setData({ integrations: list });
     if (list.length === 0) {
-        terminal.info("No integrations found.");
+        output.info("No integrations found.");
         return;
     }
-    terminal.info("Integrations");
-    terminal.blank();
-    const table = terminal.table({
+    output.info("Integrations");
+    output.blank();
+    const table = output.table({
         head: ["ID", "Category", "Provider", "Name", "Environment", "Enabled"],
     });
     for (const i of list) {
@@ -38,34 +41,39 @@ export const executeIntegrationsList = withCommandErrorHandler(async (options) =
             i.enabled ? "✓" : "✗",
         ]);
     }
-    terminal.log(table.toString());
+    output.log(table.toString());
 });
-export const executeIntegrationsShow = withCommandErrorHandler(async (options) => {
+export const executeIntegrationsShow = createCommandHandler("integrations show", async (options, output) => {
     const sdk = await createSdkFromState();
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.getIntegrationsById({
+    let response;
+    try {
+        response = await sdk.getIntegrationsById({
             path: { id: options.id },
         });
-    }, "Failed to show integration");
-    const integration = response?.data?.data;
-    if (!integration) {
-        terminal.error("Integration not found.");
-        terminal.exit(1);
     }
-    if (outputJsonOrContinue(integration, options.json))
-        return;
-    terminal.info(integration.name);
-    terminal.dim(`ID: ${integration.id}`);
-    terminal.log(`Category: ${integration.category}`);
-    terminal.log(`Provider: ${integration.provider}`);
-    terminal.log(`Environment: ${integration.environment ?? "(all)"}`);
-    terminal.log(`Enabled: ${integration.enabled ? "Yes" : "No"}`);
-    terminal.log(`Has credentials: ${integration.hasCredentials ? "Yes" : "No"}`);
-    if (integration?.config) {
-        terminal.log("Config: " + JSON.stringify(integration.config));
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to show integration");
+    }
+    const raw = response.data?.data;
+    if (!raw) {
+        output.setData({ error: "NOT_FOUND", message: "Integration not found." });
+        output.error("Integration not found.");
+        output.exit(1);
+    }
+    const i = raw;
+    output.setData(i);
+    output.info(i.name);
+    output.dim(`ID: ${i.id}`);
+    output.log(`Category: ${i.category}`);
+    output.log(`Provider: ${i.provider}`);
+    output.log(`Environment: ${i.environment ?? "(all)"}`);
+    output.log(`Enabled: ${i.enabled ? "Yes" : "No"}`);
+    output.log(`Has credentials: ${i.hasCredentials ? "Yes" : "No"}`);
+    if (i.config) {
+        output.log("Config: " + JSON.stringify(i.config));
     }
 });
-export const executeIntegrationsAdd = withCommandErrorHandler(async (options) => {
+export const executeIntegrationsAdd = createCommandHandler("integrations add", async (options, output) => {
     const env = await resolveEnvironment(options.environment);
     const sdk = await createSdkFromState();
     const body = {
@@ -76,25 +84,28 @@ export const executeIntegrationsAdd = withCommandErrorHandler(async (options) =>
         environment: env,
         enabled: options.enabled ?? true,
     };
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.postIntegrations({
-            body,
-        });
-    }, "Failed to add integration");
-    const integration = response?.data?.data;
+    let response;
+    try {
+        response = await sdk.postIntegrations({ body });
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to add integration");
+    }
+    const integration = response.data?.data;
     if (!integration) {
-        terminal.error("Failed to add integration.");
+        output.setData({ error: "Failed to add integration." });
+        output.error("Failed to add integration.");
         return;
     }
-    terminal.success(`Created integration ${integration.name} (${integration.id})`);
-    if (outputJsonOrContinue(integration, options.json))
-        return;
+    output.setData(integration);
+    output.success(`Created integration ${integration.name} (${integration.id})`);
 });
-export const executeIntegrationsUpdate = withCommandErrorHandler(async (options) => {
+export const executeIntegrationsUpdate = createCommandHandler("integrations update", async (options, output) => {
     const env = await resolveEnvironment(options.environment);
     const sdk = await createSdkFromState();
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.patchIntegrationsById({
+    let response;
+    try {
+        response = await sdk.patchIntegrationsById({
             path: { id: options.id },
             body: {
                 name: options.name,
@@ -103,37 +114,47 @@ export const executeIntegrationsUpdate = withCommandErrorHandler(async (options)
                 enabled: options.enabled,
             },
         });
-    }, "Failed to update integration");
-    const integration = response?.data?.data;
-    if (!integration) {
-        terminal.error("Integration not found.");
-        terminal.exit(1);
     }
-    if (outputJsonOrContinue(integration, options.json))
-        return;
-    terminal.success(`Updated integration ${integration.name}`);
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to update integration");
+    }
+    const raw = response.data?.data;
+    if (!raw) {
+        output.setData({ error: "NOT_FOUND", message: "Integration not found." });
+        output.error("Integration not found.");
+        output.exit(1);
+    }
+    const i = raw;
+    output.setData(i);
+    output.success(`Updated integration ${i.name}`);
 });
-export const executeIntegrationsRemove = withCommandErrorHandler(async (options) => {
+export const executeIntegrationsRemove = createCommandHandler("integrations remove", async (options, output) => {
     const sdk = await createSdkFromState();
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.deleteIntegrationsById({
+    let response;
+    try {
+        response = await sdk.deleteIntegrationsById({
             path: { id: options.id },
         });
-    }, "Failed to remove integration");
-    const integration = response?.data?.data;
-    if (!integration) {
-        terminal.error("Integration not found.");
-        terminal.exit(1);
     }
-    terminal.success(`Integration removed.`);
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to remove integration");
+    }
+    const raw = response.data?.data;
+    if (!raw) {
+        output.setData({ error: "NOT_FOUND", message: "Integration not found." });
+        output.error("Integration not found.");
+        output.exit(1);
+    }
+    const deleted = raw;
+    output.setData({ removed: true, id: options.id, name: deleted.name });
+    output.success(`Integration removed.`);
 });
 const POLL_INITIAL_MS = 2000;
 const POLL_MAX_MS = 10000;
 const POLL_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
 /** Fetch provider catalog from hub. */
-async function getProvidersFromHub() {
-    const sdk = await createSdkFromState();
-    const response = await withSDKErrorHandling(() => sdk.getIntegrationsProviders(), "Failed to load providers");
+async function getProvidersFromHub(sdk) {
+    const response = await sdk.getIntegrationsProviders();
     const data = response?.data;
     if (!data?.providers)
         return [];
@@ -163,7 +184,7 @@ export function printConnectHelp(providers) {
         terminal.blank();
     }
 }
-async function connectOAuth(options, _provider) {
+async function connectOAuth(options, _provider, output) {
     const env = await resolveEnvironment(options.environment);
     const body = {
         category: options.category,
@@ -172,26 +193,25 @@ async function connectOAuth(options, _provider) {
         environment: env,
     };
     const sdk = await createSdkFromState();
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.postIntegrationsOauthInitiate({
-            body,
-        });
-    }, "Failed to initiate OAuth");
-    const data = response?.data;
+    let response;
+    try {
+        response = await sdk.postIntegrationsOauthInitiate({ body });
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to initiate OAuth");
+    }
+    const data = response.data;
     if (!data) {
-        terminal.error("Initiate failed.");
-        return terminal.exit(1);
+        output.setData({ error: "Initiate failed." });
+        output.error("Initiate failed.");
+        output.exit(1);
     }
-    terminal.info("Open this URL in your browser to authorize:");
-    terminal.log(data.authUrl);
-    terminal.blank();
-    terminal.openBrowser(data.authUrl);
-    terminal.info("Waiting for authorization… (polling)");
-    terminal.info("Open this URL in your browser to authorize:");
-    terminal.log(data.authUrl);
-    terminal.blank();
-    terminal.openBrowser(data.authUrl);
-    terminal.info("Waiting for authorization… (polling)");
+    output.setData({ authUrl: data.authUrl });
+    output.info("Open this URL in your browser to authorize:");
+    output.log(data.authUrl);
+    output.blank();
+    output.openBrowser(data.authUrl);
+    output.info("Waiting for authorization… (polling)");
     const start = Date.now();
     let interval = POLL_INITIAL_MS;
     const poll = async () => {
@@ -212,32 +232,22 @@ async function connectOAuth(options, _provider) {
         interval = Math.min(interval + 1000, POLL_MAX_MS);
         return poll();
     };
-    try {
-        const status = await poll();
-        if (status.status === "completed" && status.integrationId) {
-            if (options.json) {
-                terminal.log(JSON.stringify({ integrationId: status.integrationId }, null, 2));
-            }
-            else {
-                terminal.success(`Integration connected: ${status.integrationId}`);
-            }
-            return;
-        }
-        if (status.status === "failed") {
-            terminal.error(status.errorMessage ?? "Authorization failed");
-            terminal.exit(1);
-        }
-        if (status.status === "expired") {
-            terminal.error(status.errorMessage ?? "Transaction expired");
-            terminal.exit(1);
-        }
-        terminal.error("Unexpected status");
-        terminal.exit(1);
+    const status = await poll();
+    if (status.status === "completed" && status.integrationId) {
+        output.setData({
+            integrationId: status.integrationId,
+            authUrl: data.authUrl,
+        });
+        output.success(`Integration connected: ${status.integrationId}`);
+        return;
     }
-    catch (err) {
-        terminal.error(err instanceof Error ? err.message : "Polling failed");
-        terminal.exit(1);
+    if (status.status === "failed") {
+        output.flushError("OAUTH_FAILED", status.errorMessage ?? "Authorization failed");
     }
+    if (status.status === "expired") {
+        output.flushError("OAUTH_EXPIRED", status.errorMessage ?? "Transaction expired");
+    }
+    output.flushError("UNKNOWN_ERROR", "Unexpected status");
 }
 function buildIntegrationConfig(provider, config) {
     if (provider.provider === "resend") {
@@ -259,14 +269,13 @@ function buildIntegrationConfig(provider, config) {
     }
     return undefined;
 }
-async function connectCredentials(options, provider) {
+async function connectCredentials(options, provider, output) {
     const env = await resolveEnvironment(options.environment);
     const config = {};
     for (const field of provider.configFields ?? []) {
-        const value = await terminal.input(`${field.label}${field.required ? " (required)" : ""}`, field.default);
+        const value = await output.input(`${field.label}${field.required ? " (required)" : ""}`, field.default);
         if (field.required && !value?.trim()) {
-            terminal.error(`${field.label} is required`);
-            terminal.exit(1);
+            output.flushError("VALIDATION_ERROR", `${field.label} is required`);
         }
         if (value?.trim())
             config[field.key] = value.trim();
@@ -274,11 +283,10 @@ async function connectCredentials(options, provider) {
     const credentials = {};
     for (const field of provider.credentialFields ?? []) {
         const value = field.secret
-            ? await terminal.password(`${field.label}${field.required ? " (required)" : ""}`)
-            : await terminal.input(`${field.label}${field.required ? " (required)" : ""}`, field.default);
+            ? await output.password(`${field.label}${field.required ? " (required)" : ""}`)
+            : await output.input(`${field.label}${field.required ? " (required)" : ""}`, field.default);
         if (field.required && !value?.trim()) {
-            terminal.error(`${field.label} is required`);
-            terminal.exit(1);
+            output.flushError("VALIDATION_ERROR", `${field.label} is required`);
         }
         if (value?.trim())
             credentials[field.key] = value.trim();
@@ -295,44 +303,55 @@ async function connectCredentials(options, provider) {
     };
     const state = await loadState();
     const sdk = await createSdkWithCredentials(state.hub.baseUrl);
-    const result = await sdk.postIntegrations({
-        body,
-    });
-    const integration = result.data?.data;
-    if (!integration) {
-        terminal.error("Integration not found.");
-        terminal.exit(1);
+    const result = await sdk.postIntegrations({ body });
+    const data = result.data?.data;
+    if (!data) {
+        output.setData({ error: "Integration not found." });
+        output.error("Integration not found.");
+        output.exit(1);
     }
-    if (outputJsonOrContinue(integration, options.json))
-        return;
-    terminal.success(`Integration connected: ${integration.name} (${integration.id})`);
+    output.setData(data);
+    const conn = data;
+    output.success(`Integration connected: ${conn.name} (${conn.id})`);
 }
-export async function executeIntegrationsConnect(options) {
-    const providers = await getProvidersFromHub();
+export const executeIntegrationsConnect = createCommandHandler("integrations connect", async (options, output) => {
+    const sdk = await createSdkFromState();
+    let providers;
+    try {
+        providers = await getProvidersFromHub(sdk);
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to load providers");
+    }
     if (!options.category || !options.provider) {
         printConnectHelp(providers);
-        return terminal.exit(0);
+        output.exit(0);
     }
     const providerDef = providers.find((p) => p.category === options.category && p.provider === options.provider);
     if (!providerDef) {
-        terminal.error(`Unknown provider: ${options.category}/${options.provider}`);
+        output.setData({
+            error: "NOT_FOUND",
+            message: `Unknown provider: ${options.category}/${options.provider}`,
+        });
+        output.error(`Unknown provider: ${options.category}/${options.provider}`);
         const providersForCategory = providers.filter((p) => p.category === options.category);
         if (providersForCategory.length > 0) {
-            terminal.info(`Available providers for ${options.category}:`);
+            output.info(`Available providers for ${options.category}:`);
             for (const p of providersForCategory) {
-                terminal.log(`  - ${p.provider} (${p.displayName})`);
+                output.log(`  - ${p.provider} (${p.displayName})`);
             }
         }
         else {
             const categories = [...new Set(providers.map((p) => p.category))].sort();
-            terminal.info("Available categories: " + categories.join(", "));
+            output.info("Available categories: " + categories.join(", "));
         }
-        return terminal.exit(1);
+        output.exit(1);
     }
-    if (providerDef.authMethod === "oauth") {
-        await connectOAuth(options, providerDef);
+    const provider = providerDef;
+    if (provider.authMethod === "oauth") {
+        await connectOAuth(options, provider, output);
     }
     else {
-        await connectCredentials(options, providerDef);
+        await connectCredentials(options, provider, output);
     }
-}
+});

package/dist/commands/hub/login.d.ts

@@ -1 +1,13 @@
-export declare function executeLogin(): Promise<void>;
+export interface LoginOptions {
+    json?: boolean;
+    /** Only output auth URL and exit; agent then runs with --poll to complete */
+    noPoll?: boolean;
+    /** Poll for completion after user has authorized in browser (use after --no-poll) */
+    poll?: boolean;
+}
+/**
+ * Authenticate with Griffin Cloud.
+ * Interactive: get URL, open browser, poll until done.
+ * Agent (two-step): use --no-poll to get authUrl, then --poll to complete after user authorizes.
+ */
+export declare const executeLogin: (options: LoginOptions) => Promise<void>;

package/dist/commands/hub/login.js

@@ -1,9 +1,8 @@
-// CLI implementation
 import { createAuthClient } from "better-auth/client";
 import { deviceAuthorizationClient, jwtClient, } from "better-auth/client/plugins";
 import { loadState, saveState } from "../../core/state.js";
-import { saveHubCredentials } from "../../core/credentials.js";
-import { terminal } from "../../utils/terminal.js";
+import { saveHubCredentials, saveDeviceAuthPending, loadDeviceAuthPending, clearDeviceAuthPending, } from "../../core/credentials.js";
+import { createCommandHandler } from "../../utils/command-wrapper.js";
 import { randomBytes } from "crypto";
 const oauthGrant = "urn:ietf:params:oauth:grant-type:device_code";
 function createAuthClientFromState(state) {
@@ -38,20 +37,87 @@ async function pollForToken(clientId, deviceCode, interval) {
             throw new Error(error?.error_description || "Unknown error");
     }
 }
-export async function executeLogin() {
+/**
+ * Authenticate with Griffin Cloud.
+ * Interactive: get URL, open browser, poll until done.
+ * Agent (two-step): use --no-poll to get authUrl, then --poll to complete after user authorizes.
+ */
+export const executeLogin = createCommandHandler("auth login", async (options, output) => {
     const state = await loadState();
     const clientId = state.hub?.clientId ?? randomBytes(16).toString("hex");
     const authClient = createAuthClientFromState(state);
+    // --- Step 2: Poll only (after user completed flow from --no-poll) ---
+    if (options.poll) {
+        const pending = await loadDeviceAuthPending();
+        if (!pending) {
+            output.setData({
+                error: "NO_PENDING_AUTH",
+                message: "No pending device auth. Run 'griffin auth login --no-poll' first, then complete authorization in the browser, then run 'griffin auth login --poll'.",
+            });
+            output.flushError("NO_PENDING_AUTH", "No pending device auth. Run 'griffin auth login --no-poll' first, complete authorization in the browser, then run 'griffin auth login --poll'.", undefined, "Run 'griffin auth login --no-poll' to start the flow.");
+        }
+        const p = pending;
+        const sessionToken = await pollForToken(p.clientId, p.deviceCode, p.interval * 1000);
+        const { data: jwtData } = await authClient.token({
+            fetchOptions: {
+                headers: {
+                    Authorization: `Bearer ${sessionToken}`,
+                },
+            },
+        });
+        if (jwtData?.token) {
+            await saveHubCredentials(jwtData.token);
+        }
+        await clearDeviceAuthPending();
+        await saveState({
+            ...state,
+            hub: {
+                ...state.hub,
+                clientId: p.clientId,
+            },
+        });
+        output.setData({ success: true });
+        output.success("Login successful");
+        output.log("  Token saved to user credentials");
+        return;
+    }
+    // --- Step 1: Get device code (and optionally exit without polling) ---
     const { data } = await authClient.device.code({
         client_id: clientId,
     });
-    terminal.info(`Go to: ${data?.verification_uri_complete}`);
-    terminal.info(`Or enter code: ${data?.user_code}`);
-    if (data?.verification_uri_complete) {
-        terminal.openBrowser(data.verification_uri_complete);
+    const authUrl = data?.verification_uri_complete ?? "";
+    const userCode = data?.user_code ?? "";
+    const deviceCode = data?.device_code ?? "";
+    const intervalMs = (data?.interval ?? 5) * 1000;
+    if (options.noPoll) {
+        await saveDeviceAuthPending({
+            clientId,
+            deviceCode,
+            interval: data?.interval ?? 5,
+            verificationUriComplete: authUrl,
+            userCode,
+        });
+        output.setData({
+            authUrl,
+            userCode,
+            message: "Complete authorization in the browser, then run: griffin auth login --poll",
+        });
+        if (!options.json) {
+            output.info(`Go to: ${authUrl}`);
+            output.info(`Or enter code: ${userCode}`);
+            output.blank();
+            output.dim("Then run: griffin auth login --poll");
+        }
+        return;
     }
-    // 2. Poll for authorization
-    const sessionToken = await pollForToken(clientId, data?.device_code, (data?.interval ?? 5) * 1000);
+    // --- Interactive: show URL, open browser, poll in same process ---
+    output.info(`Go to: ${authUrl}`);
+    output.info(`Or enter code: ${userCode}`);
+    if (authUrl) {
+        output.openBrowser(authUrl);
+    }
+    output.info("Waiting for authorization… (polling)");
+    const sessionToken = await pollForToken(clientId, deviceCode, intervalMs);
     const { data: jwtData } = await authClient.token({
         fetchOptions: {
             headers: {
@@ -59,17 +125,17 @@ export async function executeLogin() {
             },
         },
     });
-    // Save token to user-level credentials file
     if (jwtData?.token) {
         await saveHubCredentials(jwtData.token);
-        terminal.success("Login successful");
-        terminal.log(`  Token saved to user credentials`);
+        output.setData({ success: true });
+        output.success("Login successful");
+        output.log("  Token saved to user credentials");
     }
     await saveState({
         ...state,
         hub: {
             ...state.hub,
-            clientId: clientId,
+            clientId,
         },
     });
-}
+});

package/dist/commands/hub/logout.d.ts

@@ -1,6 +1,7 @@
 export interface LogoutOptions {
+    json?: boolean;
 }
 /**
  * Remove stored credentials for hub
  */
-export declare function executeLogout(options: LogoutOptions): Promise<void>;
+export declare const executeLogout: (options: LogoutOptions) => Promise<void>;

package/dist/commands/hub/logout.js

@@ -1,16 +1,11 @@
 import { removeHubCredentials } from "../../core/credentials.js";
-import { terminal } from "../../utils/terminal.js";
+import { createCommandHandler } from "../../utils/command-wrapper.js";
 /**
  * Remove stored credentials for hub
  */
-export async function executeLogout(options) {
-    try {
-        await removeHubCredentials();
-        terminal.success("Credentials removed.");
-        terminal.blank();
-    }
-    catch (error) {
-        terminal.error(error.message);
-        terminal.exit(1);
-    }
-}
+export const executeLogout = createCommandHandler("auth logout", async (_options, output) => {
+    await removeHubCredentials();
+    output.setData({ removed: true });
+    output.success("Credentials removed.");
+    output.blank();
+});