@local-labs-jpollock/local-cli 0.0.1

package/lib/bootstrap/paths.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Platform-specific paths for Local
+ *
+ * The CLI talks directly to Local's GraphQL server - no addon required for basic operations.
+ * The addon extends GraphQL with additional operations (backups, WPE sync, etc.)
+ */
+export interface LocalPaths {
+    /** Local application data directory */
+    dataDir: string;
+    /** Addons installation directory */
+    addonsDir: string;
+    /** enabled-addons.json file path */
+    enabledAddonsFile: string;
+    /** GraphQL connection info file path (Local's native GraphQL server) */
+    graphqlConnectionInfoFile: string;
+    /** Local application executable path */
+    appExecutable: string;
+    /** Local application name (for process detection) */
+    appName: string;
+}
+/**
+ * Get platform-specific paths for Local
+ */
+export declare function getLocalPaths(): LocalPaths;
+/**
+ * Get the addon package name
+ */
+export declare const ADDON_PACKAGE_NAME = "@local-labs-jpollock/local-addon-cli";

package/lib/bootstrap/paths.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Platform-specific paths for Local
+ *
+ * The CLI talks directly to Local's GraphQL server - no addon required for basic operations.
+ * The addon extends GraphQL with additional operations (backups, WPE sync, etc.)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADDON_PACKAGE_NAME = void 0;
+exports.getLocalPaths = getLocalPaths;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Get platform-specific paths for Local
+ */
+function getLocalPaths() {
+    const platform = process.platform;
+    const home = os.homedir();
+    switch (platform) {
+        case 'darwin': {
+            const dataDir = path.join(home, 'Library', 'Application Support', 'Local');
+            return {
+                dataDir,
+                addonsDir: path.join(dataDir, 'addons'),
+                enabledAddonsFile: path.join(dataDir, 'enabled-addons.json'),
+                graphqlConnectionInfoFile: path.join(dataDir, 'graphql-connection-info.json'),
+                appExecutable: '/Applications/Local.app',
+                appName: 'Local',
+            };
+        }
+        case 'win32': {
+            const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+            const dataDir = path.join(appData, 'Local');
+            const programFiles = process.env['ProgramFiles'] || 'C:\\Program Files';
+            return {
+                dataDir,
+                addonsDir: path.join(dataDir, 'addons'),
+                enabledAddonsFile: path.join(dataDir, 'enabled-addons.json'),
+                graphqlConnectionInfoFile: path.join(dataDir, 'graphql-connection-info.json'),
+                appExecutable: path.join(programFiles, 'Local', 'Local.exe'),
+                appName: 'Local.exe',
+            };
+        }
+        case 'linux': {
+            const dataDir = path.join(home, '.config', 'Local');
+            return {
+                dataDir,
+                addonsDir: path.join(dataDir, 'addons'),
+                enabledAddonsFile: path.join(dataDir, 'enabled-addons.json'),
+                graphqlConnectionInfoFile: path.join(dataDir, 'graphql-connection-info.json'),
+                appExecutable: '/opt/Local/local',
+                appName: 'local',
+            };
+        }
+        default:
+            throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+/**
+ * Get the addon package name
+ */
+exports.ADDON_PACKAGE_NAME = '@local-labs-jpollock/local-addon-cli';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/client/GraphQLClient.d.ts

@@ -0,0 +1,38 @@
+/**
+ * GraphQL Client
+ *
+ * Simple GraphQL client for communicating with Local's GraphQL server.
+ */
+import { ConnectionInfo } from '../bootstrap';
+export interface GraphQLError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: string[];
+}
+export interface GraphQLResponse<T = unknown> {
+    data?: T;
+    errors?: GraphQLError[];
+}
+export declare class GraphQLClientError extends Error {
+    errors?: GraphQLError[] | undefined;
+    constructor(message: string, errors?: GraphQLError[] | undefined);
+}
+export declare class GraphQLClient {
+    private url;
+    private authToken;
+    private timeout;
+    constructor(connectionInfo: ConnectionInfo, options?: {
+        timeout?: number;
+    });
+    /**
+     * Execute a GraphQL query or mutation
+     */
+    query<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T>;
+    /**
+     * Execute a mutation (alias for query, for clarity)
+     */
+    mutate<T = unknown>(mutation: string, variables?: Record<string, unknown>): Promise<T>;
+}

package/lib/client/GraphQLClient.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * GraphQL Client
+ *
+ * Simple GraphQL client for communicating with Local's GraphQL server.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLClient = exports.GraphQLClientError = void 0;
+class GraphQLClientError extends Error {
+    constructor(message, errors) {
+        super(message);
+        this.errors = errors;
+        this.name = 'GraphQLClientError';
+    }
+}
+exports.GraphQLClientError = GraphQLClientError;
+class GraphQLClient {
+    constructor(connectionInfo, options = {}) {
+        this.url = connectionInfo.url;
+        this.authToken = connectionInfo.authToken;
+        this.timeout = options.timeout || 30000;
+    }
+    /**
+     * Execute a GraphQL query or mutation
+     */
+    async query(query, variables = {}) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(this.url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.authToken}`,
+                },
+                body: JSON.stringify({ query, variables }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new GraphQLClientError(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const result = (await response.json());
+            if (result.errors && result.errors.length > 0) {
+                throw new GraphQLClientError(result.errors[0].message, result.errors);
+            }
+            if (!result.data) {
+                throw new GraphQLClientError('No data in response');
+            }
+            return result.data;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                throw new GraphQLClientError('Request timed out');
+            }
+            if (error instanceof GraphQLClientError) {
+                throw error;
+            }
+            throw new GraphQLClientError(error.message);
+        }
+    }
+    /**
+     * Execute a mutation (alias for query, for clarity)
+     */
+    async mutate(mutation, variables = {}) {
+        return this.query(mutation, variables);
+    }
+}
+exports.GraphQLClient = GraphQLClient;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/client/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Client exports
+ */
+export { GraphQLClient, GraphQLClientError, GraphQLError } from './GraphQLClient';

package/lib/client/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Client exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLClientError = exports.GraphQLClient = void 0;
+var GraphQLClient_1 = require("./GraphQLClient");
+Object.defineProperty(exports, "GraphQLClient", { enumerable: true, get: function () { return GraphQLClient_1.GraphQLClient; } });
+Object.defineProperty(exports, "GraphQLClientError", { enumerable: true, get: function () { return GraphQLClient_1.GraphQLClientError; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpZW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7R0FFRzs7O0FBRUgsaURBQWtGO0FBQXpFLDhHQUFBLGFBQWEsT0FBQTtBQUFFLG1IQUFBLGtCQUFrQixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDbGllbnQgZXhwb3J0c1xuICovXG5cbmV4cG9ydCB7IEdyYXBoUUxDbGllbnQsIEdyYXBoUUxDbGllbnRFcnJvciwgR3JhcGhRTEVycm9yIH0gZnJvbSAnLi9HcmFwaFFMQ2xpZW50JztcbiJdfQ==

package/lib/formatters/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Output Formatters
+ *
+ * Format command output for different modes:
+ * - table: Human-readable ASCII tables (default)
+ * - json: JSON output for scripting
+ * - quiet: Minimal output (IDs/names only)
+ */
+export type OutputFormat = 'table' | 'json' | 'quiet';
+export interface FormatterOptions {
+    json?: boolean;
+    quiet?: boolean;
+    noColor?: boolean;
+}
+/**
+ * Get the output format from CLI options
+ */
+export declare function getOutputFormat(options: FormatterOptions): OutputFormat;
+/**
+ * Format data as a table
+ */
+export declare function formatTable(headers: string[], rows: string[][], options?: {
+    noColor?: boolean;
+}): string;
+/**
+ * Format data as JSON
+ */
+export declare function formatJson(data: unknown): string;
+/**
+ * Format data as quiet output (one item per line)
+ */
+export declare function formatQuiet(items: string[]): string;
+/**
+ * Format a success message
+ */
+export declare function formatSuccess(message: string, options?: {
+    noColor?: boolean;
+}): string;
+/**
+ * Format an error message
+ */
+export declare function formatError(message: string, options?: {
+    noColor?: boolean;
+}): string;
+/**
+ * Format a warning message
+ */
+export declare function formatWarning(message: string, options?: {
+    noColor?: boolean;
+}): string;
+/**
+ * Format a status badge
+ */
+export declare function formatStatus(status: 'running' | 'stopped' | 'error' | string, options?: {
+    noColor?: boolean;
+}): string;
+/**
+ * Site formatter for list command
+ */
+export interface SiteInfo {
+    id: string;
+    name: string;
+    domain: string;
+    status: string;
+    path?: string;
+}
+export declare function formatSiteList(sites: SiteInfo[], format: OutputFormat, options?: {
+    noColor?: boolean;
+}): string;
+/**
+ * Site detail formatter
+ */
+export declare function formatSiteDetail(site: Record<string, unknown>, format: OutputFormat, options?: {
+    noColor?: boolean;
+}): string;

package/lib/formatters/index.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Output Formatters
+ *
+ * Format command output for different modes:
+ * - table: Human-readable ASCII tables (default)
+ * - json: JSON output for scripting
+ * - quiet: Minimal output (IDs/names only)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOutputFormat = getOutputFormat;
+exports.formatTable = formatTable;
+exports.formatJson = formatJson;
+exports.formatQuiet = formatQuiet;
+exports.formatSuccess = formatSuccess;
+exports.formatError = formatError;
+exports.formatWarning = formatWarning;
+exports.formatStatus = formatStatus;
+exports.formatSiteList = formatSiteList;
+exports.formatSiteDetail = formatSiteDetail;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Get the output format from CLI options
+ */
+function getOutputFormat(options) {
+    if (options.json)
+        return 'json';
+    if (options.quiet)
+        return 'quiet';
+    return 'table';
+}
+/**
+ * Format data as a table
+ */
+function formatTable(headers, rows, options = {}) {
+    const table = new cli_table3_1.default({
+        head: options.noColor ? headers : headers.map((h) => chalk_1.default.bold(h)),
+        style: {
+            head: options.noColor ? [] : ['cyan'],
+            border: options.noColor ? [] : ['grey'],
+        },
+    });
+    rows.forEach((row) => table.push(row));
+    return table.toString();
+}
+/**
+ * Format data as JSON
+ */
+function formatJson(data) {
+    return JSON.stringify(data, null, 2);
+}
+/**
+ * Format data as quiet output (one item per line)
+ */
+function formatQuiet(items) {
+    return items.join('\n');
+}
+/**
+ * Format a success message
+ */
+function formatSuccess(message, options = {}) {
+    if (options.noColor) {
+        return `✓ ${message}`;
+    }
+    return chalk_1.default.green(`✓ ${message}`);
+}
+/**
+ * Format an error message
+ */
+function formatError(message, options = {}) {
+    if (options.noColor) {
+        return `✗ ${message}`;
+    }
+    return chalk_1.default.red(`✗ ${message}`);
+}
+/**
+ * Format a warning message
+ */
+function formatWarning(message, options = {}) {
+    if (options.noColor) {
+        return `⚠ ${message}`;
+    }
+    return chalk_1.default.yellow(`⚠ ${message}`);
+}
+/**
+ * Format a status badge
+ */
+function formatStatus(status, options = {}) {
+    if (options.noColor) {
+        return status;
+    }
+    switch (status) {
+        case 'running':
+            return chalk_1.default.green(status);
+        case 'stopped':
+            return chalk_1.default.gray(status);
+        case 'error':
+            return chalk_1.default.red(status);
+        default:
+            return status;
+    }
+}
+function formatSiteList(sites, format, options = {}) {
+    switch (format) {
+        case 'json':
+            return formatJson(sites);
+        case 'quiet':
+            return formatQuiet(sites.map((s) => s.name));
+        case 'table':
+        default:
+            if (sites.length === 0) {
+                return 'No sites found.';
+            }
+            return formatTable(['Name', 'Domain', 'Status'], sites.map((s) => [s.name, s.domain, formatStatus(s.status, options)]), options);
+    }
+}
+/**
+ * Site detail formatter
+ */
+function formatSiteDetail(site, format, options = {}) {
+    switch (format) {
+        case 'json':
+            return formatJson(site);
+        case 'quiet':
+            return String(site.name || site.id);
+        case 'table':
+        default:
+            const rows = Object.entries(site).map(([key, value]) => [
+                key,
+                typeof value === 'object' ? JSON.stringify(value) : String(value),
+            ]);
+            return formatTable(['Property', 'Value'], rows, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/formatters/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Output Formatters\n *\n * Format command output for different modes:\n * - table: Human-readable ASCII tables (default)\n * - json: JSON output for scripting\n * - quiet: Minimal output (IDs/names only)\n */\n\nimport Table from 'cli-table3';\nimport chalk from 'chalk';\n\nexport type OutputFormat = 'table' | 'json' | 'quiet';\n\nexport interface FormatterOptions {\n  json?: boolean;\n  quiet?: boolean;\n  noColor?: boolean;\n}\n\n/**\n * Get the output format from CLI options\n */\nexport function getOutputFormat(options: FormatterOptions): OutputFormat {\n  if (options.json) return 'json';\n  if (options.quiet) return 'quiet';\n  return 'table';\n}\n\n/**\n * Format data as a table\n */\nexport function formatTable(\n  headers: string[],\n  rows: string[][],\n  options: { noColor?: boolean } = {}\n): string {\n  const table = new Table({\n    head: options.noColor ? headers : headers.map((h) => chalk.bold(h)),\n    style: {\n      head: options.noColor ? [] : ['cyan'],\n      border: options.noColor ? [] : ['grey'],\n    },\n  });\n\n  rows.forEach((row) => table.push(row));\n\n  return table.toString();\n}\n\n/**\n * Format data as JSON\n */\nexport function formatJson(data: unknown): string {\n  return JSON.stringify(data, null, 2);\n}\n\n/**\n * Format data as quiet output (one item per line)\n */\nexport function formatQuiet(items: string[]): string {\n  return items.join('\\n');\n}\n\n/**\n * Format a success message\n */\nexport function formatSuccess(message: string, options: { noColor?: boolean } = {}): string {\n  if (options.noColor) {\n    return `✓ ${message}`;\n  }\n  return chalk.green(`✓ ${message}`);\n}\n\n/**\n * Format an error message\n */\nexport function formatError(message: string, options: { noColor?: boolean } = {}): string {\n  if (options.noColor) {\n    return `✗ ${message}`;\n  }\n  return chalk.red(`✗ ${message}`);\n}\n\n/**\n * Format a warning message\n */\nexport function formatWarning(message: string, options: { noColor?: boolean } = {}): string {\n  if (options.noColor) {\n    return `⚠ ${message}`;\n  }\n  return chalk.yellow(`⚠ ${message}`);\n}\n\n/**\n * Format a status badge\n */\nexport function formatStatus(\n  status: 'running' | 'stopped' | 'error' | string,\n  options: { noColor?: boolean } = {}\n): string {\n  if (options.noColor) {\n    return status;\n  }\n\n  switch (status) {\n    case 'running':\n      return chalk.green(status);\n    case 'stopped':\n      return chalk.gray(status);\n    case 'error':\n      return chalk.red(status);\n    default:\n      return status;\n  }\n}\n\n/**\n * Site formatter for list command\n */\nexport interface SiteInfo {\n  id: string;\n  name: string;\n  domain: string;\n  status: string;\n  path?: string;\n}\n\nexport function formatSiteList(\n  sites: SiteInfo[],\n  format: OutputFormat,\n  options: { noColor?: boolean } = {}\n): string {\n  switch (format) {\n    case 'json':\n      return formatJson(sites);\n\n    case 'quiet':\n      return formatQuiet(sites.map((s) => s.name));\n\n    case 'table':\n    default:\n      if (sites.length === 0) {\n        return 'No sites found.';\n      }\n\n      return formatTable(\n        ['Name', 'Domain', 'Status'],\n        sites.map((s) => [s.name, s.domain, formatStatus(s.status, options)]),\n        options\n      );\n  }\n}\n\n/**\n * Site detail formatter\n */\nexport function formatSiteDetail(\n  site: Record<string, unknown>,\n  format: OutputFormat,\n  options: { noColor?: boolean } = {}\n): string {\n  switch (format) {\n    case 'json':\n      return formatJson(site);\n\n    case 'quiet':\n      return String(site.name || site.id);\n\n    case 'table':\n    default:\n      const rows = Object.entries(site).map(([key, value]) => [\n        key,\n        typeof value === 'object' ? JSON.stringify(value) : String(value),\n      ]);\n\n      return formatTable(['Property', 'Value'], rows, options);\n  }\n}\n"]}

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Local CLI (lwp)
+ *
+ * Command-line interface for managing Local WordPress sites.
+ * Connects directly to Local's GraphQL server.
+ */
+export {};