@maxisoft/instantcms-mcp 1.2.3

package/dist/tools/api-tool.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffoldApi = scaffoldApi;
+function scaffoldApi(opts) {
+    const name = opts.addon_name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+    const Name = name.split('_').map(capitalize).join('');
+    const version = opts.version || 'v1';
+    const basePath = opts.options?.base_path || `/api/${version}/${name}`;
+    const files = {};
+    const ctrl = `package/system/controllers/${name}`;
+    files[`${ctrl}/api/${version}/index.php`] = generateApiController(name, Name, version, opts.endpoints, basePath);
+    files[`${ctrl}/manifest.xml`] = generateManifest(name, Name, version);
+    if (opts.options?.use_swagger) {
+        files[`package/docs/openapi.json`] = generateOpenApi(name, version, opts.endpoints, basePath);
+    }
+    return {
+        addon_name: name,
+        api_version: version,
+        base_path: basePath,
+        endpoints_count: opts.endpoints.length,
+        files,
+        endpoints: opts.endpoints.map(e => ({
+            method: e.method,
+            path: `${basePath}${e.path}`,
+            name: e.name,
+            auth_required: e.auth_required ?? true,
+        })),
+        structure_notes: [
+            `API контроллер: ${ctrl}/api/${version}/index.php`,
+            `Маршрут: ${basePath}/*`,
+            `Аутентификация: через API ключ или OAuth токен`,
+        ],
+    };
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function generateApiController(name, Name, version, endpoints, basePath) {
+    let code = `<?php
+/**
+ * API Controller ${name} v${version}
+ * Base path: ${basePath}
+ */
+
+class api${Name}${capitalize(version)} extends cmsBackend {
+
+    protected $token;
+    protected $user_id;
+
+    public function __construct(cmsRequest $request) {
+        parent::__construct($request);
+        $this->token = $this->request->get('token', '');
+        $this->checkAuth();
+    }
+
+    protected function checkAuth() {
+        if (!$this->token) {
+            $this->errorResponse('API token required', 401);
+            return false;
+        }
+
+        $user = $this->model->getUserByToken($this->token);
+        if (!$user) {
+            $this->errorResponse('Invalid API token', 401);
+            return false;
+        }
+
+        $this->user_id = $user['id'];
+        return true;
+    }
+
+    protected function errorResponse($message, $code = 400) {
+        http_response_code($code);
+        echo json_encode(['error' => true, 'message' => $message]);
+        exit;
+    }
+
+    protected function successResponse($data, $code = 200) {
+        http_response_code($code);
+        echo json_encode(['success' => true, 'data' => $data]);
+        exit;
+    }
+
+`;
+    for (const endpoint of endpoints) {
+        code += generateEndpoint(name, Name, endpoint);
+    }
+    code += `}
+`;
+    return code;
+}
+function generateEndpoint(name, _Name, endpoint) {
+    const methodUpper = endpoint.method.toUpperCase();
+    let paramsValidation = '';
+    let pathParams = '';
+    if (endpoint.params) {
+        for (const param of endpoint.params) {
+            if (param.type === 'path') {
+                pathParams += `, $${param.name}`;
+                paramsValidation += `
+        $${param.name} = $this->request->get('${param.name}', ${param.required ? "''" : 'null'});
+        if (${param.required ? `empty($${param.name})` : 'false'}) {
+            $this->errorResponse('Missing required parameter: ${param.name}', 400);
+        }`;
+            }
+            else if (param.type === 'query') {
+                paramsValidation += `
+        $${param.name} = $this->request->get('${param.name}', null);`;
+            }
+            else if (param.type === 'body') {
+                paramsValidation += `
+        $${param.name} = $this->request->get('${param.name}', null);`;
+            }
+        }
+    }
+    const authCheck = endpoint.auth_required !== false
+        ? `
+        if (!$this->user_id) {
+            $this->errorResponse('Unauthorized', 401);
+        }`
+        : '';
+    const endpointDoc = endpoint.description
+        ? `/**
+     * ${endpoint.description}
+     */
+    `
+        : '';
+    let code = `${endpointDoc}    public function run(${pathParams}) {${authCheck}${paramsValidation}
+`;
+    switch (methodUpper) {
+        case 'GET':
+            code += generateGetHandler(name, endpoint);
+            break;
+        case 'POST':
+            code += generatePostHandler(name, endpoint);
+            break;
+        case 'PUT':
+        case 'PATCH':
+            code += generatePutPatchHandler(name, endpoint);
+            break;
+        case 'DELETE':
+            code += generateDeleteHandler(name, endpoint);
+            break;
+    }
+    code += `    }
+
+`;
+    return code;
+}
+function generateGetHandler(name, endpoint) {
+    const isList = endpoint.path.includes('/list') || endpoint.name.includes('list');
+    const isSingle = endpoint.name.includes('_by_') || endpoint.path.match(/\/[a-z_]+\/\{.*\}/);
+    if (isList) {
+        return `
+        $page = $this->request->get('page', 1);
+        $perpage = $this->request->get('perpage', 20);
+
+        $items = $this->model->get${capitalize(name)}List($this->user_id, [
+            'page' => $page,
+            'perpage' => $perpage,
+        ]);
+
+        $this->successResponse($items);
+`;
+    }
+    else if (isSingle) {
+        const idVar = endpoint.params?.find(p => p.type === 'path')?.name || 'id';
+        return `
+        $${idVar} = (int) $${idVar};
+
+        $item = $this->model->get${capitalize(name)}ById($${idVar}, $this->user_id);
+
+        if (!$item) {
+            $this->errorResponse('Item not found', 404);
+        }
+
+        $this->successResponse($item);
+`;
+    }
+    else {
+        return `
+        $this->successResponse(['status' => 'ok']);
+`;
+    }
+}
+function generatePostHandler(name, _endpoint) {
+    return `
+        $data = $this->request->getAll();
+
+        $id = $this->model->add${capitalize(name)}($data, $this->user_id);
+
+        if (!$id) {
+            $this->errorResponse('Failed to create item', 500);
+        }
+
+        $this->successResponse(['id' => $id], 201);
+`;
+}
+function generatePutPatchHandler(name, endpoint) {
+    const idVar = endpoint.params?.find(p => p.type === 'path')?.name || 'id';
+    return `
+        $${idVar} = (int) $${idVar};
+        $data = $this->request->getAll();
+
+        $item = $this->model->get${capitalize(name)}ById($${idVar}, $this->user_id);
+
+        if (!$item) {
+            $this->errorResponse('Item not found', 404);
+        }
+
+        $updated = $this->model->update${capitalize(name)}($${idVar}, $data);
+
+        if (!$updated) {
+            $this->errorResponse('Failed to update item', 500);
+        }
+
+        $this->successResponse(['id' => $${idVar}]);
+`;
+}
+function generateDeleteHandler(name, endpoint) {
+    const idVar = endpoint.params?.find(p => p.type === 'path')?.name || 'id';
+    return `
+        $${idVar} = (int) $${idVar};
+
+        $deleted = $this->model->delete${capitalize(name)}($${idVar}, $this->user_id);
+
+        if (!$deleted) {
+            $this->errorResponse('Failed to delete item', 500);
+        }
+
+        $this->successResponse(['deleted' => true]);
+`;
+}
+function generateManifest(name, Name, version) {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<addon>
+    <name>${name}_api</name>
+    <title>${Name} API ${version}</title>
+    <version>1.0.0</version>
+    <files>
+        <file>controllers/${name}/api/${version}/index.php</file>
+    </files>
+    <routes>
+        <route path="/api/${version}/${name}/">
+            <handler>${name}/api/${version}/index.php</handler>
+        </route>
+    </routes>
+</addon>`;
+}
+function generateOpenApi(name, version, endpoints, basePath) {
+    const paths = {};
+    for (const endpoint of endpoints) {
+        const path = `${basePath}${endpoint.path}`;
+        paths[path] = {
+            [endpoint.method.toLowerCase()]: {
+                summary: endpoint.description || endpoint.name,
+                tags: [name],
+                security: endpoint.auth_required !== false ? [{ ApiToken: [] }] : [],
+                parameters: endpoint.params
+                    ?.filter(p => p.type === 'query')
+                    .map(p => ({
+                    name: p.name,
+                    in: 'query',
+                    required: p.required,
+                    description: p.description,
+                })),
+                responses: {
+                    '200': { description: 'Success' },
+                    '400': { description: 'Bad Request' },
+                    '401': { description: 'Unauthorized' },
+                    '404': { description: 'Not Found' },
+                },
+            },
+        };
+    }
+    const openApiSpec = {
+        openapi: '3.0.0',
+        info: {
+            title: `${name} API ${version}`,
+            version: version,
+        },
+        paths,
+        components: {
+            securitySchemes: {
+                ApiToken: {
+                    type: 'apiKey',
+                    in: 'query',
+                    name: 'token',
+                },
+            },
+        },
+    };
+    return JSON.stringify(openApiSpec, null, 2);
+}

package/dist/tools/artifact-tool.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGeneratedArtifacts = validateGeneratedArtifacts;
+exports.buildAddonArchive = buildAddonArchive;
+exports.inspectAddonArchive = inspectAddonArchive;
+const node_buffer_1 = require("node:buffer");
+const node_child_process_1 = require("node:child_process");
+const ini_1 = require("ini");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const yaml_1 = require("yaml");
+const fflate_1 = require("fflate");
+function validateGeneratedArtifacts(files) {
+    const diagnostics = [];
+    for (const [path, content] of Object.entries(files)) {
+        try {
+            if (path.endsWith('.xml')) {
+                const result = fast_xml_parser_1.XMLValidator.validate(content);
+                if (result !== true)
+                    throw new Error(result.err.msg);
+                new fast_xml_parser_1.XMLParser().parse(content);
+            }
+            else if (path.endsWith('.ini')) {
+                (0, ini_1.parse)(content);
+            }
+            else if (/\.ya?ml$/i.test(path)) {
+                (0, yaml_1.parse)(content);
+            }
+            else if (path.endsWith('.php')) {
+                validatePhpShape(content);
+                const lint = (0, node_child_process_1.spawnSync)('php', ['-l'], { input: content, encoding: 'utf8', timeout: 5_000 });
+                if (lint.error && lint.error.code === 'ENOENT') {
+                    if (!diagnostics.some(item => item.code === 'PHP_LINTER_UNAVAILABLE')) {
+                        diagnostics.push({ code: 'PHP_LINTER_UNAVAILABLE', severity: 'warning', path, message: 'php executable не найден; выполнена только структурная проверка' });
+                    }
+                }
+                else if (lint.status !== 0) {
+                    throw new Error((lint.stderr || lint.stdout || 'php -l failed').trim());
+                }
+            }
+        }
+        catch (error) {
+            diagnostics.push({
+                code: 'INVALID_ARTIFACT_SYNTAX',
+                severity: 'error',
+                path,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return {
+        is_valid: !diagnostics.some(item => item.severity === 'error'),
+        files_checked: Object.keys(files).length,
+        diagnostics,
+    };
+}
+function buildAddonArchive(files) {
+    assertSafePaths(Object.keys(files));
+    const entries = Object.fromEntries(Object.entries(files).map(([path, content]) => [normalizePackagePath(path), (0, fflate_1.strToU8)(content)]));
+    const bytes = (0, fflate_1.zipSync)(entries, { level: 6 });
+    return {
+        encoding: 'base64',
+        archive: node_buffer_1.Buffer.from(bytes).toString('base64'),
+        bytes: bytes.length,
+        files_count: Object.keys(entries).length,
+    };
+}
+function inspectAddonArchive(base64) {
+    const entries = (0, fflate_1.unzipSync)(node_buffer_1.Buffer.from(base64, 'base64'));
+    const paths = Object.keys(entries);
+    assertSafePaths(paths);
+    const files = Object.fromEntries(paths.map(path => [path, (0, fflate_1.strFromU8)(entries[path])]));
+    return { paths, ...validateGeneratedArtifacts(files) };
+}
+function normalizePackagePath(path) {
+    return path
+        .replace(/^\[pkg\]\s*/, '')
+        .replace(/\\/g, '/')
+        .replace(/^\/+/, '');
+}
+function assertSafePaths(paths) {
+    for (const path of paths) {
+        const normalized = normalizePackagePath(path);
+        if (!normalized || normalized.split('/').includes('..'))
+            throw new Error(`Небезопасный путь архива: ${path}`);
+    }
+}
+function validatePhpShape(content) {
+    if (!content.trimStart().startsWith('<?php') && !content.trimStart().startsWith('<!DOCTYPE')) {
+        throw new Error('PHP-файл должен начинаться с <?php');
+    }
+    const opens = (content.match(/[({\[]/g) ?? []).length;
+    const closes = (content.match(/[)}\]]/g) ?? []).length;
+    if (opens !== closes)
+        throw new Error('Несбалансированные скобки в PHP-файле');
+}