@intra-mart/accel 0.1.0 → 0.3.0-next.202605250439

package/dist/commands/deploy.js

@@ -0,0 +1,188 @@
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { detectLocale } from "../utils/locale-detect.js";
+import { readSettings } from "../utils/settings-io.js";
+import { getMessage } from "../i18n/index.js";
+import { ensureCredentials as defaultEnsureCredentials } from "../interactive/credentials-prompts.js";
+import { scanTargets as defaultScanTargets } from "../deploy/target-scanner.js";
+import { createApiClient as defaultApiClientFactory, isDeployError, } from "../deploy/api-client.js";
+export const toImmFileName = (zipPath) => {
+    const base = basename(zipPath);
+    return base.replace(/\.zip$/i, "") + ".imm";
+};
+const defaultPrompts = {
+    selectStaging: async (stagings, locale) => {
+        const res = await p.select({
+            message: getMessage("deploy.selectStaging", locale),
+            options: stagings.map((s) => ({
+                value: s.stagingId,
+                label: s.description
+                    ? `${s.stagingId} (${s.description})`
+                    : s.stagingId,
+            })),
+        });
+        if (p.isCancel(res))
+            process.exit(0);
+        return res;
+    },
+    selectZip: async (zips, locale) => {
+        const res = await p.select({
+            message: getMessage("deploy.selectZip", locale),
+            options: zips.map((z) => ({ value: z, label: basename(z) })),
+        });
+        if (p.isCancel(res))
+            process.exit(0);
+        return res;
+    },
+    description: async (locale) => {
+        const res = await p.text({
+            message: getMessage("deploy.descriptionPrompt", locale),
+            defaultValue: "",
+            initialValue: "",
+        });
+        if (p.isCancel(res))
+            process.exit(0);
+        return res;
+    },
+    confirm: async (info, locale) => {
+        p.note([
+            `${getMessage("deploy.confirm.endpoint", locale)}: ${info.endpoint}`,
+            `${getMessage("deploy.confirm.stagingId", locale)}: ${info.stagingId}`,
+            `${getMessage("deploy.confirm.sourceFile", locale)}: ${info.sourceFile}`,
+            `${getMessage("deploy.confirm.sentAs", locale)}: ${info.sentAs}`,
+        ].join("\n"));
+        const res = await p.confirm({
+            message: getMessage("deploy.confirm", locale),
+            initialValue: true,
+        });
+        if (p.isCancel(res))
+            process.exit(0);
+        return res;
+    },
+};
+const resolveLocale = async (projectDir) => {
+    try {
+        const settings = await readSettings(projectDir);
+        return settings.locale ?? detectLocale();
+    }
+    catch {
+        return detectLocale();
+    }
+};
+const formatDeployError = (err, locale) => {
+    if (err.kind === "network") {
+        return getMessage("deploy.error.network", locale, {
+            message: err.serverMessage ?? "",
+        });
+    }
+    if (err.serverMessage) {
+        return getMessage("deploy.error.server", locale, {
+            message: err.serverMessage,
+        });
+    }
+    switch (err.status) {
+        case 401:
+            return getMessage("deploy.error.unauthorized", locale);
+        case 403:
+            return getMessage("deploy.error.forbidden", locale);
+        case 404:
+            return getMessage("deploy.error.notFound", locale);
+        case 400:
+            return getMessage("deploy.error.badRequest", locale);
+        case 500:
+            return getMessage("deploy.error.serverError", locale);
+        default:
+            return getMessage("deploy.error.unexpectedResponse", locale, {
+                status: String(err.status ?? "?"),
+            });
+    }
+};
+export const runDeploy = async (deps) => {
+    const { projectDir } = deps;
+    const locale = deps.locale ?? (await resolveLocale(projectDir));
+    const ensureCreds = deps.ensureCredentials ?? defaultEnsureCredentials;
+    const scan = deps.scanTargets ?? defaultScanTargets;
+    const apiClientFactory = deps.apiClientFactory ?? defaultApiClientFactory;
+    const prompts = deps.prompts ?? defaultPrompts;
+    p.intro(getMessage("deploy.intro", locale));
+    const creds = await ensureCreds(projectDir, locale);
+    const api = apiClientFactory(creds.endpoint, creds.apiKey);
+    const spin = p.spinner();
+    spin.start(getMessage("deploy.progress.fetchingStagings", locale));
+    let stagings;
+    try {
+        stagings = await api.listStagings();
+    }
+    catch (err) {
+        spin.stop(getMessage("deploy.progress.fetchingStagings", locale));
+        throw logAndRethrow(err, locale);
+    }
+    spin.stop(getMessage("deploy.progress.fetchingStagings", locale));
+    if (stagings.length === 0) {
+        p.log.error(getMessage("deploy.error.noStagings", locale));
+        throw new Error("no stagings");
+    }
+    const stagingId = await prompts.selectStaging(stagings, locale);
+    const zips = await scan(projectDir);
+    if (zips.length === 0) {
+        p.log.error(getMessage("deploy.error.noTargetZip", locale));
+        throw new Error("no target zip");
+    }
+    const zipPath = zips.length === 1 ? zips[0] : await prompts.selectZip(zips, locale);
+    const description = (await prompts.description(locale)).trim();
+    const immName = toImmFileName(zipPath);
+    const confirmed = await prompts.confirm({
+        endpoint: creds.endpoint,
+        stagingId,
+        sourceFile: basename(zipPath),
+        sentAs: immName,
+    }, locale);
+    if (!confirmed) {
+        p.log.info(getMessage("deploy.cancelled", locale));
+        return;
+    }
+    const bytes = await readFile(zipPath);
+    spin.start(getMessage("deploy.progress.deploying", locale));
+    let result;
+    try {
+        result = await api.createDeployment(stagingId, bytes, immName, description.length > 0 ? description : undefined);
+    }
+    catch (err) {
+        spin.stop(getMessage("deploy.progress.deploying", locale));
+        throw logAndRethrow(err, locale);
+    }
+    spin.stop(getMessage("deploy.progress.deploying", locale));
+    p.note([
+        `${getMessage("deploy.result.deployId", locale)}: ${result.deployId}`,
+        `${getMessage("deploy.result.stagingId", locale)}: ${result.stagingId}`,
+        `${getMessage("deploy.result.status", locale)}: ${result.status}`,
+        `${getMessage("deploy.result.createDate", locale)}: ${result.createDate}`,
+    ].join("\n"));
+    p.outro(getMessage("deploy.success", locale));
+};
+const logAndRethrow = (err, locale) => {
+    if (isDeployError(err)) {
+        p.log.error(formatDeployError(err, locale));
+    }
+    else {
+        p.log.error(err instanceof Error ? err.message : String(err));
+    }
+    return err;
+};
+export const deployCommand = defineCommand({
+    meta: {
+        name: "deploy",
+        description: "Deploy build artifacts to an iAP staging environment",
+    },
+    args: {},
+    run: async () => {
+        try {
+            await runDeploy({ projectDir: process.cwd() });
+        }
+        catch {
+            process.exit(1);
+        }
+    },
+});

package/dist/commands/init.d.ts

@@ -48,6 +48,10 @@ export declare const initCommand: import("citty").CommandDef<{
         type: "string";
         description: string;
     };
+    "package-manager": {
+        type: "string";
+        description: string;
+    };
     "git-init": {
         type: "boolean";
         description: string;

package/dist/commands/init.js

@@ -12,6 +12,9 @@ import { defaultAssetSourcePath } from "../asset/default-source.js";
 import { getMessage } from "../i18n/index.js";
 import { detectLocale } from "../utils/locale-detect.js";
 import { commandExists } from "../utils/command-exists.js";
+import { printSummary } from "../interactive/summary.js";
+import { printNextSteps } from "../interactive/next-steps.js";
+import { buildProgressCallbacks } from "../interactive/progress.js";
 export const initCommand = defineCommand({
     meta: {
         name: "init",
@@ -67,6 +70,10 @@ export const initCommand = defineCommand({
             type: "string",
             description: "Maven artifactId (defaults to project name)",
         },
+        "package-manager": {
+            type: "string",
+            description: "Package manager (bun, npm, yarn, pnpm). Default: bun",
+        },
         "git-init": {
             type: "boolean",
             description: "Initialize git repository (use --no-git-init to disable)",
@@ -113,6 +120,7 @@ export const initCommand = defineCommand({
             agent: agentArg
                 ? agentArg.split(",").map((a) => a.trim())
                 : undefined,
+            packageManager: args["package-manager"],
             locale,
             withGit: args["git-init"],
             noInteraction: args["non-interactive"],
@@ -149,20 +157,25 @@ export const initCommand = defineCommand({
             agents: resolved.agents,
             javascript: resolved.javascript,
             locale: resolved.locale,
+            packageManager: resolved.packageManager,
             jugglingProject: resolved.jugglingProject,
             deployedAssets: {},
         };
+        const isInteractive = !args["non-interactive"];
+        if (isInteractive) {
+            printSummary(settings, projectDir, locale);
+        }
         const serverUrl = args["asset-server-url"];
         const assetSource = args["asset-source"] ?? defaultAssetSourcePath();
         const provider = serverUrl
             ? createLocalAssetProvider(serverUrl)
             : createFileAssetProvider(assetSource);
-        p.log.info(getMessage("progress.deploying", locale));
         await deployAssets({
             projectDir,
             settings,
             provider,
             noInstall: args["skip-install"],
+            progress: buildProgressCallbacks(locale),
         });
         if (resolved.withGit) {
             if (commandExists("git")) {
@@ -179,5 +192,11 @@ export const initCommand = defineCommand({
             }
         }
         p.log.success(getMessage("progress.complete", locale));
+        printNextSteps({
+            projectDir,
+            agents: resolved.agents,
+            isInit: true,
+            locale,
+        });
     },
 });

package/dist/core/condition-evaluator.js

@@ -1,5 +1,5 @@
 import { satisfies } from "semver";
-import { isAndCondition, isOrCondition, isVersionCondition, isModuleCondition, isLocaleCondition, isAgentCondition, } from "./types.js";
+import { isAndCondition, isOrCondition, isVersionCondition, isModuleCondition, isLocaleCondition, isAgentCondition, isPackageManagerCondition, isJavascriptCondition, } from "./types.js";
 export const evaluateCondition = (condition, context) => {
     if (condition === undefined) {
         return true;
@@ -22,5 +22,11 @@ export const evaluateCondition = (condition, context) => {
     if (isAgentCondition(condition)) {
         return context.agents.includes(condition.agent);
     }
+    if (isPackageManagerCondition(condition)) {
+        return context.packageManager === condition.packageManager;
+    }
+    if (isJavascriptCondition(condition)) {
+        return context.javascript === condition.javascript;
+    }
     return false;
 };

package/dist/core/constants.d.ts

@@ -8,4 +8,6 @@ export declare const MODULE_OPTIONS: readonly ["workflow", "bpm", "copilot", "im
 export type ModuleOption = (typeof MODULE_OPTIONS)[number];
 export declare const LOCALE_OPTIONS: readonly ["ja", "en", "zh_CN"];
 export type LocaleOption = (typeof LOCALE_OPTIONS)[number];
+export declare const PACKAGE_MANAGER_OPTIONS: readonly ["bun", "npm", "yarn", "pnpm"];
+export type PackageManagerOption = (typeof PACKAGE_MANAGER_OPTIONS)[number];
 export declare const DEFAULT_SETTINGS: Omit<AccelSettings, "cliVersion" | "createdAt" | "deployedAssets">;

package/dist/core/constants.js

@@ -10,17 +10,24 @@ export const MODULE_OPTIONS = [
     "kaiden",
 ];
 export const LOCALE_OPTIONS = ["ja", "en", "zh_CN"];
+export const PACKAGE_MANAGER_OPTIONS = [
+    "bun",
+    "npm",
+    "yarn",
+    "pnpm",
+];
 export const DEFAULT_SETTINGS = {
     name: "my-accel-project",
     artifactId: "",
     group: "com.example",
     projectVersion: "0.1.0",
     description: "",
-    accelplatformVersion: "2025-Autumn",
+    accelplatformVersion: "2026-Spring",
     modules: [],
     database: "postgresql",
     agents: ["claude-code", "github-copilot"],
     javascript: false,
     locale: "ja",
+    packageManager: "bun",
     jugglingProject: null,
 };

package/dist/core/types.d.ts

@@ -16,7 +16,13 @@ export type LocaleCondition = {
 export type AgentCondition = {
     agent: string;
 };
-export type LeafCondition = VersionCondition | ModuleCondition | LocaleCondition | AgentCondition;
+export type PackageManagerCondition = {
+    packageManager: string;
+};
+export type JavascriptCondition = {
+    javascript: boolean;
+};
+export type LeafCondition = VersionCondition | ModuleCondition | LocaleCondition | AgentCondition | PackageManagerCondition | JavascriptCondition;
 export type Condition = AndCondition | OrCondition | LeafCondition;
 export type TextReplacement = {
     type: "text";
@@ -69,6 +75,7 @@ export type AccelSettings = {
     agents: string[];
     javascript: boolean;
     locale: string;
+    packageManager: string;
     jugglingProject: string | null;
     deployedAssets: Record<string, string>;
 };
@@ -93,6 +100,8 @@ export type EvalContext = {
     accelplatformVersion: string;
     database: string;
     projectVersion: string;
+    packageManager: string;
+    javascript: boolean;
 };
 export declare const isAndCondition: (c: Condition) => c is AndCondition;
 export declare const isOrCondition: (c: Condition) => c is OrCondition;
@@ -100,3 +109,44 @@ export declare const isVersionCondition: (c: Condition) => c is VersionCondition
 export declare const isModuleCondition: (c: Condition) => c is ModuleCondition;
 export declare const isLocaleCondition: (c: Condition) => c is LocaleCondition;
 export declare const isAgentCondition: (c: Condition) => c is AgentCondition;
+export declare const isPackageManagerCondition: (c: Condition) => c is PackageManagerCondition;
+export declare const isJavascriptCondition: (c: Condition) => c is JavascriptCondition;
+export type AccelCredentials = {
+    endpoint: string;
+    apiKey: string;
+};
+export type StagingResponse = {
+    stagingId: string;
+    description?: string | null;
+    currentDeployId?: string | null;
+    createUserCd: string;
+    createDate: string;
+};
+export type StagingListResponse = {
+    totalCount: number;
+    offset: number;
+    limit: number;
+    records: StagingResponse[];
+};
+export type DeploymentResponse = {
+    deployId: string;
+    stagingId: string;
+    status: "STAGED" | "UNDEPLOYED";
+    description?: string | null;
+    createUserCd: string;
+    createDate: string;
+};
+export type ApiSuccess<T> = {
+    error: false;
+    data: T;
+};
+export type ApiErrorBody = {
+    error: true;
+    errorMessage: string;
+};
+export type DeployError = {
+    _tag: "DeployError";
+    kind: "network" | "http";
+    status?: number;
+    serverMessage?: string;
+};

package/dist/core/types.js

@@ -4,3 +4,5 @@ export const isVersionCondition = (c) => "version" in c && !("and" in c) && !("o
 export const isModuleCondition = (c) => "module" in c;
 export const isLocaleCondition = (c) => "locale" in c;
 export const isAgentCondition = (c) => "agent" in c;
+export const isPackageManagerCondition = (c) => "packageManager" in c;
+export const isJavascriptCondition = (c) => "javascript" in c;

package/dist/core/validators.d.ts

@@ -1,4 +1,4 @@
-export type Validator = (value: string) => string | undefined;
+export type Validator = (value: string | undefined) => string | undefined;
 export type Validators = {
     name: Validator;
     artifactId: Validator;
@@ -8,5 +8,6 @@ export type Validators = {
     module: Validator;
     database: Validator;
     agent: Validator;
+    packageManager: Validator;
 };
 export declare const createValidators: (locale: string) => Validators;

package/dist/core/validators.js

@@ -1,5 +1,5 @@
 import { getMessage } from "../i18n/index.js";
-import { AGENT_OPTIONS, DATABASE_OPTIONS, MODULE_OPTIONS, } from "./constants.js";
+import { AGENT_OPTIONS, DATABASE_OPTIONS, MODULE_OPTIONS, PACKAGE_MANAGER_OPTIONS, } from "./constants.js";
 import { SELECTABLE_VERSIONS } from "./version-map.js";
 const ARTIFACT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const GROUP_PATTERN = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/;
@@ -23,29 +23,62 @@ const isValidVersionLabel = (value) => SELECTABLE_VERSIONS.some((v) => v.label =
 const isValidModule = (value) => MODULE_OPTIONS.includes(value);
 const isValidDatabase = (value) => DATABASE_OPTIONS.includes(value);
 const isValidAgent = (value) => AGENT_OPTIONS.includes(value);
+const isValidPackageManager = (value) => PACKAGE_MANAGER_OPTIONS.includes(value);
 export const createValidators = (locale) => ({
-    name: (value) => isValidName(value)
-        ? undefined
-        : getMessage("error.invalidName", locale, { value }),
-    artifactId: (value) => isValidArtifactId(value)
-        ? undefined
-        : getMessage("error.invalidArtifactId", locale, { value }),
-    group: (value) => isValidGroup(value)
-        ? undefined
-        : getMessage("error.invalidGroup", locale, { value }),
-    projectVersion: (value) => isValidProjectVersion(value)
-        ? undefined
-        : getMessage("error.invalidProjectVersion", locale, { value }),
-    versionLabel: (value) => isValidVersionLabel(value)
-        ? undefined
-        : getMessage("error.invalidVersion", locale, { version: value }),
-    module: (value) => isValidModule(value)
-        ? undefined
-        : getMessage("error.invalidModule", locale, { module: value }),
-    database: (value) => isValidDatabase(value)
-        ? undefined
-        : getMessage("error.invalidDatabase", locale, { database: value }),
-    agent: (value) => isValidAgent(value)
-        ? undefined
-        : getMessage("error.invalidAgent", locale, { agent: value }),
+    name: (value) => {
+        const v = value ?? "";
+        return isValidName(v)
+            ? undefined
+            : getMessage("error.invalidName", locale, { value: v });
+    },
+    artifactId: (value) => {
+        const v = value ?? "";
+        return isValidArtifactId(v)
+            ? undefined
+            : getMessage("error.invalidArtifactId", locale, { value: v });
+    },
+    group: (value) => {
+        const v = value ?? "";
+        return isValidGroup(v)
+            ? undefined
+            : getMessage("error.invalidGroup", locale, { value: v });
+    },
+    projectVersion: (value) => {
+        const v = value ?? "";
+        return isValidProjectVersion(v)
+            ? undefined
+            : getMessage("error.invalidProjectVersion", locale, { value: v });
+    },
+    versionLabel: (value) => {
+        const v = value ?? "";
+        return isValidVersionLabel(v)
+            ? undefined
+            : getMessage("error.invalidVersion", locale, { version: v });
+    },
+    module: (value) => {
+        const v = value ?? "";
+        return isValidModule(v)
+            ? undefined
+            : getMessage("error.invalidModule", locale, { module: v });
+    },
+    database: (value) => {
+        const v = value ?? "";
+        return isValidDatabase(v)
+            ? undefined
+            : getMessage("error.invalidDatabase", locale, { database: v });
+    },
+    agent: (value) => {
+        const v = value ?? "";
+        return isValidAgent(v)
+            ? undefined
+            : getMessage("error.invalidAgent", locale, { agent: v });
+    },
+    packageManager: (value) => {
+        const v = value ?? "";
+        return isValidPackageManager(v)
+            ? undefined
+            : getMessage("error.invalidPackageManager", locale, {
+                packageManager: v,
+            });
+    },
 });

package/dist/core/variable-interpolator.js

@@ -8,6 +8,7 @@ const VARIABLE_MAP = new Map([
     ["locale", "locale"],
     ["database", "database"],
     ["projectVersion", "projectVersion"],
+    ["packageManager", "packageManager"],
 ]);
 const INTERPOLATION_PATTERN = /\{\{\$(\w+)\}\}/g;
 export const interpolateVariables = (template, context) => {

package/dist/deploy/api-client.d.ts

@@ -0,0 +1,15 @@
+import type { StagingResponse, DeploymentResponse, DeployError } from "../core/types.js";
+type FetchFn = typeof globalThis.fetch;
+export declare const makeDeployError: (kind: DeployError["kind"], extra?: {
+    status?: number;
+    serverMessage?: string;
+}) => DeployError;
+export declare const isDeployError: (e: unknown) => e is DeployError;
+export type ApiClient = {
+    listStagings: () => Promise<StagingResponse[]>;
+    createDeployment: (stagingId: string, bytes: Uint8Array, immFileName: string, description?: string) => Promise<DeploymentResponse>;
+};
+export declare const createApiClient: (endpoint: string, apiKey: string, deps?: {
+    fetch?: FetchFn;
+}) => ApiClient;
+export {};

package/dist/deploy/api-client.js

@@ -0,0 +1,81 @@
+const STAGING_PATH = "/api/bearer/development/staging";
+const PAGE_LIMIT = 100;
+const MAX_PAGES = 1000;
+export const makeDeployError = (kind, extra = {}) => ({ _tag: "DeployError", kind, ...extra });
+export const isDeployError = (e) => typeof e === "object" &&
+    e !== null &&
+    e._tag === "DeployError";
+export const createApiClient = (endpoint, apiKey, deps = {}) => {
+    const doFetch = deps.fetch ?? globalThis.fetch;
+    const baseHeaders = {
+        "X-Intramart-Session": "never",
+        Authorization: `Bearer ${apiKey}`,
+    };
+    const request = async (url, init) => {
+        let res;
+        try {
+            res = await doFetch(url, init);
+        }
+        catch (err) {
+            throw makeDeployError("network", {
+                serverMessage: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const text = await res.text();
+        let body;
+        try {
+            body = text.length > 0 ? JSON.parse(text) : undefined;
+        }
+        catch {
+            throw makeDeployError("http", { status: res.status });
+        }
+        if (body !== null &&
+            typeof body === "object" &&
+            body.error === true) {
+            throw makeDeployError("http", {
+                status: res.status,
+                serverMessage: body.errorMessage,
+            });
+        }
+        if (!res.ok) {
+            throw makeDeployError("http", { status: res.status });
+        }
+        if (body !== null &&
+            typeof body === "object" &&
+            "data" in body) {
+            return body.data;
+        }
+        throw makeDeployError("http", { status: res.status });
+    };
+    const listStagings = async () => {
+        const records = [];
+        let offset = 0;
+        for (let page = 0; page < MAX_PAGES; page++) {
+            const url = `${endpoint}${STAGING_PATH}?offset=${offset}&limit=${PAGE_LIMIT}`;
+            const data = await request(url, {
+                method: "GET",
+                headers: baseHeaders,
+            });
+            records.push(...data.records);
+            if (records.length >= data.totalCount || data.records.length === 0) {
+                break;
+            }
+            offset += PAGE_LIMIT;
+        }
+        return records;
+    };
+    const createDeployment = async (stagingId, bytes, immFileName, description) => {
+        const form = new FormData();
+        form.append("archiveFile", new File([bytes], immFileName, { type: "application/zip" }));
+        if (description && description.length > 0) {
+            form.append("description", description);
+        }
+        const url = `${endpoint}${STAGING_PATH}/${encodeURIComponent(stagingId)}/deploy`;
+        return request(url, {
+            method: "POST",
+            headers: baseHeaders,
+            body: form,
+        });
+    };
+    return { listStagings, createDeployment };
+};

package/dist/deploy/target-scanner.d.ts

@@ -0,0 +1,5 @@
+export type ScanOptions = {
+    dir?: string;
+    pattern?: RegExp;
+};
+export declare const scanTargets: (projectDir: string, opts?: ScanOptions) => Promise<string[]>;

package/dist/deploy/target-scanner.js

@@ -0,0 +1,20 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+const DEFAULT_DIR = "target";
+const DEFAULT_PATTERN = /\.zip$/i;
+export const scanTargets = async (projectDir, opts = {}) => {
+    const dir = opts.dir ?? DEFAULT_DIR;
+    const pattern = opts.pattern ?? DEFAULT_PATTERN;
+    const targetDir = join(projectDir, dir);
+    let entries;
+    try {
+        entries = await readdir(targetDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isFile() && pattern.test(e.name))
+        .map((e) => join(targetDir, e.name))
+        .sort();
+};