@intra-mart/accel 0.2.0-dev.202605280431 → 0.2.0-dev.202606100307

package/dist/commands/deploy.js

@@ -0,0 +1,293 @@
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { readFile, stat } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { detectLocale } from "../utils/locale-detect.js";
+import { formatEpochMillis } from "../utils/date-formatter.js";
+import { readSettings, readSettingsSafe } from "../utils/settings-io.js";
+import { persistCredentials as defaultPersistCredentials, resolveCredentialInputs, } from "../utils/credentials.js";
+import { getMessage } from "../i18n/index.js";
+import { lastFlagValue } from "../utils/args.js";
+import { ensureCredentials as defaultEnsureCredentials, repromptCredentials as defaultRepromptCredentials, resolveCredentialsOrThrow as defaultResolveCredentialsOrThrow, } from "../interactive/credentials-prompts.js";
+import { scanTargets as defaultScanTargets } from "../deploy/target-scanner.js";
+import { selectDeployTarget } from "../deploy/target-selector.js";
+import { verifyCredentialsLoop } from "../interactive/credential-auth.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 ?? "?"),
+            });
+    }
+};
+const resolveZipPath = async (opts) => {
+    const { projectDir, locale, nonInteractive, fileArg, scan, selectZip } = opts;
+    if (fileArg && fileArg.length > 0) {
+        const filePath = resolve(projectDir, fileArg);
+        try {
+            const s = await stat(filePath);
+            if (!s.isFile())
+                throw new Error("not a file");
+        }
+        catch {
+            p.log.error(getMessage("deploy.error.fileNotFound", locale, { path: fileArg }));
+            throw new Error("file not found");
+        }
+        return filePath;
+    }
+    const zips = await scan(projectDir);
+    if (zips.length === 0) {
+        p.log.error(getMessage("deploy.error.noTargetZip", locale));
+        throw new Error("no target zip");
+    }
+    const settings = await readSettingsSafe(projectDir);
+    const selection = selectDeployTarget(zips, settings
+        ? { artifactId: settings.artifactId, projectVersion: settings.projectVersion }
+        : null);
+    if ("auto" in selection)
+        return selection.auto;
+    if (nonInteractive) {
+        p.log.error(getMessage("deploy.error.zipNotResolved", locale));
+        throw new Error("zip not resolved");
+    }
+    return selection.candidates.length === 1
+        ? selection.candidates[0]
+        : await selectZip(selection.candidates, locale);
+};
+export const runDeploy = async (deps) => {
+    const { projectDir } = deps;
+    const locale = deps.locale ?? (await resolveLocale(projectDir));
+    const ensureCreds = deps.ensureCredentials ?? defaultEnsureCredentials;
+    const reprompt = deps.repromptCredentials ?? defaultRepromptCredentials;
+    const resolveOrThrow = deps.resolveCredentialsOrThrow ?? defaultResolveCredentialsOrThrow;
+    const persist = deps.persistCredentials ?? defaultPersistCredentials;
+    const scan = deps.scanTargets ?? defaultScanTargets;
+    const apiClientFactory = deps.apiClientFactory ?? defaultApiClientFactory;
+    const prompts = deps.prompts ?? defaultPrompts;
+    const env = deps.env ?? process.env;
+    const nonInteractive = deps.nonInteractive ?? false;
+    const seed = resolveCredentialInputs({ endpoint: deps.endpoint, apiKey: deps.apiKey }, env);
+    const fileArg = deps.file?.trim();
+    const stagingArg = deps.stagingId?.trim();
+    p.intro(getMessage("deploy.intro", locale));
+    const spin = p.spinner();
+    const initialCreds = nonInteractive
+        ? await resolveOrThrow(projectDir, locale, seed)
+        : await ensureCreds(projectDir, locale, seed);
+    const { creds, api } = await verifyCredentialsLoop(projectDir, locale, initialCreds, { dirty: false, interactive: !nonInteractive }, {
+        apiClientFactory,
+        repromptCredentials: reprompt,
+        persistCredentials: persist,
+    });
+    let stagingId;
+    if (stagingArg && stagingArg.length > 0) {
+        stagingId = stagingArg;
+    }
+    else if (nonInteractive) {
+        p.log.error(getMessage("deploy.error.missingStagingId", locale));
+        throw new Error("missing staging id");
+    }
+    else {
+        let stagings;
+        spin.start(getMessage("deploy.progress.fetchingStagings", locale));
+        try {
+            stagings = await api.listStagings();
+            spin.stop(getMessage("deploy.progress.fetchingStagings", locale));
+        }
+        catch (err) {
+            spin.stop(getMessage("deploy.progress.fetchingStagings", locale));
+            throw logAndRethrow(err, locale);
+        }
+        if (stagings.length === 0) {
+            p.log.error(getMessage("deploy.error.noStagings", locale));
+            throw new Error("no stagings");
+        }
+        stagingId = await prompts.selectStaging(stagings, locale);
+    }
+    const zipPath = await resolveZipPath({
+        projectDir,
+        locale,
+        nonInteractive,
+        fileArg,
+        scan,
+        selectZip: prompts.selectZip,
+    });
+    const description = (deps.description !== undefined
+        ? deps.description
+        : nonInteractive
+            ? ""
+            : await prompts.description(locale)).trim();
+    const immName = toImmFileName(zipPath);
+    if (!nonInteractive) {
+        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)}: ${formatEpochMillis(result.createDate, locale)}`,
+    ].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: {
+        endpoint: {
+            type: "string",
+            description: "iAP base URL (or set ACCEL_ENDPOINT)",
+        },
+        "api-key": {
+            type: "string",
+            description: "OAuth Bearer token. Prefer the ACCEL_API_KEY env var (argv leaks to process listings / CI logs)",
+        },
+        "staging-id": {
+            type: "string",
+            description: "Target staging ID (required in non-interactive mode)",
+        },
+        file: {
+            type: "string",
+            description: "Path to the zip to deploy (not restricted to ./target/)",
+        },
+        description: {
+            type: "string",
+            description: "Deployment description",
+        },
+        "non-interactive": {
+            type: "boolean",
+            description: "Non-interactive mode (no prompts; exits non-zero on failure)",
+            default: false,
+        },
+    },
+    run: async ({ args }) => {
+        try {
+            await runDeploy({
+                projectDir: process.cwd(),
+                nonInteractive: args["non-interactive"],
+                endpoint: lastFlagValue(args.endpoint),
+                apiKey: lastFlagValue(args["api-key"]),
+                stagingId: lastFlagValue(args["staging-id"]),
+                file: lastFlagValue(args.file),
+                description: lastFlagValue(args.description),
+            });
+        }
+        catch {
+            process.exit(1);
+        }
+    },
+});

package/dist/commands/init.d.ts

@@ -67,11 +67,19 @@ export declare const initCommand: import("citty").CommandDef<{
         description: string;
         default: false;
     };
+    "asset-server-url": {
+        type: "string";
+        description: string;
+    };
+    "asset-ref": {
+        type: "string";
+        description: string;
+    };
     "asset-source": {
         type: "string";
         description: string;
     };
-    "asset-server-url": {
+    "debug-server-url": {
         type: "string";
         description: string;
     };

package/dist/commands/init.js

@@ -3,12 +3,12 @@ import * as p from "@clack/prompts";
 import { mkdir, stat } from "node:fs/promises";
 import { execSync } from "node:child_process";
 import { resolve } from "node:path";
-import { CLI_VERSION } from "../core/constants.js";
+import { CLI_VERSION, DEFAULT_ASSET_REPO_URL, DEFAULT_ASSET_REF, } from "../core/constants.js";
 import { runPrompts } from "../interactive/prompts.js";
 import { deployAssets } from "../asset/deployer.js";
 import { createLocalAssetProvider } from "../asset/local-provider.js";
 import { createFileAssetProvider } from "../asset/file-provider.js";
-import { defaultAssetSourcePath } from "../asset/default-source.js";
+import { createGitHubAssetProvider } from "../asset/github-provider.js";
 import { getMessage } from "../i18n/index.js";
 import { detectLocale } from "../utils/locale-detect.js";
 import { commandExists } from "../utils/command-exists.js";
@@ -89,13 +89,21 @@ export const initCommand = defineCommand({
             description: "Non-interactive mode",
             default: false,
         },
+        "asset-server-url": {
+            type: "string",
+            description: "GitHub repository URL to fetch assets from (overrides the default repository)",
+        },
+        "asset-ref": {
+            type: "string",
+            description: "Git ref (branch/tag/commit) to fetch from the GitHub asset repository. Default: master",
+        },
         "asset-source": {
             type: "string",
-            description: "Local asset source path (tar archive or extracted directory). Defaults to the bundled assets/assets.tar.gz.",
+            description: "(debug) Local asset source path (tar archive or extracted directory)",
         },
-        "asset-server-url": {
+        "debug-server-url": {
             type: "string",
-            description: "Asset server URL (takes precedence over --asset-source when explicitly set)",
+            description: "(debug) Local asset server URL serving GET /archive",
         },
     },
     run: async ({ args }) => {
@@ -165,11 +173,14 @@ export const initCommand = defineCommand({
         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);
+        const assetSource = args["asset-source"];
+        const debugServerUrl = args["debug-server-url"];
+        const provider = assetSource
+            ? createFileAssetProvider(assetSource)
+            : debugServerUrl
+                ? createLocalAssetProvider(debugServerUrl)
+                : createGitHubAssetProvider(args["asset-server-url"] ??
+                    DEFAULT_ASSET_REPO_URL, args["asset-ref"] ?? DEFAULT_ASSET_REF);
         await deployAssets({
             projectDir,
             settings,

package/dist/commands/login.d.ts

@@ -0,0 +1,31 @@
+import type { AccelCredentials } from "../core/types.js";
+import { type ApiClient } from "../deploy/api-client.js";
+export type RunLoginDeps = {
+    projectDir: string;
+    locale?: string;
+    nonInteractive?: boolean;
+    endpoint?: string;
+    apiKey?: string;
+    env?: Record<string, string | undefined>;
+    readCredentials?: (projectDir: string) => Promise<Partial<AccelCredentials>>;
+    repromptCredentials?: (current: AccelCredentials, locale: string, seed?: Partial<AccelCredentials>) => Promise<AccelCredentials>;
+    resolveCredentialsOrThrow?: (projectDir: string, locale: string, seed: Partial<AccelCredentials>) => Promise<AccelCredentials>;
+    persistCredentials?: (projectDir: string, creds: AccelCredentials) => Promise<void>;
+    apiClientFactory?: (endpoint: string, apiKey: string) => ApiClient;
+};
+export declare const runLogin: (deps: RunLoginDeps) => Promise<void>;
+export declare const loginCommand: import("citty").CommandDef<{
+    endpoint: {
+        type: "string";
+        description: string;
+    };
+    "api-key": {
+        type: "string";
+        description: string;
+    };
+    "non-interactive": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;

package/dist/commands/login.js

@@ -0,0 +1,75 @@
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { detectLocale } from "../utils/locale-detect.js";
+import { readSettingsSafe } from "../utils/settings-io.js";
+import { readCredentials as defaultReadCredentials, persistCredentials as defaultPersistCredentials, resolveCredentialInputs, } from "../utils/credentials.js";
+import { repromptCredentials as defaultRepromptCredentials, resolveCredentialsOrThrow as defaultResolveCredentialsOrThrow, } from "../interactive/credentials-prompts.js";
+import { verifyCredentialsLoop } from "../interactive/credential-auth.js";
+import { createApiClient as defaultApiClientFactory, } from "../deploy/api-client.js";
+import { getMessage } from "../i18n/index.js";
+import { lastFlagValue } from "../utils/args.js";
+const resolveLocale = async (projectDir) => {
+    const settings = await readSettingsSafe(projectDir);
+    return settings?.locale ?? detectLocale();
+};
+export const runLogin = async (deps) => {
+    const { projectDir } = deps;
+    const locale = deps.locale ?? (await resolveLocale(projectDir));
+    const read = deps.readCredentials ?? defaultReadCredentials;
+    const reprompt = deps.repromptCredentials ?? defaultRepromptCredentials;
+    const resolveOrThrow = deps.resolveCredentialsOrThrow ?? defaultResolveCredentialsOrThrow;
+    const persist = deps.persistCredentials ?? defaultPersistCredentials;
+    const apiClientFactory = deps.apiClientFactory ?? defaultApiClientFactory;
+    const env = deps.env ?? process.env;
+    const seed = resolveCredentialInputs({ endpoint: deps.endpoint, apiKey: deps.apiKey }, env);
+    p.intro(getMessage("login.intro", locale));
+    let initial;
+    if (deps.nonInteractive) {
+        initial = await resolveOrThrow(projectDir, locale, seed);
+    }
+    else {
+        const existing = await read(projectDir);
+        initial = await reprompt({ endpoint: existing.endpoint ?? "", apiKey: existing.apiKey ?? "" }, locale, seed);
+    }
+    const { creds } = await verifyCredentialsLoop(projectDir, locale, initial, { dirty: true, interactive: !deps.nonInteractive }, {
+        apiClientFactory,
+        repromptCredentials: reprompt,
+        persistCredentials: persist,
+    });
+    p.log.success(`endpoint: ${creds.endpoint}`);
+    p.outro(getMessage("login.complete", locale));
+};
+export const loginCommand = defineCommand({
+    meta: {
+        name: "login",
+        description: "Configure and verify iAP connection credentials",
+    },
+    args: {
+        endpoint: {
+            type: "string",
+            description: "iAP base URL (or set ACCEL_ENDPOINT)",
+        },
+        "api-key": {
+            type: "string",
+            description: "OAuth Bearer token. Prefer the ACCEL_API_KEY env var (argv leaks to process listings / CI logs)",
+        },
+        "non-interactive": {
+            type: "boolean",
+            description: "Non-interactive mode (no prompts; exits non-zero on failure)",
+            default: false,
+        },
+    },
+    run: async ({ args }) => {
+        try {
+            await runLogin({
+                projectDir: process.cwd(),
+                nonInteractive: args["non-interactive"],
+                endpoint: lastFlagValue(args.endpoint),
+                apiKey: lastFlagValue(args["api-key"]),
+            });
+        }
+        catch {
+            process.exit(1);
+        }
+    },
+});

package/dist/core/constants.d.ts

@@ -10,4 +10,6 @@ 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_ASSET_REPO_URL = "https://github.com/accelplatform/skills";
+export declare const DEFAULT_ASSET_REF = "experiment";
 export declare const DEFAULT_SETTINGS: Omit<AccelSettings, "cliVersion" | "createdAt" | "deployedAssets">;

package/dist/core/constants.js

@@ -16,13 +16,15 @@ export const PACKAGE_MANAGER_OPTIONS = [
     "yarn",
     "pnpm",
 ];
+export const DEFAULT_ASSET_REPO_URL = "https://github.com/accelplatform/skills";
+export const DEFAULT_ASSET_REF = "experiment";
 export const DEFAULT_SETTINGS = {
     name: "my-accel-project",
     artifactId: "",
     group: "com.example",
     projectVersion: "0.1.0",
     description: "",
-    accelplatformVersion: "2025-Autumn",
+    accelplatformVersion: { label: "2026-Spring", semver: "8.0.39" },
     modules: [],
     database: "postgresql",
     agents: ["claude-code", "github-copilot"],

package/dist/core/types.d.ts

@@ -61,6 +61,7 @@ export type IapVersion = {
     label: string;
     codename: string;
 };
+export type AccelplatformVersion = Pick<IapVersion, "label" | "semver">;
 export type AccelSettings = {
     cliVersion: string;
     createdAt: string;
@@ -69,7 +70,7 @@ export type AccelSettings = {
     group: string;
     projectVersion: string;
     description: string;
-    accelplatformVersion: string;
+    accelplatformVersion: AccelplatformVersion;
     modules: string[];
     database: string;
     agents: string[];
@@ -111,3 +112,42 @@ 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: number;
+};
+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: number;
+};
+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/version-map.d.ts

@@ -1,7 +1,8 @@
-import type { IapVersion } from "./types.js";
+import type { AccelplatformVersion, IapVersion } from "./types.js";
 export declare const IAP_VERSIONS: readonly IapVersion[];
 export declare const SELECTABLE_VERSIONS: readonly IapVersion[];
 export declare const labelToSemver: (label: string) => string;
 export declare const semverToLabel: (semver: string) => string;
 export declare const findByLabel: (label: string) => IapVersion | undefined;
+export declare const resolveAccelplatformVersion: (label: string) => AccelplatformVersion;
 export declare const findBySemver: (semver: string) => IapVersion | undefined;

package/dist/core/version-map.js

@@ -1,30 +1,10 @@
 export const IAP_VERSIONS = [
-    { semver: "8.0.19", label: "2018-Spring", codename: "Skylark" },
-    { semver: "8.0.20", label: "2018-Summer", codename: "Tiffany" },
-    { semver: "8.0.21", label: "2018-Winter", codename: "Urara" },
-    { semver: "8.0.22", label: "2019-Spring", codename: "Violette" },
-    { semver: "8.0.23", label: "2019-Summer", codename: "Waltz" },
-    { semver: "8.0.24", label: "2019-Winter", codename: "Xanadu" },
-    { semver: "8.0.25", label: "2020-Spring", codename: "Yorkshire" },
-    { semver: "8.0.26", label: "2020-Summer", codename: "Zephirine" },
-    { semver: "8.0.27", label: "2020-Winter", codename: "Azalea" },
-    { semver: "8.0.28", label: "2021-Spring", codename: "Bergamot" },
-    { semver: "8.0.29", label: "2021-Summer", codename: "Cattleya" },
-    { semver: "8.0.30", label: "2021-Winter", codename: "Dandelion" },
-    { semver: "8.0.31", label: "2022-Spring", codename: "Eustoma" },
-    { semver: "8.0.32", label: "2022-Winter", codename: "Freesia" },
-    { semver: "8.0.33", label: "2023-Spring", codename: "Gerbera" },
-    { semver: "8.0.34", label: "2023-Autumn", codename: "Hollyhock" },
-    { semver: "8.0.35", label: "2024-Spring", codename: "Iris" },
-    { semver: "8.0.36", label: "2024-Autumn", codename: "Jasmine" },
     { semver: "8.0.37", label: "2025-Spring", codename: "Kamille" },
     { semver: "8.0.38", label: "2025-Autumn", codename: "Lilac" },
     { semver: "8.0.39", label: "2026-Spring", codename: "Mimosa" },
+    { semver: "8.0.40", label: "2026-Autumn", codename: "" },
 ];
-export const SELECTABLE_VERSIONS = IAP_VERSIONS.filter((v) => {
-    const minor = parseInt(v.semver.split(".")[2], 10);
-    return minor >= 35;
-});
+export const SELECTABLE_VERSIONS = IAP_VERSIONS;
 const labelToVersionMap = new Map(IAP_VERSIONS.map((v) => [v.label, v]));
 const semverToVersionMap = new Map(IAP_VERSIONS.map((v) => [v.semver, v]));
 export const labelToSemver = (label) => {
@@ -42,4 +22,11 @@ export const semverToLabel = (semver) => {
     return version.label;
 };
 export const findByLabel = (label) => labelToVersionMap.get(label);
+export const resolveAccelplatformVersion = (label) => {
+    const version = labelToVersionMap.get(label);
+    if (!version) {
+        throw new Error(`Unknown iAP version label: ${label}`);
+    }
+    return { label: version.label, semver: version.semver };
+};
 export const findBySemver = (semver) => semverToVersionMap.get(semver);

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

@@ -0,0 +1,16 @@
+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 = {
+    verifyToken: () => Promise<void>;
+    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 {};