aranea-sdk-cli 0.1.4 → 0.3.0

package/dist/commands/schema.js

@@ -6,7 +6,44 @@
  *   aranea-sdk schema get --type "aranea_ar-is04a"
  *   aranea-sdk schema list
  *   aranea-sdk schema validate --type "aranea_ar-is04a" --file state.json
+ *   aranea-sdk schema validate-schema --file schema.json
+ *   aranea-sdk schema push --file schema.json [--token TOKEN]
+ *   aranea-sdk schema promote --type "aranea_ar-is04a" [--token TOKEN]
+ *   aranea-sdk schema info --type "aranea_ar-is04a"
  */
+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 };
 };
@@ -16,6 +53,8 @@ const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 // API Configuration
 const SCHEMA_API_BASE = 'https://asia-northeast1-mobesorder.cloudfunctions.net/araneaSchemaAPI';
 // API Functions
@@ -348,3 +387,410 @@ exports.schemaCommand
         process.exit(1);
     }
 });
+// Helper: Get auth token from options or environment
+function getAuthToken(options) {
+    return options.token || process.env.ARANEA_AUTH_TOKEN || process.env.FIREBASE_AUTH_TOKEN || null;
+}
+// Helper: Validate schema file structure
+function validateSchemaStructure(schema) {
+    const errors = [];
+    // Required top-level fields
+    const requiredFields = ['type', 'stateSchema'];
+    for (const field of requiredFields) {
+        if (!schema[field]) {
+            errors.push(`Missing required field: ${field}`);
+        }
+    }
+    // Type validation
+    if (schema.type && typeof schema.type !== 'string') {
+        errors.push('Field "type" must be a string');
+    }
+    // ProductType validation
+    if (schema.productType && !/^\d{3}$/.test(schema.productType)) {
+        errors.push('Field "productType" must be a 3-digit string (e.g., "001")');
+    }
+    // stateSchema validation
+    if (schema.stateSchema) {
+        if (typeof schema.stateSchema !== 'object') {
+            errors.push('Field "stateSchema" must be an object');
+        }
+        else if (schema.stateSchema.type !== 'object') {
+            errors.push('Field "stateSchema.type" must be "object"');
+        }
+    }
+    // configSchema validation (optional but if present, must be object)
+    if (schema.configSchema && typeof schema.configSchema !== 'object') {
+        errors.push('Field "configSchema" must be an object');
+    }
+    // commandSchema validation (optional but if present, must be object)
+    if (schema.commandSchema && typeof schema.commandSchema !== 'object') {
+        errors.push('Field "commandSchema" must be an object');
+    }
+    // capabilities validation (optional but if present, must be array)
+    if (schema.capabilities && !Array.isArray(schema.capabilities)) {
+        errors.push('Field "capabilities" must be an array');
+    }
+    // features validation (optional but if present, must be array)
+    if (schema.features && !Array.isArray(schema.features)) {
+        errors.push('Field "features" must be an array');
+    }
+    return { valid: errors.length === 0, errors };
+}
+// schema validate-schema - validate a schema definition file
+exports.schemaCommand
+    .command('validate-schema')
+    .description('Validate a schema definition JSON file (static validation)')
+    .requiredOption('-f, --file <path>', 'Schema JSON file path')
+    .action(async (options) => {
+    const spinner = (0, ora_1.default)('Validating schema file...').start();
+    try {
+        const filePath = path.resolve(options.file);
+        if (!fs.existsSync(filePath)) {
+            spinner.fail(`File not found: ${filePath}`);
+            process.exit(1);
+        }
+        const fileContent = fs.readFileSync(filePath, 'utf-8');
+        let schema;
+        try {
+            schema = JSON.parse(fileContent);
+        }
+        catch (parseError) {
+            spinner.fail(`Invalid JSON: ${parseError.message}`);
+            process.exit(1);
+        }
+        const { valid, errors } = validateSchemaStructure(schema);
+        spinner.stop();
+        console.log(chalk_1.default.bold('\n=== Schema File Validation ===\n'));
+        console.log(`File: ${filePath}`);
+        console.log(`Type: ${schema.type || '(not specified)'}`);
+        console.log('');
+        if (valid) {
+            console.log(chalk_1.default.green('✓ Schema structure is valid'));
+            console.log('');
+            // Show summary
+            console.log(chalk_1.default.bold('Schema Summary:'));
+            console.log(`  Type: ${schema.type}`);
+            console.log(`  DisplayName: ${schema.displayName || '(not specified)'}`);
+            console.log(`  ProductType: ${schema.productType || '(not specified)'}`);
+            const stateFields = Object.keys(schema.stateSchema?.properties || {});
+            console.log(`  State Fields: ${stateFields.length} (${stateFields.join(', ') || 'none'})`);
+            const configFields = Object.keys(schema.configSchema?.properties || {});
+            console.log(`  Config Fields: ${configFields.length} (${configFields.join(', ') || 'none'})`);
+            const cmdFields = Object.keys(schema.commandSchema?.properties || {});
+            console.log(`  Command Fields: ${cmdFields.length} (${cmdFields.join(', ') || 'none'})`);
+            console.log('');
+            console.log(chalk_1.default.cyan('Ready to push with: aranea-sdk schema push --file ' + options.file));
+        }
+        else {
+            console.log(chalk_1.default.red('✗ Schema validation failed'));
+            console.log('');
+            console.log(chalk_1.default.red('Errors:'));
+            errors.forEach((err) => {
+                console.log(chalk_1.default.red(`  - ${err}`));
+            });
+        }
+        console.log('');
+        if (!valid) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(`Validation error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// schema push - push a schema to development state
+exports.schemaCommand
+    .command('push')
+    .description('Push a schema to Firestore (development state)')
+    .requiredOption('-f, --file <path>', 'Schema JSON file path')
+    .option('-t, --token <token>', 'Firebase Auth ID token')
+    .option('-d, --dry-run', 'Show what would be pushed without actually pushing')
+    .action(async (options) => {
+    const spinner = (0, ora_1.default)('Preparing schema push...').start();
+    try {
+        const filePath = path.resolve(options.file);
+        if (!fs.existsSync(filePath)) {
+            spinner.fail(`File not found: ${filePath}`);
+            process.exit(1);
+        }
+        const fileContent = fs.readFileSync(filePath, 'utf-8');
+        let schema;
+        try {
+            schema = JSON.parse(fileContent);
+        }
+        catch (parseError) {
+            spinner.fail(`Invalid JSON: ${parseError.message}`);
+            process.exit(1);
+        }
+        // Validate schema structure
+        const { valid, errors } = validateSchemaStructure(schema);
+        if (!valid) {
+            spinner.fail('Schema validation failed');
+            console.log('');
+            errors.forEach((err) => console.log(chalk_1.default.red(`  - ${err}`)));
+            process.exit(1);
+        }
+        const token = getAuthToken(options);
+        if (!token && !options.dryRun) {
+            spinner.fail('Authentication required');
+            console.log('');
+            console.log(chalk_1.default.yellow('Provide a token using one of:'));
+            console.log('  --token <TOKEN>');
+            console.log('  export ARANEA_AUTH_TOKEN=<TOKEN>');
+            console.log('  export FIREBASE_AUTH_TOKEN=<TOKEN>');
+            console.log('');
+            console.log(chalk_1.default.gray('Or use --dry-run to see what would be pushed'));
+            process.exit(1);
+        }
+        spinner.text = `Pushing schema: ${schema.type}...`;
+        // Prepare the document data
+        const now = new Date().toISOString();
+        const docData = {
+            type: schema.type,
+            displayName: schema.displayName || schema.type,
+            description: schema.description || '',
+            productType: schema.productType || '',
+            productCodes: schema.productCodes || [],
+            capabilities: schema.capabilities || [],
+            features: schema.features || [],
+            semanticTags: schema.semanticTags || [],
+            stateSchema: schema.stateSchema || {},
+            configSchema: schema.configSchema || {},
+            commandSchema: schema.commandSchema,
+            version: schema.version || 1,
+            state: 'development', // Always push to development
+            revisionNumber: 1, // Will be incremented if already exists
+            updatedAt: now,
+            updatedBy: 'cli',
+        };
+        if (options.dryRun) {
+            spinner.stop();
+            console.log(chalk_1.default.bold('\n=== Dry Run: Schema Push ===\n'));
+            console.log(chalk_1.default.yellow('Would push the following schema:'));
+            console.log('');
+            console.log(`  Target: araneaSDK/typeSettings/schemas/${schema.type}`);
+            console.log(`  State: ${chalk_1.default.cyan('development')}`);
+            console.log('');
+            console.log('Document Data:');
+            console.log(chalk_1.default.gray(JSON.stringify(docData, null, 2)));
+            console.log('');
+            console.log(chalk_1.default.gray('Remove --dry-run to actually push'));
+            return;
+        }
+        // Call the API to push
+        const response = await axios_1.default.post(`${SCHEMA_API_BASE}`, {
+            action: 'push',
+            schema: docData,
+        }, {
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (response.data.ok) {
+            spinner.succeed(`Schema "${schema.type}" pushed to development`);
+            console.log('');
+            console.log(`  Path: ${response.data.path || `araneaSDK/typeSettings/schemas/${schema.type}`}`);
+            console.log(`  Revision: ${response.data.revisionNumber || 1}`);
+            console.log('');
+            console.log(chalk_1.default.cyan(`To promote to production: aranea-sdk schema promote --type ${schema.type}`));
+        }
+        else {
+            spinner.fail(`Push failed: ${response.data.error || 'Unknown error'}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (error.response?.status === 401) {
+            spinner.fail('Authentication failed - invalid or expired token');
+        }
+        else if (error.response?.status === 403) {
+            spinner.fail('Permission denied - insufficient privileges');
+        }
+        else if (error.response?.data?.error) {
+            spinner.fail(`Push failed: ${error.response.data.error}`);
+        }
+        else {
+            spinner.fail(`Push failed: ${error.message}`);
+        }
+        process.exit(1);
+    }
+});
+// schema promote - promote a schema from development to production
+exports.schemaCommand
+    .command('promote')
+    .description('Promote a schema from development to production')
+    .requiredOption('-t, --type <type>', 'Type name to promote')
+    .option('--token <token>', 'Firebase Auth ID token')
+    .option('-d, --dry-run', 'Show what would be promoted without actually promoting')
+    .action(async (options) => {
+    const spinner = (0, ora_1.default)(`Promoting schema: ${options.type}...`).start();
+    try {
+        const token = getAuthToken(options);
+        if (!token && !options.dryRun) {
+            spinner.fail('Authentication required');
+            console.log('');
+            console.log(chalk_1.default.yellow('Provide a token using one of:'));
+            console.log('  --token <TOKEN>');
+            console.log('  export ARANEA_AUTH_TOKEN=<TOKEN>');
+            console.log('  export FIREBASE_AUTH_TOKEN=<TOKEN>');
+            process.exit(1);
+        }
+        if (options.dryRun) {
+            // Fetch current schema info
+            const schemaResult = await fetchSchema(options.type);
+            spinner.stop();
+            console.log(chalk_1.default.bold('\n=== Dry Run: Schema Promote ===\n'));
+            if (!schemaResult.ok) {
+                console.log(chalk_1.default.red(`Schema "${options.type}" not found`));
+                process.exit(1);
+            }
+            const schema = schemaResult.schema;
+            console.log(chalk_1.default.yellow('Would promote the following schema:'));
+            console.log('');
+            console.log(`  Type: ${schema.type}`);
+            console.log(`  Current State: ${schema.state || 'unknown'}`);
+            console.log(`  New State: ${chalk_1.default.green('production')}`);
+            console.log(`  Revision: ${schema.revisionNumber || schema.version}`);
+            console.log('');
+            console.log(chalk_1.default.gray('Remove --dry-run to actually promote'));
+            return;
+        }
+        // Call the API to promote
+        const response = await axios_1.default.post(`${SCHEMA_API_BASE}`, {
+            action: 'promote',
+            type: options.type,
+        }, {
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (response.data.ok) {
+            spinner.succeed(`Schema "${options.type}" promoted to production`);
+            console.log('');
+            console.log(`  Previous State: ${response.data.previousState || 'development'}`);
+            console.log(`  New State: ${chalk_1.default.green('production')}`);
+            console.log(`  Revision: ${response.data.revisionNumber || 'N/A'}`);
+            console.log('');
+        }
+        else {
+            spinner.fail(`Promote failed: ${response.data.error || 'Unknown error'}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (error.response?.status === 401) {
+            spinner.fail('Authentication failed - invalid or expired token');
+        }
+        else if (error.response?.status === 403) {
+            spinner.fail('Permission denied - insufficient privileges');
+        }
+        else if (error.response?.status === 404) {
+            spinner.fail(`Schema "${options.type}" not found`);
+        }
+        else if (error.response?.data?.error) {
+            spinner.fail(`Promote failed: ${error.response.data.error}`);
+        }
+        else {
+            spinner.fail(`Promote failed: ${error.message}`);
+        }
+        process.exit(1);
+    }
+});
+// schema info - show detailed schema information with revision history
+exports.schemaCommand
+    .command('info')
+    .description('Show detailed schema information with revision history')
+    .requiredOption('-t, --type <type>', 'Type name')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const spinner = (0, ora_1.default)(`Fetching schema info: ${options.type}...`).start();
+    try {
+        // Fetch schema from API with extended info
+        const response = await axios_1.default.get(`${SCHEMA_API_BASE}`, {
+            params: {
+                action: 'info',
+                type: options.type,
+            },
+        });
+        spinner.stop();
+        if (!response.data.ok) {
+            console.log(chalk_1.default.red(`\nSchema "${options.type}" not found`));
+            if (response.data.availableTypes) {
+                console.log('');
+                console.log(chalk_1.default.yellow('Available Types:'));
+                response.data.availableTypes.forEach((t) => console.log(`  - ${t}`));
+            }
+            process.exit(1);
+        }
+        const schema = response.data.schema;
+        const revisions = response.data.revisions || [];
+        if (options.json) {
+            console.log(JSON.stringify({ schema, revisions }, null, 2));
+            return;
+        }
+        console.log(chalk_1.default.bold(`\n=== Schema Info: ${schema.type} ===\n`));
+        // Basic info
+        console.log(chalk_1.default.cyan('Basic Information:'));
+        console.log(`  Type: ${schema.type}`);
+        console.log(`  DisplayName: ${schema.displayName || '(not set)'}`);
+        console.log(`  Description: ${schema.description || '(not set)'}`);
+        console.log(`  ProductType: ${schema.productType || '(not set)'}`);
+        console.log('');
+        // State info
+        console.log(chalk_1.default.cyan('State:'));
+        const stateColor = schema.state === 'production' ? chalk_1.default.green : chalk_1.default.yellow;
+        console.log(`  Current State: ${stateColor(schema.state || 'unknown')}`);
+        console.log(`  Revision Number: ${schema.revisionNumber || 1}`);
+        console.log(`  Version: ${schema.version || 1}`);
+        console.log('');
+        // Timestamps
+        console.log(chalk_1.default.cyan('Timestamps:'));
+        console.log(`  Created: ${schema.createdAt || 'N/A'}`);
+        console.log(`  Updated: ${schema.updatedAt || 'N/A'}`);
+        console.log(`  Updated By: ${schema.updatedBy || 'N/A'}`);
+        console.log('');
+        // Capabilities & Features
+        console.log(chalk_1.default.cyan('Capabilities & Features:'));
+        console.log(`  Capabilities: ${(schema.capabilities || []).join(', ') || '(none)'}`);
+        console.log(`  Features: ${(schema.features || []).join(', ') || '(none)'}`);
+        console.log('');
+        // Schema fields summary
+        console.log(chalk_1.default.cyan('Schema Fields:'));
+        const stateFields = Object.keys(schema.stateSchema?.properties || {});
+        const configFields = Object.keys(schema.configSchema?.properties || {});
+        const cmdFields = Object.keys(schema.commandSchema?.properties || {});
+        console.log(`  State: ${stateFields.length} fields (${stateFields.slice(0, 5).join(', ')}${stateFields.length > 5 ? '...' : ''})`);
+        console.log(`  Config: ${configFields.length} fields (${configFields.slice(0, 5).join(', ')}${configFields.length > 5 ? '...' : ''})`);
+        console.log(`  Command: ${cmdFields.length} fields (${cmdFields.slice(0, 5).join(', ')}${cmdFields.length > 5 ? '...' : ''})`);
+        console.log('');
+        // Revision history
+        if (revisions.length > 0) {
+            console.log(chalk_1.default.cyan('Revision History:'));
+            revisions.forEach((rev) => {
+                const state = rev.state === 'production' ? chalk_1.default.green(rev.state) : chalk_1.default.yellow(rev.state);
+                console.log(`  [${rev.revisionNumber}] ${state} - ${rev.updatedAt} by ${rev.updatedBy || 'system'}`);
+            });
+            console.log('');
+        }
+        // Actions
+        console.log(chalk_1.default.gray('Actions:'));
+        if (schema.state !== 'production') {
+            console.log(chalk_1.default.gray(`  Promote: aranea-sdk schema promote --type ${schema.type}`));
+        }
+        console.log(chalk_1.default.gray(`  Get full schema: aranea-sdk schema get --type ${schema.type} --json`));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch schema info');
+        if (error.response?.status === 404) {
+            console.log(chalk_1.default.red(`\nSchema "${options.type}" not found`));
+        }
+        else {
+            console.log(chalk_1.default.red(`\nError: ${error.message}`));
+        }
+        process.exit(1);
+    }
+});

package/dist/config.d.ts

@@ -4,6 +4,7 @@
 export interface Endpoint {
     gate: string;
     state: string;
+    command: string;
     mqtt?: string;
 }
 export declare const ENDPOINTS: Record<string, Endpoint>;

package/dist/config.js

@@ -9,11 +9,13 @@ exports.ENDPOINTS = {
     production: {
         gate: 'https://asia-northeast1-mobesorder.cloudfunctions.net/araneaDeviceGate',
         state: 'https://asia-northeast1-mobesorder.cloudfunctions.net/deviceStateReport',
+        command: 'https://asia-northeast1-mobesorder.cloudfunctions.net/araneaDeviceCommand',
         mqtt: 'wss://aranea-mqtt-bridge-1010551946141.asia-northeast1.run.app',
     },
     staging: {
         gate: 'https://asia-northeast1-mobesorder-staging.cloudfunctions.net/araneaDeviceGate',
         state: 'https://asia-northeast1-mobesorder-staging.cloudfunctions.net/deviceStateReport',
+        command: 'https://asia-northeast1-mobesorder-staging.cloudfunctions.net/araneaDeviceCommand',
         mqtt: 'wss://aranea-mqtt-bridge-staging.asia-northeast1.run.app',
     },
 };

package/dist/index.js

@@ -20,11 +20,14 @@ const simulate_1 = require("./commands/simulate");
 const validate_1 = require("./commands/validate");
 const schema_1 = require("./commands/schema");
 const register_1 = require("./commands/register");
+const mqtt_1 = require("./commands/mqtt");
+const knowledge_1 = require("./commands/knowledge");
+const metatron_1 = require("./commands/metatron");
 const program = new commander_1.Command();
 program
     .name('aranea-sdk')
     .description('AraneaSDK CLI - デバイス開発支援ツール')
-    .version('0.1.0');
+    .version('0.3.0');
 // test コマンド
 program.addCommand(test_1.testCommand);
 // simulate コマンド
@@ -35,4 +38,10 @@ program.addCommand(validate_1.validateCommand);
 program.addCommand(schema_1.schemaCommand);
 // register コマンド
 program.addCommand(register_1.registerCommand);
+// mqtt コマンド (v0.2.0 P0)
+program.addCommand(mqtt_1.mqttCommand);
+// knowledge コマンド (v0.2.1)
+program.addCommand(knowledge_1.knowledgeCommand);
+// metatron コマンド (v0.2.1)
+program.addCommand(metatron_1.metatronCommand);
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aranea-sdk-cli",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "description": "AraneaSDK CLI - ESP32 IoTデバイス開発支援ツール",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -59,6 +59,14 @@
   "engines": {
     "node": ">=18.0.0"
   },
+  "peerDependencies": {
+    "firebase-admin": ">=11.0.0"
+  },
+  "peerDependenciesMeta": {
+    "firebase-admin": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public"
   }