@akanjs/devkit 2.1.0-rc.1 → 2.1.0-rc.3

package/commandDecorators/command.ts

@@ -1,5 +1,5 @@
-import { confirm, input, select } from "@inquirer/prompts";
 import path from "node:path";
+import { confirm, input, select } from "@inquirer/prompts";
 import { Logger } from "akanjs/common";
 import chalk from "chalk";
 import { type Command, program } from "commander";
@@ -19,6 +19,32 @@ import { formatCommandHelp, formatHelp } from "./helpFormatter";
 import { type CommandCls, getTargetMetas } from "./targetMeta";
 
 const camelToKebabCase = (str: string) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
+const loggedCliErrorObjects = new WeakSet<object>();
+const loggedCliErrorMessages = new Set<string>();
+
+const formatCliError = (error: unknown): string => {
+  if (error instanceof Error) return error.message || error.name;
+  if (typeof error === "string") return error.trim() || "Unknown error";
+  if (error === null || error === undefined) return "Unknown error";
+  try {
+    const json = JSON.stringify(error);
+    if (json) return json;
+  } catch {
+    return String(error);
+  }
+  return String(error) || "Unknown error";
+};
+
+const printCliError = (error: unknown) => {
+  if (typeof error === "object" && error !== null) {
+    if (loggedCliErrorObjects.has(error)) return;
+    loggedCliErrorObjects.add(error);
+  }
+  const message = formatCliError(error);
+  if (loggedCliErrorMessages.has(message)) return;
+  loggedCliErrorMessages.add(message);
+  Logger.rawLog(`\n${chalk.red(message)}`);
+};
 
 const handleOption = (programCommand: Command, argMeta: ArgMeta) => {
   const {
@@ -219,6 +245,7 @@ const getInternalArgumentValue = async (
 
 export const runCommands = async (...commands: CommandCls[]) => {
   process.on("unhandledRejection", (error) => {
+    printCliError(error);
     process.exit(1);
   });
   const __dirname = getDirname(import.meta.url);
@@ -339,8 +366,7 @@ It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`,
             await targetMeta.handler.call(cmd, ...commandArgs);
             Logger.rawLog();
           } catch (e) {
-            const errMsg = e instanceof Error ? e.message : typeof e === "string" ? e : JSON.stringify(e);
-            Logger.rawLog(`\n${chalk.red(errMsg)}`);
+            printCliError(e);
             throw e;
           }
         });

package/executors.test.ts

@@ -3,7 +3,7 @@ import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises"
 import os from "node:os";
 import path from "node:path";
 import { AkanAppConfig } from "./akanConfig";
-import { AppExecutor, Executor, PkgExecutor, WorkspaceExecutor } from "./executors";
+import { AppExecutor, CommandExecutionError, Executor, PkgExecutor, WorkspaceExecutor } from "./executors";
 import { AppInfo } from "./scanInfo";
 import type { PackageJson } from "./types";
 
@@ -48,6 +48,41 @@ afterEach(async () => {
 });
 
 describe("Executor filesystem helpers", () => {
+  test("reports command failures with command context and captured output", async () => {
+    const root = await makeTempRoot();
+    const exec = new Executor("fixture", root);
+
+    let error: unknown;
+    try {
+      await exec.spawn(process.execPath, ["--eval", "console.error('spawn failed'); process.exit(7)"]);
+    } catch (caught) {
+      error = caught;
+    }
+
+    expect(error).toBeInstanceOf(CommandExecutionError);
+    expect((error as CommandExecutionError).message).toContain(`Command failed: ${process.execPath}`);
+    expect((error as CommandExecutionError).message).toContain(`cwd: ${root}`);
+    expect((error as CommandExecutionError).message).toContain("exit code: 7");
+    expect((error as CommandExecutionError).message).toContain("spawn failed");
+  });
+
+  test("reports inherited stdio command failures with a fallback message", async () => {
+    const root = await makeTempRoot();
+    const exec = new Executor("fixture", root);
+
+    let error: unknown;
+    try {
+      await exec.spawn(process.execPath, ["--eval", "process.exit(3)"], { stdio: "inherit" });
+    } catch (caught) {
+      error = caught;
+    }
+
+    expect(error).toBeInstanceOf(CommandExecutionError);
+    expect((error as CommandExecutionError).message).toContain(`Command failed: ${process.execPath}`);
+    expect((error as CommandExecutionError).message).toContain(`cwd: ${root}`);
+    expect((error as CommandExecutionError).message).toContain("exit code: 3");
+  });
+
   test("resolves paths and reads/writes files relative to cwd", async () => {
     const root = await makeTempRoot();
     const exec = new Executor("fixture", root);

package/executors.ts

@@ -64,6 +64,58 @@ const staticTemplateFileExtensions = new Set([
   ".xml",
 ]);
 
+const formatCommandArg = (value: string) => (/^[\w@%+=:,./-]+$/.test(value) ? value : JSON.stringify(value));
+
+const formatCommandForDisplay = (command: string, args: string[] = []) =>
+  [command, ...args].map(formatCommandArg).join(" ");
+
+export interface CommandExecutionErrorOptions {
+  command: string;
+  args?: string[];
+  cwd: string;
+  code: number | null;
+  signal: string | null;
+  stdout?: string;
+  stderr?: string;
+  cause?: unknown;
+}
+
+export class CommandExecutionError extends Error {
+  command: string;
+  args: string[];
+  cwd: string;
+  code: number | null;
+  signal: string | null;
+  stdout: string;
+  stderr: string;
+
+  constructor({
+    command,
+    args = [],
+    cwd,
+    code,
+    signal,
+    stdout = "",
+    stderr = "",
+    cause,
+  }: CommandExecutionErrorOptions) {
+    const displayCommand = formatCommandForDisplay(command, args);
+    const status = signal ? `signal: ${signal}` : `exit code: ${code ?? "unknown"}`;
+    const output = (stderr || stdout).trim();
+    super([`Command failed: ${displayCommand}`, `cwd: ${cwd}`, status, output ? `\n${output}` : ""].join("\n"), {
+      cause,
+    });
+    this.name = "CommandExecutionError";
+    this.command = command;
+    this.args = args;
+    this.cwd = cwd;
+    this.code = code;
+    this.signal = signal;
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+}
+
 export const execEmoji = {
   workspace: "🏠",
   app: "🚀",
@@ -197,22 +249,31 @@ export class Executor {
     Logger.raw(chalk.red(data.toString()));
   }
   exec(command: string, options: ExecOptions = {}) {
+    const cwd = options.cwd?.toString() ?? this.cwdPath;
     const proc = exec(command, { cwd: this.cwdPath, ...options });
+    let stdout = "";
+    let stderr = "";
     proc.stdout?.on("data", (data: Buffer) => {
+      stdout += data.toString();
       this.#stdout(data);
     });
     proc.stderr?.on("data", (data: Buffer) => {
+      stderr += data.toString();
       this.#stdout(data); // 정상로그도 stderr로 나옴
     });
     return new Promise((resolve, reject) => {
+      proc.on("error", (error) => {
+        reject(new CommandExecutionError({ command, cwd, code: null, signal: null, stdout, stderr, cause: error }));
+      });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal) reject({ code, signal });
+        if (!!code || signal) reject(new CommandExecutionError({ command, cwd, code, signal, stdout, stderr }));
         else resolve({ code, signal });
       });
     });
   }
 
   spawn(command: string, args: string[] = [], options: SpawnOptions = {}): Promise<string> {
+    const cwd = options.cwd?.toString() ?? this.cwdPath;
     const proc = spawn(command, args, {
       cwd: this.cwdPath,
       // stdio: "inherit",
@@ -232,8 +293,14 @@ export class Executor {
       this.#stdout(data); // 정상로그도 stderr로 나옴
     });
     return new Promise((resolve, reject) => {
+      proc.on("error", (error) => {
+        reject(
+          new CommandExecutionError({ command, args, cwd, code: null, signal: null, stdout, stderr, cause: error }),
+        );
+      });
       proc.on("close", (code, signal) => {
-        if (code !== 0 || signal) reject(stderr || stdout);
+        if (code !== 0 || signal)
+          reject(new CommandExecutionError({ command, args, cwd, code, signal, stdout, stderr }));
         else resolve(stdout);
       });
     });
@@ -247,20 +314,40 @@ export class Executor {
     return proc;
   }
   fork(modulePath: string, args: string[] = [], options: ForkOptions = {}) {
+    const cwd = options.cwd?.toString() ?? this.cwdPath;
     const proc = fork(modulePath, args, {
       cwd: this.cwdPath,
       // stdio: ["ignore", "inherit", "inherit", "ipc"],
       ...options,
     });
+    let stdout = "";
+    let stderr = "";
     proc.stdout?.on("data", (data: Buffer) => {
+      stdout += data.toString();
       this.#stdout(data);
     });
     proc.stderr?.on("data", (data: Buffer) => {
+      stderr += data.toString();
       this.#stderr(data);
     });
     return new Promise((resolve, reject) => {
+      proc.on("error", (error) => {
+        reject(
+          new CommandExecutionError({
+            command: modulePath,
+            args,
+            cwd,
+            code: null,
+            signal: null,
+            stdout,
+            stderr,
+            cause: error,
+          }),
+        );
+      });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal) reject({ code, signal });
+        if (!!code || signal)
+          reject(new CommandExecutionError({ command: modulePath, args, cwd, code, signal, stdout, stderr }));
         else resolve({ code, signal });
       });
     });

package/frontendBuild/cssImportResolver.ts

@@ -24,9 +24,9 @@ export class CssImportResolver {
 
   async resolve(id: string, fromBase: string): Promise<string | null> {
     for (const resolve of [
+      () => this.#resolveWithTsconfig(id),
       () => this.#resolveWithBun(id, fromBase),
       () => this.#resolveWithRequire(id, fromBase),
-      () => this.#resolveWithTsconfig(id),
       () => this.#resolvePackageStyle(id, fromBase),
     ]) {
       const resolved = await resolve();
@@ -36,21 +36,27 @@ export class CssImportResolver {
   }
 
   #resolveWithBun(id: string, fromBase: string): string | null {
-    try {
-      const resolved = Bun.resolveSync(id, fromBase);
-      return CssImportResolver.isCssFile(resolved) ? resolved : null;
-    } catch {
-      return null;
+    for (const base of this.#resolutionBases(fromBase)) {
+      try {
+        const resolved = Bun.resolveSync(id, base);
+        if (CssImportResolver.isCssFile(resolved)) return resolved;
+      } catch {
+        // Try the next known package resolution root.
+      }
     }
+    return null;
   }
 
   #resolveWithRequire(id: string, fromBase: string): string | null {
-    try {
-      const resolved = require.resolve(id, { paths: [fromBase] });
-      return CssImportResolver.isCssFile(resolved) ? resolved : null;
-    } catch {
-      return null;
+    for (const base of this.#resolutionBases(fromBase)) {
+      try {
+        const resolved = require.resolve(id, { paths: [base] });
+        if (CssImportResolver.isCssFile(resolved)) return resolved;
+      } catch {
+        // Try the next known package resolution root.
+      }
     }
+    return null;
   }
 
   async #resolveWithTsconfig(id: string): Promise<string | null> {
@@ -77,8 +83,25 @@ export class CssImportResolver {
   async #resolvePackageStyle(id: string, fromBase: string): Promise<string | null> {
     const pkgName = CssImportResolver.getPackageName(id);
     if (!pkgName) return null;
+    for (const base of this.#resolutionBases(fromBase)) {
+      try {
+        const pkgPath = require.resolve(`${pkgName}/package.json`, { paths: [base] });
+        const resolved = await this.#resolvePackageStyleFromPackageJson(id, pkgName, pkgPath);
+        if (resolved) return resolved;
+      } catch {
+        // Try the next known package resolution root.
+      }
+    }
+    for (const pkgPath of this.#packageJsonCandidates(pkgName)) {
+      const resolved = await this.#resolvePackageStyleFromPackageJson(id, pkgName, pkgPath);
+      if (resolved) return resolved;
+    }
+    return null;
+  }
+
+  async #resolvePackageStyleFromPackageJson(id: string, pkgName: string, pkgPath: string): Promise<string | null> {
     try {
-      const pkgPath = require.resolve(`${pkgName}/package.json`, { paths: [fromBase] });
+      if (!(await Bun.file(pkgPath).exists())) return null;
       const pkgDir = path.dirname(pkgPath);
       const pkg = await Bun.file(pkgPath).json();
       const subpath = id === pkgName ? "." : `.${id.slice(pkgName.length)}`;
@@ -96,6 +119,24 @@ export class CssImportResolver {
     }
   }
 
+  #resolutionBases(fromBase: string): string[] {
+    return [
+      fromBase,
+      this.#workspaceRoot,
+      path.dirname(Bun.main),
+      path.resolve(path.dirname(Bun.main), "../.."),
+    ];
+  }
+
+  #packageJsonCandidates(pkgName: string): string[] {
+    return [
+      path.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
+      path.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
+      path.join(path.dirname(Bun.main), "node_modules", pkgName, "package.json"),
+      path.join(path.dirname(Bun.main), "../../", pkgName, "package.json"),
+    ];
+  }
+
   async #firstExisting(basePath: string): Promise<string | null> {
     for (const suffix of CSS_IMPORT_EXTS) {
       const candidate = `${basePath}${suffix}`;

package/frontendBuild/ssrBaseArtifactBuilder.ts

@@ -94,13 +94,26 @@ export class SsrBaseArtifactBuilder {
   async #resolveAkanServerPath() {
     const candidates = [
       path.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"),
+      path.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"),
+      path.join(path.dirname(Bun.main), "node_modules/akanjs/server"),
+      path.join(path.dirname(Bun.main), "../../akanjs/server"),
       path.resolve(import.meta.dir, "../../server"),
       path.resolve(import.meta.dir, "../server"),
     ];
+    try {
+      candidates.unshift(path.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
+    } catch {
+      // Source workspaces and bundled CLI execution have different resolution roots; try the explicit candidates.
+    }
+    try {
+      candidates.unshift(path.dirname(Bun.resolveSync("akanjs/server", path.dirname(Bun.main))));
+    } catch {
+      // Published CLI installs may hoist dependencies differently; explicit Bun.main candidates cover that.
+    }
     for (const candidate of candidates) {
       if (await Bun.file(path.join(candidate, "rscClient.tsx")).exists()) return candidate;
     }
-    return candidates[0];
+    throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
   }
 
   async #buildStyleAssets(): Promise<{

package/incrementalBuilder/incrementalBuilder.host.ts

@@ -143,6 +143,7 @@ export class IncrementalBuilderHost {
         app.workspace.workspaceRoot,
         "node_modules/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts",
       ),
+      path.join(import.meta.dir, "incrementalBuilder.proc.js"),
       path.join(import.meta.dir, "incrementalBuilder.proc.ts"),
     ];
     for (const c of candidates)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "2.1.0-rc.1",
+  "version": "2.1.0-rc.3",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -36,7 +36,7 @@
     "@langchain/deepseek": "^1.0.26",
     "@langchain/openai": "^1.4.6",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "2.1.0-rc.0",
+    "akanjs": "2.1.0-rc.3",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "fontaine": "^0.8.0",