@akanjs/devkit 3.0.0-beta.26 → 3.0.0-beta.27

package/mobile/nativeApp.ts

@@ -2,6 +2,7 @@ import { mkdir } from "node:fs/promises";
 import path from "node:path";
 import type { AkanNativeConfig } from "@akanjs/native/config";
 import type { App } from "../commandDecorators";
+import { Executor } from "../executors";
 import {
   type DesktopPlatform,
   type MobilePlatform,
@@ -10,6 +11,7 @@ import {
   targetHtmlFilename,
 } from "./mobileTarget";
 import { NativeApi, type NativeBuildApiModule } from "./nativeApi";
+import { NativeAppLine, type NativeAppLineRead } from "./nativeAppLine";
 import { NativeConfig } from "./nativeConfig";
 import { NativeWebDir } from "./nativeWebDir";
 
@@ -24,6 +26,11 @@ export interface NativeRunOptions {
   teamId?: string;
 }
 
+interface NativeDevBoot {
+  steps: string[];
+  lines: NativeAppLineRead[];
+}
+
 export interface NativeDevOptions extends NativeRunOptions {
   /** The akan dev server the gateway proxies. */
   upstream: string;
@@ -35,6 +42,8 @@ export interface NativeDevOptions extends NativeRunOptions {
 export class NativeApp {
   readonly targetRoot: string;
   readonly web: NativeWebDir;
+  //? A dev boot holds its steps and the app's first lines back: one line says it is up, all of it when it failed.
+  #boot: NativeDevBoot | null = null;
 
   constructor(
     readonly app: App,
@@ -83,7 +92,9 @@ export class NativeApp {
 
   //? The app's own output: its console (mirrored by a dev build), the simulator log stream or logcat.
   #appLine = (line: string) => {
-    this.app.logger.info(`[${this.target.name}] ${line}`);
+    const read = NativeAppLine.read(line, { verbose: Executor.verbose });
+    if (this.#boot) this.#boot.lines.push(read);
+    else this.app.logger[read.level](read.message);
   };
 
   //* `AKAN_PUBLIC_*` is already inlined into the CSR bundle, so the runtime reads no .env file of its own.
@@ -98,6 +109,7 @@ export class NativeApp {
       log: (event) => {
         if (event.level === "error") this.app.logger.error(event.message);
         else if (event.level === "warn") this.app.logger.warn(event.message);
+        else if (this.#boot) this.#boot.steps.push(event.message);
         else if (event.level === "tool") this.app.logger.verbose(event.message);
         else this.app.logger.info(event.message);
       },
@@ -128,19 +140,47 @@ export class NativeApp {
   //* The gateway serves the page and its HMR socket on the app origin; API calls go to the dev server itself (baseEnv),
   //* which an Android device reaches through the reversed port.
   async dev(platform: NativePlatform, { upstream, lang, device, teamId }: NativeDevOptions) {
-    await mkdir(this.web.dir, { recursive: true });
-    const [{ api, config }, { api: routes }] = await Promise.all([this.prepare(), this.app.getConfig()]);
-    return await api.dev({
-      ...this.#task(platform, config),
-      upstream,
-      hmrPath: "/_akan/hmr",
-      //? A dev page calls its own origin (akanjs baseEnv), so the gateway relays the socket it opens for the API too.
-      wsPaths: [`${routes.prefix}${routes.websocketPrefix}`],
-      onLine: this.#appLine,
-      startPath: this.startPath(lang),
-      ...(device ? { device } : {}),
-      ...(teamId ? { ios: { signing: { teamId } } } : {}),
-    });
+    const startedAt = performance.now();
+    const boot: NativeDevBoot = { steps: [], lines: [] };
+    this.#boot = boot;
+    try {
+      await mkdir(this.web.dir, { recursive: true });
+      const [{ api, config }, { api: routes }] = await Promise.all([this.prepare(), this.app.getConfig()]);
+      const session = await api.dev({
+        ...this.#task(platform, config),
+        upstream,
+        hmrPath: "/_akan/hmr",
+        //? A dev page calls its own origin (akanjs baseEnv), so the gateway relays the socket it opens for the API too.
+        wsPaths: [`${routes.prefix}${routes.websocketPrefix}`],
+        onLine: this.#appLine,
+        startPath: this.startPath(lang),
+        ...(device ? { device } : {}),
+        ...(teamId ? { ios: { signing: { teamId } } } : {}),
+      });
+      this.#boot = null;
+      this.app.logger.info(this.readyLine(platform, { upstream, device: session.device, startedAt }));
+      for (const step of [...boot.steps, `pages through ${session.gateway}`]) this.app.logger.debug(step);
+      for (const line of boot.lines) this.app.logger[line.level](line.message);
+      return session;
+    } catch (error) {
+      this.#boot = null;
+      for (const step of boot.steps) this.app.logger.info(step);
+      for (const line of boot.lines) this.app.logger[line.level === "debug" ? "info" : line.level](line.message);
+      throw error;
+    }
+  }
+
+  /** What a dev boot that came up says, and all it says: `cmdc ios ready · iPhone 16 · http://localhost:8283 · 12.4s`. */
+  readyLine(
+    platform: NativePlatform,
+    { upstream, device, startedAt }: { upstream: string; device?: { name: string }; startedAt: number },
+  ) {
+    const label = platform === "ios" || platform === "android" ? platform : "desktop";
+    const target = this.target.name === "default" ? "" : `/${this.target.name}`;
+    const seconds = ((performance.now() - startedAt) / 1000).toFixed(1);
+    return [`${this.app.name}${target} ${label} ready`, ...(device ? [device.name] : []), upstream, `${seconds}s`].join(
+      " · ",
+    );
   }
 
   async releaseIos({ teamId, adHoc = false }: { teamId?: string; adHoc?: boolean } = {}) {

package/mobile/nativeAppLine.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { NativeAppLine } from "./nativeAppLine";
+
+describe("NativeAppLine", () => {
+  test("a page logger line keeps its level and its logger's name", () => {
+    expect(NativeAppLine.read("[page warn] [WsClient] WebSocket message process failed")).toEqual({
+      level: "warn",
+      message: "[page:WsClient] WebSocket message process failed",
+    });
+  });
+
+  test("a bare console call keeps its level, `log` reading as info", () => {
+    expect(NativeAppLine.read("[page log] hello")).toEqual({ level: "info", message: "[page] hello" });
+    expect(NativeAppLine.read("[page debug] [akan:frame:x:1] csr.render {}")).toEqual({
+      level: "debug",
+      message: "[page:akan:frame:x:1] csr.render {}",
+    });
+  });
+
+  test("a continuation line follows its message's level without a prefix of its own", () => {
+    expect(NativeAppLine.read("[page+ error]     at run (app.js:1:2)")).toEqual({
+      level: "error",
+      message: "      at run (app.js:1:2)",
+    });
+  });
+
+  test("a second window is named, the first is not", () => {
+    expect(NativeAppLine.read("[page#2 info] [App] ready")).toEqual({ level: "info", message: "[page#2:App] ready" });
+  });
+
+  test("logcat lines read by tag and priority", () => {
+    expect(NativeAppLine.read("W/AkanNativeConsole( 1234): [WsClient] failed")).toEqual({
+      level: "warn",
+      message: "[page:WsClient] failed",
+    });
+    expect(NativeAppLine.read("E/AndroidRuntime( 1234): FATAL EXCEPTION: main")).toEqual({
+      level: "error",
+      message: "[AndroidRuntime] FATAL EXCEPTION: main",
+    });
+    expect(
+      NativeAppLine.read("I/AkanNative( 1234): pages from http://10.0.2.2:5000 (akan-native dev --hmr)").level,
+    ).toBe("debug");
+  });
+
+  test("the host's own lines stay visible but for where its pages come from", () => {
+    expect(NativeAppLine.read("[akan-native] opened in the browser: https://x.test")).toEqual({
+      level: "info",
+      message: "[akan-native] opened in the browser: https://x.test",
+    });
+    expect(
+      NativeAppLine.read("[akan-native native] pages from http://127.0.0.1:6000 (akan-native dev --hmr)").level,
+    ).toBe("debug");
+  });
+
+  test("a line no page or host wrote is kept for debug, or for info when verbose", () => {
+    expect(NativeAppLine.read("WebContent[123] Could not signal service")).toEqual({
+      level: "debug",
+      message: "WebContent[123] Could not signal service",
+    });
+    expect(NativeAppLine.read("WebContent[123] Could not signal service", { verbose: true }).level).toBe("info");
+  });
+});

package/mobile/nativeAppLine.ts

@@ -0,0 +1,63 @@
+import type { LogLevel } from "akanjs/common";
+
+export interface NativeAppLineRead {
+  level: LogLevel;
+  message: string;
+}
+
+//* A line a native dev build prints — the page console its host mirrors, the simulator's console, logcat — read back
+//* at the level the page logged it, so the terminal shows it once, stamped by the app's own logger.
+export class NativeAppLine {
+  //? The host's grammar (desktop host.ts, iOS AkanNativeShell.swift): `[page<+><#window> <level>] text`, where `+`
+  //? marks a continuation line of a multi-line message and `#n` any window but the first.
+  static readonly #page = /^\[page(\+)?(?:#(\d+))? (trace|verbose|debug|log|info|warn|error)\] ?(.*)$/;
+  static readonly #logcat = /^([VDIWEFA])\/([^(]+?)\s*\(\s*\d+\):\s?(.*)$/;
+  static readonly #named = /^\[([^\]\s]+)\] ([\s\S]*)$/;
+  static readonly #logcatLevels: { [priority: string]: LogLevel } = {
+    V: "verbose",
+    D: "debug",
+    I: "info",
+    W: "warn",
+    E: "error",
+    F: "error",
+    A: "error",
+  };
+
+  /** `verbose` keeps the lines no page or host wrote (WebKit, the simulator) at info instead of debug. */
+  static read(line: string, { verbose = false }: { verbose?: boolean } = {}): NativeAppLineRead {
+    const logcat = NativeAppLine.#logcat.exec(line);
+    if (logcat) {
+      const [, priority = "I", tag = "", text = ""] = logcat;
+      const level = NativeAppLine.#logcatLevels[priority] ?? "info";
+      if (tag === "AkanNativeConsole") return NativeAppLine.#pageLine(level, text, { continuation: false });
+      if (tag === "AkanNative") return NativeAppLine.#hostLine(`[akan-native] ${text}`, level);
+      return { level, message: `[${tag}] ${text}` };
+    }
+    const page = NativeAppLine.#page.exec(line);
+    if (page) {
+      const [, continuation, window, level = "info", text = ""] = page;
+      return NativeAppLine.#pageLine(level === "log" ? "info" : (level as LogLevel), text, {
+        continuation: continuation === "+",
+        window,
+      });
+    }
+    if (line.startsWith("[akan-native")) return NativeAppLine.#hostLine(line, "info");
+    return { level: verbose ? "info" : "debug", message: line };
+  }
+
+  static #pageLine(
+    level: LogLevel,
+    text: string,
+    { continuation, window }: { continuation: boolean; window?: string },
+  ): NativeAppLineRead {
+    if (continuation) return { level, message: `  ${text}` };
+    const named = NativeAppLine.#named.exec(text);
+    const scope = `page${window ? `#${window}` : ""}${named ? `:${named[1]}` : ""}`;
+    return { level, message: `[${scope}] ${named ? named[2] : text}` };
+  }
+
+  //? The host's own lines are about the host, not the app: where its pages come from is boot detail.
+  static #hostLine(line: string, level: LogLevel): NativeAppLineRead {
+    return { level: /\bpages from\b/.test(line) ? "debug" : level, message: line };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.0.0-beta.26",
+  "version": "3.0.0-beta.27",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -47,7 +47,7 @@
     "@earendil-works/pi-tui": "0.86.1",
     "@inquirer/prompts": "^8.4.3",
     "@tailwindcss/node": "^4.3.0",
-    "akanjs": "3.0.0-beta.26",
+    "akanjs": "3.0.0-beta.27",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dayjs": "^1.11.20",