@akanjs/cli 2.1.0-rc.11 → 2.1.0-rc.12

package/index.js

@@ -10286,6 +10286,7 @@ class PackageScript extends script("package", [PackageRunner]) {
 }
 
 // pkgs/@akanjs/cli/cloud/cloud.runner.ts
+import path38 from "path";
 import { confirm as confirm3 } from "@inquirer/prompts";
 import { Logger as Logger15, sleep } from "akanjs/common";
 import chalk7 from "chalk";
@@ -10309,6 +10310,24 @@ async function getLatestPackageVersion(packageName, tag = "latest", registryUrl)
 
 // pkgs/@akanjs/cli/cloud/cloud.runner.ts
 class CloudRunner extends runner("cloud") {
+  #akanFrameworkPackages = new Set(["akanjs", "@akanjs/devkit", "@akanjs/cli", "create-akan-workspace"]);
+  #getRegistryArgs(registryUrl) {
+    return registryUrl ? ["--registry", getNpmRegistryUrl(registryUrl)] : [];
+  }
+  #getLocalRegistryAuthArgs(registryUrl) {
+    if (!registryUrl)
+      return [];
+    const { host, pathname } = new URL(getNpmRegistryUrl(registryUrl));
+    const registryPath = pathname === "/" ? "/" : `${pathname.replace(/\/+$/, "")}/`;
+    return [`--//${host}${registryPath}:_authToken=akan-local-registry`];
+  }
+  #getRegistryEnv(registryUrl) {
+    return registryUrl ? {
+      ...process.env,
+      AKAN_NPM_REGISTRY: getNpmRegistryUrl(registryUrl),
+      NPM_CONFIG_REGISTRY: getNpmRegistryUrl(registryUrl)
+    } : process.env;
+  }
   async login() {
     const config = await getHostConfig();
     const self = config.auth ? await getSelf(config.auth.token) : null;
@@ -10387,15 +10406,16 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     const pkgs = await workspace.getPkgs();
     return pkgs.filter((pkg) => pkg === "akanjs" || pkg === "create-akan-workspace" || pkg.startsWith("@akanjs/"));
   }
-  async deployAkan(workspace, akanPkgs) {
+  async deployAkan(workspace, akanPkgs, { registryUrl, confirmPublish = true, tag: distTag } = {}) {
+    const registry = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
     const akanPackageJson2 = await workspace.readJson("pkgs/akanjs/package.json");
     const [majorVersion, minorVersion, patchVersion, devPatchVersion] = akanPackageJson2.version.split(".");
     const isOfficialRelease = !devPatchVersion;
     const targetVersionPrefix = isOfficialRelease ? `${majorVersion}.${minorVersion}` : `${majorVersion}.${minorVersion}.${patchVersion}`;
-    const tag = isOfficialRelease ? "latest" : patchVersion.split("-").at(1) ?? "dev";
+    const tag = distTag ?? (isOfficialRelease ? "latest" : patchVersion.split("-").at(1) ?? "dev");
     const getNextVersion = async (prefix, tag2) => {
       try {
-        const latestPublishedVersion2 = await getLatestPackageVersion("akanjs", tag2);
+        const latestPublishedVersion2 = await getLatestPackageVersion("akanjs", tag2, registry);
         const latestPatch = latestPublishedVersion2.startsWith(prefix) ? parseInt(latestPublishedVersion2.split(".").at(-1) ?? "-1") : -1;
         const nextVersion2 = `${prefix}.${latestPatch + 1}`;
         return { nextVersion: nextVersion2, latestPublishedVersion: latestPublishedVersion2 };
@@ -10408,37 +10428,46 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     Logger15.info(`Next version of akanjs: ${nextVersion}`);
     for (const library of akanPkgs) {
       const packageJson = await workspace.readJson(`pkgs/${library}/package.json`);
-      const newPackageJsonStr = JSON.stringify({ ...packageJson, version: nextVersion }, null, 2);
+      const newPackageJsonStr = JSON.stringify(this.#normalizeAkanPackageJson(packageJson, library, nextVersion), null, 2);
       await workspace.writeFile(`pkgs/${library}/package.json`, newPackageJsonStr);
       const distPackageJson = await workspace.readJson(`dist/pkgs/${library}/package.json`);
-      const newDistPackageJson = { ...distPackageJson, version: nextVersion };
+      const newDistPackageJson = this.#normalizeAkanPackageJson(distPackageJson, library, nextVersion);
       await workspace.writeJson(`dist/pkgs/${library}/package.json`, newDistPackageJson);
     }
-    const isDeployConfirmed = await confirm3({
-      message: "Are you sure you want to deploy the libraries?"
-    });
-    if (!isDeployConfirmed) {
-      Logger15.error("Deployment cancelled");
-      return;
+    if (confirmPublish) {
+      const isDeployConfirmed = await confirm3({
+        message: "Are you sure you want to deploy the libraries?"
+      });
+      if (!isDeployConfirmed) {
+        Logger15.error("Deployment cancelled");
+        return;
+      }
     }
     await Promise.all(akanPkgs.map(async (library) => {
-      Logger15.info(`Publishing ${library}@${nextVersion} to npm...`);
-      await workspace.exec(`npm publish --tag ${tag}`, { cwd: `dist/pkgs/${library}` });
-      Logger15.info(`${library}@${nextVersion} is published to npm`);
+      Logger15.info(`Publishing ${library}@${nextVersion} to ${registry ?? "npm"}...`);
+      await workspace.spawn("npm", ["publish", "--tag", tag, ...this.#getRegistryArgs(registry), ...this.#getLocalRegistryAuthArgs(registry)], {
+        cwd: path38.join(workspace.workspaceRoot, "dist/pkgs", library),
+        env: this.#getRegistryEnv(registry),
+        stdio: "inherit"
+      });
+      Logger15.info(`${library}@${nextVersion} is published to ${registry ?? "npm"}`);
     }));
-    Logger15.info("All libraries are published to npm");
+    Logger15.info(`All libraries are published to ${registry ?? "npm"}`);
   }
-  async update(workspace, tag = "latest") {
+  async update(workspace, tag = "latest", { registryUrl } = {}) {
+    const registry = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
+    const registryArgs = this.#getRegistryArgs(registry);
+    const env = this.#getRegistryEnv(registry);
     if (!await workspace.exists("package.json"))
-      await workspace.spawn("bun", ["update", "-g", "akanjs", "--latest", `--tag=${tag}`]);
+      await workspace.spawn("bun", ["update", "-g", "akanjs", "--latest", `--tag=${tag}`, ...registryArgs], { env });
     else
       await Promise.all([
-        workspace.spawn("bun", ["update", "-g", "akanjs", "--latest", `--tag=${tag}`]),
-        this.#updateAkanPkgs(workspace, tag)
+        workspace.spawn("bun", ["update", "-g", "akanjs", "--latest", `--tag=${tag}`, ...registryArgs], { env }),
+        this.#updateAkanPkgs(workspace, tag, registry)
       ]);
   }
-  async#updateAkanPkgs(workspace, tag = "latest") {
-    const latestPublishedVersion = await getLatestPackageVersion("akanjs", tag);
+  async#updateAkanPkgs(workspace, tag = "latest", registryUrl) {
+    const latestPublishedVersion = await getLatestPackageVersion("akanjs", tag, registryUrl);
     const rootPackageJson = await workspace.getPackageJson();
     if (!rootPackageJson.dependencies)
       throw new Error("No dependencies found in package.json");
@@ -10450,8 +10479,23 @@ ${chalk7.green("\u27A4")} Authentication Required`));
       rootPackageJson.dependencies["@akanjs/devkit"] = latestPublishedVersion;
     if (rootPackageJson.devDependencies?.["@akanjs/devkit"])
       rootPackageJson.devDependencies["@akanjs/devkit"] = latestPublishedVersion;
-    workspace.setPackageJson(rootPackageJson);
-    await workspace.spawn("bun", ["install"]);
+    await workspace.setPackageJson(rootPackageJson);
+    await workspace.spawn("bun", ["install", ...this.#getRegistryArgs(registryUrl)], {
+      env: this.#getRegistryEnv(registryUrl)
+    });
+  }
+  #normalizeAkanPackageJson(packageJson, packageName, version) {
+    const normalized = { ...packageJson, version };
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const dependencies = normalized[field];
+      if (!dependencies)
+        continue;
+      normalized[field] = Object.fromEntries(Object.entries(dependencies).map(([dep, depVersion]) => [
+        dep,
+        dep !== packageName && this.#akanFrameworkPackages.has(dep) ? version : depVersion
+      ]));
+    }
+    return normalized;
   }
 }
 
@@ -10473,7 +10517,7 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
     const session = new AiSession("general", { workspace, isContinued: true });
     await session.ask(question);
   }
-  async deployAkan(workspace, { test = true } = {}) {
+  async deployAkan(workspace, { test = true, registryUrl } = {}) {
     const akanPkgs = await this.cloudRunner.getAkanPkgs(workspace);
     await this.packageScript.updateWorskpaceRootPackageJson(workspace);
     const pkgs = akanPkgs.map((pkgName) => PkgExecutor.from(workspace, pkgName));
@@ -10482,11 +10526,11 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
         await this.applicationScript.test(pkg);
     for (const pkg of pkgs)
       await this.packageScript.buildPackage(pkg);
-    await this.cloudRunner.deployAkan(workspace, akanPkgs);
+    await this.cloudRunner.deployAkan(workspace, akanPkgs, { registryUrl });
   }
-  async update(workspace, tag = "latest") {
+  async update(workspace, tag = "latest", { registryUrl } = {}) {
     const spinner2 = workspace.spinning("Updating Akan.js packages and CLI...");
-    await this.cloudRunner.update(workspace, tag);
+    await this.cloudRunner.update(workspace, tag, { registryUrl });
     spinner2.succeed("Akan.js packages and CLI updated, global version is below");
     Logger16.raw("> Akan version: ");
     await workspace.spawn("akan", ["--version"], { stdio: "inherit" });
@@ -10494,6 +10538,9 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
 }
 
 // pkgs/@akanjs/cli/cloud/cloud.command.ts
+var localRegistryUrl = () => process.env.AKAN_NPM_REGISTRY ?? "http://127.0.0.1:4873";
+var resolveRegistryUrl = (registry) => registry === "local" ? localRegistryUrl() : undefined;
+
 class CloudCommand extends command("cloud", [CloudScript], ({ public: target }) => ({
   login: target({ desc: "Login to Akan Cloud services" }).with(Workspace).exec(async function(workspace) {
     await this.cloudScript.login(workspace);
@@ -10510,15 +10557,32 @@ class CloudCommand extends command("cloud", [CloudScript], ({ public: target })
   ask: target({ desc: "Ask AI assistant a question about your project" }).option("question", String, { ask: "question to ask" }).with(Workspace).exec(async function(question, workspace) {
     await this.cloudScript.ask(question, workspace);
   }),
-  deployAkan: target({ devOnly: true, desc: "Deploy Akan.js framework to cloud (internal use)" }).option("test", Boolean, { desc: "test the deployment", default: true }).with(Workspace).exec(async function(test, workspace) {
-    await this.cloudScript.deployAkan(workspace, { test });
+  deployAkan: target({ devOnly: true, desc: "Deploy Akan.js framework to cloud (internal use)" }).option("test", Boolean, { desc: "test the deployment", default: true }).option("registry", String, {
+    desc: "registry target for publishing Akan packages",
+    ask: "Select a registry target",
+    enum: [
+      { label: "local", value: "local" },
+      { label: "npm", value: "npm" }
+    ]
+  }).with(Workspace).exec(async function(test, registry, workspace) {
+    await this.cloudScript.deployAkan(workspace, {
+      test,
+      registryUrl: resolveRegistryUrl(registry)
+    });
   }),
   update: target({ desc: "Update Akan.js framework to the latest version" }).with(Workspace).option("tag", String, {
     desc: "tag of the update",
     default: "latest",
     enum: ["latest", "dev", "canary", "beta", "rc", "alpha"]
-  }).exec(async function(workspace, tag) {
-    await this.cloudScript.update(workspace, tag);
+  }).option("registry", String, {
+    desc: "registry target for resolving Akan packages",
+    ask: "Select a registry target",
+    enum: [
+      { label: "npm", value: "npm" },
+      { label: "local", value: "local" }
+    ]
+  }).exec(async function(workspace, tag, registry) {
+    await this.cloudScript.update(workspace, tag, { registryUrl: resolveRegistryUrl(registry) });
   })
 })) {
 }
@@ -10544,14 +10608,14 @@ class GuidelinePrompt extends Prompter {
   async#getScanFilePaths(matchPattern, { avoidDirs = ["node_modules", ".next"], filterText } = {}) {
     const glob = new Bun.Glob(matchPattern);
     const paths = [];
-    for await (const path38 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
-      if (avoidDirs.some((dir) => path38.includes(dir)))
+    for await (const path39 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
+      if (avoidDirs.some((dir) => path39.includes(dir)))
         continue;
-      const fileContent = await FileSys.readText(path38);
+      const fileContent = await FileSys.readText(path39);
       const textFilter = filterText ? new RegExp(filterText) : null;
       if (filterText && !textFilter?.test(fileContent))
         continue;
-      paths.push(path38);
+      paths.push(path39);
     }
     return paths;
   }
@@ -10846,6 +10910,147 @@ class LibraryCommand extends command("library", [LibraryScript], ({ public: targ
 })) {
 }
 
+// pkgs/@akanjs/cli/localRegistry/localRegistry.runner.ts
+import { mkdir as mkdir11, rm as rm5 } from "fs/promises";
+import path39 from "path";
+import { Logger as Logger17 } from "akanjs/common";
+var defaultLocalRegistryUrl = "http://127.0.0.1:4873";
+var containerName = "akan-verdaccio";
+var smokeRepoName = "akan-local-smoke";
+var smokeAppName = "demo";
+
+class LocalRegistryRunner extends runner("localRegistry") {
+  getRegistryUrl(registryUrl = process.env.AKAN_NPM_REGISTRY ?? defaultLocalRegistryUrl) {
+    return getNpmRegistryUrl(registryUrl);
+  }
+  async start(workspace, { registryUrl } = {}) {
+    const registry = this.getRegistryUrl(registryUrl);
+    try {
+      await workspace.spawn("docker", ["inspect", containerName]);
+      Logger17.info(`Local registry is already running at ${registry}`);
+      return registry;
+    } catch {}
+    const configPath2 = path39.join(workspace.workspaceRoot, "pkgs/@akanjs/cli/localRegistry/verdaccio.yaml");
+    const storagePath = path39.join(workspace.workspaceRoot, ".akan/verdaccio/storage");
+    await mkdir11(storagePath, { recursive: true });
+    await workspace.spawn("docker", [
+      "run",
+      "--rm",
+      "-d",
+      "--name",
+      containerName,
+      "-p",
+      "4873:4873",
+      "-v",
+      `${configPath2}:/verdaccio/conf/config.yaml:ro`,
+      "-v",
+      `${storagePath}:/verdaccio/storage`,
+      "verdaccio/verdaccio:6"
+    ], { stdio: "inherit" });
+    Logger17.info(`Local registry is running at ${registry}`);
+    return registry;
+  }
+  async reset(workspace) {
+    try {
+      await workspace.spawn("docker", ["rm", "-f", containerName], { stdio: "inherit" });
+    } catch {}
+    await rm5(path39.join(workspace.workspaceRoot, ".akan/verdaccio"), { recursive: true, force: true });
+    Logger17.info("Local registry storage has been reset");
+  }
+  async smoke(workspace, { registryUrl } = {}) {
+    const registry = this.getRegistryUrl(registryUrl);
+    const smokeRoot = path39.join(workspace.workspaceRoot, ".akan/e2e");
+    await rm5(path39.join(smokeRoot, smokeRepoName), { recursive: true, force: true });
+    await workspace.spawn(process.execPath, [
+      "dist/pkgs/create-akan-workspace/index.js",
+      smokeRepoName,
+      "--app",
+      smokeAppName,
+      "--dir",
+      ".akan/e2e",
+      "--init",
+      "true",
+      "--registry",
+      registry
+    ], {
+      env: { ...process.env, AKAN_NPM_REGISTRY: registry, NPM_CONFIG_REGISTRY: registry },
+      stdio: "inherit"
+    });
+    await workspace.spawn("akan", ["build", smokeAppName], {
+      cwd: path39.join(smokeRoot, smokeRepoName),
+      env: { ...process.env, AKAN_NPM_REGISTRY: registry, NPM_CONFIG_REGISTRY: registry },
+      stdio: "inherit"
+    });
+    Logger17.info(`Local registry smoke test completed for ${smokeRepoName}/${smokeAppName}`);
+  }
+}
+
+// pkgs/@akanjs/cli/localRegistry/localRegistry.script.ts
+class LocalRegistryScript extends script("localRegistry", [
+  LocalRegistryRunner,
+  CloudRunner,
+  ApplicationScript,
+  PackageScript
+]) {
+  async start(workspace, { registryUrl } = {}) {
+    const spinner2 = workspace.spinning("Starting local npm registry...");
+    const registry = await this.localRegistryRunner.start(workspace, { registryUrl });
+    spinner2.succeed(`Local npm registry is ready at ${registry}`);
+  }
+  async reset(workspace) {
+    const spinner2 = workspace.spinning("Resetting local npm registry...");
+    await this.localRegistryRunner.reset(workspace);
+    spinner2.succeed("Local npm registry reset");
+  }
+  async smoke(workspace, { tag = "rc", test = true, registryUrl } = {}) {
+    const registry = await this.localRegistryRunner.start(workspace, { registryUrl });
+    const akanPkgs = await this.cloudRunner.getAkanPkgs(workspace);
+    await this.#preparePackages(workspace, akanPkgs, { test });
+    await this.cloudRunner.deployAkan(workspace, akanPkgs, {
+      registryUrl: registry,
+      confirmPublish: false,
+      tag
+    });
+    await this.localRegistryRunner.smoke(workspace, { registryUrl: registry });
+  }
+  async#preparePackages(workspace, akanPkgs, { test = true } = {}) {
+    await this.packageScript.updateWorskpaceRootPackageJson(workspace);
+    const pkgs = akanPkgs.map((pkgName) => PkgExecutor.from(workspace, pkgName));
+    if (test)
+      for (const pkg of pkgs)
+        await this.applicationScript.test(pkg);
+    for (const pkg of pkgs)
+      await this.packageScript.buildPackage(pkg, { showSpinner: false });
+  }
+}
+
+// pkgs/@akanjs/cli/localRegistry/localRegistry.command.ts
+class LocalRegistryCommand extends command("local-registry", [LocalRegistryScript], ({ public: target }) => ({
+  startRegistry: target({ devOnly: true, desc: "Start the local Verdaccio npm registry" }).with(Workspace).option("registry", String, {
+    desc: "local npm registry URL",
+    default: process.env.AKAN_NPM_REGISTRY ?? "http://127.0.0.1:4873"
+  }).exec(async function(workspace, registry) {
+    await this.localRegistryScript.start(workspace, { registryUrl: registry });
+  }),
+  resetRegistry: target({ devOnly: true, desc: "Stop and clear the local Verdaccio npm registry" }).with(Workspace).exec(async function(workspace) {
+    await this.localRegistryScript.reset(workspace);
+  }),
+  smokeRegistry: target({ devOnly: true, desc: "Publish to local registry and build a generated workspace" }).with(Workspace).option("tag", String, {
+    flag: "g",
+    desc: "dist-tag for local registry publish",
+    default: "rc"
+  }).option("test", Boolean, {
+    desc: "run package tests before publishing",
+    default: true
+  }).option("registry", String, {
+    desc: "local npm registry URL",
+    default: process.env.AKAN_NPM_REGISTRY
+  }).exec(async function(workspace, tag, test, registry) {
+    await this.localRegistryScript.smoke(workspace, { tag, test, registryUrl: registry });
+  })
+})) {
+}
+
 // pkgs/@akanjs/cli/module/module.command.ts
 import { lowerlize } from "akanjs/common";
 
@@ -11641,11 +11846,11 @@ class ScalarCommand extends command("scalar", [ScalarScript], ({ public: target
 }
 
 // pkgs/@akanjs/cli/workspace/workspace.script.ts
-import path39 from "path";
-import { Logger as Logger17 } from "akanjs/common";
+import path41 from "path";
+import { Logger as Logger18 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/workspace/workspace.runner.ts
-import path38 from "path";
+import path40 from "path";
 var defaultWorkspacePeerDependencies = new Set([
   "@radix-ui/react-dialog",
   "@react-spring/web",
@@ -11672,7 +11877,7 @@ class WorkspaceRunner extends runner("workspace") {
     registryUrl
   }) {
     const cwdPath = process.cwd();
-    const workspaceRoot = path38.join(cwdPath, dirname3, repoName);
+    const workspaceRoot = path40.join(cwdPath, dirname3, repoName);
     const normalizedRegistryUrl = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
     const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
     const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname3}/${repoName}...`);
@@ -11728,9 +11933,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getCliPackageJson() {
     const packageJsonCandidates = [
-      path38.join(import.meta.dir, "../package.json"),
-      path38.join(import.meta.dir, "package.json"),
-      path38.join(path38.dirname(Bun.main), "package.json")
+      path40.join(import.meta.dir, "../package.json"),
+      path40.join(import.meta.dir, "package.json"),
+      path40.join(path40.dirname(Bun.main), "package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("@akanjs/cli/package.json", import.meta.dir));
@@ -11746,9 +11951,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getAkanPackageJson() {
     const packageJsonCandidates = [
-      path38.join(import.meta.dir, "../../../akanjs/package.json"),
-      path38.join(process.cwd(), "pkgs/akanjs/package.json"),
-      path38.join(path38.dirname(Bun.main), "node_modules/akanjs/package.json")
+      path40.join(import.meta.dir, "../../../akanjs/package.json"),
+      path40.join(process.cwd(), "pkgs/akanjs/package.json"),
+      path40.join(path40.dirname(Bun.main), "node_modules/akanjs/package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", import.meta.dir));
@@ -11762,13 +11967,13 @@ class WorkspaceRunner extends runner("workspace") {
     }
     let current = import.meta.dir;
     for (let depth = 0;depth < 6; depth++) {
-      const packageJsonPath = path38.join(current, "package.json");
+      const packageJsonPath = path40.join(current, "package.json");
       if (await Bun.file(packageJsonPath).exists()) {
         const packageJson = await FileSys.readJson(packageJsonPath);
         if (packageJson.name === "akanjs")
           return packageJson;
       }
-      const parent = path38.dirname(current);
+      const parent = path40.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -11803,7 +12008,7 @@ class WorkspaceScript extends script("workspace", [
       dirname: dirname3,
       init,
       akanVersion,
-      registryUrl
+      ...registryUrl ? { registryUrl } : {}
     });
     if (installLibs) {
       await this.libraryScript.installLibrary(workspace, "util");
@@ -11817,11 +12022,11 @@ class WorkspaceScript extends script("workspace", [
     } catch (_) {
       gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
     }
-    const workspacePath = path39.join(dirname3, repoName);
-    Logger17.rawLog(`
+    const workspacePath = path41.join(dirname3, repoName);
+    Logger18.rawLog(`
 \uD83C\uDF89 Welcome aboard! Workspace created in ${dirname3}/${repoName}`);
-    Logger17.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
-    Logger17.rawLog(`
+    Logger18.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
+    Logger18.rawLog(`
 \uD83D\uDC4B Happy coding!`);
   }
   async lint(exec2, workspace, { fix = true } = {}) {
@@ -11881,7 +12086,7 @@ class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public
     default: process.env.AKAN_NPM_REGISTRY
   }).exec(async function(workspaceName, app, dir, libs, init, registry) {
     const appName = app || "app";
-    await this.workspaceScript.createWorkspace(workspaceName.toLowerCase().replace(/ /g, "-"), appName.toLowerCase().replace(/ /g, "-"), { dirname: dir, installLibs: libs, init, registryUrl: registry });
+    await this.workspaceScript.createWorkspace(workspaceName.toLowerCase().replace(/ /g, "-"), appName.toLowerCase().replace(/ /g, "-"), { dirname: dir, installLibs: libs, init, ...registry ? { registryUrl: registry } : {} });
   }),
   lint: target({ desc: "Lint and fix code in a specific app/lib/pkg" }).with(Exec).option("fix", Boolean, { default: true }).with(Workspace).exec(async function(exec2, fix, workspace) {
     await this.workspaceScript.lint(exec2, workspace, { fix });
@@ -11896,4 +12101,4 @@ class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public
 }
 
 // pkgs/@akanjs/cli/index.ts
-runCommands(WorkspaceCommand, ApplicationCommand, LibraryCommand, PackageCommand, ModuleCommand, PageCommand, CloudCommand, GuidelineCommand, ScalarCommand);
+runCommands(WorkspaceCommand, ApplicationCommand, LibraryCommand, LocalRegistryCommand, PackageCommand, ModuleCommand, PageCommand, CloudCommand, GuidelineCommand, ScalarCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/cli",
-  "version": "2.1.0-rc.11",
+  "version": "2.1.0-rc.12",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -34,7 +34,7 @@
     "@langchain/deepseek": "^1.0.26",
     "@langchain/openai": "^1.4.6",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "2.1.0-rc.10",
+    "akanjs": "2.1.0-rc.12",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "daisyui": "^5.5.20",