listpage_cli 0.0.294 → 0.0.296

package/bin/{prompts.js → adapters/cli-interaction.js}

@@ -7,13 +7,12 @@ 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");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
-const interaction_result_1 = require("./domain/interaction-result");
+const interaction_result_1 = require("../domain/interaction-result");
 let promptTestScript = null;
 let promptTestScriptIndex = 0;
 function getTestPromptMode() {
@@ -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,12 +142,16 @@ function printHelp() {
         "说明: 安装技能到 Cursor。默认 skillName 为 test，安装到当前命令执行目录的 .cursor/skills/",
         "用法: listpage_cli build-project",
         "说明: 非交互校验当前目录是否为有效项目根（需存在 listpage.config.json）",
+        "用法: 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);
 }
 function printVersion() {
     try {
-        const p = path_1.default.join(__dirname, "..", "package.json");
+        const p = path_1.default.join(__dirname, "..", "..", "package.json");
         const pkg = JSON.parse((0, fs_1.readFileSync)(p, "utf8"));
         console.log(pkg.version || "");
     }

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,7 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseArgs = parseArgs;
-const KNOWN_COMMANDS = new Set(["init", "install-skill", "build-project"]);
+exports.parseCommandOptions = parseCommandOptions;
+exports.parseCommandPositionals = parseCommandPositionals;
+const KNOWN_COMMANDS = new Set([
+    "init",
+    "install-skill",
+    "build-project",
+    "release-project",
+    "deploy-project",
+]);
 function parseArgs(argv) {
     const rawArgs = [...argv];
     const commandToken = rawArgs[0];
@@ -32,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

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const prompts_1 = require("./prompts");
+const cli_interaction_1 = require("./adapters/cli-interaction");
 const execute_1 = require("./app/execute");
 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");
 const fsAdapter = (0, node_fs_adapter_1.createNodeFsAdapter)();
@@ -15,10 +17,9 @@ const filesystemCapability = (0, filesystem_capability_service_1.createFilesyste
 });
 const initCommandHandler = (0, init_command_1.createInitCommandHandler)({
     prompts: {
-        askProjectPath: prompts_1.askProjectPath,
-        askOverwrite: prompts_1.askOverwrite,
-        askRushQuestions: prompts_1.askRushQuestions,
-        askInstallDeployScript: prompts_1.askInstallDeployScript,
+        askProjectPath: cli_interaction_1.askProjectPath,
+        askOverwrite: cli_interaction_1.askOverwrite,
+        askRushQuestions: cli_interaction_1.askRushQuestions,
     },
     fs: fsAdapter,
     files: filesystemCapability,
@@ -34,14 +35,22 @@ 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,
+});
 async function main() {
     const result = await (0, execute_1.executeCommand)(process.argv.slice(2), {
-        printHelp: prompts_1.printHelp,
-        printVersion: prompts_1.printVersion,
+        printHelp: cli_interaction_1.printHelp,
+        printVersion: cli_interaction_1.printVersion,
         handlers: {
             init: initCommandHandler,
             "install-skill": installSkillCommandHandler,
             "build-project": buildProjectCommandHandler,
+            "release-project": releaseProjectCommandHandler,
+            "deploy-project": deployProjectCommandHandler,
         },
     });
     applyCommandResult(result);

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

@@ -0,0 +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) => {
+        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/domain/package-name.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composePkgName = composePkgName;
+function composePkgName(name) {
+    return safePkgName(name);
+}
+function safePkgName(name) {
+    return name
+        .toLowerCase()
+        .replace(/\s+/g, "-")
+        .replace(/[^a-z0-9-_.]/g, "-");
+}

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

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

package/bin/services/build-artifact-validator.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuildArtifactValidator = createBuildArtifactValidator;
+const ARTIFACT_STAGE = "artifact";
+function createBuildArtifactValidator(fs) {
+    return (expectation) => {
+        const issues = [];
+        if (!fs.exists(expectation.outputDir)) {
+            issues.push({
+                stage: ARTIFACT_STAGE,
+                message: `[${ARTIFACT_STAGE}] 构建产物目录不存在: ${expectation.outputDir}`,
+            });
+            return { ok: false, issues };
+        }
+        if (!fs.isDirectory(expectation.outputDir)) {
+            issues.push({
+                stage: ARTIFACT_STAGE,
+                message: `[${ARTIFACT_STAGE}] 构建产物路径不是目录: ${expectation.outputDir}`,
+            });
+            return { ok: false, issues };
+        }
+        const rootEntries = fs.readDir(expectation.outputDir);
+        if (rootEntries.length === 0) {
+            issues.push({
+                stage: ARTIFACT_STAGE,
+                message: `[${ARTIFACT_STAGE}] 构建产物目录为空: ${expectation.outputDir}`,
+            });
+        }
+        for (const relativePath of expectation.requiredRelativePaths) {
+            const normalized = relativePath.trim();
+            if (!normalized) {
+                continue;
+            }
+            const absolutePath = fs.resolve(expectation.outputDir, normalized);
+            if (!fs.exists(absolutePath)) {
+                issues.push({
+                    stage: ARTIFACT_STAGE,
+                    message: `[${ARTIFACT_STAGE}] 缺少必需产物: ${normalized} (base=${expectation.outputDir})`,
+                });
+            }
+        }
+        return {
+            ok: issues.length === 0,
+            issues,
+        };
+    };
+}

package/bin/services/command-runner.js

@@ -5,11 +5,11 @@ exports.createCommandRunner = createCommandRunner;
 const node_child_process_1 = require("node:child_process");
 exports.COMMAND_RUNNER_STAGE = "build";
 class ExecutionError extends Error {
-    constructor(code, command, exitCode, message) {
+    constructor(code, stage, command, exitCode, message) {
         super(message);
-        this.stage = exports.COMMAND_RUNNER_STAGE;
         this.name = "ExecutionError";
         this.code = code;
+        this.stage = stage;
         this.command = command;
         this.exitCode = exitCode;
     }
@@ -17,6 +17,7 @@ class ExecutionError extends Error {
 exports.ExecutionError = ExecutionError;
 function createCommandRunner(deps) {
     const spawnSyncImpl = deps?.spawnSyncImpl ?? node_child_process_1.spawnSync;
+    const stage = deps?.stage ?? exports.COMMAND_RUNNER_STAGE;
     return async (input) => {
         const args = input.args ?? [];
         const output = spawnSyncImpl(input.command, args, {
@@ -35,7 +36,7 @@ function createCommandRunner(deps) {
                 ? "COMMAND_NOT_FOUND"
                 : "COMMAND_EXECUTION_FAILED";
             const messagePrefix = isNotFound ? "命令不存在" : "命令执行异常";
-            throw new ExecutionError(code, input.command, 1, `[${exports.COMMAND_RUNNER_STAGE}][${code}] ${messagePrefix}: ${input.command} (${output.error.message})`);
+            throw new ExecutionError(code, stage, input.command, 1, `[${stage}][${code}] ${messagePrefix}: ${input.command} (${output.error.message})`);
         }
         return {
             exitCode: output.status ?? 1,