@papercraneai/cli 1.0.0

package/lib/function-client.js

@@ -0,0 +1,451 @@
+import axios from "axios"
+import chalk from "chalk"
+import { getApiKey, getApiBaseUrl } from "./config.js"
+
+// Streaming content types that should be piped directly to stdout
+const STREAMING_CONTENT_TYPES = [
+  "application/x-ndjson",
+  "application/jsonl",
+  "text/event-stream",
+  "application/stream+json"
+]
+
+/**
+ * Check if content type indicates a streaming response
+ * @param {string} contentType - Content-Type header value
+ * @returns {boolean}
+ */
+function isStreamingContentType(contentType) {
+  if (!contentType) return false
+  const normalized = contentType.toLowerCase().split(";")[0].trim()
+  return STREAMING_CONTENT_TYPES.includes(normalized)
+}
+
+/**
+ * Make a request to the function API
+ * @param {string} path - Function path (e.g., "google-ads-api.Customer.123.campaigns.list")
+ * @param {'GET' | 'POST'} method - HTTP method
+ * @param {Object} params - Parameters for POST requests
+ * @param {string} instance - Integration instance name
+ * @param {string} mode - Mode for GET requests: "list" or "describe"
+ * @param {Object} extraQueryParams - Additional query parameters
+ * @returns {Promise<Object>} API response data
+ */
+async function functionRequest(
+  path,
+  method,
+  params = {},
+  instance = "Default",
+  mode = undefined,
+  extraQueryParams = {}
+) {
+  const apiKey = await getApiKey()
+  if (!apiKey) {
+    throw new Error("Not logged in. Please run: papercrane login")
+  }
+
+  const baseUrl = await getApiBaseUrl()
+  const url = path ? `${baseUrl}/function/${path}` : `${baseUrl}/function`
+
+  try {
+    const queryParams = { instance, ...extraQueryParams }
+    if (mode) {
+      queryParams.mode = mode
+    }
+
+    // For POST requests, use streaming to handle large/streaming responses
+    if (method === "POST") {
+      const response = await axios({
+        method,
+        url,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        params: queryParams,
+        data: params,
+        responseType: "stream",
+        validateStatus: () => true // Don't throw on any status, we'll handle it
+      })
+
+      const contentType = response.headers["content-type"]
+      const status = response.status
+
+      // For error responses, read the body and throw with the error message
+      if (status >= 400) {
+        const chunks = []
+        for await (const chunk of response.data) {
+          chunks.push(chunk)
+        }
+        const body = Buffer.concat(chunks).toString("utf-8")
+        try {
+          const errorData = JSON.parse(body)
+          // error can be a string or an object with a message field
+          const err = errorData.error
+          const message = typeof err === "string" ? err : err?.message || body
+
+          // Display schema if present in the error response
+          if (errorData.schema) {
+            console.error(chalk.yellow('\nExpected parameters:'))
+            for (const [name, info] of Object.entries(errorData.schema)) {
+              const req = info.required ? chalk.red('required') : chalk.dim('optional')
+              console.error(`  ${chalk.cyan(name)} (${info.type}) ${req}`)
+              if (info.description) {
+                console.error(`    ${chalk.dim(info.description)}`)
+              }
+            }
+            console.error('')
+          }
+
+          throw new Error(message)
+        } catch (parseError) {
+          // If it's our error, rethrow it
+          if (parseError instanceof Error && parseError.message !== "Unexpected token") throw parseError
+          // Otherwise show the raw body
+          throw new Error(body)
+        }
+      }
+
+      // If streaming content type, pipe directly to stdout and return marker
+      if (isStreamingContentType(contentType)) {
+        return new Promise((resolve, reject) => {
+          response.data.pipe(process.stdout)
+          response.data.on("end", () => resolve({ __streamed: true }))
+          response.data.on("error", reject)
+        })
+      }
+
+      // Otherwise, buffer the response and parse as JSON
+      const chunks = []
+      for await (const chunk of response.data) {
+        chunks.push(chunk)
+      }
+      const body = Buffer.concat(chunks).toString("utf-8")
+      return JSON.parse(body)
+    }
+
+    // GET requests - use regular axios behavior
+    const response = await axios({
+      method,
+      url,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      params: queryParams
+    })
+
+    return response.data
+  } catch (error) {
+    // Connection errors (server not running, network issues)
+    if (error.code === "ECONNREFUSED") {
+      const { getApiBaseUrl } = await import("./config.js")
+      const baseUrl = await getApiBaseUrl()
+      throw new Error(`Cannot connect to server at ${baseUrl}. Is it running?`)
+    }
+    if (error.code === "ENOTFOUND" || error.code === "EAI_AGAIN") {
+      throw new Error(`Cannot resolve server address. Check your --url setting.`)
+    }
+    if (error.response?.status === 401) {
+      throw new Error("Invalid or expired API key. Please run: papercrane login")
+    }
+    if (error.response?.data) {
+      // Include full error context for AI consumers
+      const errorData = error.response.data
+      if (typeof errorData === "object") {
+        // If there's structured error data, include it all
+        const errorMessage = errorData.error || "Unknown error"
+        const extraContext = Object.entries(errorData)
+          .filter(([k]) => k !== "error")
+          .map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
+          .join(", ")
+        throw new Error(extraContext ? `${errorMessage} (${extraContext})` : errorMessage)
+      }
+      throw new Error(String(errorData))
+    }
+    throw error
+  }
+}
+
+/**
+ * List available functions at a path (names only, no descriptions)
+ * @param {string} path - Optional path to list at
+ * @param {string} instance - Integration instance name
+ * @param {boolean} all - If true, recursively list all nested functions
+ * @param {boolean} showUnavailable - If true, include functions without credentials
+ * @returns {Promise<Object>} List response with sdks or next items
+ */
+export async function listFunctions(path = "", instance = "Default", all = false, showUnavailable = false) {
+  const mode = all ? "list-all" : "list"
+  // Add showUnavailable as 'all' query param when in list mode (not list-all)
+  const extraParams = !all && showUnavailable ? { all: "true" } : {}
+  return functionRequest(path, "GET", {}, instance, mode, extraParams)
+}
+
+/**
+ * Get detailed info about a function (description, params, etc.)
+ * @param {string} path - Function path
+ * @param {string} instance - Integration instance name
+ * @returns {Promise<Object>} Function info with description, params, available sub-paths
+ */
+export async function getFunction(path, instance = "Default") {
+  return functionRequest(path, "GET", {}, instance, "describe")
+}
+
+/**
+ * Execute a function
+ * @param {string} path - Function path
+ * @param {Object} params - Parameters to pass to the function
+ * @param {string} instance - Integration instance name
+ * @returns {Promise<Object>} Function result
+ */
+export async function runFunction(path, params = {}, instance = "Default") {
+  return functionRequest(path, "POST", params, instance)
+}
+
+/**
+ * Format the root-level describe output (no path given).
+ * Shows connected integrations with their endpoints.
+ * @param {Object} data - Response from listFunctions (mode=list at root)
+ */
+export function formatDescribeRoot(data) {
+  if (data.items !== undefined) {
+    if (data.items.length > 0) {
+      console.log(chalk.bold("\nConnected modules:\n"))
+
+      let hasDynamic = false
+      data.items.forEach((item) => {
+        const displayPath = item.isGroup ? `${item.path}.*` : item.path
+
+        const instanceSuffix =
+          item.instances && item.instances.length > 1 ? chalk.dim(` (via: ${item.instances.join(", ")})`) : ""
+
+        if (item.isDynamic) {
+          hasDynamic = true
+          console.log(`  ${chalk.yellow(displayPath)}${instanceSuffix}`)
+        } else if (item.isGroup) {
+          console.log(`  ${chalk.cyan(displayPath)}${instanceSuffix}`)
+        } else {
+          console.log(`  ${chalk.green(displayPath)}${instanceSuffix}`)
+        }
+
+        if (item.description) {
+          console.log(`    ${chalk.dim(item.description)}`)
+        }
+      })
+      console.log()
+
+      console.log(chalk.dim('Run "papercrane describe <module>" to see endpoints, or "papercrane describe <module> --flat" for all paths.'))
+      console.log()
+    } else {
+      console.log(chalk.dim("\nNo connected modules.\n"))
+      console.log(chalk.dim('Run "papercrane connect" to see available integrations.\n'))
+    }
+    return
+  }
+
+  // Legacy: SDK list format
+  if (data.sdks) {
+    console.log(chalk.bold("\nConnected modules:\n"))
+    data.sdks.forEach((sdk) => {
+      console.log(`  ${chalk.cyan(sdk.name)}`)
+      if (sdk.description) {
+        console.log(`    ${chalk.dim(sdk.description)}`)
+      }
+    })
+    console.log()
+  }
+}
+
+/**
+ * Format describe output for a specific path (branch or leaf).
+ * @param {Object} data - Response from getFunction (mode=describe)
+ * @param {string} path - Function path
+ */
+export function formatDescribe(data, path) {
+  console.log(chalk.bold(`\n${path}\n`))
+  console.log(`  ${data.description}\n`)
+
+  // Show strategic usage guidance
+  if (data.guide) {
+    console.log(chalk.bold("Guide:\n"))
+    data.guide.split("\n").forEach((line) => {
+      console.log(`  ${chalk.dim(line)}`)
+    })
+    console.log()
+  }
+
+  // Show required scopes
+  if (data.scopes && data.scopes.length > 0) {
+    console.log(chalk.bold("Required scopes:\n"))
+    data.scopes.forEach((scope) => {
+      console.log(`  ${chalk.dim("•")} ${scope}`)
+    })
+    console.log()
+  }
+
+  // Show params if this is a runnable function
+  if (data.params) {
+    console.log(chalk.bold("Parameters:\n"))
+    formatParamsSchema(data.params, "  ")
+  }
+
+  // Show available sub-paths, separated by type
+  if (data.next && data.next.length > 0) {
+    const endpoints = data.next.filter((item) => item.isEndpoint)
+    const modules = data.next.filter((item) => !item.isEndpoint)
+
+    if (endpoints.length > 0) {
+      console.log(chalk.bold("Endpoints:\n"))
+      endpoints.forEach((item) => {
+        const name = item.isDynamic ? chalk.yellow(item.name) : chalk.green(item.name)
+        console.log(`  ${name} - ${chalk.dim(item.description)}`)
+      })
+      console.log()
+    }
+
+    if (modules.length > 0) {
+      console.log(chalk.bold("Modules:\n"))
+      modules.forEach((item) => {
+        const name = item.isDynamic ? chalk.yellow(item.name) : chalk.cyan(item.name)
+        console.log(`  ${name} - ${chalk.dim(item.description)}`)
+      })
+      console.log()
+    }
+  }
+
+  // Show example usage for runnable functions
+  if (!data.next) {
+    console.log(chalk.bold("Example:\n"))
+    if (data.params && data.params.properties) {
+      const exampleParams = buildExampleParams(data.params)
+      console.log(chalk.dim(`  papercrane call ${path} '${JSON.stringify(exampleParams)}'`))
+    } else {
+      console.log(chalk.dim(`  papercrane call ${path}`))
+    }
+    console.log()
+  }
+}
+
+/**
+ * Format flat listing of all endpoint paths.
+ * @param {Object} data - Response from listFunctions with all=true (mode=list-all)
+ */
+export function formatFlat(data) {
+  if (data.paths && data.paths.length > 0) {
+    console.log()
+    data.paths.forEach((p) => {
+      const display = p.isDynamic ? chalk.yellow(p.path) : chalk.green(p.path)
+      console.log(`  ${display}`)
+    })
+    console.log()
+  } else {
+    console.log(chalk.dim("\nNo endpoints found.\n"))
+  }
+}
+
+/**
+ * Format unconnected integrations for the `connect` command.
+ * @param {Object} data - Response from listFunctions (mode=list at root)
+ */
+export function formatUnconnected(data) {
+  if (data.notConnected && data.notConnected.length > 0) {
+    console.log(chalk.bold("\nAvailable to connect:\n"))
+    data.notConnected.forEach((item) => {
+      console.log(`  ${chalk.cyan(item.sdk)}`)
+      console.log(`    ${chalk.dim(item.displayName)}`)
+    })
+    console.log()
+    console.log(chalk.dim('Run "papercrane connect <name>" to get started.\n'))
+  } else {
+    console.log(chalk.dim("\nAll integrations are already connected.\n"))
+  }
+}
+
+/**
+ * Format JSON schema params for display
+ * @param {Object} schema - JSON Schema object
+ * @param {string} indent - Indentation string
+ */
+function formatParamsSchema(schema, indent = "") {
+  if (!schema.properties) {
+    console.log(`${indent}${chalk.dim("(no parameters)")}\n`)
+    return
+  }
+
+  const required = new Set(schema.required || [])
+
+  Object.entries(schema.properties).forEach(([name, prop]) => {
+    const isRequired = required.has(name)
+    const reqLabel = isRequired ? chalk.red("required") : chalk.dim("optional")
+
+    let typeStr = prop.type || "any"
+    if (prop.enum) {
+      typeStr = `enum (${prop.enum.join(" | ")})`
+    }
+    if (prop.default !== undefined) {
+      typeStr += `, default: ${JSON.stringify(prop.default)}`
+    }
+    if (prop.maximum !== undefined) {
+      typeStr += `, max: ${prop.maximum}`
+    }
+
+    console.log(`${indent}${chalk.cyan(name)}  ${chalk.dim(typeStr)}  ${reqLabel}`)
+    if (prop.description) {
+      console.log(`${indent}  ${chalk.dim(prop.description)}`)
+    }
+  })
+  console.log()
+}
+
+/**
+ * Build example params from JSON schema
+ * @param {Object} schema - JSON Schema object
+ * @returns {Object} Example params object
+ */
+function buildExampleParams(schema) {
+  const params = {}
+  if (!schema.properties) return params
+
+  Object.entries(schema.properties).forEach(([name, prop]) => {
+    if (prop.enum) {
+      params[name] = prop.enum[0]
+    } else if (prop.default !== undefined) {
+      params[name] = prop.default
+    } else if (prop.type === "string") {
+      if (prop.pattern) {
+        // Try to generate from pattern
+        if (prop.pattern.includes("\\d{4}-\\d{2}-\\d{2}")) {
+          params[name] = "2024-01-01"
+        } else {
+          params[name] = "<value>"
+        }
+      } else {
+        params[name] = "<value>"
+      }
+    } else if (prop.type === "number" || prop.type === "integer") {
+      params[name] = prop.default || 10
+    } else if (prop.type === "boolean") {
+      params[name] = true
+    }
+  })
+
+  return params
+}
+
+/**
+ * Format function result output for display
+ * @param {Object} data - Response from runFunction
+ */
+export function formatResult(data) {
+  // If response was streamed directly to stdout, nothing more to do
+  if (data.__streamed) {
+    return
+  }
+
+  if (data.result !== undefined) {
+    console.log(JSON.stringify(data.result, null, 2))
+  } else {
+    console.log(JSON.stringify(data, null, 2))
+  }
+}

package/lib/google-auth.js

@@ -0,0 +1,134 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import open from 'open';
+import { generatePKCE } from './pkce.js';
+import { startCallbackServer, stopCallbackServer } from './callback-server.js';
+import { saveGoogleCredentials } from './storage.js';
+
+const GOOGLE_AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
+const GOOGLE_TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const REDIRECT_URI = 'http://127.0.0.1:8080/callback';
+const PORT = 8080;
+
+/**
+ * Handles the Google OAuth authentication flow
+ * @param {string[]} scopes - Array of OAuth scopes to request
+ * @param {string} clientId - Google OAuth Client ID
+ * @param {string} clientSecret - Google OAuth Client Secret
+ */
+export async function handleGoogleAuth(scopes, clientId, clientSecret) {
+  console.log(chalk.bold('\n🔐 Starting Google OAuth flow...\n'));
+
+  // Validate required credentials
+  if (!clientId) {
+    console.log(chalk.yellow('Google OAuth Client ID is required.'));
+    console.log(chalk.dim('You can create one in the Google Cloud Console:'));
+    console.log(chalk.dim('https://console.cloud.google.com/apis/credentials\n'));
+    throw new Error('Client ID is required. Pass it as: papercrane google <scopes> --client-id YOUR_CLIENT_ID');
+  }
+
+  if (!clientSecret) {
+    console.log(chalk.yellow('Google OAuth Client Secret is required.'));
+    console.log(chalk.dim('You can find this in the Google Cloud Console:'));
+    console.log(chalk.dim('https://console.cloud.google.com/apis/credentials\n'));
+    throw new Error('Client Secret is required. Pass it as: --client-secret YOUR_CLIENT_SECRET');
+  }
+
+  // Generate PKCE credentials
+  const pkce = generatePKCE();
+  console.log(chalk.green('✓ Generated PKCE credentials'));
+
+  // Start local callback server
+  let server;
+  let cleanupDone = false;
+
+  // Handle Ctrl+C gracefully
+  const handleExit = async () => {
+    if (!cleanupDone && server) {
+      cleanupDone = true;
+      console.log(chalk.yellow('\n\n⚠️  Authentication cancelled by user'));
+      await stopCallbackServer(server);
+      process.exit(0);
+    }
+  };
+
+  process.on('SIGINT', handleExit);
+
+  try {
+    const serverPromise = startCallbackServer(PORT);
+
+    // Build authorization URL
+    const scopeString = scopes.join(' ');
+    const authParams = new URLSearchParams({
+      client_id: clientId,
+      redirect_uri: REDIRECT_URI,
+      response_type: 'code',
+      scope: scopeString,
+      access_type: 'offline',
+      code_challenge: pkce.challenge,
+      code_challenge_method: 'S256',
+      prompt: 'consent'
+    });
+
+    const authUrl = `${GOOGLE_AUTH_URL}?${authParams.toString()}`;
+
+    console.log(chalk.green('✓ Authorization URL created'));
+    console.log(chalk.cyan('\n🌐 Opening browser for authentication...'));
+    console.log(chalk.dim(`If the browser doesn't open, visit: ${authUrl}\n`));
+
+    // Open the authorization URL in the default browser
+    await open(authUrl);
+
+    // Wait for the callback
+    const { code, server: callbackServer } = await serverPromise;
+    server = callbackServer;
+
+    console.log(chalk.green('\n✓ Authorization code received'));
+
+    // Exchange authorization code for tokens
+    console.log(chalk.cyan('🔄 Exchanging authorization code for tokens...'));
+
+    const tokenResponse = await axios.post(
+      GOOGLE_TOKEN_URL,
+      new URLSearchParams({
+        code,
+        client_id: clientId,
+        client_secret: clientSecret,
+        redirect_uri: REDIRECT_URI,
+        grant_type: 'authorization_code',
+        code_verifier: pkce.verifier
+      }),
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        }
+      }
+    );
+
+    const credentials = tokenResponse.data;
+    console.log(chalk.green('✓ Tokens received successfully'));
+
+    // Save credentials
+    console.log(chalk.cyan('💾 Saving credentials...'));
+    const filepath = await saveGoogleCredentials(credentials, clientId, clientSecret);
+    console.log(chalk.green(`✓ Credentials saved to: ${filepath}`));
+
+    console.log(chalk.bold.green('\n✅ Authentication completed successfully!\n'));
+    console.log(chalk.dim('Granted scopes:'));
+    console.log(chalk.dim(`  ${credentials.scope}\n`));
+
+    // Stop the server
+    await stopCallbackServer(server);
+  } catch (error) {
+    if (server) {
+      await stopCallbackServer(server);
+    }
+
+    if (error.response) {
+      console.error(chalk.red('\n❌ Token exchange failed:'));
+      console.error(chalk.red(`   ${error.response.data.error_description || error.response.data.error}`));
+    } else {
+      throw error;
+    }
+  }
+}

package/lib/list-credentials.js

@@ -0,0 +1,116 @@
+import chalk from 'chalk';
+import {
+  listGoogleCredentials,
+  getGoogleCredentialsDir,
+  listFacebookCredentials,
+  getFacebookCredentialsDir
+} from './storage.js';
+import { listCloudCredentials } from './cloud-client.js';
+import { isLoggedIn } from './config.js';
+
+/**
+ * Lists all stored credentials
+ */
+export async function listCredentials() {
+  console.log(chalk.bold('\n📋 Stored Credentials\n'));
+
+  // Check for cloud credentials
+  let cloudCredentials = [];
+  const loggedIn = await isLoggedIn();
+
+  if (loggedIn) {
+    try {
+      cloudCredentials = await listCloudCredentials();
+    } catch (error) {
+      console.log(chalk.yellow('⚠️  Unable to fetch cloud credentials:'), error.message);
+      console.log();
+    }
+  }
+
+  const googleCredentials = await listGoogleCredentials();
+  const facebookCredentials = await listFacebookCredentials();
+
+  if (googleCredentials.length === 0 && facebookCredentials.length === 0 && cloudCredentials.length === 0) {
+    console.log(chalk.yellow('No credentials found.'));
+    console.log(chalk.dim('\nUse "papercrane google <scopes>" or "papercrane facebook <scopes> --app-id YOUR_APP_ID" to authenticate.\n'));
+    if (!loggedIn) {
+      console.log(chalk.dim('Or run "papercrane login" to use cloud credentials.\n'));
+    }
+    return;
+  }
+
+  // Display Cloud credentials
+  if (cloudCredentials.length > 0) {
+    console.log(chalk.bold.magenta('☁️  Cloud Credentials:'));
+    console.log(chalk.dim(`Found ${cloudCredentials.length} credential(s) in cloud storage\n`));
+
+    cloudCredentials.forEach((cred, index) => {
+      const createdAt = cred.createdAt ? new Date(cred.createdAt) : null;
+      const expiresAt = cred.expiresAt ? new Date(cred.expiresAt) : null;
+      const isExpired = expiresAt ? Date.now() > cred.expiresAt : false;
+      const scopeDisplay = Array.isArray(cred.scopes) ? cred.scopes.join(' ') : (cred.scopes || '');
+
+      console.log(chalk.bold(`  ${index + 1}. ${cred.displayName || cred.provider} - ${cred.instanceName || 'Default'}`));
+      if (createdAt) {
+        console.log(`     Created: ${createdAt.toLocaleString()}`);
+      }
+      if (expiresAt) {
+        console.log(`     Expires: ${expiresAt.toLocaleString()} ${isExpired ? chalk.red('(EXPIRED)') : chalk.green('(Valid)')}`);
+      }
+      if (scopeDisplay) {
+        console.log(`     Scopes: ${chalk.cyan(scopeDisplay)}`);
+      }
+      console.log(`     Provider: ${cred.provider}`);
+      console.log(`     Source: ${chalk.magenta('Cloud')}`);
+      console.log();
+    });
+  }
+
+  // Display Google credentials
+  if (googleCredentials.length > 0) {
+    console.log(chalk.bold.cyan('Google Credentials:'));
+    console.log(chalk.dim(`Found ${googleCredentials.length} credential file(s)\n`));
+
+    googleCredentials.forEach((cred, index) => {
+      const { file, filepath, data } = cred;
+      const createdAt = new Date(data.created_at);
+      const expiresAt = new Date(data.expires_at);
+      const isExpired = Date.now() > data.expires_at;
+
+      console.log(chalk.bold(`  ${index + 1}. ${file}`));
+      console.log(chalk.dim(`     Path: ${filepath}`));
+      console.log(`     Created: ${createdAt.toLocaleString()}`);
+      console.log(`     Expires: ${expiresAt.toLocaleString()} ${isExpired ? chalk.red('(EXPIRED)') : chalk.green('(Valid)')}`);
+      console.log(`     Token Type: ${data.token_type}`);
+      console.log(`     Scopes: ${chalk.cyan(data.scope)}`);
+      console.log(`     Has Refresh Token: ${data.refresh_token ? chalk.green('Yes') : chalk.red('No')}`);
+      console.log();
+    });
+
+    console.log(chalk.dim(`  Storage directory: ${getGoogleCredentialsDir()}\n`));
+  }
+
+  // Display Facebook credentials
+  if (facebookCredentials.length > 0) {
+    console.log(chalk.bold.blue('Facebook Credentials:'));
+    console.log(chalk.dim(`Found ${facebookCredentials.length} credential file(s)\n`));
+
+    facebookCredentials.forEach((cred, index) => {
+      const { file, filepath, data } = cred;
+      const createdAt = new Date(data.created_at);
+      const expiresAt = new Date(data.expires_at);
+      const isExpired = Date.now() > data.expires_at;
+
+      console.log(chalk.bold(`  ${index + 1}. ${file}`));
+      console.log(chalk.dim(`     Path: ${filepath}`));
+      console.log(`     Created: ${createdAt.toLocaleString()}`);
+      console.log(`     Expires: ${expiresAt.toLocaleString()} ${isExpired ? chalk.red('(EXPIRED)') : chalk.green('(Valid)')}`);
+      console.log(`     Token Type: ${data.token_type}`);
+      console.log(`     Scopes: ${chalk.cyan(data.scope)}`);
+      console.log(`     App ID: ${data.app_id}`);
+      console.log();
+    });
+
+    console.log(chalk.dim(`  Storage directory: ${getFacebookCredentialsDir()}\n`));
+  }
+}