@akanjs/cli 0.0.88 → 0.0.89

package/index.js

@@ -764,10 +764,10 @@ var getDefaultFileScan = () => ({
 
 // pkgs/@akanjs/devkit/src/executors.ts
 var import_child_process = require("child_process");
+var import_dotenv = __toESM(require("dotenv"), 1);
 var import_fs7 = __toESM(require("fs"), 1);
 var import_promises = __toESM(require("fs/promises"), 1);
 var import_path3 = __toESM(require("path"), 1);
-var import_dotenv = __toESM(require("dotenv"), 1);
 
 // pkgs/@akanjs/devkit/src/dependencyScanner.ts
 var fs7 = __toESM(require("fs"), 1);
@@ -1206,10 +1206,10 @@ var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
   }
   async commit(message, { init = false, add = true } = {}) {
     if (init)
-      await this.exec(`git init`);
+      await this.exec(`git init --quiet`);
     if (add)
       await this.exec(`git add .`);
-    await this.exec(`git commit -m "${message}"`);
+    await this.exec(`git commit --quiet -m "${message}"`);
   }
   async #getDirHasFile(basePath2, targetFilename) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "./next"];
@@ -1444,8 +1444,10 @@ var SysExecutor = class extends Executor {
   }
 };
 var AppExecutor = class _AppExecutor extends SysExecutor {
+  dist;
   constructor({ workspace, name }) {
     super({ workspace, name, type: "app" });
+    this.dist = new Executor(`${name} Dist App Executor`, `${this.workspace.workspaceRoot}/dist/apps/${name}`);
   }
   static from(executor, name) {
     if (executor instanceof WorkspaceExecutor)
@@ -1475,23 +1477,13 @@ var AppExecutor = class _AppExecutor extends SysExecutor {
     );
   }
 };
-var DistAppExecutor = class _DistAppExecutor extends Executor {
-  name;
-  constructor({ workspace, name }) {
-    super(`${name} Dist App Executor`, `${workspace.workspaceRoot}/dist/apps/${name}`);
-    this.name = name;
-  }
-  static from(executor, name) {
-    if (executor instanceof WorkspaceExecutor)
-      return new _DistAppExecutor({ workspace: executor, name });
-    return new _DistAppExecutor({ workspace: executor.workspace, name });
-  }
-};
 var LibExecutor = class _LibExecutor extends SysExecutor {
   workspaceRoot;
   repoName;
+  dist;
   constructor({ workspace, name }) {
     super({ workspace, name, type: "lib" });
+    this.dist = new Executor(`${name} Dist Lib Executor`, `${this.workspace.workspaceRoot}/dist/libs/${name}`);
   }
   static from(executor, name) {
     if (executor instanceof WorkspaceExecutor)
@@ -1510,10 +1502,12 @@ var LibExecutor = class _LibExecutor extends SysExecutor {
 var PkgExecutor = class _PkgExecutor extends Executor {
   workspace;
   name;
+  dist;
   constructor({ workspace = WorkspaceExecutor.fromRoot(), name }) {
     super(`${name} Pkg Executor`, `${workspace.workspaceRoot}/pkgs/${name}`);
     this.workspace = workspace;
     this.name = name;
+    this.dist = new Executor(`${name} Dist Pkg Executor`, `${this.workspace.workspaceRoot}/dist/pkgs/${name}`);
   }
   static from(executor, name) {
     if (executor instanceof WorkspaceExecutor)
@@ -1543,24 +1537,6 @@ var PkgExecutor = class _PkgExecutor extends Executor {
     return pkgScanResult;
   }
 };
-var DistPkgExecutor = class _DistPkgExecutor extends Executor {
-  workspaceRoot;
-  repoName;
-  name;
-  constructor({ workspaceRoot, repoName, name }) {
-    super(`${name} Dist Pkg Executor`, `${workspaceRoot}/dist/pkgs/${name}`);
-    this.workspaceRoot = workspaceRoot;
-    this.repoName = repoName;
-    this.name = name;
-  }
-  static from(workspaceExecutor, name) {
-    return new _DistPkgExecutor({
-      workspaceRoot: workspaceExecutor.workspaceRoot,
-      repoName: workspaceExecutor.repoName,
-      name
-    });
-  }
-};
 
 // pkgs/@akanjs/devkit/src/constants.ts
 var import_os = require("os");
@@ -2100,7 +2076,9 @@ var LibraryRunner = class {
   }
   async installLibrary(workspace, libName) {
     workspace.log(`Installing ${libName} library as git subtree...`);
-    await workspace.exec(`git subtree add --prefix=libs/${libName} git@github.com:akan-team/${libName}.git main`);
+    await workspace.exec(
+      `git subtree add --quiet --prefix=libs/${libName} git@github.com:akan-team/${libName}.git main`
+    );
     await workspace.cp(`libs/${libName}/env/env.server.example.ts`, `libs/${libName}/env/env.server.testing.ts`);
     workspace.setTsPaths("lib", libName);
     await workspace.commit(`Add ${libName} library`);
@@ -2129,18 +2107,18 @@ var LibraryRunner = class {
     });
     const newRootPackageJson = { ...rootPackageJson, dependencies, devDependencies };
     lib.workspace.writeJson("package.json", newRootPackageJson);
-    await lib.workspace.spawn("pnpm", ["install"]);
+    await lib.workspace.spawn("pnpm", ["install", "--reporter=silent"]);
     await lib.workspace.commit(`Merge ${lib.name} library dependencies`);
   }
   async pushLibrary(lib, branch) {
     await lib.workspace.exec(
-      `git subtree push --prefix=libs/${lib.name} git@github.com:akan-team/${lib.name}.git ${branch}`
+      `git subtree push --quiet --prefix=libs/${lib.name} git@github.com:akan-team/${lib.name}.git ${branch}`
     );
     lib.logger.log(`${lib.name} library pushed to ${branch} branch`);
   }
   async pullLibrary(lib, branch) {
     await lib.workspace.exec(
-      `git subtree pull --prefix=libs/${lib.name} git@github.com:akan-team/${lib.name}.git ${branch}`
+      `git subtree pull --quiet --prefix=libs/${lib.name} git@github.com:akan-team/${lib.name}.git ${branch}`
     );
     lib.logger.log(`${lib.name} library pulled from ${branch} branch`);
   }
@@ -2216,6 +2194,7 @@ var esbuild = __toESM(require("esbuild"));
 var import_fs12 = __toESM(require("fs"));
 var import_promises2 = __toESM(require("fs/promises"));
 var import_js_yaml2 = __toESM(require("js-yaml"));
+var import_open = __toESM(require("open"));
 var import_ora2 = __toESM(require("ora"));
 var import_path4 = __toESM(require("path"));
 var vite = __toESM(require("vite"));
@@ -3216,16 +3195,16 @@ var ApplicationRunner = class {
       ...env
     };
   }
-  async #prepareCommand(app, distApp, type, target) {
-    await distApp.exec(`rm -rf ${target}`);
+  async #prepareCommand(app, type, target) {
+    await app.dist.exec(`rm -rf ${target}`);
     if (target === "frontend") {
       await app.exec("rm -rf .next");
       app.writeFile("next.config.ts", defaultNextConfigFile);
     }
     return { env: this.#getEnv(app, { AKAN_COMMAND_TYPE: type }) };
   }
-  async buildBackend(app, distApp) {
-    await this.#prepareCommand(app, distApp, "serve", "backend");
+  async buildBackend(app) {
+    await this.#prepareCommand(app, "serve", "backend");
     const akanConfig = await app.getConfig("build");
     const buildResult = await esbuild.build({
       write: false,
@@ -3233,12 +3212,12 @@ var ApplicationRunner = class {
       bundle: true,
       packages: "external",
       platform: "node",
-      outdir: `${distApp.cwdPath}/backend`,
+      outdir: `${app.dist.cwdPath}/backend`,
       logLevel: "warning"
     });
     const rootPackageJson = app.workspace.readJson("package.json");
     const dependencies = extractDependencies(buildResult.outputFiles, rootPackageJson);
-    buildResult.outputFiles.map((file) => distApp.writeFile(file.path, file.text));
+    buildResult.outputFiles.map((file) => app.dist.writeFile(file.path, file.text));
     const appPackageJson = {
       name: `${app.name}/backend`,
       description: `${app.name} backend`,
@@ -3247,31 +3226,33 @@ var ApplicationRunner = class {
       engines: { node: ">=22" },
       dependencies
     };
-    distApp.writeJson("backend/package.json", appPackageJson);
-    distApp.writeFile(import_path4.default.join(distApp.cwdPath, "backend", "Dockerfile"), akanConfig.backend.dockerfile);
+    app.dist.writeJson("backend/package.json", appPackageJson);
+    app.dist.writeFile(import_path4.default.join(app.dist.cwdPath, "backend", "Dockerfile"), akanConfig.backend.dockerfile);
   }
-  async serveBackend(app, distApp) {
-    const { env } = await this.#prepareCommand(app, distApp, "serve", "backend");
+  async serveBackend(app, { open: open2 = false } = {}) {
+    const { env } = await this.#prepareCommand(app, "serve", "backend");
     const ctx = await esbuild.context({
       write: true,
       entryPoints: [`${app.cwdPath}/main.ts`],
       bundle: true,
       packages: "external",
       platform: "node",
-      outdir: import_path4.default.join(distApp.cwdPath, "backend"),
+      outdir: import_path4.default.join(app.dist.cwdPath, "backend"),
       logLevel: "warning"
     });
     await ctx.watch();
     await sleep(100);
-    await distApp.spawn("node", ["--watch", "backend/main.js"], { env });
+    if (open2)
+      setTimeout(() => (0, import_open.default)("http://localhost:8080/backend/graphql"), 3e3);
+    await app.dist.spawn("node", ["--watch", "backend/main.js"], { env });
   }
-  async buildFrontend(app, distApp) {
-    const { env } = await this.#prepareCommand(app, distApp, "build", "frontend");
+  async buildFrontend(app) {
+    const { env } = await this.#prepareCommand(app, "build", "frontend");
     const akanConfig = await app.getConfig("build");
     await app.spawn("npx", ["next", "build", "--no-lint"], { env });
     const buildResult = await esbuild.build({
       entryPoints: [`${app.cwdPath}/next.config.ts`],
-      outdir: `${distApp.cwdPath}/frontend`,
+      outdir: `${app.dist.cwdPath}/frontend`,
       bundle: true,
       packages: "external",
       platform: "node",
@@ -3282,7 +3263,7 @@ var ApplicationRunner = class {
     });
     const rootPackageJson = app.workspace.readJson("package.json");
     const dependencies = extractDependencies(buildResult.outputFiles, rootPackageJson, ["next", "react", "react-dom"]);
-    buildResult.outputFiles.map((file) => distApp.writeFile(file.path, file.text));
+    buildResult.outputFiles.map((file) => app.dist.writeFile(file.path, file.text));
     const appPackageJson = {
       name: `${app.name}/frontend`,
       description: `${app.name} frontend`,
@@ -3293,26 +3274,28 @@ var ApplicationRunner = class {
         start: "next start"
       }
     };
-    distApp.writeJson("frontend/package.json", appPackageJson);
+    app.dist.writeJson("frontend/package.json", appPackageJson);
     await Promise.all([
-      app.cp(".next", import_path4.default.join(distApp.cwdPath, "frontend", ".next")),
-      app.cp("public", import_path4.default.join(distApp.cwdPath, "frontend", "public"))
+      app.cp(".next", import_path4.default.join(app.dist.cwdPath, "frontend", ".next")),
+      app.cp("public", import_path4.default.join(app.dist.cwdPath, "frontend", "public"))
     ]);
-    distApp.writeFile("frontend/Dockerfile", akanConfig.frontend.dockerfile);
+    app.dist.writeFile("frontend/Dockerfile", akanConfig.frontend.dockerfile);
   }
-  async serveFrontend(app, distApp) {
-    const { env } = await this.#prepareCommand(app, distApp, "serve", "frontend");
+  async serveFrontend(app, { open: open2 = false } = {}) {
+    const { env } = await this.#prepareCommand(app, "serve", "frontend");
+    if (open2)
+      setTimeout(() => (0, import_open.default)("http://localhost:4200"), 3e3);
     await app.spawn("npx", ["next", "dev", "-p", "4200"], { env });
   }
-  async #getViteConfig(app, distApp) {
-    const { env } = await this.#prepareCommand(app, distApp, "build", "csr");
+  async #getViteConfig(app) {
+    const { env } = await this.#prepareCommand(app, "build", "csr");
     const processEnv = env;
     const akanjsPrefix = process.env.USE_AKANJS_PKGS === "true" ? "../../../../pkgs/" : "";
     const config = vite.defineConfig({
       root: `${app.cwdPath}/app`,
       base: "/",
       build: {
-        outDir: `${distApp.cwdPath}/csr`,
+        outDir: `${app.dist.cwdPath}/csr`,
         sourcemap: false,
         emptyOutDir: true,
         rollupOptions: { external: ["next/server"], input: `${app.cwdPath}/app/index.html` }
@@ -3370,15 +3353,17 @@ var ApplicationRunner = class {
     });
     return config;
   }
-  async buildCsr(app, distApp) {
-    const config = await this.#getViteConfig(app, distApp);
+  async buildCsr(app) {
+    const config = await this.#getViteConfig(app);
     await vite.build(config);
   }
-  async serveCsr(app, distApp) {
-    const config = await this.#getViteConfig(app, distApp);
+  async serveCsr(app, { open: open2 = false } = {}) {
+    const config = await this.#getViteConfig(app);
     const server = await vite.createServer(config);
     await server.listen(4201);
     app.log(`CSR server is running on http://localhost:4201`);
+    if (open2)
+      setTimeout(() => (0, import_open.default)("http://localhost:4201"), 3e3);
   }
   async #prepareIos(app) {
     const isAdded = import_fs12.default.existsSync(`${app.cwdPath}/ios/App/Podfile`);
@@ -3495,24 +3480,23 @@ var ApplicationRunner = class {
     await capacitorApp.save();
   }
   async releaseSource(app, { rebuild, buildNum = 0, environment = "debug", local = true } = {}) {
-    const distApp = DistAppExecutor.from(app, app.name);
     const buildRoot = `${app.workspace.workspaceRoot}/releases/builds/${app.name}`;
     const appVersionInfo = import_js_yaml2.default.load(app.readFile("config.yaml"));
     const platformVersion = appVersionInfo.platforms.android.versionName;
     if (import_fs12.default.existsSync(buildRoot))
       await import_promises2.default.rm(buildRoot, { recursive: true, force: true });
     await import_promises2.default.mkdir(buildRoot, { recursive: true });
-    if (rebuild || !import_fs12.default.existsSync(`${distApp.cwdPath}/backend`))
-      await this.buildBackend(app, distApp);
-    if (rebuild || !import_fs12.default.existsSync(`${distApp.cwdPath}/frontend`))
-      await this.buildFrontend(app, distApp);
-    if (rebuild || !import_fs12.default.existsSync(`${distApp.cwdPath}/csr`))
-      await this.buildCsr(app, distApp);
+    if (rebuild || !import_fs12.default.existsSync(`${app.dist.cwdPath}/backend`))
+      await this.buildBackend(app);
+    if (rebuild || !import_fs12.default.existsSync(`${app.dist.cwdPath}/frontend`))
+      await this.buildFrontend(app);
+    if (rebuild || !import_fs12.default.existsSync(`${app.dist.cwdPath}/csr`))
+      await this.buildCsr(app);
     const buildVersion = `${platformVersion}-${buildNum}`;
     const buildPath = `${buildRoot}/${buildVersion}`;
     await import_promises2.default.mkdir(buildPath, { recursive: true });
-    await import_promises2.default.cp(`${distApp.cwdPath}/backend`, `${buildPath}/backend`, { recursive: true });
-    await import_promises2.default.cp(distApp.cwdPath, buildRoot, { recursive: true });
+    await import_promises2.default.cp(`${app.dist.cwdPath}/backend`, `${buildPath}/backend`, { recursive: true });
+    await import_promises2.default.cp(app.dist.cwdPath, buildRoot, { recursive: true });
     await import_promises2.default.rm(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
     await app.workspace.spawn("tar", [
       "-zcf",
@@ -3521,8 +3505,8 @@ var ApplicationRunner = class {
       buildRoot,
       "./"
     ]);
-    if (import_fs12.default.existsSync(`${distApp.cwdPath}/csr`)) {
-      await import_promises2.default.cp(`${distApp.cwdPath}/csr`, "./csr", { recursive: true });
+    if (import_fs12.default.existsSync(`${app.dist.cwdPath}/csr`)) {
+      await import_promises2.default.cp(`${app.dist.cwdPath}/csr`, "./csr", { recursive: true });
       await app.workspace.spawn("zip", [
         "-r",
         `${app.workspace.workspaceRoot}/releases/builds/${app.name}-appBuild.zip`,
@@ -3541,7 +3525,7 @@ var ApplicationRunner = class {
       }
     }
     await import_promises2.default.mkdir(sourceRoot, { recursive: true });
-    await import_promises2.default.cp(distApp.cwdPath, `${sourceRoot}/apps/${app.name}`, { recursive: true });
+    await import_promises2.default.cp(app.dist.cwdPath, `${sourceRoot}/apps/${app.name}`, { recursive: true });
     const libDeps = ["social", "shared", "platform", "util"];
     await Promise.all(
       libDeps.map(
@@ -3680,9 +3664,11 @@ var ApplicationRunner = class {
 var ApplicationScript = class {
   #runner = new ApplicationRunner();
   libraryScript = new LibraryScript();
-  async createApplication(appName, workspace) {
+  async createApplication(appName, workspace, { serve = false } = {}) {
     const app = await this.#runner.createApplication(appName, workspace);
     await this.syncApplication(app);
+    if (serve)
+      await this.serve(app, { open: true });
   }
   async scanApplication(app, verbose = false) {
     const scanResult = await this.#runner.scanSync(app);
@@ -3697,64 +3683,78 @@ var ApplicationScript = class {
     for (const libName of scanResult.akanConfig.libs)
       await this.libraryScript.syncLibrary(LibExecutor.from(app, libName), { recursive: false });
   }
-  async build(app, distApp = DistAppExecutor.from(app, app.name)) {
-    await this.syncApplication(app);
-    await Promise.all([this.buildBackend(app, distApp), this.buildFrontend(app, distApp)]);
-  }
-  async serve(app, distApp = DistAppExecutor.from(app, app.name)) {
-    await this.syncApplication(app);
-    await Promise.all([this.#runner.serveBackend(app, distApp), this.#runner.serveFrontend(app, distApp)]);
-  }
-  async buildBackend(app, distApp = DistAppExecutor.from(app, app.name)) {
-    await this.syncApplication(app);
-    await this.#runner.buildBackend(app, distApp);
-  }
-  async serveBackend(app, distApp = DistAppExecutor.from(app, app.name)) {
-    await this.syncApplication(app);
-    await this.#runner.serveBackend(app, distApp);
-  }
-  async buildFrontend(app, distApp = DistAppExecutor.from(app, app.name)) {
-    await this.syncApplication(app);
-    await this.#runner.buildFrontend(app, distApp);
-  }
-  async serveFrontend(app, distApp = DistAppExecutor.from(app, app.name)) {
-    await this.syncApplication(app);
-    await this.#runner.serveFrontend(app, distApp);
-  }
-  async buildCsr(app, distApp = DistAppExecutor.from(app, app.name)) {
-    await this.syncApplication(app);
-    await this.#runner.buildCsr(app, distApp);
-  }
-  async serveCsr(app, distApp = DistAppExecutor.from(app, app.name)) {
+  async build(app) {
     await this.syncApplication(app);
-    await this.#runner.serveCsr(app, distApp);
+    await Promise.all([this.buildBackend(app), this.buildFrontend(app)]);
   }
-  async buildIos(app) {
+  async serve(app, { open: open2 = false } = {}) {
     await this.syncApplication(app);
-    await this.#runner.buildCsr(app, DistAppExecutor.from(app, app.name));
+    await Promise.all([this.serveBackend(app, { open: open2, sync: false }), this.serveFrontend(app, { open: open2, sync: false })]);
+  }
+  async buildBackend(app, { sync = true } = {}) {
+    if (sync)
+      await this.syncApplication(app);
+    await this.#runner.buildBackend(app);
+  }
+  async serveBackend(app, { open: open2 = false, sync = true } = {}) {
+    if (sync)
+      await this.syncApplication(app);
+    await this.#runner.serveBackend(app, { open: open2 });
+  }
+  async buildFrontend(app, { sync = true } = {}) {
+    if (sync)
+      await this.syncApplication(app);
+    await this.#runner.buildFrontend(app);
+  }
+  async serveFrontend(app, { open: open2 = false, sync = true } = {}) {
+    if (sync)
+      await this.syncApplication(app);
+    await this.#runner.serveFrontend(app, { open: open2 });
+  }
+  async buildCsr(app, { sync = true } = {}) {
+    if (sync)
+      await this.syncApplication(app);
+    await this.#runner.buildCsr(app);
+  }
+  async serveCsr(app, { open: open2 = false, sync = true } = {}) {
+    if (sync)
+      await this.syncApplication(app);
+    await this.#runner.serveCsr(app, { open: open2 });
+  }
+  async buildIos(app, { sync = true } = {}) {
+    if (sync)
+      await this.syncApplication(app);
     await this.#runner.buildIos(app);
   }
-  async serveIos(app, { open: open2 = false, operation = "local" } = {}) {
-    await this.syncApplication(app);
-    await this.#runner.buildCsr(app, DistAppExecutor.from(app, app.name));
+  async serveIos(app, {
+    open: open2 = false,
+    operation = "local",
+    sync = true
+  } = {}) {
+    if (sync)
+      await this.syncApplication(app);
     await this.#runner.serveIos(app, { open: open2, operation });
   }
-  async releaseIos(app) {
-    await this.buildCsr(app);
+  async releaseIos(app, { sync = true } = {}) {
+    await this.buildCsr(app, { sync });
     await this.#runner.releaseIos(app);
   }
-  async buildAndroid(app) {
-    await this.syncApplication(app);
-    await this.#runner.buildCsr(app, DistAppExecutor.from(app, app.name));
+  async buildAndroid(app, { sync = true } = {}) {
+    if (sync)
+      await this.syncApplication(app);
     await this.#runner.buildAndroid(app);
   }
-  async serveAndroid(app, { open: open2 = false, operation = "local" } = {}) {
-    await this.syncApplication(app);
-    await this.#runner.buildCsr(app, DistAppExecutor.from(app, app.name));
+  async serveAndroid(app, {
+    open: open2 = false,
+    operation = "local",
+    sync = true
+  } = {}) {
+    if (sync)
+      await this.syncApplication(app);
     await this.#runner.serveAndroid(app, { open: open2, operation });
   }
-  async releaseAndroid(app) {
-    await this.buildCsr(app);
+  async releaseAndroid(app, { sync = true } = {}) {
+    await this.buildCsr(app, { sync });
     await this.#runner.releaseAndroid(app);
   }
   async dumpDatabase(app, environment) {
@@ -3797,8 +3797,8 @@ var ApplicationScript = class {
 // pkgs/@akanjs/cli/src/application/application.command.ts
 var ApplicationCommand = class {
   applicationScript = new ApplicationScript();
-  async createApplication(name, workspace) {
-    await this.applicationScript.createApplication(name, workspace);
+  async createApplication(name, serve, workspace) {
+    await this.applicationScript.createApplication(name, workspace, { serve });
   }
   async removeApplication(app, workspace) {
   }
@@ -3823,17 +3823,17 @@ var ApplicationCommand = class {
   async buildAndroid(app) {
     await this.applicationScript.buildAndroid(app);
   }
-  async serve(app) {
-    await this.applicationScript.serve(app);
+  async serve(app, open2) {
+    await this.applicationScript.serve(app, { open: open2 });
   }
-  async serveBackend(app) {
-    await this.applicationScript.serveBackend(app);
+  async serveBackend(app, open2) {
+    await this.applicationScript.serveBackend(app, { open: open2 });
   }
-  async serveFrontend(app) {
-    await this.applicationScript.serveFrontend(app);
+  async serveFrontend(app, open2) {
+    await this.applicationScript.serveFrontend(app, { open: open2 });
   }
-  async serveCsr(app) {
-    await this.applicationScript.serveCsr(app);
+  async serveCsr(app, open2) {
+    await this.applicationScript.serveCsr(app, { open: open2 });
   }
   async serveIos(app, open2, release) {
     await this.applicationScript.serveIos(app, { open: open2, operation: release ? "release" : "local" });
@@ -3875,7 +3875,8 @@ var ApplicationCommand = class {
 __decorateClass([
   Target.Public(),
   __decorateParam(0, Option("name", { desc: "name of application" })),
-  __decorateParam(1, Workspace())
+  __decorateParam(1, Option("serve", { type: "boolean", desc: "serve application", default: false })),
+  __decorateParam(2, Workspace())
 ], ApplicationCommand.prototype, "createApplication", 1);
 __decorateClass([
   Target.Public(),
@@ -3912,31 +3913,35 @@ __decorateClass([
 ], ApplicationCommand.prototype, "buildAndroid", 1);
 __decorateClass([
   Target.Public({ short: true }),
-  __decorateParam(0, App())
+  __decorateParam(0, App()),
+  __decorateParam(1, Option("open", { type: "boolean", desc: "open web browser", default: false }))
 ], ApplicationCommand.prototype, "serve", 1);
 __decorateClass([
   Target.Public({ short: true }),
-  __decorateParam(0, App())
+  __decorateParam(0, App()),
+  __decorateParam(1, Option("open", { type: "boolean", desc: "open graphql playground", default: false }))
 ], ApplicationCommand.prototype, "serveBackend", 1);
 __decorateClass([
   Target.Public({ short: true }),
-  __decorateParam(0, App())
+  __decorateParam(0, App()),
+  __decorateParam(1, Option("open", { type: "boolean", desc: "open web browser", default: false }))
 ], ApplicationCommand.prototype, "serveFrontend", 1);
 __decorateClass([
   Target.Public({ short: true }),
-  __decorateParam(0, App())
+  __decorateParam(0, App()),
+  __decorateParam(1, Option("open", { type: "boolean", desc: "open web browser", default: false }))
 ], ApplicationCommand.prototype, "serveCsr", 1);
 __decorateClass([
   Target.Public({ short: true }),
   __decorateParam(0, App()),
-  __decorateParam(1, Option("open", { desc: "open ios simulator", default: false })),
-  __decorateParam(2, Option("release", { desc: "release mode", default: false }))
+  __decorateParam(1, Option("open", { type: "boolean", desc: "open ios simulator", default: false })),
+  __decorateParam(2, Option("release", { type: "boolean", desc: "release mode", default: false }))
 ], ApplicationCommand.prototype, "serveIos", 1);
 __decorateClass([
   Target.Public({ short: true }),
   __decorateParam(0, App()),
-  __decorateParam(1, Option("open", { desc: "open android simulator", default: false })),
-  __decorateParam(2, Option("release", { desc: "release mode", default: false }))
+  __decorateParam(1, Option("open", { type: "boolean", desc: "open android simulator", default: false })),
+  __decorateParam(2, Option("release", { type: "boolean", desc: "release mode", default: false }))
 ], ApplicationCommand.prototype, "serveAndroid", 1);
 __decorateClass([
   Target.Public(),
@@ -3949,10 +3954,10 @@ __decorateClass([
 __decorateClass([
   Target.Public(),
   __decorateParam(0, App()),
-  __decorateParam(1, Option("rebuild", { desc: "rebuild", default: false })),
+  __decorateParam(1, Option("rebuild", { type: "boolean", desc: "rebuild", default: false })),
   __decorateParam(2, Option("buildNum", { desc: "build number", default: 0 })),
   __decorateParam(3, Option("environment", { desc: "environment", default: "debug" })),
-  __decorateParam(4, Option("local", { desc: "local", default: true }))
+  __decorateParam(4, Option("local", { type: "boolean", desc: "local", default: true }))
 ], ApplicationCommand.prototype, "releaseSource", 1);
 __decorateClass([
   Target.Public(),
@@ -4026,11 +4031,11 @@ var PackageRunner = class {
     const scanResult = await pkg.scan();
     return scanResult;
   }
-  async buildPackage(pkg, distPkg) {
+  async buildPackage(pkg) {
     const rootPackageJson = pkg.workspace.readJson("package.json");
     const pkgJson = pkg.readJson("package.json");
-    if (import_fs13.default.existsSync(distPkg.cwdPath))
-      await pkg.workspace.exec(`rm -rf ${distPkg.cwdPath}`);
+    if (import_fs13.default.existsSync(pkg.dist.cwdPath))
+      await pkg.workspace.exec(`rm -rf ${pkg.dist.cwdPath}`);
     let buildResult;
     if (pkg.name === "@akanjs/config") {
       buildResult = await esbuild2.build({
@@ -4039,7 +4044,7 @@ var PackageRunner = class {
         bundle: false,
         packages: "external",
         format: "cjs",
-        outdir: distPkg.cwdPath,
+        outdir: pkg.dist.cwdPath,
         logLevel: "error",
         outExtension: { ".js": pkgJson.type === "module" ? ".cjs" : ".js" },
         plugins: [(0, import_esbuild_plugin_d.dtsPlugin)({ tsconfig: `${pkg.cwdPath}/tsconfig.json` })]
@@ -4050,10 +4055,9 @@ var PackageRunner = class {
         bundle: false,
         packages: "external",
         format: "esm",
-        outdir: distPkg.cwdPath,
+        outdir: pkg.dist.cwdPath,
         logLevel: "error",
         outExtension: { ".js": pkgJson.type === "module" ? ".js" : ".mjs" },
-        // copy css files
         loader: { ".css": "copy", ".js": "copy" }
       });
     } else if (pkg.name === "@akanjs/cli") {
@@ -4063,7 +4067,7 @@ var PackageRunner = class {
         bundle: true,
         format: "cjs",
         packages: "external",
-        outdir: distPkg.cwdPath,
+        outdir: pkg.dist.cwdPath,
         logLevel: "error",
         plugins: [(0, import_esbuild_plugin_d.dtsPlugin)({ tsconfig: `${pkg.cwdPath}/tsconfig.json` })]
       });
@@ -4071,14 +4075,14 @@ var PackageRunner = class {
         write: true,
         entryPoints: [`${pkg.cwdPath}/src/templates/**/*.ts`, `${pkg.cwdPath}/src/templates/**/*.tsx`],
         packages: "external",
-        outdir: `${distPkg.cwdPath}/src/templates`,
+        outdir: `${pkg.dist.cwdPath}/src/templates`,
         outbase: `${pkg.cwdPath}/src/templates`,
         format: "cjs",
         platform: "node",
         footer: { js: "module.exports = module.exports.default;" }
       });
       await pkg.workspace.exec(
-        `rsync -aq --exclude="*.ts" --exclude="*.tsx" ${pkg.cwdPath}/src/templates/ ${distPkg.cwdPath}/src/templates/`
+        `rsync -aq --exclude="*.ts" --exclude="*.tsx" ${pkg.cwdPath}/src/templates/ ${pkg.dist.cwdPath}/src/templates/`
       );
     } else {
       const platform = [
@@ -4097,7 +4101,7 @@ var PackageRunner = class {
         splitting: false,
         platform,
         format: "cjs",
-        outdir: distPkg.cwdPath,
+        outdir: pkg.dist.cwdPath,
         outExtension: { ".js": pkgJson.type === "module" ? ".cjs" : ".js" },
         logLevel: "error",
         plugins: [(0, import_esbuild_plugin_d.dtsPlugin)({ tsconfig: `${pkg.cwdPath}/tsconfig.json` })]
@@ -4110,7 +4114,7 @@ var PackageRunner = class {
         splitting: false,
         platform,
         format: "esm",
-        outdir: distPkg.cwdPath,
+        outdir: pkg.dist.cwdPath,
         outExtension: { ".js": pkgJson.type === "module" ? ".js" : ".mjs" },
         logLevel: "error",
         plugins: []
@@ -4133,8 +4137,8 @@ var PackageRunner = class {
       }
     };
     if (buildResult.outputFiles)
-      buildResult.outputFiles.map((file) => distPkg.writeFile(file.path, file.text));
-    distPkg.writeJson("package.json", pkgPackageJson);
+      buildResult.outputFiles.map((file) => pkg.dist.writeFile(file.path, file.text));
+    pkg.dist.writeJson("package.json", pkgPackageJson);
     pkg.writeJson("package.json", pkgPackageJson);
   }
 };
@@ -4152,8 +4156,8 @@ var PackageScript = class {
     const scanResult = await this.#runner.scanSync(pkg);
     pkg.logger.rawLog(JSON.stringify(scanResult, null, 2));
   }
-  async buildPackage(pkg, distPkg = DistPkgExecutor.from(pkg.workspace, pkg.name)) {
-    await this.#runner.buildPackage(pkg, distPkg);
+  async buildPackage(pkg) {
+    await this.#runner.buildPackage(pkg);
   }
 };
 
@@ -4161,7 +4165,7 @@ var PackageScript = class {
 var import_prompts7 = require("@inquirer/prompts");
 var import_chalk = __toESM(require("chalk"));
 var import_latest_version = __toESM(require("latest-version"));
-var import_open = __toESM(require("open"));
+var import_open2 = __toESM(require("open"));
 var QRcode = __toESM(require("qrcode"));
 var import_uuid = require("uuid");
 var CloudRunner = class {
@@ -4189,7 +4193,7 @@ ${import_chalk.default.green("\u27A4")} Authentication Required`));
         });
       });
       Logger.rawLog(qrcode);
-      await (0, import_open.default)(signinUrl);
+      await (0, import_open2.default)(signinUrl);
       Logger.rawLog(import_chalk.default.dim("Opening browser..."));
     } catch {
       Logger.rawLog(import_chalk.default.yellow("Could not open browser. Please visit the URL manually."));
@@ -4839,7 +4843,7 @@ var WorkspaceScript = class {
     };
     workspace.writeFile("package.json", packageJson);
     workspace.log("Installing dependencies...");
-    await workspace.spawn("pnpm", ["i"]);
+    await workspace.spawn("pnpm", ["install", "--reporter=silent"]);
     workspace.log("Initializing git repository and commit...");
     await workspace.commit("Initial commit", { init: true });
     await this.libraryScript.installLibrary(workspace, "util");

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "commonjs",
   "name": "@akanjs/cli",
-  "version": "0.0.88",
+  "version": "0.0.89",
   "bin": {
     "akan": "index.js"
   },

package/pkgs/@akanjs/cli/src/application/application.command.d.ts

@@ -2,7 +2,7 @@ import { App, Sys, Workspace } from "@akanjs/devkit";
 import { ApplicationScript } from "./application.script";
 export declare class ApplicationCommand {
     applicationScript: ApplicationScript;
-    createApplication(name: string, workspace: Workspace): Promise<void>;
+    createApplication(name: string, serve: boolean, workspace: Workspace): Promise<void>;
     removeApplication(app: App, workspace: Workspace): Promise<void>;
     scanApplication(app: App): Promise<void>;
     build(app: App): Promise<void>;
@@ -11,10 +11,10 @@ export declare class ApplicationCommand {
     buildCsr(app: App): Promise<void>;
     buildIos(app: App): Promise<void>;
     buildAndroid(app: App): Promise<void>;
-    serve(app: App): Promise<void>;
-    serveBackend(app: App): Promise<void>;
-    serveFrontend(app: App): Promise<void>;
-    serveCsr(app: App): Promise<void>;
+    serve(app: App, open: boolean): Promise<void>;
+    serveBackend(app: App, open: boolean): Promise<void>;
+    serveFrontend(app: App, open: boolean): Promise<void>;
+    serveCsr(app: App, open: boolean): Promise<void>;
     serveIos(app: App, open: boolean, release: boolean): Promise<void>;
     serveAndroid(app: App, open: boolean, release: boolean): Promise<void>;
     releaseIos(app: App): Promise<void>;

package/pkgs/@akanjs/cli/src/application/application.runner.d.ts

@@ -1,4 +1,4 @@
-import { App, AppExecutor, DistAppExecutor, type Workspace } from "@akanjs/devkit";
+import { App, AppExecutor, type Workspace } from "@akanjs/devkit";
 export interface ReleaseSourceOptions {
     rebuild?: boolean;
     buildNum?: number;
@@ -9,12 +9,18 @@ export declare class ApplicationRunner {
     #private;
     createApplication(appName: string, workspace: Workspace): Promise<AppExecutor>;
     scanSync(app: App): Promise<import("@akanjs/config").AppScanResult | import("@akanjs/config").LibScanResult>;
-    buildBackend(app: App, distApp: DistAppExecutor): Promise<void>;
-    serveBackend(app: App, distApp: DistAppExecutor): Promise<void>;
-    buildFrontend(app: App, distApp: DistAppExecutor): Promise<void>;
-    serveFrontend(app: App, distApp: DistAppExecutor): Promise<void>;
-    buildCsr(app: App, distApp: DistAppExecutor): Promise<void>;
-    serveCsr(app: App, distApp: DistAppExecutor): Promise<void>;
+    buildBackend(app: App): Promise<void>;
+    serveBackend(app: App, { open }?: {
+        open?: boolean;
+    }): Promise<void>;
+    buildFrontend(app: App): Promise<void>;
+    serveFrontend(app: App, { open }?: {
+        open?: boolean;
+    }): Promise<void>;
+    buildCsr(app: App): Promise<void>;
+    serveCsr(app: App, { open }?: {
+        open?: boolean;
+    }): Promise<void>;
     buildIos(app: App): Promise<void>;
     serveIos(app: App, { open, operation }?: {
         open?: boolean;

package/pkgs/@akanjs/cli/src/application/application.script.d.ts

@@ -1,35 +1,63 @@
 import type { App, Sys, Workspace } from "@akanjs/devkit";
-import { DistAppExecutor } from "@akanjs/devkit";
 import { LibraryScript } from "../library/library.script";
 import { type ReleaseSourceOptions } from "./application.runner";
 export declare class ApplicationScript {
     #private;
     libraryScript: LibraryScript;
-    createApplication(appName: string, workspace: Workspace): Promise<void>;
+    createApplication(appName: string, workspace: Workspace, { serve }?: {
+        serve?: boolean;
+    }): Promise<void>;
     scanApplication(app: App, verbose?: boolean): Promise<import("@akanjs/config").AppScanResult | import("@akanjs/config").LibScanResult>;
     syncApplication(app: App, { recursive }?: {
         recursive?: boolean;
     }): Promise<void>;
-    build(app: App, distApp?: DistAppExecutor): Promise<void>;
-    serve(app: App, distApp?: DistAppExecutor): Promise<void>;
-    buildBackend(app: App, distApp?: DistAppExecutor): Promise<void>;
-    serveBackend(app: App, distApp?: DistAppExecutor): Promise<void>;
-    buildFrontend(app: App, distApp?: DistAppExecutor): Promise<void>;
-    serveFrontend(app: App, distApp?: DistAppExecutor): Promise<void>;
-    buildCsr(app: App, distApp?: DistAppExecutor): Promise<void>;
-    serveCsr(app: App, distApp?: DistAppExecutor): Promise<void>;
-    buildIos(app: App): Promise<void>;
-    serveIos(app: App, { open, operation }?: {
+    build(app: App): Promise<void>;
+    serve(app: App, { open }?: {
+        open?: boolean;
+    }): Promise<void>;
+    buildBackend(app: App, { sync }?: {
+        sync?: boolean;
+    }): Promise<void>;
+    serveBackend(app: App, { open, sync }?: {
+        open?: boolean;
+        sync?: boolean;
+    }): Promise<void>;
+    buildFrontend(app: App, { sync }?: {
+        sync?: boolean;
+    }): Promise<void>;
+    serveFrontend(app: App, { open, sync }?: {
+        open?: boolean;
+        sync?: boolean;
+    }): Promise<void>;
+    buildCsr(app: App, { sync }?: {
+        sync?: boolean;
+    }): Promise<void>;
+    serveCsr(app: App, { open, sync }?: {
+        open?: boolean;
+        sync?: boolean;
+    }): Promise<void>;
+    buildIos(app: App, { sync }?: {
+        sync?: boolean;
+    }): Promise<void>;
+    serveIos(app: App, { open, operation, sync, }?: {
         open?: boolean;
         operation?: "local" | "release";
+        sync?: boolean;
+    }): Promise<void>;
+    releaseIos(app: App, { sync }?: {
+        sync?: boolean;
     }): Promise<void>;
-    releaseIos(app: App): Promise<void>;
-    buildAndroid(app: App): Promise<void>;
-    serveAndroid(app: App, { open, operation }?: {
+    buildAndroid(app: App, { sync }?: {
+        sync?: boolean;
+    }): Promise<void>;
+    serveAndroid(app: App, { open, operation, sync, }?: {
         open?: boolean;
         operation?: "local" | "release";
+        sync?: boolean;
+    }): Promise<void>;
+    releaseAndroid(app: App, { sync }?: {
+        sync?: boolean;
     }): Promise<void>;
-    releaseAndroid(app: App): Promise<void>;
     dumpDatabase(app: App, environment: string): Promise<void>;
     restoreDatabase(app: App, source: string, target: string): Promise<void>;
     pullDatabase(app: App, environment: string, dump?: boolean): Promise<void>;

package/pkgs/@akanjs/cli/src/package/package.runner.d.ts

@@ -1,7 +1,7 @@
-import { type DistPkgExecutor, type Pkg, type Workspace } from "@akanjs/devkit";
+import { type Pkg, type Workspace } from "@akanjs/devkit";
 export declare class PackageRunner {
     version(workspace: Workspace): Promise<void>;
     createPackage(workspace: Workspace, pkgName: string): Promise<void>;
     scanSync(pkg: Pkg): Promise<import("@akanjs/config").PkgScanResult>;
-    buildPackage(pkg: Pkg, distPkg: DistPkgExecutor): Promise<void>;
+    buildPackage(pkg: Pkg): Promise<void>;
 }

package/pkgs/@akanjs/cli/src/package/package.script.d.ts

@@ -1,8 +1,8 @@
-import { DistPkgExecutor, type Pkg, type Workspace } from "@akanjs/devkit";
+import { type Pkg, type Workspace } from "@akanjs/devkit";
 export declare class PackageScript {
     #private;
     version(workspace: Workspace): Promise<void>;
     createPackage(workspace: Workspace, pkgName: string): Promise<void>;
     scanPackage(pkg: Pkg): Promise<void>;
-    buildPackage(pkg: Pkg, distPkg?: DistPkgExecutor): Promise<void>;
+    buildPackage(pkg: Pkg): Promise<void>;
 }

package/pkgs/@akanjs/devkit/src/executors.d.ts

@@ -110,20 +110,12 @@ interface AppExecutorOptions {
     name: string;
 }
 export declare class AppExecutor extends SysExecutor {
+    dist: Executor;
     constructor({ workspace, name }: AppExecutorOptions);
     static from(executor: SysExecutor | WorkspaceExecutor, name: string): AppExecutor;
     getConfig(command?: string): Promise<AppConfigResult>;
     syncAssets(libDeps: string[]): Promise<void>;
 }
-interface DistAppExecutorOptions {
-    workspace: WorkspaceExecutor;
-    name: string;
-}
-export declare class DistAppExecutor extends Executor {
-    name: string;
-    constructor({ workspace, name }: DistAppExecutorOptions);
-    static from(executor: SysExecutor | WorkspaceExecutor, name: string): DistAppExecutor;
-}
 interface LibExecutorOptions {
     workspace?: WorkspaceExecutor;
     name: string;
@@ -131,19 +123,11 @@ interface LibExecutorOptions {
 export declare class LibExecutor extends SysExecutor {
     workspaceRoot: string;
     repoName: string;
+    dist: Executor;
     constructor({ workspace, name }: LibExecutorOptions);
     static from(executor: SysExecutor | WorkspaceExecutor, name: string): LibExecutor;
     getConfig(command?: string): Promise<LibConfigResult>;
 }
-interface DistLibExecutorOptions {
-    workspace: WorkspaceExecutor;
-    name: string;
-}
-export declare class DistLibExecutor extends Executor {
-    name: string;
-    constructor({ workspace, name }: DistLibExecutorOptions);
-    static from(executor: SysExecutor | WorkspaceExecutor, name: string): DistAppExecutor | DistLibExecutor;
-}
 interface PkgExecutorOptions {
     workspace?: WorkspaceExecutor;
     name: string;
@@ -151,6 +135,7 @@ interface PkgExecutorOptions {
 export declare class PkgExecutor extends Executor {
     workspace: WorkspaceExecutor;
     name: string;
+    dist: Executor;
     constructor({ workspace, name }: PkgExecutorOptions);
     static from(executor: SysExecutor | WorkspaceExecutor, name: string): PkgExecutor;
     scan({ packageJson, tsconfig, }?: {
@@ -158,16 +143,4 @@ export declare class PkgExecutor extends Executor {
         tsconfig?: TsConfigJson;
     }): Promise<PkgScanResult>;
 }
-interface DistPkgExecutorOptions {
-    workspaceRoot: string;
-    repoName: string;
-    name: string;
-}
-export declare class DistPkgExecutor extends Executor {
-    workspaceRoot: string;
-    repoName: string;
-    name: string;
-    constructor({ workspaceRoot, repoName, name }: DistPkgExecutorOptions);
-    static from(workspaceExecutor: WorkspaceExecutor, name: string): DistPkgExecutor;
-}
 export {};

package/pkgs/@akanjs/devkit/src/index.d.ts

@@ -13,5 +13,4 @@ export * from "./types";
 export * from "./capacitorApp";
 export * from "./extractDeps";
 export * from "./commandDecorators";
-export * from "./installExternalLib";
 export * from "./aiEditor";

package/pkgs/@akanjs/devkit/src/installExternalLib.d.ts

@@ -1,2 +0,0 @@
-import { type WorkspaceExecutor } from "@akanjs/devkit";
-export declare const installExternalLib: (libName: string, workspace: WorkspaceExecutor) => Promise<void>;