@akanjs/devkit 1.0.19 → 2.1.0-rc.0

package/akanConfig/akanConfig.test.ts

@@ -0,0 +1,236 @@
+import { describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { PackageJson } from "../types";
+import { AkanAppConfig, AkanLibConfig } from "./akanConfig";
+import type { DeepPartial, LibConfigResult } from "./types";
+
+const akanPackageJson = JSON.parse(
+  fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), "../../../akanjs/package.json"), "utf8"),
+) as PackageJson;
+
+const packageJson: PackageJson = {
+  name: "repo",
+  version: "1.0.0",
+  description: "repo",
+  dependencies: {
+    react: "19.0.0",
+    "react-dom": "19.0.0",
+    "react-server-dom-webpack": "19.0.0",
+    sharp: "1.0.0",
+    "@external/runtime": "2.0.0",
+  },
+};
+
+const app = { name: "portal" } as never;
+const baseDevEnv = {
+  repoName: "akansoft",
+  serveDomain: "akamir.com",
+  env: "debug" as const,
+  portOffset: 0,
+  workspaceRoot: "/workspace",
+};
+
+describe("AkanAppConfig", () => {
+  test("applies defaults for route domains, i18n, image, mobile, and imports", () => {
+    const config = new AkanAppConfig(app, ["shared"], packageJson, {}, baseDevEnv);
+
+    expect([...config.domains].sort()).toEqual([
+      "portal-debug.akamir.com",
+      "portal-develop.akamir.com",
+      "portal-main.akamir.com",
+    ]);
+    expect(config.basePaths.size).toBe(0);
+    expect(config.i18n.defaultLocale).toBe("en");
+    expect(config.i18n.locales).toContain("en");
+    expect(config.images.formats).toEqual(["image/webp"]);
+    expect(config.mobile).toMatchObject({
+      appName: "portal",
+      appId: "com.portal.app",
+      version: "0.0.1",
+      buildNum: 1,
+      targets: {
+        default: {
+          name: "default",
+          appName: "portal",
+          appId: "com.portal.app",
+          version: "0.0.1",
+          buildNum: 1,
+        },
+      },
+    });
+    expect(config.barrelImports).toEqual(
+      expect.arrayContaining(["@apps/portal/ui", "@libs/shared/server", "akanjs/common"]),
+    );
+    expect(config.docker.content).toContain("ENV AKAN_PUBLIC_APP_NAME=portal");
+    expect(process.env.AKAN_PUBLIC_DEFAULT_LOCALE).toBe("en");
+  });
+
+  test("normalizes explicit routes, branch domains, base paths, and docker options", () => {
+    const config = new AkanAppConfig(
+      app,
+      [],
+      packageJson,
+      {
+        routes: [
+          { domains: { debug: ["Root.Local:8282"], qa: ["QA.Root.Local"] } },
+          { basePath: "/admin/", domains: { debug: ["Admin.Local:8282"], main: ["Admin.Main.Local"] } },
+        ],
+        i18n: { locales: ["ko", "en"], defaultLocale: "ko" },
+        mobile: { appName: "Portal App", appId: "com.portal.mobile", version: "1.2.3", buildNum: 7 },
+        images: { qualities: [80, 90], dangerouslyAllowSVG: true },
+        docker: {
+          image: { amd64: "oven/bun:amd64", arm64: "oven/bun:arm64" },
+          preRuns: ["echo before", { arm64: "echo arm" }],
+          postRuns: ["echo after"],
+          command: ["bun", "server.js"],
+        },
+        optimizeImports: ["custom-icons"],
+        publicEnv: ["AKAN_PUBLIC_FEATURE"],
+      },
+      baseDevEnv,
+    );
+
+    expect([...config.domains].sort()).toEqual(["qa.root.local", "root.local"]);
+    expect([...config.basePaths]).toEqual(["admin"]);
+    expect([...(config.subRoutes.get("admin") ?? [])].sort()).toEqual([
+      "admin-debug.akamir.com",
+      "admin-develop.akamir.com",
+      "admin-main.akamir.com",
+      "admin-qa.akamir.com",
+      "admin.local",
+      "admin.main.local",
+    ]);
+    expect([...config.branches].sort()).toEqual(["debug", "develop", "main", "qa"]);
+    expect(config.i18n.defaultLocale).toBe("ko");
+    expect(config.images.qualities).toEqual([80, 90]);
+    expect(config.images.dangerouslyAllowSVG).toBe(true);
+    expect(config.mobile.buildNum).toBe(7);
+    expect(config.mobile.targets.default).toMatchObject({
+      name: "default",
+      appName: "Portal App",
+      appId: "com.portal.mobile",
+      version: "1.2.3",
+      buildNum: 7,
+    });
+    expect(config.publicEnv).toEqual(["AKAN_PUBLIC_FEATURE"]);
+    expect(config.optimizeImports).toContain("custom-icons");
+    expect(config.docker.content).toContain('CMD ["bun","server.js"]');
+    expect(config.docker.content).toContain("FROM oven/bun:amd64 AS amd64");
+    expect(config.docker.content).toContain('RUN if [ "$TARGETARCH" = "arm64"');
+  });
+
+  test("creates production package json and reports missing external versions", () => {
+    const config = new AkanAppConfig(app, [], packageJson, { externalLibs: ["@external/runtime"] }, baseDevEnv);
+
+    expect(config.getProductionPackageJson({ scripts: { start: "bun main.js" } })).toMatchObject({
+      name: "portal",
+      main: "./main.js",
+      scripts: { start: "bun main.js" },
+      dependencies: {
+        react: "19.0.0",
+        "react-dom": "19.0.0",
+        "react-server-dom-webpack": "19.0.0",
+        sharp: "1.0.0",
+        "@external/runtime": "2.0.0",
+      },
+    });
+
+    const brokenConfig = new AkanAppConfig(
+      app,
+      [],
+      { ...packageJson, dependencies: { react: "19.0.0" } },
+      { externalLibs: ["missing-lib"] },
+      baseDevEnv,
+    );
+    expect(() => brokenConfig.getProductionPackageJson()).toThrow("Dependency missing-lib not found");
+  });
+
+  test("falls back to akanjs package versions for built-in runtime dependencies", () => {
+    const runtimeDependencies = { ...akanPackageJson.dependencies, ...akanPackageJson.peerDependencies };
+    const config = new AkanAppConfig(
+      app,
+      [],
+      {
+        name: "repo",
+        version: "1.0.0",
+        description: "repo",
+        dependencies: {
+          akanjs: "2.0.5-canary.0",
+        },
+      },
+      {},
+      baseDevEnv,
+    );
+
+    expect(config.getProductionPackageJson().dependencies).toEqual({
+      react: runtimeDependencies.react,
+      "react-dom": runtimeDependencies["react-dom"],
+      "react-server-dom-webpack": runtimeDependencies["react-server-dom-webpack"],
+      sharp: runtimeDependencies.sharp,
+    });
+  });
+
+  test("normalizes multiple mobile targets and validates base paths", () => {
+    const config = new AkanAppConfig(
+      app,
+      [],
+      packageJson,
+      {
+        routes: [{ basePath: "admin", domains: {} }],
+        mobile: {
+          appName: "Portal",
+          appId: "com.portal.app",
+          version: "1.0.0",
+          buildNum: 3,
+          targets: {
+            admin: {
+              basePath: "admin",
+              appName: "Portal Admin",
+              appId: "com.portal.admin",
+              buildNum: 8,
+              permissions: ["camera"],
+              links: { schemes: ["portal-admin"] },
+            },
+          },
+        },
+      },
+      baseDevEnv,
+    );
+
+    expect(config.mobile.targets.admin).toMatchObject({
+      name: "admin",
+      basePath: "admin",
+      appName: "Portal Admin",
+      appId: "com.portal.admin",
+      version: "1.0.0",
+      buildNum: 8,
+      permissions: ["camera"],
+      links: { schemes: ["portal-admin"] },
+    });
+
+    expect(
+      () =>
+        new AkanAppConfig(
+          app,
+          [],
+          packageJson,
+          {
+            mobile: { targets: { bad: { basePath: "missing" } } },
+          },
+          baseDevEnv,
+        ),
+    ).toThrow("unknown basePath");
+  });
+});
+
+describe("AkanLibConfig", () => {
+  test("uses empty external libs by default and preserves explicit libs", () => {
+    const lib = { name: "shared" } as never;
+    expect(new AkanLibConfig(lib, {}).externalLibs).toEqual([]);
+
+    const config: DeepPartial<LibConfigResult> = { externalLibs: ["firebase-admin"] };
+    expect(new AkanLibConfig(lib, config).externalLibs).toEqual(["firebase-admin"]);
+  });
+});

package/akanConfig/akanConfig.ts

@@ -0,0 +1,384 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { type AkanI18nConfig, resolveAkanI18nConfig } from "akanjs/common";
+import type { AkanImageConfig } from "akanjs/server";
+import type { App, Lib } from "../commandDecorators";
+import { WorkspaceExecutor } from "../executors";
+import type { BaseDevEnv, PackageJson } from "../types";
+import {
+  type AkanMobileConfig,
+  type AkanMobileTargetConfig,
+  type AkanRouteConfig,
+  type AppConfigResult,
+  type Arch,
+  archs,
+  type DatabaseMode,
+  type DeepPartial,
+  type DockerConfig,
+  type LibConfigResult,
+} from "./types";
+
+const DEFAULT_BARREL_IMPORTS = ["akanjs/webkit", "akanjs/common", "akanjs/ui"];
+const DEFAULT_OPTIMIZE_IMPORTS = [
+  "lucide-react",
+  "date-fns",
+  "lodash-es",
+  "ramda",
+  "antd",
+  "react-bootstrap",
+  "ahooks",
+  "@ant-design/icons",
+  "@headlessui/react",
+  "@headlessui-float/react",
+  "@heroicons/react/20/solid",
+  "@heroicons/react/24/solid",
+  "@heroicons/react/24/outline",
+  "@visx/visx",
+  "@tremor/react",
+  "rxjs",
+  "@mui/material",
+  "@mui/icons-material",
+  "recharts",
+  "react-use",
+  "@material-ui/core",
+  "@material-ui/icons",
+  "@tabler/icons-react",
+  "mui-core",
+  "react-icons/*",
+];
+const WORKSPACE_BARREL_FACETS = ["ui", "webkit", "common", "client", "server"] as const;
+const SSR_RUNTIME_PACKAGES = ["react", "react-dom", "react-server-dom-webpack"] as const;
+const NATIVE_RUNTIME_PACKAGES = ["sharp"] as const;
+const AKAN_RUNTIME_PACKAGES = new Set<string>([...SSR_RUNTIME_PACKAGES, ...NATIVE_RUNTIME_PACKAGES]);
+const DEFAULT_AKAN_IMAGE_CONFIG: AkanImageConfig = {
+  deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+  imageSizes: [32, 48, 64, 96, 128, 256, 384],
+  formats: ["image/webp"],
+  qualities: [75],
+  minimumCacheTTL: 14400,
+  remotePatterns: [],
+  localPatterns: [{ pathname: "/**" }],
+  dangerouslyAllowSVG: false,
+  maximumRedirects: 3,
+  fetchTimeoutMs: 7000,
+  maxRemoteBytes: 25 * 1024 * 1024,
+};
+
+export class AkanAppConfig implements AppConfigResult {
+  app: App;
+  rootPackageJson: PackageJson;
+  docker: DockerConfig;
+  defaultDatabaseMode: DatabaseMode;
+  externalLibs: string[];
+  barrelImports: string[];
+  optimizeImports: string[];
+  images: AkanImageConfig;
+  i18n: AkanI18nConfig;
+  publicEnv: string[];
+  mobile: AkanMobileConfig;
+  baseDevEnv: BaseDevEnv;
+  libs: string[];
+  domains = new Set<string>();
+  subRoutes = new Map<string, Set<string>>();
+  basePaths = new Set<string>();
+  branches = new Set<string>(["debug", "develop", "main"]);
+  constructor(
+    app: App,
+    libs: string[],
+    rootPackageJson: PackageJson,
+    config: DeepPartial<AppConfigResult>,
+    baseDevEnv: BaseDevEnv,
+  ) {
+    this.app = app;
+    this.rootPackageJson = rootPackageJson;
+    this.libs = libs;
+    this.baseDevEnv = baseDevEnv;
+    this.#applyRoutes(config?.routes);
+    this.defaultDatabaseMode = config?.defaultDatabaseMode ?? "single";
+    this.externalLibs = config?.externalLibs ?? [];
+    this.barrelImports = [
+      ...DEFAULT_BARREL_IMPORTS,
+      ...WORKSPACE_BARREL_FACETS.map((facet) => `@apps/${app.name}/${facet}`),
+      ...libs.flatMap((lib) => WORKSPACE_BARREL_FACETS.map((facet) => `@libs/${lib}/${facet}`)),
+      ...(config?.barrelImports ?? []),
+    ];
+    this.optimizeImports = [...new Set([...DEFAULT_OPTIMIZE_IMPORTS, ...(config?.optimizeImports ?? [])])];
+    this.images = mergeImageConfig(config?.images as Partial<AkanImageConfig> | undefined);
+    this.i18n = resolveAkanI18nConfig(config?.i18n);
+    process.env.AKAN_PUBLIC_DEFAULT_LOCALE = this.i18n.defaultLocale;
+    process.env.AKAN_PUBLIC_LOCALES = this.i18n.locales.join(",");
+    this.publicEnv = (config?.publicEnv as string[] | undefined) ?? ([] as string[]);
+    this.mobile = this.#resolveMobileConfig(config.mobile);
+    this.docker = this.#makeDockerContent(config?.docker ?? {});
+  }
+  #resolveMobileConfig(mobile: DeepPartial<AkanMobileConfig> | undefined): AkanMobileConfig {
+    const { targets: rawTargets, ...rawMobile } = mobile ?? {};
+    const appName = rawMobile.appName ?? this.app.name;
+    const appId = rawMobile.appId ?? `com.${this.app.name}.app`;
+    const version = rawMobile.version ?? "0.0.1";
+    const buildNum = rawMobile.buildNum ?? 1;
+    const defaultTargetName = this.#defaultMobileTargetName(rawTargets);
+    const targetEntries = Object.entries(
+      rawTargets ?? {
+        [defaultTargetName]: {},
+      },
+    );
+    const targets = Object.fromEntries(
+      targetEntries.map(([name, rawTarget]) => {
+        const target = rawTarget as DeepPartial<AkanMobileTargetConfig>;
+        const fallbackBasePath = !rawTargets && this.basePaths.has(name) ? name : undefined;
+        const basePath = (target.basePath ?? fallbackBasePath)?.replace(/^\/+|\/+$/g, "") || undefined;
+        if (basePath && !this.basePaths.has(basePath)) {
+          throw new Error(
+            `Mobile target '${name}' uses unknown basePath '${basePath}' in apps/${this.app.name}/akan.config.ts`,
+          );
+        }
+        const resolved = {
+          ...rawMobile,
+          ...target,
+          name,
+          basePath,
+          appName: target.appName ?? appName,
+          appId: target.appId ?? appId,
+          version: target.version ?? version,
+          buildNum: target.buildNum ?? buildNum,
+          plugins: {
+            ...rawMobile.plugins,
+            ...target.plugins,
+          },
+          android: {
+            ...rawMobile.android,
+            ...target.android,
+          },
+          ios: {
+            ...rawMobile.ios,
+            ...target.ios,
+          },
+        } satisfies AkanMobileTargetConfig;
+        return [name, resolved];
+      }),
+    );
+    return {
+      ...rawMobile,
+      appName,
+      appId,
+      version,
+      buildNum,
+      targets,
+      plugins: rawMobile.plugins,
+    } as AkanMobileConfig;
+  }
+  #defaultMobileTargetName(rawTargets: DeepPartial<AkanMobileConfig>["targets"] | undefined) {
+    if (rawTargets && Object.keys(rawTargets).length > 0) return Object.keys(rawTargets)[0] as string;
+    return this.basePaths.has(this.app.name) ? this.app.name : "default";
+  }
+  #applyRoutes(routes: AkanRouteConfig[] = []) {
+    for (const route of routes) {
+      if (route.basePath) {
+        const basePath = route.basePath.replace(/^\/+|\/+$/g, "");
+        this.basePaths.add(basePath);
+        const domains = this.subRoutes.getOrInsert(basePath, new Set());
+        Object.keys(route.domains).forEach((branch) => void this.branches.add(branch));
+        Object.values(route.domains)
+          .flat()
+          .forEach((domain) => {
+            if (domain) domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
+          });
+      } else {
+        Object.keys(route.domains).forEach((branch) => void this.branches.add(branch));
+        Object.values(route.domains)
+          .flat()
+          .forEach((domain) => {
+            if (domain) this.domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
+          });
+      }
+    }
+    const appName = this.app.name.toLowerCase();
+    const serveDomain = this.baseDevEnv.serveDomain.toLowerCase();
+    if (this.subRoutes.size === 0)
+      this.branches.forEach((branch) => void this.domains.add(`${appName}-${branch}.${serveDomain}`));
+    else
+      Array.from(this.subRoutes.entries()).forEach(([basePath, domains]) => {
+        this.branches.forEach((domain) => void domains.add(`${basePath}-${domain}.${serveDomain}`));
+      });
+  }
+  #getDockerRunScripts(runs: (string | { [key in Arch]?: string })[]) {
+    return runs.map((run) => {
+      if (typeof run === "string") return `RUN ${run}`;
+      else
+        return Object.entries(run)
+          .map(
+            ([arch, script]) => `RUN if [ "$TARGETARCH" = "${arch}" ]; then \
+    ${script}; \
+  fi`,
+          )
+          .join("\n");
+    });
+  }
+  #getDockerImageScript(image: string | { [key in Arch]?: string }, defaultImage: string) {
+    if (typeof image === "string") return `FROM ${image}`;
+    else return archs.map((arch) => `FROM ${image[arch] ?? defaultImage} AS ${arch}`).join("\n");
+  }
+  #makeDockerContent(docker: DeepPartial<DockerConfig>): DockerConfig {
+    if (docker.content) return { content: docker.content, image: {}, preRuns: [], postRuns: [], command: [] };
+    const preRunScripts = this.#getDockerRunScripts(docker.preRuns ?? []);
+    const postRunScripts = this.#getDockerRunScripts(docker.postRuns ?? []);
+
+    const imageScript = docker.image
+      ? this.#getDockerImageScript(docker.image, "oven/bun:1-slim")
+      : "FROM oven/bun:1-slim";
+    const command = docker.command ?? ["bun", "main.js"];
+    const content = `${imageScript}
+RUN ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
+RUN apt-get update && apt-get upgrade -y
+RUN apt-get install -y --no-install-recommends git redis build-essential python3 ca-certificates fonts-liberation libappindicator3-1 libasound2 libatk-bridge2.0-0 libatk1.0-0 libc6 libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 libgbm1 libgcc1 libglib2.0-0 libgtk-3-0 libnspr4 libnss3 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 libx11-xcb1 libxcb1 libxcomposite1 libxcursor1 libxdamage1 libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 libxtst6 lsb-release wget xdg-utils udev ffmpeg
+ARG TARGETARCH
+${preRunScripts.join("\n")}
+RUN mkdir -p /workspace
+WORKDIR /workspace
+COPY ./package.json ./package.json
+RUN bun install --production
+${postRunScripts.join("\n")}
+COPY . .
+ENV PORT=8282
+ENV NODE_ENV=production
+ENV AKAN_PUBLIC_REPO_NAME=${this.baseDevEnv.repoName}
+ENV AKAN_PUBLIC_SERVE_DOMAIN=${this.baseDevEnv.serveDomain}
+ENV AKAN_PUBLIC_APP_NAME=${this.app.name}
+ENV AKAN_PUBLIC_ENV=${this.baseDevEnv.env}
+${this.basePaths.size ? `ENV AKAN_PUBLIC_BASE_PATHS=${[...this.basePaths].join(",")}` : ""}
+ENV AKAN_PUBLIC_DEFAULT_LOCALE=${this.i18n.defaultLocale}
+ENV AKAN_PUBLIC_LOCALES=${this.i18n.locales.join(",")}
+ENV AKAN_PUBLIC_OPERATION_MODE=cloud
+
+CMD [${command.map((c) => `"${c}"`).join(",")}]`;
+    return { content, image: imageScript, preRuns: docker.preRuns ?? [], postRuns: docker.postRuns ?? [], command };
+  }
+  static async from(app: App) {
+    const [configImp, baseDevEnv, libs, rootPackageJson] = await Promise.all([
+      import(`${app.cwdPath}/akan.config.ts`).then((mod) => mod.default),
+      WorkspaceExecutor.getBaseDevEnv(path.join(app.workspace.workspaceRoot, ".env")),
+      app.workspace.getLibs(),
+      app.workspace.getPackageJson(),
+    ]);
+    const config = typeof configImp === "function" ? configImp(app) : configImp;
+    return new AkanAppConfig(app, libs, rootPackageJson, config, baseDevEnv);
+  }
+  #resolveProductionDependencyVersion(lib: string) {
+    const rootVersion = this.rootPackageJson.dependencies?.[lib] ?? this.rootPackageJson.devDependencies?.[lib];
+    if (rootVersion) return rootVersion;
+    const akanPackageJson = getAkanPackageJson();
+    if (AKAN_RUNTIME_PACKAGES.has(lib))
+      return akanPackageJson.dependencies?.[lib] ?? akanPackageJson.peerDependencies?.[lib];
+  }
+  getProductionPackageJson(data: Partial<PackageJson> = {}): PackageJson {
+    return {
+      name: this.app.name,
+      description: this.app.name,
+      version: "1.0.0",
+      main: "./main.js",
+      dependencies: Object.fromEntries(
+        [...new Set([...this.externalLibs, ...SSR_RUNTIME_PACKAGES, ...NATIVE_RUNTIME_PACKAGES])].map((lib) => {
+          const version = this.#resolveProductionDependencyVersion(lib);
+          if (!version) throw new Error(`Dependency ${lib} not found in package.json`);
+          return [lib, version];
+        }),
+      ),
+      ...data,
+    };
+  }
+}
+
+let akanPackageJson: PackageJson | null = null;
+
+function getAkanPackageJson() {
+  if (akanPackageJson) return akanPackageJson;
+  const sourceDir = path.dirname(fileURLToPath(import.meta.url));
+  const packageJsonPaths = [
+    path.join(sourceDir, "../../../akanjs/package.json"),
+    path.join(process.cwd(), "pkgs/akanjs/package.json"),
+    path.join(path.dirname(Bun.main), "node_modules/akanjs/package.json"),
+  ];
+  try {
+    packageJsonPaths.unshift(Bun.resolveSync("akanjs/package.json", sourceDir));
+  } catch {
+    // Monorepo source execution usually resolves Akan packages through tsconfig paths, not node_modules.
+  }
+  for (const packageJsonPath of packageJsonPaths) {
+    try {
+      akanPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")) as PackageJson;
+      return akanPackageJson;
+    } catch {
+      // Try the next known layout: source package first, bundled CLI package second.
+    }
+  }
+  akanPackageJson = { name: "akanjs", version: "0.0.0", description: "akanjs", dependencies: {} };
+  return akanPackageJson;
+}
+
+function mergeImageConfig(config: Partial<AkanImageConfig> = {}): AkanImageConfig {
+  return {
+    ...DEFAULT_AKAN_IMAGE_CONFIG,
+    ...config,
+    deviceSizes: config.deviceSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.deviceSizes,
+    imageSizes: config.imageSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.imageSizes,
+    formats: config.formats ?? DEFAULT_AKAN_IMAGE_CONFIG.formats,
+    qualities: config.qualities ?? DEFAULT_AKAN_IMAGE_CONFIG.qualities,
+    remotePatterns: config.remotePatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.remotePatterns,
+    localPatterns: config.localPatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.localPatterns,
+  };
+}
+
+export class AkanLibConfig implements LibConfigResult {
+  lib: Lib;
+  externalLibs: string[];
+  constructor(lib: Lib, config: DeepPartial<LibConfigResult>) {
+    this.lib = lib;
+    this.externalLibs = config?.externalLibs ?? [];
+  }
+  static async from(lib: Lib) {
+    const [configImp] = await Promise.all([import(`${lib.cwdPath}/akan.config.ts`).then((mod) => mod.default)]);
+    const config = typeof configImp === "function" ? configImp(lib) : configImp;
+    return new AkanLibConfig(lib, config);
+  }
+}
+
+// export const getCapacitorConfig = (configImp: AppConfig, appInfo: AppScanResult, tsconfig: TsConfigJson) => {
+//   const props: RunnerProps = {
+//     type: "app",
+//     name: appInfo.name,
+//     repoName: appInfo.repoName,
+//     serveDomain: appInfo.serveDomain,
+//     env: (process.env.AKAN_PUBLIC_ENV ?? "debug") as "testing" | "local" | "debug" | "develop" | "main",
+//     libs: appInfo.libDeps,
+//     tsconfig,
+//   };
+//   const config = typeof configImp === "function" ? configImp(props) : configImp;
+//   const akanConfig = makeAppConfig(config, props);
+//   return akanConfig;
+// };
+
+//! need to refactor
+export const increaseBuildNum = async (app: App) => {
+  const appConfig = await AkanAppConfig.from(app);
+  const akanConfigPath = path.join(app.cwdPath, "akan.config.ts");
+  const akanConfig = fs.readFileSync(akanConfigPath, "utf8");
+  const akanConfigContent = akanConfig.replace(
+    `buildNum: ${appConfig.mobile.buildNum}`,
+    `buildNum: ${appConfig.mobile.buildNum + 1}`,
+  );
+  //? 개선할 여지가 있는지 확인
+  fs.writeFileSync(akanConfigPath, akanConfigContent);
+};
+
+export const decreaseBuildNum = async (app: App) => {
+  const appConfig = await AkanAppConfig.from(app);
+  const akanConfigPath = path.join(app.cwdPath, "akan.config.ts");
+  const akanConfig = fs.readFileSync(akanConfigPath, "utf8");
+  const akanConfigContent = akanConfig.replace(
+    `buildNum: ${appConfig.mobile.buildNum}`,
+    `buildNum: ${appConfig.mobile.buildNum - 1}`,
+  );
+  fs.writeFileSync(akanConfigPath, akanConfigContent);
+};

package/akanConfig/index.ts

@@ -0,0 +1,2 @@
+export * from "./akanConfig";
+export * from "./types";

package/akanConfig/types.ts

@@ -0,0 +1,23 @@
+export { archs } from "akanjs";
+export type {
+  AkanConfigFile,
+  AkanMobileConfig,
+  AkanMobileTargetConfig,
+  AkanRouteConfig,
+  AppConfig,
+  AppConfigResult,
+  AppScanResult,
+  Arch,
+  DatabaseMode,
+  DeepPartial,
+  DockerConfig,
+  FileConventionScanResult,
+  LibConfig,
+  LibConfigResult,
+  LibScanResult,
+  MobileEnv,
+  MobilePermission,
+  PkgScanResult,
+  ScanResult,
+  WorkspaceScanResult,
+} from "akanjs";