listpage_cli 0.0.295 → 0.0.296

package/bin/adapters/cli-interaction.js

@@ -7,7 +7,6 @@ exports.runPrompt = runPrompt;
 exports.askRushQuestions = askRushQuestions;
 exports.askProjectPath = askProjectPath;
 exports.askOverwrite = askOverwrite;
-exports.askInstallDeployScript = askInstallDeployScript;
 exports.printHelp = printHelp;
 exports.printVersion = printVersion;
 const enquirer_1 = require("enquirer");
@@ -135,18 +134,6 @@ async function askOverwrite() {
     }
     return (0, interaction_result_1.interactionValue)(result.value.ok);
 }
-async function askInstallDeployScript() {
-    const result = await runPrompt({
-        type: "confirm",
-        name: "ok",
-        message: "是否添加部署脚本？这个脚本允许你可以帮你快速构建docker镜像，并发布到阿里云等环境，但是需要本机有docker环境。",
-        initial: false,
-    });
-    if (result.status !== "value") {
-        return result;
-    }
-    return (0, interaction_result_1.interactionValue)(result.value.ok);
-}
 function printHelp() {
     const h = [
         "用法: listpage_cli init",
@@ -155,8 +142,10 @@ function printHelp() {
         "说明: 安装技能到 Cursor。默认 skillName 为 test，安装到当前命令执行目录的 .cursor/skills/",
         "用法: listpage_cli build-project",
         "说明: 非交互校验当前目录是否为有效项目根（需存在 listpage.config.json）",
-        "用法: listpage_cli deploy-project",
-        "说明: 先校验 .listpage/output 产物，再按 login/build/tag/push 执行 Docker 部署",
+        "用法: listpage_cli release-project [tag] [--profile dev] [--platform linux/amd64] [--env KEY=VALUE]",
+        "说明: 先校验 .listpage/output 产物，再按 login/build/tag/push 执行 Docker 发布；参数优先级: CLI > profile > base",
+        "用法: listpage_cli deploy-project [tag] [--profile dev] [--platform linux/amd64] [--env KEY=VALUE]",
+        "说明: 使用 docker.remote + docker.container 执行部署，支持 ports[] 与 envFile/env 合并；参数优先级: CLI > profile > base",
     ].join("\n");
     console.log(h);
 }

package/bin/adapters/dockerode-client.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDockerodeClient = void 0;
+exports.toDockerConnectionOptions = toDockerConnectionOptions;
+exports.parsePorts = parsePorts;
+exports.loadEnvFromFile = loadEnvFromFile;
+exports.mergeEnv = mergeEnv;
+exports.toRuntimeContainerInput = toRuntimeContainerInput;
+const dockerode_1 = __importDefault(require("dockerode"));
+const node_fs_1 = require("node:fs");
+const createDockerodeClient = (config) => {
+    const options = toDockerConnectionOptions(config);
+    const client = new dockerode_1.default(options);
+    return {
+        ping: async () => {
+            await client.ping();
+        },
+        imageExists: async (image) => {
+            try {
+                await client.getImage(image).inspect();
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        removeImage: async (image) => {
+            await client.getImage(image).remove({ force: true });
+        },
+        pullImage: async (image, auth) => {
+            const stream = await new Promise((resolve, reject) => {
+                const pullOptions = auth ? { authconfig: auth } : undefined;
+                client.pull(image, pullOptions, (err, output) => {
+                    if (err || !output) {
+                        reject(err ?? new Error("docker pull 返回空输出"));
+                        return;
+                    }
+                    resolve(output);
+                });
+            });
+            await new Promise((resolve, reject) => {
+                client.modem.followProgress(stream, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                }, () => undefined);
+            });
+        },
+        findContainerIdByName: async (name) => {
+            const containers = await client.listContainers({ all: true });
+            const matched = containers.find((item) => (item.Names ?? []).some((n) => n === `/${name}`));
+            return matched?.Id;
+        },
+        stopContainer: async (id) => {
+            const container = client.getContainer(id);
+            try {
+                await container.stop();
+            }
+            catch {
+                // Container may already be stopped.
+            }
+        },
+        removeContainer: async (id) => {
+            const container = client.getContainer(id);
+            await container.remove({ force: true });
+        },
+        createContainer: async (input) => {
+            const payload = toContainerCreateOptions(input);
+            const container = await client.createContainer(payload);
+            return container.id;
+        },
+        startContainer: async (id) => {
+            const container = client.getContainer(id);
+            await container.start();
+        },
+        inspectContainer: async (id) => {
+            const container = client.getContainer(id);
+            const inspectInfo = await container.inspect();
+            const state = inspectInfo?.State;
+            const portMappings = formatPortMappings(inspectInfo);
+            return {
+                running: state?.Running,
+                status: state?.Status,
+                exitCode: state?.ExitCode,
+                error: state?.Error,
+                startedAt: state?.StartedAt,
+                finishedAt: state?.FinishedAt,
+                health: state?.Health?.Status,
+                portMappings,
+            };
+        },
+        getContainerLogs: async (id, tail = 100) => {
+            const container = client.getContainer(id);
+            const logs = await container.logs({
+                stdout: true,
+                stderr: true,
+                timestamps: true,
+                follow: false,
+                tail,
+            });
+            if (typeof logs === "string") {
+                return logs;
+            }
+            return logs.toString("utf8");
+        },
+    };
+};
+exports.createDockerodeClient = createDockerodeClient;
+function toDockerConnectionOptions(config) {
+    const protocol = (config.protocol ?? "https").toLowerCase();
+    const isHttps = protocol === "https";
+    const options = {
+        host: config.host ?? "127.0.0.1",
+        port: config.port ?? 2376,
+        protocol,
+    };
+    const socketPath = (config.socketPath ?? "").trim();
+    if (socketPath !== "") {
+        options.socketPath = socketPath;
+    }
+    if (isHttps) {
+        const tlsOptions = {
+            ca: asOptionalTlsBuffer(config.ca),
+            cert: asOptionalTlsBuffer(config.cert),
+            key: asOptionalTlsBuffer(config.key),
+        };
+        if (tlsOptions.ca) {
+            options.ca = tlsOptions.ca;
+        }
+        if (tlsOptions.cert) {
+            options.cert = tlsOptions.cert;
+        }
+        if (tlsOptions.key) {
+            options.key = tlsOptions.key;
+        }
+        options.checkServerIdentity = () => undefined;
+    }
+    return options;
+}
+function parsePorts(ports) {
+    if (!ports || ports.length === 0) {
+        return {};
+    }
+    const exposedPorts = {};
+    const portBindings = {};
+    for (const rawPort of ports) {
+        const normalized = rawPort.trim();
+        if (normalized === "") {
+            continue;
+        }
+        const [hostAndContainer, protocolPart] = normalized.split("/");
+        const protocol = protocolPart?.trim() === "udp" ? "udp" : "tcp";
+        const segments = hostAndContainer.split(":").map((part) => part.trim());
+        if (segments.length !== 2 || !segments[0] || !segments[1]) {
+            throw new Error(`container.ports 配置无效: ${rawPort}`);
+        }
+        const hostPort = segments[0];
+        const containerPort = segments[1];
+        const key = `${containerPort}/${protocol}`;
+        exposedPorts[key] = {};
+        portBindings[key] = [{ HostPort: hostPort }];
+    }
+    return {
+        exposedPorts: Object.keys(exposedPorts).length > 0 ? exposedPorts : undefined,
+        portBindings: Object.keys(portBindings).length > 0 ? portBindings : undefined,
+    };
+}
+function loadEnvFromFile(input) {
+    if (!input.envFilePath) {
+        return {};
+    }
+    const targetPath = input.resolve(input.projectRoot, input.envFilePath);
+    const raw = input.readText(targetPath);
+    const result = {};
+    for (const line of raw.split(/\r?\n/)) {
+        const normalized = line.trim();
+        if (normalized === "" || normalized.startsWith("#")) {
+            continue;
+        }
+        const eqIndex = normalized.indexOf("=");
+        if (eqIndex <= 0) {
+            continue;
+        }
+        const key = normalized.slice(0, eqIndex).trim();
+        const value = normalized.slice(eqIndex + 1);
+        if (key !== "") {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function mergeEnv(...inputs) {
+    const merged = {};
+    for (const input of inputs) {
+        if (!input) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(input)) {
+            if (key.trim() === "") {
+                continue;
+            }
+            merged[key] = value;
+        }
+    }
+    return Object.entries(merged).map(([key, value]) => `${key}=${value}`);
+}
+function toRuntimeContainerInput(input) {
+    const envFromFile = loadEnvFromFile({
+        projectRoot: input.runtime.projectRoot,
+        envFilePath: input.runtime.envFilePath,
+        resolve: input.resolve,
+        readText: input.readText,
+    });
+    const env = mergeEnv(envFromFile, input.runtime.env, input.runtime.cliEnv);
+    const ports = parsePorts(input.runtime.ports);
+    return {
+        name: input.runtime.name,
+        image: input.runtime.image,
+        env,
+        exposedPorts: ports.exposedPorts,
+        portBindings: ports.portBindings,
+        binds: input.runtime.binds,
+        nanoCpus: input.runtime.nanoCpus,
+        memory: input.runtime.memory,
+    };
+}
+function toContainerCreateOptions(input) {
+    const hostConfig = {};
+    let hasHostConfig = false;
+    if (input.portBindings) {
+        hostConfig.PortBindings = input.portBindings;
+        hasHostConfig = true;
+    }
+    if (input.binds) {
+        hostConfig.Binds = input.binds;
+        hasHostConfig = true;
+    }
+    if (typeof input.nanoCpus === "number") {
+        hostConfig.NanoCpus = input.nanoCpus;
+        hasHostConfig = true;
+    }
+    if (typeof input.memory === "number") {
+        hostConfig.Memory = Number(input.memory) * 1024 * 1024;
+        hasHostConfig = true;
+    }
+    const payload = {
+        name: input.name,
+        Image: input.image,
+        Env: input.env,
+    };
+    if (input.exposedPorts) {
+        payload.ExposedPorts = input.exposedPorts;
+    }
+    if (hasHostConfig) {
+        payload.HostConfig = hostConfig;
+    }
+    return payload;
+}
+function asOptionalTlsBuffer(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim();
+    if (normalized === "") {
+        return undefined;
+    }
+    if ((0, node_fs_1.existsSync)(normalized)) {
+        return (0, node_fs_1.readFileSync)(normalized);
+    }
+    return Buffer.from(normalized);
+}
+function formatPortMappings(inspectInfo) {
+    const ports = inspectInfo?.NetworkSettings?.Ports;
+    if (!ports || typeof ports !== "object") {
+        return undefined;
+    }
+    const mappings = [];
+    for (const [containerPort, hostBindings] of Object.entries(ports)) {
+        if (!hostBindings || hostBindings.length === 0) {
+            mappings.push(`${containerPort} -> <not-published>`);
+            continue;
+        }
+        for (const binding of hostBindings) {
+            const hostIp = binding.HostIp || "0.0.0.0";
+            const hostPort = binding.HostPort || "<unknown>";
+            mappings.push(`${containerPort} -> ${hostIp}:${hostPort}`);
+        }
+    }
+    return mappings.length > 0 ? mappings : undefined;
+}

package/bin/app/parse-args.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseArgs = parseArgs;
+exports.parseCommandOptions = parseCommandOptions;
+exports.parseCommandPositionals = parseCommandPositionals;
 const KNOWN_COMMANDS = new Set([
     "init",
     "install-skill",
     "build-project",
+    "release-project",
     "deploy-project",
 ]);
 function parseArgs(argv) {
@@ -37,3 +40,86 @@ function parseArgs(argv) {
         positionals,
     };
 }
+function parseCommandOptions(rawArgs) {
+    const args = rawArgs.slice(1);
+    const profile = readSingleOption(args, "profile");
+    const platform = readSingleOption(args, "platform");
+    const envEntries = readMultiOption(args, "env");
+    const env = parseEnvEntries(envEntries);
+    return {
+        profile,
+        platform,
+        env: Object.keys(env).length > 0 ? env : undefined,
+    };
+}
+function parseCommandPositionals(rawArgs) {
+    const args = rawArgs.slice(1);
+    const positionals = [];
+    const optionsWithValue = new Set(["--profile", "--platform", "--env"]);
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token.startsWith("--")) {
+            if (token.includes("=")) {
+                continue;
+            }
+            if (optionsWithValue.has(token)) {
+                index += 1;
+            }
+            continue;
+        }
+        if (token.startsWith("-")) {
+            continue;
+        }
+        positionals.push(token);
+    }
+    return positionals;
+}
+function readSingleOption(args, optionName) {
+    const values = readMultiOption(args, optionName);
+    const last = values.at(-1);
+    if (typeof last !== "string") {
+        return undefined;
+    }
+    const normalized = last.trim();
+    return normalized === "" ? undefined : normalized;
+}
+function readMultiOption(args, optionName) {
+    const values = [];
+    const longFlag = `--${optionName}`;
+    const prefix = `${longFlag}=`;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token === longFlag) {
+            const next = args[index + 1];
+            if (typeof next === "string" && !next.startsWith("-")) {
+                values.push(next);
+                index += 1;
+            }
+            continue;
+        }
+        if (token.startsWith(prefix)) {
+            values.push(token.slice(prefix.length));
+        }
+    }
+    return values;
+}
+function parseEnvEntries(entries) {
+    const result = {};
+    for (const entry of entries) {
+        const normalized = entry.trim();
+        if (normalized === "") {
+            continue;
+        }
+        const eqIndex = normalized.indexOf("=");
+        if (eqIndex <= 0) {
+            continue;
+        }
+        const key = normalized.slice(0, eqIndex).trim();
+        const value = normalized.slice(eqIndex + 1);
+        if (key === "") {
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}

package/bin/cli.js

@@ -7,6 +7,7 @@ const command_result_1 = require("./domain/command-result");
 const init_command_1 = require("./commands/init-command");
 const install_skill_command_1 = require("./commands/install-skill-command");
 const build_project_command_1 = require("./commands/build-project-command");
+const release_project_command_1 = require("./commands/release-project-command");
 const deploy_project_command_1 = require("./commands/deploy-project-command");
 const node_fs_adapter_1 = require("./adapters/node-fs-adapter");
 const filesystem_capability_service_1 = require("./services/filesystem-capability-service");
@@ -19,7 +20,6 @@ const initCommandHandler = (0, init_command_1.createInitCommandHandler)({
         askProjectPath: cli_interaction_1.askProjectPath,
         askOverwrite: cli_interaction_1.askOverwrite,
         askRushQuestions: cli_interaction_1.askRushQuestions,
-        askInstallDeployScript: cli_interaction_1.askInstallDeployScript,
     },
     fs: fsAdapter,
     files: filesystemCapability,
@@ -35,6 +35,9 @@ const installSkillCommandHandler = (0, install_skill_command_1.createInstallSkil
 const buildProjectCommandHandler = (0, build_project_command_1.createBuildProjectCommandHandler)({
     fs: fsAdapter,
 });
+const releaseProjectCommandHandler = (0, release_project_command_1.createReleaseProjectCommandHandler)({
+    fs: fsAdapter,
+});
 const deployProjectCommandHandler = (0, deploy_project_command_1.createDeployProjectCommandHandler)({
     fs: fsAdapter,
 });
@@ -46,6 +49,7 @@ async function main() {
             init: initCommandHandler,
             "install-skill": installSkillCommandHandler,
             "build-project": buildProjectCommandHandler,
+            "release-project": releaseProjectCommandHandler,
             "deploy-project": deployProjectCommandHandler,
         },
     });

package/bin/commands/deploy-project-command.js

@@ -1,9 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDeployProjectCommandHandler = createDeployProjectCommandHandler;
+const parse_args_1 = require("../app/parse-args");
 const deploy_project_service_1 = require("../services/deploy-project-service");
 function createDeployProjectCommandHandler(deps) {
-    return async (_input) => {
-        return (0, deploy_project_service_1.runDeployProjectFlow)(deps);
+    return async (input) => {
+        const firstPositional = (0, parse_args_1.parseCommandPositionals)(input.rawArgs)[0];
+        const tag = typeof firstPositional === "string" && firstPositional.trim() !== ""
+            ? firstPositional.trim()
+            : undefined;
+        const options = (0, parse_args_1.parseCommandOptions)(input.rawArgs);
+        const cliOverrides = {
+            tag,
+            profile: options.profile,
+            platform: options.platform,
+            env: options.env,
+        };
+        return (0, deploy_project_service_1.runDeployProjectFlow)({
+            ...deps,
+            cliOverrides,
+        });
     };
 }

package/bin/commands/release-project-command.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReleaseProjectCommandHandler = createReleaseProjectCommandHandler;
+const parse_args_1 = require("../app/parse-args");
+const release_project_service_1 = require("../services/release-project-service");
+function createReleaseProjectCommandHandler(deps) {
+    return async (input) => {
+        const firstPositional = (0, parse_args_1.parseCommandPositionals)(input.rawArgs)[0];
+        const tag = typeof firstPositional === "string" && firstPositional.trim() !== ""
+            ? firstPositional.trim()
+            : undefined;
+        const options = (0, parse_args_1.parseCommandOptions)(input.rawArgs);
+        const cliOverrides = {
+            tag,
+            profile: options.profile,
+            platform: options.platform,
+            env: options.env,
+        };
+        return (0, release_project_service_1.runReleaseProjectFlow)({
+            ...deps,
+            cliOverrides,
+        });
+    };
+}

package/bin/ports/release-project-command.js

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

package/bin/services/{artifact-validator.js → build-artifact-validator.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createArtifactValidator = createArtifactValidator;
+exports.createBuildArtifactValidator = createBuildArtifactValidator;
 const ARTIFACT_STAGE = "artifact";
-function createArtifactValidator(fs) {
+function createBuildArtifactValidator(fs) {
     return (expectation) => {
         const issues = [];
         if (!fs.exists(expectation.outputDir)) {

package/bin/services/config-value-utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asObject = asObject;
+exports.asOptionalObject = asOptionalObject;
+exports.asRequiredString = asRequiredString;
+exports.asRequiredNumber = asRequiredNumber;
+exports.asOptionalString = asOptionalString;
+function asObject(value, fieldName) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`缺少对象字段: ${fieldName}`);
+    }
+    return value;
+}
+function asOptionalObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function asRequiredString(value, fieldName) {
+    if (typeof value === "string" && value.trim() !== "") {
+        return value.trim();
+    }
+    throw new Error(`缺少字段: ${fieldName}`);
+}
+function asRequiredNumber(value, fieldName) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    throw new Error(`字段类型无效: ${fieldName} (需要 number)`);
+}
+function asOptionalString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return normalized === "" ? undefined : normalized;
+}