directus-template-cli 0.7.0-beta.9 → 0.7.0

package/dist/lib/constants.js

@@ -2,6 +2,8 @@ import chalk from 'chalk';
 export const DIRECTUS_PURPLE = '#6644ff';
 export const DIRECTUS_PINK = '#FF99DD';
 export const SEPARATOR = '------------------';
+export const pinkText = chalk.hex(DIRECTUS_PINK);
+export const purpleText = chalk.hex(DIRECTUS_PURPLE);
 export const COMMUNITY_TEMPLATE_REPO = {
     string: 'github:directus-labs/directus-templates',
     url: 'https://github.com/directus-labs/directus-templates',
@@ -17,4 +19,8 @@ export const POSTHOG_PUBLIC_KEY = 'phc_STopE6gj6LDIjYonVF7493kQJK8S4v0Xrl6YPr2z9
 export const POSTHOG_HOST = 'https://us.i.posthog.com';
 export const DEFAULT_BRANCH = 'main';
 export const BSL_LICENSE_URL = 'https://directus.io/bsl';
-export const BSL_LICENSE_TEXT = `You REQUIRE a license to use Directus if your organisation has more than $5MM USD a year in revenue and/or funding. For all organizations and people with less than $5MM USD a year in revenue and funding, Directus is free for personal projects, hobby projects and in production. This second group does not require a license. \nDirectus is licensed under BSL1.1. Visit ${chalk.underline(chalk.cyan(BSL_LICENSE_URL))} for more information or reach out to us at ${chalk.underline(chalk.cyan('sales-demo-with-evil-sales@directus.io'))}.`;
+export const BSL_EMAIL = 'licensing@directus.io';
+export const BSL_LICENSE_HEADLINE = 'You REQUIRE a license to use Directus if your organization has more than $5MM USD a year in revenue and/or funding.';
+export const BSL_LICENSE_TEXT = 'For all organizations with less than $5MM USD a year in revenue and funding, Directus is free for personal projects, hobby projects and in production. This second group does not require a license. Directus is licensed under BSL 1.1.';
+export const BSL_LICENSE_CTA = `Visit ${pinkText(BSL_LICENSE_URL)} for more information or reach out to us at ${pinkText(BSL_EMAIL)}.`;
+export const DEFAULT_DIRECTUS_URL = 'http://localhost:8055';

package/dist/lib/init/index.js

@@ -1,6 +1,5 @@
 import { note, outro, spinner, log as clackLog } from '@clack/prompts';
 import { ux } from '@oclif/core';
-import chalk from 'chalk';
 import { execa } from 'execa';
 import { downloadTemplate } from 'giget';
 import { glob } from 'glob';
@@ -14,12 +13,12 @@ import catchError from '../utils/catch-error.js';
 import { createGigetString, parseGitHubUrl } from '../utils/parse-github-url.js';
 import { readTemplateConfig } from '../utils/template-config.js';
 import { DOCKER_CONFIG } from './config.js';
-import { BSL_LICENSE_TEXT } from '../constants.js';
+import { BSL_LICENSE_TEXT, BSL_LICENSE_HEADLINE, BSL_LICENSE_CTA, pinkText } from '../constants.js';
 export async function init({ dir, flags }) {
     // Check target directory
-    const shouldForce = flags.overrideDir;
+    const shouldForce = flags.overwriteDir;
     if (fs.existsSync(dir) && !shouldForce) {
-        throw new Error('Directory already exists. Use --override-dir to override.');
+        throw new Error('Directory already exists. Use --overwrite-dir to override.');
     }
     // If template is a URL, we need to handle it differently
     const isDirectUrl = flags.template?.startsWith('http');
@@ -104,36 +103,40 @@ export async function init({ dir, flags }) {
             if (!dockerStatus.installed || !dockerStatus.running) {
                 throw new Error(dockerStatus.message);
             }
-            try {
-                await dockerService.startContainers(directusDir);
-                const healthCheckUrl = `${directusInfo.url || 'http://localhost:8055'}${DOCKER_CONFIG.healthCheckEndpoint}`;
-                // Wait for healthy before proceeding
-                const isHealthy = await dockerService.waitForHealthy(healthCheckUrl);
-                if (!isHealthy) {
-                    throw new Error('Directus failed to become healthy');
-                }
-                const templatePath = path.join(directusDir, 'template');
-                ux.stdout(`Attempting to apply template from: ${templatePath}`);
+            await dockerService.startContainers(directusDir);
+            const healthCheckUrl = `${directusInfo.url || 'http://localhost:8055'}${DOCKER_CONFIG.healthCheckEndpoint}`;
+            // Wait for healthy before proceeding
+            const isHealthy = await dockerService.waitForHealthy(healthCheckUrl);
+            if (!isHealthy) {
+                throw new Error('Directus failed to become healthy');
+            }
+            // Check if a template path is specified in the config and exists
+            let templatePath;
+            if (templateInfo?.config?.template && typeof templateInfo.config.template === 'string') {
+                templatePath = path.join(dir, templateInfo.config.template); // Path relative to root dir
+            }
+            if (templatePath && fs.existsSync(templatePath)) {
+                ux.stdout(`Applying template from: ${templatePath}`);
                 await ApplyCommand.run([
-                    '--directusUrl=http://localhost:8055',
+                    `--directusUrl=${directusInfo.url || 'http://localhost:8055'}`,
                     '-p',
-                    '--userEmail=admin@example.com',
-                    '--userPassword=d1r3ctu5',
+                    `--userEmail=${directusInfo.email}`,
+                    `--userPassword=${directusInfo.password}`,
                     `--templateLocation=${templatePath}`,
                 ]);
             }
-            catch (error) {
-                ux.error('Failed to start Directus containers or apply template');
-                throw error;
+            else {
+                ux.stdout('Skipping backend template application.');
             }
         }
+        // Detect package manager even if not installing dependencies
+        packageManager = await detectPackageManager(frontendDir);
         // Install dependencies if requested
         if (flags.installDeps) {
             const s = spinner();
             s.start('Installing dependencies');
             try {
                 if (fs.existsSync(frontendDir)) {
-                    packageManager = await detectPackageManager(frontendDir);
                     await installDependencies({
                         cwd: frontendDir,
                         packageManager,
@@ -156,14 +159,18 @@ export async function init({ dir, flags }) {
         }
         // Finishing up
         const relativeDir = path.relative(process.cwd(), dir);
-        const directusText = `- Directus is running on ${directusInfo.url ?? 'http://localhost:8055'}. You can login with the email: ${chalk.cyan(directusInfo.email)} and password: ${chalk.cyan(directusInfo.password)}. \n`;
-        const frontendText = flags.frontend ? `- To start the frontend, run ${chalk.cyan(`cd ${flags.frontend}`)} and then ${chalk.cyan(`${packageManager?.name} run dev`)}. \n` : '';
-        const projectText = `- Navigate to your project directory using ${chalk.cyan(`cd ${relativeDir}`)}. \n`;
+        const directusUrl = directusInfo.url ?? 'http://localhost:8055';
+        const directusText = `- Directus is running on ${directusUrl}. \n`;
+        const directusLoginText = `- You can login with the email: ${pinkText(directusInfo.email)} and password: ${pinkText(directusInfo.password)}. \n`;
+        const frontendText = flags.frontend ? `- To start the frontend, run ${pinkText(`cd ${flags.frontend}`)} and then ${pinkText(`${packageManager?.name} run dev`)}. \n` : '';
+        const projectText = `- Navigate to your project directory using ${pinkText(`cd ${relativeDir}`)}. \n`;
         const readmeText = '- Review the \`./README.md\` file for more information and next steps.';
-        const nextSteps = chalk.white(`${directusText}${projectText}${frontendText}${readmeText}`);
+        const nextSteps = `${directusText}${directusLoginText}${projectText}${frontendText}${readmeText}`;
         note(nextSteps, 'Next Steps');
-        clackLog.warn(BSL_LICENSE_TEXT);
-        outro(`Problems or questions? Hop into the community on Discord at ${chalk.underline(chalk.cyan('https://directus.chat'))}`);
+        clackLog.warn(BSL_LICENSE_HEADLINE);
+        clackLog.info(BSL_LICENSE_TEXT);
+        clackLog.info(BSL_LICENSE_CTA);
+        outro(`Problems or questions? Hop into the community at ${pinkText('https://directus.chat')}`);
     }
     catch (error) {
         catchError(error, {

package/dist/lib/load/apply-flags.d.ts

@@ -15,7 +15,8 @@ export interface ApplyFlags {
     templateType: 'community' | 'github' | 'local';
     userEmail: string;
     userPassword: string;
-    users: boolean;
+    users?: boolean;
+    disableTelemetry?: boolean;
 }
 export declare const loadFlags: readonly ["content", "dashboards", "extensions", "files", "flows", "permissions", "schema", "settings", "users"];
 export declare function validateProgrammaticFlags(flags: ApplyFlags): ApplyFlags;

package/dist/lib/sdk.js

@@ -1,6 +1,9 @@
 import { authentication, createDirectus, rest } from '@directus/sdk';
 import { ux } from '@oclif/core';
 import Bottleneck from 'bottleneck';
+function log(message) {
+    ux.stdout(`${ux.colorize('dim', '--')} ${message}`);
+}
 export class DirectusError extends Error {
     errors;
     headers;
@@ -54,38 +57,44 @@ class Api {
             retryCount: 3, // Retry a maximum of 3 times
         });
         this.limiter.on('failed', async (error, jobInfo) => {
+            // @ts-ignore
+            if (error instanceof TypeError && error.message === 'fetch failed' && error.cause?.code === 'ECONNREFUSED') {
+                log(`Connection refused. Please check the Directus URL and ensure the server is running. Not retrying. ${error.message}`);
+                return;
+            }
             if (error instanceof DirectusError) {
                 const retryAfter = error.headers?.get('Retry-After');
                 const statusCode = error.status;
+                // If the status code is 400 or 401, we don't want to retry
+                if (statusCode === 400 || statusCode === 401) {
+                    log(`Request failed with status ${statusCode}. Not retrying. ${error.message}`);
+                    return;
+                }
                 if (statusCode === 429) {
                     const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : 60_000;
-                    ux.stdout(`${ux.colorize('dim', '--')} Rate limited. Retrying after ${delay}ms`);
+                    log(`Rate limited. Retrying after ${delay}ms`);
                     return delay;
                 }
                 if (statusCode === 503) {
                     const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : 5000;
-                    ux.stdout(`${ux.colorize('dim', '--')} Server under pressure. Retrying after ${delay}ms`);
+                    log(`Server under pressure. Retrying after ${delay}ms`);
                     return delay;
                 }
-                // If the status code is 400 or 401, we don't want to retry
-                if (statusCode === 400 || statusCode === 401) {
-                    return;
-                }
             }
             // For other errors, use exponential backoff, but only if we haven't exceeded retryCount
             if (jobInfo.retryCount < 3) {
                 const delay = Math.min(1000 * 2 ** jobInfo.retryCount, 30_000);
-                ux.stdout(`${ux.colorize('dim', '--')} Request failed. Retrying after ${delay}ms`);
+                log(`Request failed. Retrying after ${delay}ms`);
                 return delay;
             }
-            ux.stdout(`${ux.colorize('dim', '--')} Max retries reached, not retrying further`);
+            log('Max retries reached, not retrying further');
         });
         this.limiter.on('retry', (error, jobInfo) => {
-            ux.stdout(`${ux.colorize('dim', '--')} Retrying job (attempt ${jobInfo.retryCount + 1})`);
+            log(`Retrying job (attempt ${jobInfo.retryCount + 1})`);
         });
         this.limiter.on('depleted', empty => {
             if (empty) {
-                ux.stdout(`${ux.colorize('dim', '--')} Rate limit quota depleted. Requests will be queued.`);
+                log('Rate limit quota depleted. Requests will be queued.');
             }
         });
     }

package/dist/lib/types.d.ts

@@ -5,7 +5,7 @@ export interface DirectusTemplateFrontend {
 export interface DirectusTemplateConfig {
     name: string;
     description: string;
-    template: string;
+    template: string | null;
     frontends: {
         [key: string]: DirectusTemplateFrontend;
     };

package/dist/lib/utils/auth.d.ts

@@ -15,6 +15,10 @@ export declare function getDirectusUrl(): Promise<string>;
  * @returns The Directus token
  */
 export declare function getDirectusToken(directusUrl: string): Promise<string>;
+export declare function getDirectusEmailAndPassword(): Promise<{
+    userEmail: string;
+    userPassword: string;
+}>;
 /**
  * Initialize the Directus API with the provided flags and log in the user
  * @param flags - The validated ApplyFlags

package/dist/lib/utils/auth.js

@@ -1,22 +1,27 @@
 import { readMe } from '@directus/sdk';
-import { text, log, isCancel } from '@clack/prompts';
+import { text, log, isCancel, password } from '@clack/prompts';
 import { ux } from '@oclif/core';
 import { api } from '../sdk.js';
 import catchError from './catch-error.js';
 import validateUrl from './validate-url.js';
+import { DEFAULT_DIRECTUS_URL } from '../../lib/constants.js';
 /**
  * Get the Directus URL from the user
  * @returns The Directus URL
  */
 export async function getDirectusUrl() {
     const directusUrl = await text({
-        placeholder: 'http://localhost:8055',
+        placeholder: DEFAULT_DIRECTUS_URL,
         message: 'What is your Directus URL?',
     });
     if (isCancel(directusUrl)) {
         log.info('Exiting...');
         ux.exit(0);
     }
+    if (!directusUrl) {
+        ux.warn(`No URL provided, using default: ${DEFAULT_DIRECTUS_URL}`);
+        return DEFAULT_DIRECTUS_URL;
+    }
     // Validate URL
     if (!validateUrl(directusUrl)) {
         ux.warn('Invalid URL');
@@ -56,6 +61,33 @@ export async function getDirectusToken(directusUrl) {
         return getDirectusToken(directusUrl);
     }
 }
+export async function getDirectusEmailAndPassword() {
+    const userEmail = await text({
+        message: 'What is your email?',
+        validate(value) {
+            if (!value) {
+                return 'Email is required';
+            }
+        },
+    });
+    if (isCancel(userEmail)) {
+        log.info('Exiting...');
+        ux.exit(0);
+    }
+    const userPassword = await password({
+        message: 'What is your password?',
+        validate(value) {
+            if (!value) {
+                return 'Password is required';
+            }
+        },
+    });
+    if (isCancel(userPassword)) {
+        log.info('Exiting...');
+        ux.exit(0);
+    }
+    return { userEmail, userPassword };
+}
 /**
  * Initialize the Directus API with the provided flags and log in the user
  * @param flags - The validated ApplyFlags

package/dist/lib/utils/catch-error.d.ts

@@ -3,7 +3,7 @@
  */
 interface ErrorHandlerOptions {
     /** Additional context to be included in the error log. */
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
     /** If true, the error will be treated as fatal and the process will exit. */
     fatal?: boolean;
     /** If true, the error will be logged to a file. */

package/dist/lib/utils/catch-error.js

@@ -1,6 +1,8 @@
 import { ux } from '@oclif/core';
 import { DirectusError } from '../sdk.js';
 import { logger } from '../utils/logger.js';
+import { captureException } from '../../services/posthog.js';
+import { getExecutionContext } from '../../services/execution-context.js';
 /**
  * Handles errors by formatting them and optionally logging to console and file.
  * @param error - The error to be handled.
@@ -9,6 +11,7 @@ import { logger } from '../utils/logger.js';
  */
 export default function catchError(error, options = {}) {
     const { context = {}, fatal = false, logToFile = true } = options;
+    const { distinctId, disableTelemetry } = getExecutionContext();
     let errorMessage;
     if (error instanceof DirectusError) {
         errorMessage = error.message;
@@ -19,6 +22,10 @@ export default function catchError(error, options = {}) {
     else {
         errorMessage = `Unknown error: ${JSON.stringify(error)}`;
     }
+    // Capture exception before logging/exiting
+    if (!disableTelemetry && distinctId) {
+        captureException({ error, distinctId, properties: { context } });
+    }
     // Format the error message with context if provided
     const formattedMessage = [
         errorMessage,

package/dist/lib/utils/parse-github-url.js

@@ -39,30 +39,59 @@ export function parseGitHubUrl(url) {
     if (!url) {
         throw new Error('URL is required');
     }
-    // Clean the URL first
     const cleanedUrl = cleanGitHubUrl(url);
-    // Handle full GitHub URLs
     if (cleanedUrl.includes('github.com')) {
         try {
             const parsed = new URL(cleanedUrl);
-            const parts = parsed.pathname.split('/').filter(Boolean);
-            if (parts.length < 2) {
-                throw new Error('Invalid GitHub URL format');
+            const pathParts = parsed.pathname.split('/').filter(Boolean);
+            if (pathParts.length < 2) {
+                throw new Error('Invalid GitHub URL format: Needs owner and repo.');
             }
-            const [owner, repo, ...rest] = parts;
-            const path = rest.length > 0 ? rest.join('/') : undefined;
-            const ref = parsed.searchParams.get('ref') || DEFAULT_BRANCH;
+            const owner = pathParts[0];
+            const repo = pathParts[1];
+            let ref = DEFAULT_BRANCH; // Default ref
+            let path;
+            // Check for /tree/ref/ or /blob/ref/ patterns
+            const treeIndex = pathParts.indexOf('tree');
+            const blobIndex = pathParts.indexOf('blob');
+            let refIndex = -1;
+            if (treeIndex > 1 && treeIndex + 1 < pathParts.length) {
+                refIndex = treeIndex + 1;
+            }
+            else if (blobIndex > 1 && blobIndex + 1 < pathParts.length) {
+                refIndex = blobIndex + 1;
+            }
+            if (refIndex !== -1) {
+                ref = pathParts[refIndex];
+                // Path is everything after the ref
+                path = pathParts.slice(refIndex + 1).join('/') || undefined;
+            }
+            else if (pathParts.length > 2) {
+                // If no tree/blob, but more parts exist, assume it's part of the path
+                // This handles cases like github.com/owner/repo/some/path without a specific ref marker
+                path = pathParts.slice(2).join('/') || undefined;
+                // If URL has an explicit ?ref= param, use that, otherwise keep default
+                ref = parsed.searchParams.get('ref') || ref;
+            }
+            else {
+                // No path, just owner/repo
+                ref = parsed.searchParams.get('ref') || ref;
+            }
+            // Ensure path is undefined if empty string
+            if (path === '')
+                path = undefined;
             return { owner, repo, path, ref };
         }
         catch (error) {
-            throw new Error(`Invalid GitHub URL: ${url}`);
+            throw new Error(`Invalid GitHub URL: ${url}. Error: ${error.message}`);
         }
     }
-    // Handle repository paths (owner/repo format)
+    // Handle repository paths (owner/repo/path format) without github.com
     const parts = cleanedUrl.split('/').filter(Boolean);
     if (parts.length >= 2) {
         const [owner, repo, ...rest] = parts;
         const path = rest.length > 0 ? rest.join('/') : undefined;
+        // Assume default branch for simple paths unless we add ref detection here too
         return { owner, repo, path, ref: DEFAULT_BRANCH };
     }
     // Handle simple template names using DEFAULT_REPO

package/dist/services/docker.js

@@ -1,4 +1,4 @@
-import { spinner } from '@clack/prompts';
+import { spinner, log } from '@clack/prompts';
 import { execa } from 'execa';
 import net from 'node:net';
 import { ux } from '@oclif/core';
@@ -89,23 +89,80 @@ async function checkDocker() {
     }
 }
 /**
- * Start Docker containers using docker-compose
+ * Get the list of image names defined in the docker-compose file
+ * @param {string} cwd - The current working directory
+ * @returns {Promise<string[]>} - A list of image names
+ */
+async function getRequiredImagesFromCompose(cwd) {
+    try {
+        const { stdout } = await execa('docker', ['compose', 'config', '--images'], { cwd });
+        // stdout contains a list of image names, one per line
+        return stdout.split('\n').filter(img => img.trim() !== ''); // Filter out empty lines
+    }
+    catch (error) {
+        // Handle potential errors, e.g., compose file not found or invalid
+        log.error('Failed to get images from docker-compose file.');
+        catchError(error, {
+            context: { cwd, function: 'getRequiredImagesFromCompose' },
+            fatal: false, // Don't necessarily exit, maybe let startContainers handle it
+            logToFile: true,
+        });
+        return []; // Return empty list on error
+    }
+}
+/**
+ * Check if a list of Docker images exist locally
+ * @param {string[]} imageNames - An array of Docker image names (e.g., "postgres:16")
+ * @returns {Promise<boolean>} - True if all images exist locally, false otherwise
+ */
+async function checkImagesExist(imageNames) {
+    if (imageNames.length === 0) {
+        return true; // No images to check, technically they all "exist"
+    }
+    try {
+        // Use Promise.allSettled to check all images even if some commands fail
+        const results = await Promise.allSettled(imageNames.map(imageName => execa('docker', ['inspect', '--type=image', imageName])));
+        // Check if all inspect commands succeeded (exit code 0)
+        return results.every(result => result.status === 'fulfilled' && result.value.exitCode === 0);
+    }
+    catch (error) {
+        // This catch block might be redundant due to allSettled, but good for safety
+        log.error('Error checking for Docker images.');
+        catchError(error, {
+            context: { imageNames, function: 'checkImagesExist' },
+            fatal: false,
+            logToFile: true,
+        });
+        return false; // Assume images don't exist if there's an error checking
+    }
+}
+/**
+ * Start Docker containers using docker compose
  * @param {string} cwd - The current working directory
  * @returns {Promise<void>} - Returns nothing
  */
 async function startContainers(cwd) {
+    const s = spinner();
     try {
         // Check if required ports are available
         await checkRequiredPorts();
-        const s = spinner();
-        s.start('Starting Docker containers');
-        return execa('docker-compose', ['up', '-d'], {
+        // Get required images from compose file
+        const requiredImages = await getRequiredImagesFromCompose(cwd);
+        const imagesExist = await checkImagesExist(requiredImages);
+        // Log a message if images need downloading
+        if (!imagesExist && requiredImages.length > 0) {
+            log.info('Required Docker image(s) are missing and will be downloaded.');
+        }
+        const startMessage = imagesExist || requiredImages.length === 0 ? 'Starting Docker containers...' : 'Downloading required Docker images...';
+        const endMessage = imagesExist || requiredImages.length === 0 ? 'Docker containers running!' : 'Docker images downloaded and containers started!';
+        s.start(startMessage); // Start spinner with the appropriate message
+        await execa('docker', ['compose', 'up', '-d'], {
             cwd,
-        }).then(() => {
-            s.stop('Docker containers running!');
         });
+        s.stop(endMessage); // Update spinner message on success
     }
     catch (error) {
+        s.stop('Error starting Docker containers.'); // Stop spinner on error
         catchError(error, {
             context: { cwd, function: 'startContainers' },
             fatal: true,
@@ -115,13 +172,13 @@ async function startContainers(cwd) {
     }
 }
 /**
- * Stop Docker containers
+ * Stop Docker containers using docker compose
  * @param {string} cwd - The current working directory
  * @returns {Promise<void>} - Returns nothing
  */
 async function stopContainers(cwd) {
     try {
-        return execa('docker-compose', ['down'], {
+        return execa('docker', ['compose', 'down'], {
             cwd,
         }).then(() => { });
     }

package/dist/services/execution-context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Defines the structure for the execution context, holding telemetry information.
+ */
+export interface ExecutionContext {
+    distinctId?: string;
+    disableTelemetry?: boolean;
+}
+/**
+ * Sets the global execution context.
+ * This should be called early in the command lifecycle.
+ * @param context The context object containing distinctId and disableTelemetry status.
+ */
+export declare function setExecutionContext(context: ExecutionContext): void;
+/**
+ * Gets the currently set global execution context.
+ * @returns The current execution context.
+ */
+export declare function getExecutionContext(): ExecutionContext;

package/dist/services/execution-context.js

@@ -0,0 +1,20 @@
+// Module-level variable to hold the current context.
+// Initialize with default values (telemetry enabled, no distinctId yet).
+let currentContext = {
+    disableTelemetry: false,
+};
+/**
+ * Sets the global execution context.
+ * This should be called early in the command lifecycle.
+ * @param context The context object containing distinctId and disableTelemetry status.
+ */
+export function setExecutionContext(context) {
+    currentContext = context;
+}
+/**
+ * Gets the currently set global execution context.
+ * @returns The current execution context.
+ */
+export function getExecutionContext() {
+    return currentContext;
+}

package/dist/services/github.d.ts

@@ -5,14 +5,19 @@ interface GitHubUrlParts {
     ref?: string;
     repo: string;
 }
+export interface TemplateInfo {
+    id: string;
+    name: string;
+    description?: string;
+}
 export interface GitHubService {
     getTemplateDirectories(template: string, customUrl?: string): Promise<string[]>;
-    getTemplates(customUrl?: string): Promise<string[]>;
+    getTemplates(customUrl?: string): Promise<TemplateInfo[]>;
     parseGitHubUrl(url: string): GitHubUrlParts;
 }
 export declare function createGitHub(token?: string): {
     getTemplateDirectories: (template: string, customUrl?: string) => Promise<string[]>;
-    getTemplates: (customUrl?: string) => Promise<string[]>;
+    getTemplates: (customUrl?: string) => Promise<TemplateInfo[]>;
     parseGitHubUrl: typeof parseGitHubUrl;
 };
 export {};