directus-template-cli 0.6.0-beta.2 → 0.7.0-beta.10

package/dist/services/docker.js

@@ -0,0 +1,187 @@
+import { spinner } from '@clack/prompts';
+import { execa } from 'execa';
+import net from 'node:net';
+import { ux } from '@oclif/core';
+import catchError from '../lib/utils/catch-error.js';
+import { waitFor } from '../lib/utils/wait.js';
+/**
+ * Check if a port is in use and what's using it
+ * @param port The port to check
+ * @returns Object indicating if port is in use and what's using it
+ */
+async function checkPort(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', async (err) => {
+            if (err.code === 'EADDRINUSE') {
+                // Try to get information about what's using the port
+                try {
+                    const { stdout } = await execa('lsof', ['-i', `:${port}`]);
+                    const process = stdout.split('\n')[1]?.split(/\s+/)[0]; // Get process name
+                    resolve({ inUse: true, process });
+                }
+                catch {
+                    resolve({ inUse: true });
+                }
+            }
+            else {
+                resolve({ inUse: false });
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve({ inUse: false });
+        });
+        server.listen(port);
+    });
+}
+/**
+ * Check if required ports are available and warn if they're in use
+ * @returns Promise<void>
+ */
+async function checkRequiredPorts() {
+    const portsToCheck = [
+        { port: 8055, name: 'Directus API' },
+        { port: 5432, name: 'PostgreSQL' },
+    ];
+    let hasConflicts = false;
+    for (const { port, name } of portsToCheck) {
+        const status = await checkPort(port);
+        if (status.inUse) {
+            hasConflicts = true;
+            const process = status.process ? ` by ${status.process}` : '';
+            ux.warn(`Port ${port} (${name}) is already in use${process}`);
+        }
+    }
+    if (hasConflicts) {
+        ux.warn('Please stop any conflicting services before continuing.');
+        process.exit(1);
+    }
+}
+/**
+ * Check if Docker is installed and running
+ * @returns {Promise<DockerCheckResult>} Docker installation and running status
+ */
+async function checkDocker() {
+    try {
+        // Check if Docker is installed
+        const versionResult = await execa('docker', ['--version']);
+        const isInstalled = versionResult.exitCode === 0;
+        if (!isInstalled) {
+            return { installed: false, message: 'Docker is not installed. Please install Docker at https://docs.docker.com/get-started/get-docker/', running: false };
+        }
+        // Check if Docker daemon is running
+        const statusResult = await execa('docker', ['info']);
+        const isRunning = statusResult.exitCode === 0;
+        return {
+            installed: true,
+            message: 'Docker is installed and running.',
+            running: isRunning,
+        };
+    }
+    catch {
+        // If any command fails, Docker is either not installed or not running
+        return {
+            installed: false,
+            message: 'Docker is not running. Please start Docker and try again.',
+            running: false,
+        };
+    }
+}
+/**
+ * Start Docker containers using docker-compose
+ * @param {string} cwd - The current working directory
+ * @returns {Promise<void>} - Returns nothing
+ */
+async function startContainers(cwd) {
+    try {
+        // Check if required ports are available
+        await checkRequiredPorts();
+        const s = spinner();
+        s.start('Starting Docker containers');
+        return execa('docker-compose', ['up', '-d'], {
+            cwd,
+        }).then(() => {
+            s.stop('Docker containers running!');
+        });
+    }
+    catch (error) {
+        catchError(error, {
+            context: { cwd, function: 'startContainers' },
+            fatal: true,
+            logToFile: true,
+        });
+        throw error;
+    }
+}
+/**
+ * Stop Docker containers
+ * @param {string} cwd - The current working directory
+ * @returns {Promise<void>} - Returns nothing
+ */
+async function stopContainers(cwd) {
+    try {
+        return execa('docker-compose', ['down'], {
+            cwd,
+        }).then(() => { });
+    }
+    catch (error) {
+        catchError(error, {
+            context: { cwd, function: 'stopContainers' },
+            fatal: false,
+            logToFile: true,
+        });
+        throw error;
+    }
+}
+/**
+ * Wait for service health check to pass
+ * @param {DockerConfig} config - The Docker configuration
+ * @returns {Promise<boolean>} - Returns true if the service is healthy, false otherwise
+ */
+function createWaitForHealthy(config) {
+    async function waitForHealthy(healthCheckUrl) {
+        const s = spinner();
+        s.start('Waiting for Directus to be ready.');
+        try {
+            await waitFor(async () => {
+                try {
+                    const response = await fetch(healthCheckUrl);
+                    return response.ok;
+                }
+                catch {
+                    return false;
+                }
+            }, {
+                errorMessage: 'Service failed to become healthy',
+                interval: config.interval,
+                maxAttempts: config.maxAttempts,
+            });
+            s.stop('Directus is ready!');
+            return true;
+        }
+        catch (error) {
+            s.stop('');
+            catchError(error, {
+                context: { function: 'waitForHealthy', url: healthCheckUrl },
+                fatal: true,
+                logToFile: true,
+            });
+            return false;
+        }
+    }
+    return waitForHealthy;
+}
+/**
+ * Create a Docker service instance
+ * @param {DockerConfig} config - The Docker configuration
+ * @returns {DockerService} - Returns a Docker service instance
+ */
+export function createDocker(config) {
+    return {
+        checkDocker,
+        startContainers,
+        stopContainers,
+        waitForHealthy: createWaitForHealthy(config),
+    };
+}

package/dist/services/github.d.ts

@@ -0,0 +1,18 @@
+import { parseGitHubUrl } from '../lib/utils/parse-github-url.js';
+interface GitHubUrlParts {
+    owner: string;
+    path?: string;
+    ref?: string;
+    repo: string;
+}
+export interface GitHubService {
+    getTemplateDirectories(template: string, customUrl?: string): Promise<string[]>;
+    getTemplates(customUrl?: string): Promise<string[]>;
+    parseGitHubUrl(url: string): GitHubUrlParts;
+}
+export declare function createGitHub(token?: string): {
+    getTemplateDirectories: (template: string, customUrl?: string) => Promise<string[]>;
+    getTemplates: (customUrl?: string) => Promise<string[]>;
+    parseGitHubUrl: typeof parseGitHubUrl;
+};
+export {};

package/dist/services/github.js

@@ -0,0 +1,88 @@
+import { Octokit } from '@octokit/rest';
+import { DEFAULT_REPO } from '../lib/constants.js';
+import { parseGitHubUrl } from '../lib/utils/parse-github-url.js';
+export function createGitHub(token) {
+    const octokit = new Octokit({
+        auth: token,
+    });
+    /**
+     * Get the directories for a template.
+     * @param template - The template to get the directories for.
+     * @param customUrl - The custom URL to get the directories for.
+     * @returns The directories for the template.
+     */
+    async function getTemplateDirectories(template, customUrl) {
+        // If template is a URL, parse it directly
+        if (template.startsWith('http')) {
+            const repo = parseGitHubUrl(template);
+            try {
+                const { data } = await octokit.rest.repos.getContent({
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    path: repo.path || '',
+                    ref: repo.ref,
+                });
+                if (!Array.isArray(data))
+                    return [];
+                // For direct URLs, we don't filter out the directus directory
+                // as the entire repo might be a directus template
+                return data
+                    .filter(item => item.type === 'dir')
+                    .map(item => item.name);
+            }
+            catch (error) {
+                // If we can't get contents, return empty array
+                // This indicates no frontends are available
+                return [];
+            }
+        }
+        // Otherwise use default repo behavior
+        const repo = customUrl ? parseGitHubUrl(customUrl) : DEFAULT_REPO;
+        const templatePath = repo.path ? `${repo.path}/${template}` : template;
+        try {
+            const { data } = await octokit.rest.repos.getContent({
+                owner: repo.owner,
+                path: templatePath,
+                ref: repo.ref,
+                repo: repo.repo,
+            });
+            if (!Array.isArray(data))
+                return [];
+            return data
+                .filter(item => item.type === 'dir' && item.name !== 'directus')
+                .map(item => item.name);
+        }
+        catch (error) {
+            // If we can't get contents, return empty array
+            return [];
+        }
+    }
+    /**
+     * Get the templates for a repository.
+     * @param customUrl - The custom URL to get the templates for.
+     * @returns The templates for the repository.
+     */
+    async function getTemplates(customUrl) {
+        // If customUrl is provided and it's a full repository URL, return it as the only template
+        if (customUrl?.startsWith('http')) {
+            return [customUrl];
+        }
+        const repo = customUrl ? parseGitHubUrl(customUrl) : DEFAULT_REPO;
+        const { data } = await octokit.rest.repos.getContent({
+            owner: repo.owner,
+            path: repo.path || '',
+            ref: repo.ref,
+            repo: repo.repo,
+        });
+        if (!Array.isArray(data))
+            return [];
+        return data
+            .filter(item => item.type === 'dir')
+            .map(item => item.name);
+    }
+    return {
+        getTemplateDirectories,
+        getTemplates,
+        parseGitHubUrl,
+    };
+}

package/dist/services/posthog.d.ts

@@ -0,0 +1,37 @@
+import type { Config } from '@oclif/core';
+import { PostHog } from 'posthog-node';
+/**
+ * Initialize and get the PostHog client
+ * @param debug Whether to log debug information
+ * @returns The PostHog client
+ */
+export declare function getClient(debug?: boolean): PostHog;
+/**
+ * Shutdown the PostHog client
+ * @param debug Whether to log debug information
+ * @returns void
+ */
+export declare function shutdown(debug?: boolean): Promise<void>;
+/**
+ * Track an event in PostHog
+ * @param options The tracking options
+ * @param options.lifecycle The lifecycle event to track ('start', 'complete', 'error')
+ * @param options.distinctId The distinct ID for the user
+ * @param options.command Optional command name (for command tracking)
+ * @param options.flags Optional command flags
+ * @param options.runId Optional run ID
+ * @param options.config Optional config object
+ * @param options.properties Optional additional properties to track
+ * @param options.debug Whether to log debug information
+ */
+export declare function track({ lifecycle, distinctId, command, flags, runId, message, config, properties, debug }: {
+    lifecycle: 'start' | 'complete' | 'error';
+    message?: string;
+    distinctId: string;
+    command?: string;
+    flags?: Record<string, unknown>;
+    runId?: string;
+    config?: Config;
+    properties?: Record<string, unknown>;
+    debug?: boolean;
+}): void;

package/dist/services/posthog.js

@@ -0,0 +1,104 @@
+import { ux } from '@oclif/core';
+import { PostHog } from 'posthog-node';
+import { POSTHOG_PUBLIC_KEY, POSTHOG_HOST } from '../lib/constants.js';
+import { sanitizeFlags } from '../lib/utils/sanitize-flags.js';
+// Create a singleton client using module scope
+let client = null;
+/**
+ * Initialize and get the PostHog client
+ * @param debug Whether to log debug information
+ * @returns The PostHog client
+ */
+export function getClient(debug = false) {
+    if (debug)
+        ux.stdout('Initializing PostHog client...');
+    if (!client) {
+        client = new PostHog(POSTHOG_PUBLIC_KEY, {
+            host: POSTHOG_HOST,
+            disableGeoip: false,
+        });
+        // Add error handling
+        client.on('error', err => {
+            ux.warn(`PostHog Error: ${err}`);
+        });
+    }
+    if (debug)
+        ux.stdout('PostHog client initialized successfully');
+    return client;
+}
+/**
+ * Shutdown the PostHog client
+ * @param debug Whether to log debug information
+ * @returns void
+ */
+export async function shutdown(debug = false) {
+    if (debug)
+        ux.stdout('Shutting down PostHog client...');
+    if (!client)
+        return;
+    try {
+        await client.shutdown();
+        client = null;
+        if (debug)
+            ux.stdout('PostHog client shut down successfully');
+    }
+    catch (error) {
+        ux.warn(`Error shutting down PostHog client: ${error}`);
+    }
+}
+/**
+ * Track an event in PostHog
+ * @param options The tracking options
+ * @param options.lifecycle The lifecycle event to track ('start', 'complete', 'error')
+ * @param options.distinctId The distinct ID for the user
+ * @param options.command Optional command name (for command tracking)
+ * @param options.flags Optional command flags
+ * @param options.runId Optional run ID
+ * @param options.config Optional config object
+ * @param options.properties Optional additional properties to track
+ * @param options.debug Whether to log debug information
+ */
+export function track({ lifecycle, distinctId, command, flags, runId, message, config, properties = {}, debug = false }) {
+    if (debug)
+        ux.stdout('Tracking event...');
+    const phClient = getClient(debug);
+    const eventProperties = command
+        ? {
+            runId,
+            message,
+            ...properties,
+            ...getEnvironmentInfo(config),
+            // Always sanitize sensitive flags
+            ...sanitizeFlags(flags),
+        }
+        : properties;
+    if (debug) {
+        ux.stdout('Capturing event...');
+        ux.stdout(JSON.stringify(eventProperties));
+    }
+    phClient.capture({
+        distinctId,
+        event: `directus_template_cli.${command}.${lifecycle}`,
+        properties: eventProperties
+    });
+    if (debug)
+        ux.stdout('Event tracked successfully');
+}
+/**
+ * Get environment info
+ * @param config The config to get environment info from
+ * @returns The environment info
+ */
+function getEnvironmentInfo(config) {
+    return {
+        // PostHog properties
+        $os: process.platform,
+        $raw_user_agent: config?.userAgent || 'unknown',
+        // Custom properties
+        arch: process.arch || 'unknown',
+        nodeVersion: process.version,
+        platform: config?.platform || 'unknown',
+        shell: config?.shell || 'unknown',
+        version: config?.version || 'unknown',
+    };
+}

package/oclif.manifest.json

@@ -169,21 +169,39 @@
       "pluginType": "core",
       "strict": true,
       "enableJsonFlag": false,
-      "isESM": false,
+      "isESM": true,
       "relativePath": [
         "dist",
         "commands",
         "apply.js"
       ]
     },
+    "base": {
+      "aliases": [],
+      "args": {},
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "base",
+      "pluginAlias": "directus-template-cli",
+      "pluginName": "directus-template-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "base.js"
+      ]
+    },
     "extract": {
       "aliases": [],
       "args": {},
       "description": "Extract a template from a Directus instance.",
       "examples": [
         "$ directus-template-cli extract",
-        "$ directus-template-cli extract -p --templateName=\"My Template\" --templateLocation=\"./my-template\" --directusToken=\"admin-token-here\" --directusUrl=\"http://localhost:8055\"",
-        "$ directus-template-cli extract -p --templateName=\"My Template\" --templateLocation=\"./my-template\" --directusToken=\"admin-token-here\" --directusUrl=\"http://localhost:8055\" --excludeCollections=collection1,collection2"
+        "$ directus-template-cli extract -p --templateName=\"My Template\" --templateLocation=\"./my-template\" --directusToken=\"admin-token-here\" --directusUrl=\"http://localhost:8055\""
       ],
       "flags": {
         "directusToken": {
@@ -206,16 +224,6 @@
           "multiple": false,
           "type": "option"
         },
-        "excludeCollections": {
-          "char": "e",
-          "description": "Comma-separated list of collection names to exclude from extraction",
-          "name": "excludeCollections",
-          "required": false,
-          "delimiter": ",",
-          "hasDynamicHelp": false,
-          "multiple": true,
-          "type": "option"
-        },
         "programmatic": {
           "char": "p",
           "description": "Run in programmatic mode (non-interactive) for use cases such as CI/CD pipelines.",
@@ -224,14 +232,6 @@
           "allowNo": false,
           "type": "boolean"
         },
-        "skipFiles": {
-          "char": "f",
-          "description": "Skip extracting files and assets",
-          "name": "skipFiles",
-          "required": false,
-          "allowNo": false,
-          "type": "boolean"
-        },
         "templateLocation": {
           "dependsOn": [
             "programmatic"
@@ -291,13 +291,92 @@
       "pluginType": "core",
       "strict": true,
       "enableJsonFlag": false,
-      "isESM": false,
+      "isESM": true,
       "relativePath": [
         "dist",
         "commands",
         "extract.js"
       ]
+    },
+    "init": {
+      "aliases": [],
+      "args": {
+        "directory": {
+          "default": ".",
+          "description": "Directory to create the project in",
+          "name": "directory",
+          "required": false
+        }
+      },
+      "description": "Initialize a new Directus + Frontend monorepo using official or community starters.",
+      "examples": [
+        "$ directus-template-cli init",
+        "$ directus-template-cli init my-project",
+        "$ directus-template-cli init --frontend=nextjs --template=simple-cms",
+        "$ directus-template-cli init my-project --frontend=nextjs --template=simple-cms"
+      ],
+      "flags": {
+        "frontend": {
+          "description": "Frontend framework to use (e.g., nextjs, nuxt, astro)",
+          "name": "frontend",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "gitInit": {
+          "aliases": [
+            "git-init"
+          ],
+          "description": "Initialize a new Git repository",
+          "name": "gitInit",
+          "allowNo": true,
+          "type": "boolean"
+        },
+        "installDeps": {
+          "aliases": [
+            "install-deps"
+          ],
+          "description": "Install dependencies automatically",
+          "name": "installDeps",
+          "allowNo": true,
+          "type": "boolean"
+        },
+        "overrideDir": {
+          "description": "Override the default directory",
+          "name": "overrideDir",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "template": {
+          "description": "Template name (e.g., simple-cms) or GitHub URL (e.g., https://github.com/directus-labs/starters/tree/main/simple-cms)",
+          "name": "template",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "disableTelemetry": {
+          "description": "Disable telemetry",
+          "env": "DISABLE_TELEMETRY",
+          "name": "disableTelemetry",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "init",
+      "pluginAlias": "directus-template-cli",
+      "pluginName": "directus-template-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "init.js"
+      ]
     }
   },
-  "version": "0.6.0-beta.2"
+  "version": "0.7.0-beta.10"
 }