@apso/cli 0.7.4 → 0.8.3

package/dist/lib/config/manager.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Configuration Manager
+ *
+ * Handles reading/writing configuration and credentials files
+ * with proper security measures.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBackup = exports.syncQueue = exports.projectLink = exports.credentials = exports.globalConfig = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const types_1 = require("./types");
+const paths_1 = require("./paths");
+// Get CLI version from package.json
+let cliVersion = "0.0.0";
+try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const pkg = require("../../../package.json");
+    cliVersion = pkg.version;
+}
+catch {
+    // Ignore if package.json not found
+}
+/**
+ * Read JSON file safely
+ */
+function readJsonFile(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        // eslint-disable-next-line unicorn/prefer-json-parse-buffer
+        const content = fs.readFileSync(filePath, "utf8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write JSON file with optional restrictive permissions
+ */
+function writeJsonFile(filePath, data, secure = false) {
+    const dir = path.dirname(filePath);
+    (0, paths_1.ensureDir)(dir);
+    const content = JSON.stringify(data, null, 2);
+    fs.writeFileSync(filePath, content, "utf-8");
+    // Set restrictive permissions for sensitive files on Unix
+    if (secure && process.platform !== "win32") {
+        try {
+            fs.chmodSync(filePath, 0o600);
+        }
+        catch {
+            // Ignore permission errors
+        }
+    }
+}
+/**
+ * Global Configuration Manager
+ */
+exports.globalConfig = {
+    /**
+     * Read global configuration, merging defaults and environment variables
+     */
+    read() {
+        (0, paths_1.ensureGlobalConfigDir)();
+        const fileConfig = readJsonFile((0, paths_1.getGlobalConfigPath)());
+        // Start with defaults
+        const config = { ...types_1.DEFAULT_GLOBAL_CONFIG };
+        // Merge file config
+        if (fileConfig) {
+            Object.assign(config, fileConfig);
+        }
+        // Override with environment variables
+        if (process.env.APSO_API_URL) {
+            config.apiUrl = process.env.APSO_API_URL;
+        }
+        if (process.env.APSO_WEB_URL) {
+            config.webUrl = process.env.APSO_WEB_URL;
+        }
+        if (process.env.APSO_DEBUG === "true" || process.env.APSO_DEBUG === "1") {
+            config.verbose = true;
+        }
+        if (process.env.APSO_NO_COLOR === "true" ||
+            process.env.APSO_NO_COLOR === "1" ||
+            process.env.NO_COLOR) {
+            config.noColor = true;
+        }
+        return config;
+    },
+    /**
+     * Write global configuration
+     */
+    write(config) {
+        (0, paths_1.ensureGlobalConfigDir)();
+        const existing = this.read();
+        const merged = { ...existing, ...config };
+        writeJsonFile((0, paths_1.getGlobalConfigPath)(), merged);
+    },
+    /**
+     * Get a specific configuration value
+     */
+    get(key) {
+        return this.read()[key];
+    },
+    /**
+     * Set a specific configuration value
+     */
+    set(key, value) {
+        this.write({ [key]: value });
+    },
+    /**
+     * Reset configuration to defaults
+     */
+    reset() {
+        writeJsonFile((0, paths_1.getGlobalConfigPath)(), types_1.DEFAULT_GLOBAL_CONFIG);
+    },
+};
+/**
+ * Credentials Manager
+ */
+exports.credentials = {
+    /**
+     * Read stored credentials
+     */
+    read() {
+        return readJsonFile((0, paths_1.getCredentialsPath)());
+    },
+    /**
+     * Write credentials (with secure file permissions)
+     */
+    write(creds) {
+        (0, paths_1.ensureGlobalConfigDir)();
+        const fullCreds = {
+            ...creds,
+            updatedAt: new Date().toISOString(),
+            cliVersion,
+        };
+        writeJsonFile((0, paths_1.getCredentialsPath)(), fullCreds, true);
+    },
+    /**
+     * Clear stored credentials
+     */
+    clear() {
+        const credsPath = (0, paths_1.getCredentialsPath)();
+        if (fs.existsSync(credsPath)) {
+            fs.unlinkSync(credsPath);
+        }
+    },
+    /**
+     * Check if credentials exist and are not expired
+     */
+    isValid() {
+        const creds = this.read();
+        if (!creds) {
+            return false;
+        }
+        // Check if access token is expired
+        const expiresAt = new Date(creds.tokens.expiresAt);
+        const now = new Date();
+        return expiresAt > now;
+    },
+    /**
+     * Check if credentials exist (may be expired)
+     */
+    exists() {
+        return this.read() !== null;
+    },
+    /**
+     * Check if token needs refresh (expires within 5 minutes)
+     */
+    needsRefresh() {
+        const creds = this.read();
+        if (!creds) {
+            return false;
+        }
+        const expiresAt = new Date(creds.tokens.expiresAt);
+        const fiveMinutesFromNow = new Date(Date.now() + 5 * 60 * 1000);
+        return expiresAt <= fiveMinutesFromNow;
+    },
+};
+/**
+ * Project Link Manager
+ */
+exports.projectLink = {
+    /**
+     * Read project link configuration
+     */
+    read(projectDir) {
+        return readJsonFile((0, paths_1.getProjectLinkPath)(projectDir));
+    },
+    /**
+     * Write project link configuration
+     */
+    write(link, projectDir) {
+        (0, paths_1.ensureProjectConfigDir)(projectDir);
+        writeJsonFile((0, paths_1.getProjectLinkPath)(projectDir), link);
+    },
+    /**
+     * Remove project link
+     */
+    remove(projectDir) {
+        const linkPath = (0, paths_1.getProjectLinkPath)(projectDir);
+        if (fs.existsSync(linkPath)) {
+            fs.unlinkSync(linkPath);
+        }
+    },
+    /**
+     * Check if project is linked
+     */
+    exists(projectDir) {
+        return this.read(projectDir) !== null;
+    },
+    /**
+     * Update sync metadata after successful sync
+     */
+    updateSyncMetadata(metadata, projectDir) {
+        const link = this.read(projectDir);
+        if (link) {
+            this.write({ ...link, ...metadata }, projectDir);
+        }
+    },
+};
+/**
+ * Sync Queue Manager
+ */
+exports.syncQueue = {
+    /**
+     * Read sync queue
+     */
+    read(projectDir) {
+        const queue = readJsonFile((0, paths_1.getSyncQueuePath)(projectDir));
+        return queue || { version: 1, operations: [] };
+    },
+    /**
+     * Write sync queue
+     */
+    write(queue, projectDir) {
+        (0, paths_1.ensureProjectConfigDir)(projectDir);
+        writeJsonFile((0, paths_1.getSyncQueuePath)(projectDir), queue);
+    },
+    /**
+     * Add operation to queue
+     */
+    add(operation, projectDir) {
+        const queue = this.read(projectDir);
+        const id = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const item = {
+            ...operation,
+            id,
+            queuedAt: new Date().toISOString(),
+            retryCount: 0,
+        };
+        queue.operations.push(item);
+        this.write(queue, projectDir);
+        return id;
+    },
+    /**
+     * Remove operation from queue
+     */
+    remove(id, projectDir) {
+        const queue = this.read(projectDir);
+        queue.operations = queue.operations.filter((op) => op.id !== id);
+        this.write(queue, projectDir);
+    },
+    /**
+     * Get pending operations count
+     */
+    count(projectDir) {
+        return this.read(projectDir).operations.length;
+    },
+    /**
+     * Clear all operations
+     */
+    clear(projectDir) {
+        this.write({ version: 1, operations: [] }, projectDir);
+    },
+    /**
+     * Update operation retry count and error
+     */
+    updateRetry(id, error, projectDir) {
+        const queue = this.read(projectDir);
+        const op = queue.operations.find((o) => o.id === id);
+        if (op) {
+            op.retryCount += 1;
+            op.lastError = error;
+            this.write(queue, projectDir);
+        }
+    },
+};
+/**
+ * Create a backup of a file
+ */
+function createBackup(filePath, projectDir) {
+    const backupsDir = (0, paths_1.getProjectBackupsDir)(projectDir);
+    (0, paths_1.ensureDir)(backupsDir);
+    const timestamp = new Date().toISOString().replace(/[.:]/g, "-");
+    const fileName = path.basename(filePath);
+    const backupPath = path.join(backupsDir, `${fileName}-${timestamp}`);
+    fs.copyFileSync(filePath, backupPath);
+    return backupPath;
+}
+exports.createBackup = createBackup;

package/dist/lib/config/paths.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Platform CLI Configuration Paths
+ *
+ * Manages file paths for global and project-level configuration.
+ */
+/**
+ * Get the global configuration directory (~/.apso/)
+ * Can be overridden with APSO_CONFIG_DIR environment variable
+ */
+export declare function getGlobalConfigDir(): string;
+/**
+ * Get path to global config file (~/.apso/config.json)
+ */
+export declare function getGlobalConfigPath(): string;
+/**
+ * Get path to credentials file (~/.apso/credentials.json)
+ */
+export declare function getCredentialsPath(): string;
+/**
+ * Get path to cache directory (~/.apso/cache/)
+ */
+export declare function getCacheDir(): string;
+/**
+ * Get project-level config directory (.apso/)
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+export declare function getProjectConfigDir(projectDir?: string): string;
+/**
+ * Get path to project link file (.apso/link.json)
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+export declare function getProjectLinkPath(projectDir?: string): string;
+/**
+ * Get path to sync queue file (.apso/sync-queue.json)
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+export declare function getSyncQueuePath(projectDir?: string): string;
+/**
+ * Get path to project backups directory (.apso/backups/)
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+export declare function getProjectBackupsDir(projectDir?: string): string;
+/**
+ * Ensure a directory exists, creating it if necessary
+ * @param dirPath - Path to the directory
+ */
+export declare function ensureDir(dirPath: string): void;
+/**
+ * Ensure the global config directory exists with correct permissions
+ */
+export declare function ensureGlobalConfigDir(): void;
+/**
+ * Ensure the project config directory exists
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+export declare function ensureProjectConfigDir(projectDir?: string): void;
+/**
+ * Check if a project is linked to the platform
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+export declare function isProjectLinked(projectDir?: string): boolean;
+/**
+ * Check if user is authenticated (credentials file exists)
+ */
+export declare function hasCredentials(): boolean;

package/dist/lib/config/paths.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Platform CLI Configuration Paths
+ *
+ * Manages file paths for global and project-level configuration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasCredentials = exports.isProjectLinked = exports.ensureProjectConfigDir = exports.ensureGlobalConfigDir = exports.ensureDir = exports.getProjectBackupsDir = exports.getSyncQueuePath = exports.getProjectLinkPath = exports.getProjectConfigDir = exports.getCacheDir = exports.getCredentialsPath = exports.getGlobalConfigPath = exports.getGlobalConfigDir = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const os = tslib_1.__importStar(require("os"));
+const fs = tslib_1.__importStar(require("fs"));
+/**
+ * Get the global configuration directory (~/.apso/)
+ * Can be overridden with APSO_CONFIG_DIR environment variable
+ */
+function getGlobalConfigDir() {
+    const envDir = process.env.APSO_CONFIG_DIR;
+    if (envDir) {
+        return envDir;
+    }
+    return path.join(os.homedir(), ".apso");
+}
+exports.getGlobalConfigDir = getGlobalConfigDir;
+/**
+ * Get path to global config file (~/.apso/config.json)
+ */
+function getGlobalConfigPath() {
+    return path.join(getGlobalConfigDir(), "config.json");
+}
+exports.getGlobalConfigPath = getGlobalConfigPath;
+/**
+ * Get path to credentials file (~/.apso/credentials.json)
+ */
+function getCredentialsPath() {
+    return path.join(getGlobalConfigDir(), "credentials.json");
+}
+exports.getCredentialsPath = getCredentialsPath;
+/**
+ * Get path to cache directory (~/.apso/cache/)
+ */
+function getCacheDir() {
+    return path.join(getGlobalConfigDir(), "cache");
+}
+exports.getCacheDir = getCacheDir;
+/**
+ * Get project-level config directory (.apso/)
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+function getProjectConfigDir(projectDir) {
+    return path.join(projectDir || process.cwd(), ".apso");
+}
+exports.getProjectConfigDir = getProjectConfigDir;
+/**
+ * Get path to project link file (.apso/link.json)
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+function getProjectLinkPath(projectDir) {
+    return path.join(getProjectConfigDir(projectDir), "link.json");
+}
+exports.getProjectLinkPath = getProjectLinkPath;
+/**
+ * Get path to sync queue file (.apso/sync-queue.json)
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+function getSyncQueuePath(projectDir) {
+    return path.join(getProjectConfigDir(projectDir), "sync-queue.json");
+}
+exports.getSyncQueuePath = getSyncQueuePath;
+/**
+ * Get path to project backups directory (.apso/backups/)
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+function getProjectBackupsDir(projectDir) {
+    return path.join(getProjectConfigDir(projectDir), "backups");
+}
+exports.getProjectBackupsDir = getProjectBackupsDir;
+/**
+ * Ensure a directory exists, creating it if necessary
+ * @param dirPath - Path to the directory
+ */
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+exports.ensureDir = ensureDir;
+/**
+ * Ensure the global config directory exists with correct permissions
+ */
+function ensureGlobalConfigDir() {
+    const configDir = getGlobalConfigDir();
+    ensureDir(configDir);
+    // Set restrictive permissions on Unix systems
+    if (process.platform !== "win32") {
+        try {
+            fs.chmodSync(configDir, 0o700);
+        }
+        catch {
+            // Ignore permission errors (e.g., on some CI systems)
+        }
+    }
+}
+exports.ensureGlobalConfigDir = ensureGlobalConfigDir;
+/**
+ * Ensure the project config directory exists
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+function ensureProjectConfigDir(projectDir) {
+    ensureDir(getProjectConfigDir(projectDir));
+}
+exports.ensureProjectConfigDir = ensureProjectConfigDir;
+/**
+ * Check if a project is linked to the platform
+ * @param projectDir - The project directory (defaults to cwd)
+ */
+function isProjectLinked(projectDir) {
+    return fs.existsSync(getProjectLinkPath(projectDir));
+}
+exports.isProjectLinked = isProjectLinked;
+/**
+ * Check if user is authenticated (credentials file exists)
+ */
+function hasCredentials() {
+    return fs.existsSync(getCredentialsPath());
+}
+exports.hasCredentials = hasCredentials;