@yamo/cli 1.3.12 → 1.3.14

package/dist/index.js

@@ -1,337 +1,72 @@
 #!/usr/bin/env node
 "use strict";
-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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const chalk_1 = __importDefault(require("chalk"));
-const crypto_1 = __importDefault(require("crypto"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const dotenv = __importStar(require("dotenv"));
 const core_1 = require("@yamo/core");
-const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '../package.json'), 'utf8'));
-dotenv.config();
-// Constants
-const CONSTANTS = {
-    HASH_PATTERN: /^0x[a-fA-F0-9]{64}$/,
-    GENESIS_HASH: "0x0000000000000000000000000000000000000000000000000000000000000000",
-    DEFAULT_FILENAME: "block.yamo",
-    DEFAULT_CONSENSUS: "cli_manual",
-    DEFAULT_LEDGER: "yamo_cli",
-    DEFAULT_INTENT: "execute_task",
-    HEX_PREFIX: "0x",
-    HASH_ALGORITHM: "sha256",
-};
+const config_js_1 = require("./utils/config.js");
+const constants_js_1 = require("./utils/constants.js");
+const hash_js_1 = require("./commands/hash.js");
+const init_js_1 = require("./commands/init.js");
+const submit_js_1 = require("./commands/submit.js");
+const audit_js_1 = require("./commands/audit.js");
+const download_bundle_js_1 = require("./commands/download-bundle.js");
+const config_js_2 = require("./commands/config.js");
+const bridge_js_1 = require("./commands/bridge.js");
 const program = new commander_1.Command();
-const ipfsManager = new core_1.IpfsManager();
-const chainClient = new core_1.YamoChainClient();
-// Hash utilities
-const hash = {
-    sha256: (content) => {
-        return crypto_1.default.createHash(CONSTANTS.HASH_ALGORITHM).update(content).digest("hex");
-    },
-    bytes32: (content) => {
-        return `${CONSTANTS.HEX_PREFIX}${hash.sha256(content)}`;
-    },
-};
-// Response formatting helpers
-const format = {
-    success: (msg) => console.log(chalk_1.default.green(msg)),
-    error: (msg) => console.error(chalk_1.default.red(`Error: ${msg}`)),
-    info: (msg) => console.log(chalk_1.default.blue(msg)),
-    warn: (msg) => console.log(chalk_1.default.yellow(msg)),
-    detail: (msg) => console.log(chalk_1.default.gray(msg)),
-    value: (msg) => console.log(chalk_1.default.cyan(msg)),
-};
-// Error handling helper
-function handleCommandError(error, context) {
-    if (error instanceof Error) {
-        const message = context ? `${context}: ${error.message}` : error.message;
-        format.error(message);
-    }
-    else {
-        format.error("Unknown error occurred");
-    }
-}
-// Validation helpers
-function validateBytes32(value, fieldName) {
-    if (!value.match(CONSTANTS.HASH_PATTERN)) {
-        throw new Error(`${fieldName} must be a valid bytes32 hash (0x + 64 hex chars). ` +
-            `Received: ${value.substring(0, 20)}...` +
-            `\nDo NOT include algorithm prefixes like "sha256:"`);
-    }
-}
-function validateBlockId(blockId) {
-    if (!blockId)
-        throw new Error("blockId is required");
-    const parts = blockId.split('_');
-    if (parts.length < 2) {
-        throw new Error(`blockId must follow format {origin}_{workflow} (e.g., 'claude_chain'). Received: ${blockId}`);
-    }
-}
-// Submit command helpers
-async function validateEncryptionKey(key) {
-    const { validatePasswordStrength } = await import("@yamo/core");
-    try {
-        validatePasswordStrength(key);
-    }
-    catch (e) {
-        format.error("Password validation failed:");
-        format.error(e.message);
-        format.warn("\nKey requirements:");
-        console.error("  • Minimum 12 characters");
-        console.error("  • Mix of uppercase, lowercase, numbers, symbols");
-        console.error("  • Avoid common patterns (password, 123456, qwerty)");
-        throw e;
-    }
-}
-function prepareIpfsFiles(content, file) {
-    const files = [{ name: CONSTANTS.DEFAULT_FILENAME, content }];
-    const outputMatch = content.match(/output:\s*([^;]+);/);
-    if (outputMatch) {
-        const artifactName = outputMatch[1].trim();
-        // Security: Check for path traversal patterns
-        if (artifactName.includes('..') || artifactName.startsWith('/')) {
-            throw new Error(`Invalid artifact name: ${artifactName} (path-like names are not allowed)`);
-        }
-        const artifactPath = path_1.default.join(path_1.default.dirname(file), artifactName);
-        const resolvedPath = path_1.default.resolve(artifactPath);
-        const inputDir = path_1.default.resolve(path_1.default.dirname(file));
-        if (!resolvedPath.startsWith(inputDir)) {
-            throw new Error(`Artifact path outside allowed directory: ${artifactName}`);
-        }
-        if (fs_1.default.existsSync(resolvedPath)) {
-            format.info(`Bundling output: ${artifactName}`);
-            files.push({ name: artifactName, content: fs_1.default.readFileSync(resolvedPath, "utf8") });
-        }
-    }
-    return files;
-}
-async function resolvePreviousBlock(prev) {
-    if (prev) {
-        validateBytes32(prev, "previousBlock");
-        return prev;
-    }
-    format.info("[INFO] No previousBlock provided, fetching latest block from chain...");
-    const latestHash = await chainClient.getLatestBlockHash();
-    if (latestHash && latestHash !== CONSTANTS.GENESIS_HASH) {
-        format.success(`[INFO] Using latest block's contentHash: ${latestHash}`);
-        return latestHash;
-    }
-    format.warn("[INFO] No existing blocks found, using genesis");
-    return CONSTANTS.GENESIS_HASH;
-}
 program
-    .name("yamo")
-    .description("YAMO Protocol CLI - Manage Agentic Reasoning Chains")
-    .version(pkg.version);
+    .name('yamo')
+    .description('YAMO CLI - Blockchain-anchored agent workflow system')
+    .version('1.3.14');
 program
-    .command("hash")
-    .description("Calculate the content hash of a YAMO block")
-    .argument("<file>", "Path to the YAMO file")
-    .action((file) => {
-    try {
-        const content = fs_1.default.readFileSync(file, "utf8").trim();
-        const contentHash = hash.bytes32(content);
-        format.success("Block Content Hash:");
-        format.value(contentHash);
-    }
-    catch (error) {
-        handleCommandError(error);
-    }
-});
+    .command('hash')
+    .description('Calculate SHA256 hash of a file')
+    .argument('<file>', 'Path to the file')
+    .action(hash_js_1.hashCommand);
 program
-    .command("init")
-    .description("Initialize a new YAMO block template")
-    .argument("<agent_name>", "Name of the agent")
-    .option("-i, --intent <intent>", "Agent intent", CONSTANTS.DEFAULT_INTENT)
-    .action((agent_name, options) => {
-    try {
-        const template = `
-agent: ${agent_name};
-intent: ${options.intent};
-context:
-  platform;yamo_v0.5;
-constraints:
-  - human_readable;true;
-priority: medium;
-output: result.json;
-meta: hypothesis;Initial hypothesis;
-meta: confidence;0.9;
-log: session_start;timestamp;${new Date().toISOString()};
-handoff: User;
-    `.trim();
-        fs_1.default.writeFileSync(CONSTANTS.DEFAULT_FILENAME, template);
-        format.success(`Created YAMO template: ${chalk_1.default.bold(CONSTANTS.DEFAULT_FILENAME)}`);
-    }
-    catch (error) {
-        handleCommandError(error);
-    }
-});
+    .command('init')
+    .description('Create a new YAMO block template')
+    .argument('<agent_name>', 'Name of the agent')
+    .option('--intent <intent>', 'Intent description', constants_js_1.CONSTANTS.DEFAULT_INTENT)
+    .action(init_js_1.initCommand);
 program
-    .command("submit")
-    .description("Submit a YAMO block to the blockchain")
-    .argument("<file>", "Path to the YAMO file")
-    .requiredOption("--id <blockId>", "Unique Block ID")
-    .option("--prev <previousBlock>", "Previous Block Hash (omits to auto-fetch from chain)")
-    .option("--consensus <type>", "Consensus Type", CONSTANTS.DEFAULT_CONSENSUS)
-    .option("--ledger <name>", "Ledger Name", CONSTANTS.DEFAULT_LEDGER)
-    .option("--ipfs", "Upload content to IPFS before submitting")
-    .option("-e, --encrypt", "Encrypt the bundle")
-    .option("-k, --key <key>", "Encryption key (or set YAMO_ENCRYPTION_KEY)")
-    .action(async (file, options) => {
-    try {
-        // Validate inputs
-        validateBlockId(options.id);
-        // Validate encryption key if needed
-        if (options.encrypt) {
-            const key = options.key || process.env.YAMO_ENCRYPTION_KEY;
-            if (!key) {
-                throw new Error("Encryption enabled but no key provided. Use --key or set YAMO_ENCRYPTION_KEY");
-            }
-            await validateEncryptionKey(key);
-        }
-        // Calculate content hash
-        const content = fs_1.default.readFileSync(file, "utf8").trim();
-        const contentHash = hash.bytes32(content);
-        format.info(`Calculated Hash: ${contentHash}`);
-        // Handle IPFS upload
-        let ipfsCID;
-        if (options.ipfs) {
-            const files = prepareIpfsFiles(content, file);
-            const encryptionKey = options.encrypt
-                ? (options.key || process.env.YAMO_ENCRYPTION_KEY)
-                : undefined;
-            if (encryptionKey) {
-                format.warn("🔒 Encrypting bundle...");
-            }
-            ipfsCID = await ipfsManager.upload({ content, files, encryptionKey });
-            format.info(`IPFS Bundle CID: ${ipfsCID}`);
-        }
-        // Resolve previous block
-        const resolvedPreviousBlock = await resolvePreviousBlock(options.prev);
-        // Submit to blockchain
-        await chainClient.submitBlock(options.id, resolvedPreviousBlock, contentHash, options.consensus, options.ledger, ipfsCID);
-    }
-    catch (error) {
-        handleCommandError(error);
-    }
+    .command('submit')
+    .description('Submit a YAMO block to the blockchain')
+    .argument('<file>', 'Path to the YAMO file')
+    .option('--id <blockId>', 'Unique Block ID (format: {origin}_{workflow})')
+    .option('--prev <previousBlock>', 'Previous block hash (auto-fetches if omitted)')
+    .option('--consensus <type>', 'Consensus mechanism', constants_js_1.CONSTANTS.DEFAULT_CONSENSUS)
+    .option('--ledger <name>', 'Ledger name', constants_js_1.CONSTANTS.DEFAULT_LEDGER)
+    .option('--ipfs', 'Upload content to IPFS', false)
+    .option('-e, --encrypt', 'Encrypt bundle before IPFS upload', false)
+    .option('-k, --key <key>', 'Encryption/decryption key')
+    .action((file, options) => {
+    const chainClient = new core_1.YamoChainClient(config_js_1.config.rpcUrl, config_js_1.config.privateKey, config_js_1.config.contractAddress);
+    const ipfsClient = new core_1.IpfsManager({ jwt: config_js_1.config.pinataJwt });
+    return (0, submit_js_1.submitCommand)(file, options, { chainClient, ipfsClient });
 });
 program
-    .command("audit")
-    .description("Audit a block's integrity (Chain vs IPFS)")
-    .argument("<blockId>", "Block ID to audit")
-    .option("-k, --key <key>", "Decryption key")
-    .action(async (blockId, options) => {
-    try {
-        format.info(`Auditing Block ${blockId}...`);
-        const block = await chainClient.getBlock(blockId);
-        if (!block) {
-            format.error("Block not found on-chain.");
-            return;
-        }
-        format.detail("Found on-chain record:");
-        console.log(`  Agent: ${block.agentAddress}`);
-        console.log(`  Hash:  ${block.contentHash}`);
-        console.log(`  IPFS:  ${block.ipfsCID || "None"}`);
-        if (!block.ipfsCID) {
-            format.warn("⚠️  No IPFS CID. Cannot perform deep content audit.");
-            return;
-        }
-        format.info("Fetching content from IPFS...");
-        const key = options.key || process.env.YAMO_ENCRYPTION_KEY;
-        const content = await ipfsManager.download(block.ipfsCID, key);
-        const calcHash = hash.bytes32(content);
-        console.log(`  Calculated: ${calcHash}`);
-        if (calcHash === block.contentHash) {
-            format.success("✅ INTEGRITY VERIFIED: Content matches chain hash.");
-        }
-        else {
-            format.error("❌ INTEGRITY FAILED: Hash mismatch!");
-            console.log(`  Expected: ${block.contentHash}`);
-            console.log(`  Got:      ${calcHash}`);
-        }
-    }
-    catch (error) {
-        handleCommandError(error);
-    }
+    .command('audit')
+    .description('Verify a block on the blockchain')
+    .argument('<blockId>', 'Block ID to audit')
+    .option('-k, --key <key>', 'Decryption key')
+    .action((blockId, options) => {
+    const chainClient = new core_1.YamoChainClient(config_js_1.config.rpcUrl, config_js_1.config.privateKey, config_js_1.config.contractAddress);
+    const ipfsClient = new core_1.IpfsManager({ jwt: config_js_1.config.pinataJwt });
+    return (0, audit_js_1.auditCommand)(blockId, options, { chainClient, ipfsClient });
 });
 program
-    .command("download-bundle")
-    .description("Download complete IPFS bundle including all artifacts")
-    .argument("<cid>", "IPFS CID to download")
-    .option("-k, --key <key>", "Decryption key (if encrypted)")
-    .option("-o, --output <dir>", "Output directory (default: ./bundle_<cid>)", "./bundle_<cid>")
-    .action(async (cid, options) => {
-    try {
-        format.info(`Downloading bundle ${cid}...`);
-        const { IpfsManager } = await import("@yamo/core");
-        const ipfs = new IpfsManager();
-        const key = options.key || process.env.YAMO_ENCRYPTION_KEY;
-        const bundle = await ipfs.downloadBundle(cid, key);
-        // Create output directory
-        const outputDir = options.output.replace("<cid>", cid.substring(0, 8));
-        if (!fs_1.default.existsSync(outputDir)) {
-            fs_1.default.mkdirSync(outputDir, { recursive: true });
-        }
-        // Write block.yamo
-        fs_1.default.writeFileSync(path_1.default.join(outputDir, CONSTANTS.DEFAULT_FILENAME), bundle.block);
-        format.success(`✓ Downloaded ${CONSTANTS.DEFAULT_FILENAME}`);
-        // Write metadata
-        if (bundle.metadata) {
-            fs_1.default.writeFileSync(path_1.default.join(outputDir, "metadata.json"), JSON.stringify(bundle.metadata, null, 2));
-            format.success("✓ Downloaded metadata.json");
-        }
-        // Write artifact files
-        for (const [filename, content] of Object.entries(bundle.files)) {
-            const filePath = path_1.default.join(outputDir, filename);
-            fs_1.default.writeFileSync(filePath, content);
-            format.success(`✓ Downloaded ${filename}`);
-        }
-        format.success(`\nBundle saved to: ${outputDir}`);
-        format.detail(`Files: ${1 + Object.keys(bundle.files).length} total`);
-        if (bundle.metadata?.hasEncryption) {
-            format.warn("🔒 Bundle was decrypted using provided key");
-        }
-    }
-    catch (error) {
-        handleCommandError(error);
-        format.detail("\nIf the bundle is encrypted, provide --key or set YAMO_ENCRYPTION_KEY");
-    }
-});
+    .command('config')
+    .description('Manage local configuration and secrets')
+    .argument('<action>', 'Action: set, get, list, remove')
+    .argument('[key]', 'Configuration key')
+    .argument('[value]', 'Configuration value')
+    .action(config_js_2.configCommand);
+program
+    .command('download-bundle')
+    .description('Download bundle from IPFS')
+    .argument('<cid>', 'IPFS content identifier')
+    .requiredOption('-o, --output <path>', 'Output file path')
+    .option('-k, --key <key>', 'Decryption key')
+    .action(download_bundle_js_1.downloadBundleCommand);
+program.addCommand((0, bridge_js_1.bridgeCommand)());
 program.parse();

package/dist/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/config.js

@@ -0,0 +1,67 @@
+"use strict";
+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.validateConfig = exports.config = void 0;
+const dotenv = __importStar(require("dotenv"));
+const storage_js_1 = require("./storage.js");
+// Load environment variables
+dotenv.config();
+/**
+ * Centralized configuration for YAMO CLI.
+ * Loads and types environment variables with local storage fallback.
+ */
+exports.config = {
+    rpcUrl: process.env.RPC_URL || storage_js_1.storage.get('RPC_URL') || 'http://127.0.0.1:8545',
+    privateKey: process.env.PRIVATE_KEY || storage_js_1.storage.get('PRIVATE_KEY'),
+    contractAddress: process.env.CONTRACT_ADDRESS || storage_js_1.storage.get('CONTRACT_ADDRESS'),
+    encryptionKey: process.env.YAMO_ENCRYPTION_KEY || storage_js_1.storage.get('YAMO_ENCRYPTION_KEY'),
+    pinataJwt: process.env.PINATA_JWT || storage_js_1.storage.get('PINATA_JWT'),
+    bridgeUrl: process.env.YAMO_BRIDGE_URL || storage_js_1.storage.get('YAMO_BRIDGE_URL'),
+};
+/**
+ * Validates that required configuration is present for specific operations.
+ */
+exports.validateConfig = {
+    /**
+     * Ensure encryption key is available
+     */
+    requireEncryptionKey: (providedKey) => {
+        const key = providedKey || exports.config.encryptionKey;
+        if (!key) {
+            throw new Error('Encryption enabled but no key provided. Use --key or set YAMO_ENCRYPTION_KEY');
+        }
+        return key;
+    }
+};

package/dist/utils/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONSTANTS = void 0;
+exports.CONSTANTS = {
+    HASH_PATTERN: /^0x[a-fA-F0-9]{64}$/,
+    GENESIS_HASH: '0x0000000000000000000000000000000000000000000000000000000000000000',
+    DEFAULT_FILENAME: 'block.yamo',
+    DEFAULT_CONSENSUS: 'cli_manual',
+    DEFAULT_LEDGER: 'yamo_cli',
+    DEFAULT_INTENT: 'execute_task',
+    HEX_PREFIX: '0x',
+    HASH_ALGORITHM: 'sha256',
+};

package/dist/utils/format.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = void 0;
+exports.handleCommandError = handleCommandError;
+const chalk_1 = __importDefault(require("chalk"));
+exports.format = {
+    success(msg) {
+        console.log(chalk_1.default.green(msg));
+    },
+    error(msg) {
+        console.error(chalk_1.default.red(`[ERROR] ${msg}`));
+    },
+    info(msg) {
+        console.log(chalk_1.default.blue(msg));
+    },
+    warn(msg) {
+        console.error(chalk_1.default.yellow(`[WARN] ${msg}`));
+    },
+    detail(msg) {
+        console.log(chalk_1.default.gray(msg));
+    },
+    value(msg) {
+        console.log(chalk_1.default.cyan(msg));
+    },
+};
+/**
+ * Handles command errors with consistent formatting.
+ * @param error - Error object or unknown value
+ * @param context - Optional context message
+ */
+function handleCommandError(error, context) {
+    if (error instanceof Error) {
+        const message = context ? `${context}: ${error.message}` : error.message;
+        exports.format.error(message);
+    }
+    else {
+        exports.format.error('Unknown error occurred');
+    }
+    process.exit(1);
+}

package/dist/utils/spinner.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpinner = createSpinner;
+exports.withSpinner = withSpinner;
+const ora_1 = __importDefault(require("ora"));
+/**
+ * Creates and starts a professional, emoji-free spinner.
+ * @param text - The text to display with the spinner
+ * @returns The spinner instance
+ */
+function createSpinner(text) {
+    return (0, ora_1.default)({
+        text,
+        color: 'blue',
+        spinner: 'dots',
+    }).start();
+}
+/**
+ * Wraps a promise with a spinner.
+ * @param promise - The promise to track
+ * @param text - The text to display
+ * @returns The result of the promise
+ */
+async function withSpinner(promise, text) {
+    const spinner = createSpinner(text);
+    try {
+        const result = await promise;
+        spinner.succeed(`[DONE] ${text}`);
+        return result;
+    }
+    catch (error) {
+        spinner.fail(`[FAILED] ${text}`);
+        throw error;
+    }
+}

package/dist/utils/storage.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storage = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_DIR = process.env.YAMO_CONFIG_DIR || path_1.default.join(os_1.default.homedir(), '.yamo');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+/**
+ * Handles persistent storage of local YAMO configuration.
+ */
+exports.storage = {
+    /**
+     * Ensures the config directory exists.
+     */
+    ensureDir() {
+        if (!fs_1.default.existsSync(CONFIG_DIR)) {
+            fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+        }
+    },
+    /**
+     * Reads the configuration file.
+     */
+    read() {
+        if (!fs_1.default.existsSync(CONFIG_FILE)) {
+            return {};
+        }
+        try {
+            const data = fs_1.default.readFileSync(CONFIG_FILE, 'utf8');
+            return JSON.parse(data);
+        }
+        catch {
+            return {};
+        }
+    },
+    /**
+     * Writes the configuration file.
+     */
+    write(config) {
+        this.ensureDir();
+        fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+    },
+    /**
+     * Sets a value in the configuration.
+     */
+    set(key, value) {
+        const configData = this.read();
+        configData[key] = value;
+        this.write(configData);
+    },
+    /**
+     * Gets a value from the configuration.
+     */
+    get(key) {
+        const configData = this.read();
+        return configData[key];
+    },
+    /**
+     * Removes a key from the configuration.
+     */
+    remove(key) {
+        const configData = this.read();
+        const remaining = Object.fromEntries(Object.entries(configData).filter(([k]) => k !== key));
+        this.write(remaining);
+    },
+};