create-flow-os 0.0.23 → 0.0.25

package/.vscode/settings.json

@@ -1,6 +1,6 @@
-{
-  "files.exclude": {
-    "**/node_modules": true,
-    "**/index.html": true
-  }
-}
+{
+  "files.exclude": {
+    "**/node_modules": true,
+    "**/index.html": true
+  }
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "create-flow-os",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "license": "PolyForm-Shield-1.0.0",
   "type": "module",
   "dependencies": {
-    "@flow-os/client": "^0.0.23"
+    "@flow-os/client": "^0.0.25"
   },
   "bin": {
     "create-flow-os": "./src/index.ts"

package/prova.tsx

@@ -0,0 +1,2 @@
+provaaaaa
+sdwdw

package/src/init/index.ts

@@ -3,8 +3,8 @@
 import * as readline from "readline";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { libsWithConfig, toShortName } from "./lib";
-import { initLib, fetchFlowClientVersion } from "./scaffold";
+import { libsWithConfig, toShortName, toPkgName } from "./lib";
+import { initLib, fetchFlowPackageVersions } from "./scaffold";
 
 // ───────────────────────────────────────────────────────────────────────────────
 // Usage: bun create flow-os i [lib...] | bun create flow-os i (prompt interattivo)
@@ -62,12 +62,13 @@ if (!toInit.length) {
 }
 
 // ───────────────────────────────────────────────────────────────────────────────
-// Execute: fetch versione client da npm (latest/dev), init libs, poi output box
+// Execute: fetch versioni pacchetti da npm (latest/dev), init libs, poi output box
 // ───────────────────────────────────────────────────────────────────────────────
-process.stdout.write(V + "Fetching latest @flow-os/client..." + R);
-const clientVersion = await fetchFlowClientVersion();
-process.stdout.write(clientVersion ? ` ${V}${clientVersion}${R}\n` : " (fallback)\n");
-await initLib(toInit, cwd, clientVersion);
+const pkgNames = toInit.map(toPkgName);
+process.stdout.write(V + "Fetching latest @flow-os/* packages..." + R);
+const versions = await fetchFlowPackageVersions(pkgNames);
+process.stdout.write(versions.size ? ` ${V}${versions.size} pkg${R}\n` : " (fallback)\n");
+await initLib(toInit, cwd, versions);
 
 const iconOk = V + "◆" + R;
 const iconUnrec = Y + "?" + R;

package/src/init/scaffold.ts

@@ -72,28 +72,67 @@ function isCreateFlowOsDev(): boolean {
   }
 }
 
-/** Recupera la versione di @flow-os/client dal registry npm in tempo reale (latest o dev) */
-export async function fetchFlowClientVersion(): Promise<string | undefined> {
+/** Recupera versione di un pacchetto @flow-os/* dal registry npm (latest o dev) */
+async function fetchFlowPackageVersion(pkgName: string): Promise<string | undefined> {
   const tag = isCreateFlowOsDev() ? "dev" : "latest";
   try {
-    const res = await fetch(`${NPM_REGISTRY}/@flow-os/client?t=${Date.now()}`, {
+    const res = await fetch(`${NPM_REGISTRY}/${pkgName}?t=${Date.now()}`, {
       cache: "no-store",
       headers: { "Cache-Control": "no-cache", Pragma: "no-cache" },
     });
     if (!res.ok) return undefined;
     const data = (await res.json()) as { "dist-tags"?: Record<string, string> };
-    const version = data["dist-tags"]?.[tag] ?? data["dist-tags"]?.["latest"];
-    return version;
+    return data["dist-tags"]?.[tag] ?? data["dist-tags"]?.["latest"];
   } catch {
     return undefined;
   }
 }
 
+/** Recupera versioni di tutti i pacchetti @flow-os/* richiesti dal registry npm */
+export async function fetchFlowPackageVersions(pkgNames: string[]): Promise<Map<string, string>> {
+  const out = new Map<string, string>();
+  await Promise.all(
+    pkgNames.map(async (name) => {
+      const v = await fetchFlowPackageVersion(name);
+      if (v) out.set(name, v);
+    })
+  );
+  return out;
+}
+
+/** @deprecated Usa fetchFlowPackageVersions. Mantenuto per retrocompatibilità. */
+export async function fetchFlowClientVersion(): Promise<string | undefined> {
+  return fetchFlowPackageVersion("@flow-os/client");
+}
+
+/** Scarica config da npm per qualsiasi @flow-os/* (bypass cache) */
+async function fetchConfigFromNpm(
+  pkgName: string,
+  version: string
+): Promise<{ files: Map<string, string>; configDir: string; tmpDir: string } | null> {
+  const shortName = pkgName.replace(/^@flow-os\//, "");
+  const url = `${NPM_REGISTRY}/${pkgName}/-/${shortName}-${version}.tgz`;
+  try {
+    const res = await fetch(url, { cache: "no-store" });
+    if (!res.ok) return null;
+    const archive = new Bun.Archive(await res.blob());
+    const { tmpdir } = await import("os");
+    const tmpDir = join(tmpdir(), `flow-os-${shortName}-${version}-${Date.now()}`);
+    await archive.extract(tmpDir, { glob: ["package/config/**"] });
+    const configDir = join(tmpDir, "package", "config");
+    if (!existsSync(configDir)) return null;
+    const files = collectConfigFiles(configDir);
+    return { files, configDir, tmpDir };
+  } catch {
+    return null;
+  }
+}
+
 /** Sostituisce workspace:* e 0.0.1 con versione concreta (workspace va bene solo dentro flow-os) */
 function resolveFlowDeps(
   deps: Record<string, string> | undefined,
   configDir: string,
-  clientVersionFromNpm: string | undefined
+  versionsFromNpm: Map<string, string>
 ): Record<string, string> {
   if (!deps) return {};
   const resolved = { ...deps };
@@ -108,21 +147,13 @@ function resolveFlowDeps(
   for (const k of Object.keys(resolved)) {
     if (!k.startsWith("@flow-os/")) continue;
     const v = resolved[k];
-    if (v !== "workspace:*" && v !== "0.0.1" && k !== "@flow-os/client") continue;
+    if (v !== "workspace:*" && v !== "0.0.1" && !versionsFromNpm.has(k)) continue;
     let spec: string | undefined;
-    if (k === "@flow-os/client") {
-      if (clientVersionFromNpm) {
-        spec = isDevSpec ? "dev" : `^${clientVersionFromNpm}`;
-      } else if (isDevSpec) {
-        spec = "dev";
-      } else {
-        try {
-          const root = pkgRoot(k);
-          const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf-8")) as { version?: string };
-          if (pkg.version) spec = `^${pkg.version}`;
-        } catch {}
-        if (!spec && ownerVersion) spec = `^${ownerVersion}`;
-      }
+    const npmVer = versionsFromNpm.get(k);
+    if (npmVer) {
+      spec = isDevSpec && k === "@flow-os/client" ? "dev" : `^${npmVer}`;
+    } else if (k === "@flow-os/client" && isDevSpec) {
+      spec = "dev";
     } else {
       try {
         const root = pkgRoot(k);
@@ -136,7 +167,7 @@ function resolveFlowDeps(
   return resolved;
 }
 
-function mergePkg(configDir: string, cwd: string, clientVersionFromNpm: string | undefined): void {
+function mergePkg(configDir: string, cwd: string, versionsFromNpm: Map<string, string>): void {
   const configPkg = join(configDir, "package.json");
   if (!existsSync(configPkg)) return;
   const targetPath = join(cwd, "package.json");
@@ -146,55 +177,128 @@ function mergePkg(configDir: string, cwd: string, clientVersionFromNpm: string |
     : { ...config, name: basename(cwd) || "flow-app" };
   target.dependencies = { ...target.dependencies, ...config.dependencies };
   target.devDependencies = { ...target.devDependencies, ...config.devDependencies };
-  for (const [k, v] of Object.entries(resolveFlowDeps(config.dependencies, configDir, clientVersionFromNpm)))
+  for (const [k, v] of Object.entries(resolveFlowDeps(config.dependencies, configDir, versionsFromNpm)))
     target.dependencies[k] = v;
-  for (const [k, v] of Object.entries(resolveFlowDeps(config.devDependencies, configDir, clientVersionFromNpm)))
+  for (const [k, v] of Object.entries(resolveFlowDeps(config.devDependencies, configDir, versionsFromNpm)))
     target.devDependencies[k] = v;
   target.scripts = { ...target.scripts, ...config.scripts };
   writeFileSync(targetPath, JSON.stringify(target, null, 2));
 }
 
+/** Assicura che versions abbia le versioni per pkgNames (fetch lazy) */
+async function ensureVersions(versions: Map<string, string>, pkgNames: string[]): Promise<void> {
+  const missing = pkgNames.filter((n) => !versions.has(n));
+  if (!missing.length) return;
+  const fetched = await fetchFlowPackageVersions(missing);
+  for (const [k, v] of fetched) versions.set(k, v);
+}
+
+/** Legge flow deps da package.json (path a package.json o dir che lo contiene) */
+function flowDepsFromPkg(pkgPath: string): string[] {
+  const pkgJson = pkgPath.endsWith("package.json") ? pkgPath : join(pkgPath, "package.json");
+  if (!existsSync(pkgJson)) return [];
+  try {
+    const pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
+    const deps = { ...pkg.dependencies, ...pkg.peerDependencies } as Record<string, string>;
+    return Object.keys(deps).filter((k) => k.startsWith("@flow-os/"));
+  } catch {
+    return [];
+  }
+}
+
 /** Fase 1: raccoglie e merge tutti i template in memoria, ritorna ordine pacchetti */
 async function collectAllTemplates(
   libs: string[],
   combined: Map<string, string>,
   done: Set<string>,
   order: string[],
-  _clientVersionFromNpm?: string
+  versionsFromNpm: Map<string, string>,
+  tmpDirs: string[]
 ): Promise<void> {
   for (const lib of libs) {
     const pkgName = toPkgName(lib);
     if (done.has(pkgName)) continue;
 
-    const root = pkgRoot(pkgName);
-    const configDir = join(root, "config");
-    if (!existsSync(configDir)) continue;
-
-    for (const sub of flowDeps(root)) {
-      await collectAllTemplates([toShortName(sub)], combined, done, order, _clientVersionFromNpm);
+    let root: string;
+    let configDir: string;
+    try {
+      root = pkgRoot(pkgName);
+      configDir = join(root, "config");
+    } catch {
+      root = "";
+      configDir = "";
     }
+    const hasLocal = existsSync(configDir);
 
-    const pkgFiles = collectConfigFiles(configDir);
+    let pkgFiles: Map<string, string>;
+    let configDirForPkg: string;
+    const npmVer = versionsFromNpm.get(pkgName);
+    if (npmVer) {
+      const fetched = await fetchConfigFromNpm(pkgName, npmVer);
+      if (fetched) {
+        pkgFiles = fetched.files;
+        configDirForPkg = fetched.configDir;
+        tmpDirs.push(fetched.tmpDir);
+        const subDeps = flowDepsFromPkg(join(configDirForPkg, ".."));
+        await ensureVersions(versionsFromNpm, subDeps);
+        for (const sub of subDeps) {
+          await collectAllTemplates([toShortName(sub)], combined, done, order, versionsFromNpm, tmpDirs);
+        }
+      } else if (hasLocal) {
+        const subDeps = flowDeps(root);
+        await ensureVersions(versionsFromNpm, subDeps);
+        for (const sub of subDeps) {
+          await collectAllTemplates([toShortName(sub)], combined, done, order, versionsFromNpm, tmpDirs);
+        }
+        pkgFiles = collectConfigFiles(configDir);
+        configDirForPkg = configDir;
+      } else {
+        continue;
+      }
+    } else if (hasLocal) {
+      const subDeps = flowDeps(root);
+      await ensureVersions(versionsFromNpm, subDeps);
+      for (const sub of subDeps) {
+        await collectAllTemplates([toShortName(sub)], combined, done, order, versionsFromNpm, tmpDirs);
+      }
+      pkgFiles = collectConfigFiles(configDir);
+      configDirForPkg = configDir;
+    } else {
+      continue;
+    }
     mergeTemplateInto(combined, pkgFiles);
-    order.push(configDir);
+    order.push(configDirForPkg);
     done.add(pkgName);
   }
 }
 
-/** Init: 1) merge tutti i template in memoria, 2) mergePkg per ogni lib, 3) un solo merge con file utente */
+/** Init: 1) fetch versioni npm per tutti i pacchetti, 2) merge template in memoria, 3) mergePkg, 4) merge con file utente */
 export async function initLib(
   libs: string[],
   cwd: string,
-  clientVersionFromNpm?: string
+  versionsFromNpm?: Map<string, string>
 ): Promise<void> {
+  const pkgNames = libs.map(toPkgName);
+  const versions = versionsFromNpm ?? new Map<string, string>();
+  const fetched = await fetchFlowPackageVersions(pkgNames);
+  for (const [k, v] of fetched) versions.set(k, v);
+
   const combined = new Map<string, string>();
   const done = new Set<string>();
   const order: string[] = [];
-  await collectAllTemplates(libs, combined, done, order, clientVersionFromNpm);
+  const tmpDirs: string[] = [];
+  await collectAllTemplates(libs, combined, done, order, versions, tmpDirs);
 
   for (const configDir of order) {
-    mergePkg(configDir, cwd, clientVersionFromNpm);
+    mergePkg(configDir, cwd, versions);
   }
 
   await writeMergedWithUser(combined, cwd, (path, conflicts) => resolveConflicts(conflicts, path));
+
+  const { rmSync } = await import("fs");
+  for (const d of tmpDirs) {
+    try {
+      rmSync(d, { recursive: true, force: true });
+    } catch {}
+  }
 }