create-flow-os 0.0.47 → 0.0.51-dev.1772054587

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "create-flow-os",
-  "version": "0.0.47",
+  "version": "0.0.51-dev.1772054587",
   "license": "PolyForm-Shield-1.0.0",
   "type": "module",
   "dependencies": {
-    "@flow-os/client": "^0.0.47"
+    "@flow-os/client": ">=0.0.1-dev.0"
   },
   "bin": {
     "create-flow-os": "./src/index.ts"
@@ -13,7 +13,7 @@
     "create": "bun run src/create/index.ts",
     "dev": "flow-os dev",
     "build": "flow-os build",
-    "start": "bun run server/start.ts"
+    "start": "bun ./node_modules/@flow-os/server/src/bin.ts"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",

package/src/init/index.ts

@@ -1,12 +1,10 @@
 #!/usr/bin/env bun
-// Clear subito per nascondere resolving/installing di Bun
-process.stdout.write("\x1b[2J\x1b[H");
 
 import * as readline from "readline";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { libsWithConfig, toShortName, toPkgName } from "./lib";
-import { initLib, fetchFlowPackageVersions } from "./scaffold";
+import { initLib, fetchFlowPackageVersions, shouldUseWorkspace, findFlowOsRepoRoot } from "./scaffold";
 import { bannerBox, withLoading, colors } from "./ui";
 
 const { V, V_LIGHT, Y, E, R, B } = colors;
@@ -16,7 +14,8 @@ const { V, V_LIGHT, Y, E, R, B } = colors;
 // ───────────────────────────────────────────────────────────────────────────────
 const cwd = process.cwd();
 const cliRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
-const available = libsWithConfig(cliRoot).map(toShortName);
+const flowOsRepoRoot = findFlowOsRepoRoot(cwd);
+const available = libsWithConfig(cliRoot, flowOsRepoRoot).map(toShortName);
 
 let libs = [...new Set(process.argv.slice(3))];
 
@@ -43,7 +42,7 @@ if (!toInit.length) {
 // ───────────────────────────────────────────────────────────────────────────────
 const pkgNames = toInit.map(toPkgName);
 await withLoading(async (onStep) => {
-  const versions = await fetchFlowPackageVersions(pkgNames);
+  const versions = shouldUseWorkspace(cwd) ? new Map<string, string>() : await fetchFlowPackageVersions(pkgNames);
   await initLib(toInit, cwd, versions, onStep);
 });
 

package/src/init/lib.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, readdirSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 
@@ -21,7 +21,27 @@ export function flowDeps(root: string): string[] {
   return Object.keys(deps).filter((k) => k.startsWith(FLOW_PREFIX));
 }
 
-export function libsWithConfig(cliRoot: string): string[] {
+/** Scansiona packages/ per tutti gli @flow-os/* (con o senza config) */
+function scanPackagesDir(packagesDir: string): string[] {
+  const found: string[] = [];
+  try {
+    for (const name of readdirSync(packagesDir, { withFileTypes: true })) {
+      if (!name.isDirectory()) continue;
+      const pkgPath = join(packagesDir, name.name, "package.json");
+      if (!existsSync(pkgPath)) continue;
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as { name?: string };
+        if (pkg?.name?.startsWith(FLOW_PREFIX)) found.push(pkg.name);
+      } catch {}
+    }
+  } catch {}
+  return found;
+}
+
+export function libsWithConfig(cliRoot: string, flowOsRepoRoot?: string | null): string[] {
+  const packagesDir = flowOsRepoRoot ? join(flowOsRepoRoot, "packages") : join(cliRoot, "..");
+  const fromScan = scanPackagesDir(packagesDir);
+  if (fromScan.length > 0) return fromScan;
   const pkg = JSON.parse(readFileSync(join(cliRoot, "package.json"), "utf-8"));
   const deps = Object.keys(pkg.dependencies ?? {}).filter((k) => k.startsWith(FLOW_PREFIX));
   return deps.filter((name) => existsSync(join(pkgRoot(name), "config")));

package/src/init/merge.ts

@@ -1,12 +1,19 @@
 /**
- * Merge generico per qualsiasi file: additivo (aggiunge, non toglie).
- * In conflitto: chiede all'utente.
+ * Merge: strategia "never overwrite" (create-react-app, ecc.).
+ * File vuoto → template. File con contenuto → mantieni utente. Mai corrompere.
+ * JSON: merge additivo strutturato.
  */
 
 import * as readline from "readline";
 
 export type Conflict = { key: string; userVal: unknown; templateVal: unknown; path: string };
 
+/** Opzioni (compatibilità): non usate con never-overwrite */
+export type Merge3WayOptions = {
+  baseContent?: string;
+  saveBase?: (content: string) => void;
+};
+
 /** Deep merge di oggetti: aggiunge chiavi nuove, per esistenti chiede se diverso */
 function deepMergeAdditive(
   user: Record<string, unknown>,
@@ -30,71 +37,6 @@ function deepMergeAdditive(
   return out;
 }
 
-/** Trova la posizione della parentesi graffa di chiusura corrispondente */
-function findMatchingBrace(str: string, start: number): number {
-  let depth = 1;
-  for (let i = start; i < str.length; i++) {
-    if (str[i] === "{") depth++;
-    else if (str[i] === "}") {
-      depth--;
-      if (depth === 0) return i;
-    }
-  }
-  return -1;
-}
-
-type Extracted = { obj: Record<string, unknown>; fullMatch: string; fn: string };
-
-/** Estrae oggetto da pattern fn({...}) o fn() nel contenuto - qualsiasi libreria */
-function extractObjectArg(content: string): Extracted | null {
-  const re = /(\w+)\s*\(\s*(\{)?/g;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(content)) !== null) {
-    const fn = m[1];
-    const openBrace = m[2];
-    const startIdx = m.index + m[0].length;
-    let arg = "";
-    let closeIdx = startIdx - 1;
-    if (openBrace === "{") {
-      closeIdx = findMatchingBrace(content, startIdx);
-      if (closeIdx >= 0) arg = content.slice(startIdx, closeIdx);
-    }
-    const parenIdx = content.indexOf(")", closeIdx + 1);
-    const fullMatch = parenIdx >= 0 ? content.slice(m.index, parenIdx + 1) : "";
-    if (arg && arg.trim()) {
-      try {
-        const obj = new Function("return " + "{" + arg + "}")() as Record<string, unknown>;
-        return { obj, fullMatch, fn };
-      } catch {
-        continue;
-      }
-    }
-    return { obj: {}, fullMatch, fn };
-  }
-  return null;
-}
-
-/** Serializza oggetto in formato JS compatibile */
-function serializeObject(obj: Record<string, unknown>): string {
-  const entries = Object.entries(obj)
-    .map(([k, v]) => {
-      const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? k : JSON.stringify(k);
-      if (typeof v === "object" && v !== null && !Array.isArray(v)) {
-        return `${key}: ${serializeObject(v as Record<string, unknown>)}`;
-      }
-      return `${key}: ${JSON.stringify(v)}`;
-    })
-    .join(", ");
-  return `{ ${entries} }`;
-}
-
-/** Sostituisce l'argomento nella chiamata fn(...) con il nuovo oggetto */
-function replaceObjectArg(content: string, ext: Extracted, newObj: Record<string, unknown>): string {
-  const newArg = Object.keys(newObj).length > 0 ? serializeObject(newObj) : "";
-  const replacement = `${ext.fn}(${newArg})`;
-  return content.replace(ext.fullMatch, replacement);
-}
-
 /** Merge template+template (senza conflitti: il secondo vince) - per pre-merge pacchetti */
 function mergeTemplatesOnly(a: Record<string, unknown>, b: Record<string, unknown>): Record<string, unknown> {
   const out = { ...a };
@@ -124,30 +66,9 @@ export function mergeJsonTemplates(a: string, b: string): string {
   return JSON.stringify(mergeTemplatesOnly(objA, objB), null, 2);
 }
 
-/** Merge template+template per code (sync, nessun conflitto) */
+/** Merge template+template per code: nessun merge automatico (evita corruzione). Il secondo vince. */
 export function mergeCodeTemplates(a: string, b: string): string {
-  const extA = extractObjectArg(a);
-  const extB = extractObjectArg(b);
-  if (!extB) return a || b;
-  const objA = extA?.obj ?? {};
-  const objB = extB.obj;
-  const merged = mergeTemplatesOnly(objA, objB);
-  const base = a || b;
-  return replaceObjectArg(base, extB, merged);
-}
-
-/** Merge per file con pattern fn({...}) - config(), defineConfig(), ecc. */
-export function mergeCodeObject(userContent: string, templateContent: string, _path: string): { merged: string; conflicts: Conflict[]; ext: Extracted | null } {
-  const conflicts: Conflict[] = [];
-  const userExt = extractObjectArg(userContent);
-  const templateExt = extractObjectArg(templateContent);
-  if (!templateExt) return { merged: userContent || templateContent, conflicts: [], ext: null };
-  const userObj = userExt?.obj ?? {};
-  const templateObj = templateExt.obj;
-  const mergedObj = deepMergeAdditive(userObj, templateObj, "", conflicts);
-  const base = userContent || templateContent;
-  const merged = replaceObjectArg(base, templateExt, mergedObj);
-  return { merged, conflicts, ext: templateExt };
+  return b || a;
 }
 
 /** Chiede all'utente se applicare i valori del template in conflitto */
@@ -166,15 +87,15 @@ export async function resolveConflicts(conflicts: Conflict[], path: string): Pro
   return overrides;
 }
 
-/** Merge generico: sceglie strategia in base al file */
+/** Never overwrite: file vuoto → template, file con contenuto → mantieni. Mai corrompere. */
 export async function mergeFile(
   userContent: string | null,
   templateContent: string,
   relPath: string,
-  promptConflict: (path: string, conflicts: Conflict[]) => Promise<Record<string, unknown>>
+  promptConflict: (path: string, conflicts: Conflict[]) => Promise<Record<string, unknown>>,
+  _options?: Merge3WayOptions
 ): Promise<string> {
   const isJson = relPath.toLowerCase().endsWith(".json");
-  const isCode = /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(relPath);
 
   if (isJson) {
     const { merged, conflicts } = mergeJson(userContent ?? "{}", templateContent, relPath);
@@ -187,18 +108,13 @@ export async function mergeFile(
     return merged;
   }
 
-  if (isCode) {
-    const { merged, conflicts, ext } = mergeCodeObject(userContent ?? "", templateContent, relPath);
-    if (conflicts.length > 0 && ext) {
-      const overrides = await promptConflict(relPath, conflicts);
-      const extCur = extractObjectArg(merged);
-      if (extCur) {
-        const obj = { ...extCur.obj, ...overrides };
-        return replaceObjectArg(merged, extCur, obj);
-      }
-    }
-    return merged;
+  // Never overwrite: vuoto → template. Con contenuto → mantieni. Eccezione: file incompleto (manca export che template ha)
+  const content = (userContent ?? "").trim();
+  if (!content) return templateContent;
+  const tHasExport = /\bexport\s+default\b/.test(templateContent);
+  const uHasExport = /\bexport\s+default\b/.test(userContent ?? "");
+  if (tHasExport && !uHasExport) {
+    return templateContent; // File troncato
   }
-
-  return userContent ?? templateContent;
+  return userContent!;
 }

package/src/init/scaffold.ts

@@ -1,4 +1,4 @@
-import { existsSync, cpSync, readFileSync, writeFileSync, readdirSync } from "fs";
+import { existsSync, cpSync, readFileSync, writeFileSync, readdirSync, mkdirSync } from "fs";
 import { join, basename, dirname } from "path";
 import { fileURLToPath } from "url";
 import { pkgRoot, flowDeps, toPkgName, toShortName } from "./lib";
@@ -48,7 +48,7 @@ function mergeTemplateInto(combined: Map<string, string>, pkgFiles: Map<string,
   }
 }
 
-/** Scrive combined template in cwd facendo merge con file utente (un solo pass) */
+/** Scrive combined template in cwd. Never overwrite: file con contenuto → mantieni. */
 async function writeMergedWithUser(
   combined: Map<string, string>,
   cwd: string,
@@ -58,7 +58,6 @@ async function writeMergedWithUser(
     const dest = join(cwd, relPath);
     const destDir = dirname(dest);
     if (!existsSync(destDir)) {
-      const { mkdirSync } = await import("fs");
       mkdirSync(destDir, { recursive: true });
     }
     const userContent = existsSync(dest) ? readFileSync(dest, "utf-8") : null;
@@ -79,6 +78,29 @@ function isCreateFlowOsDev(): boolean {
   }
 }
 
+/** Trova la root del repo flow-os salendo da cwd (contiene packages/client) */
+export function findFlowOsRepoRoot(cwd: string): string | null {
+  let d = cwd;
+  while (true) {
+    const pkgClient = join(d, "packages", "client", "package.json");
+    if (existsSync(pkgClient)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgClient, "utf-8")) as { name?: string };
+        if (pkg?.name === "@flow-os/client") return d;
+      } catch {}
+    }
+    const parent = dirname(d);
+    if (parent === d) break;
+    d = parent;
+  }
+  return null;
+}
+
+/** True se usare workspace:* (cwd dentro repo flow-os) */
+export function shouldUseWorkspace(cwd: string): boolean {
+  return !!findFlowOsRepoRoot(cwd);
+}
+
 /** Recupera versione di un pacchetto @flow-os/* dal registry npm (con cache 5 min) */
 async function fetchFlowPackageVersion(pkgName: string): Promise<string | undefined> {
   const tag = isCreateFlowOsDev() ? "dev" : "latest";
@@ -169,12 +191,19 @@ async function fetchConfigFromNpm(
 /** 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,
-  versionsFromNpm: Map<string, string>
+  pkgRootDir: string,
+  versionsFromNpm: Map<string, string>,
+  useWorkspace: boolean
 ): Record<string, string> {
   if (!deps) return {};
   const resolved = { ...deps };
-  const ownerPkgPath = join(configDir, "..", "package.json");
+  if (useWorkspace) {
+    for (const k of Object.keys(resolved)) {
+      if (k.startsWith("@flow-os/")) resolved[k] = "workspace:*";
+    }
+    return resolved;
+  }
+  const ownerPkgPath = join(pkgRootDir, "package.json");
   let ownerVersion: string | undefined;
   if (existsSync(ownerPkgPath)) {
     try {
@@ -205,7 +234,25 @@ function resolveFlowDeps(
   return resolved;
 }
 
-function mergePkg(configDir: string, cwd: string, versionsFromNpm: Map<string, string>): void {
+const PKG_KEY_ORDER = ["name", "version", "private", "type", "scripts", "dependencies", "devDependencies"];
+
+function sortPkgKeys(pkg: Record<string, unknown>): Record<string, unknown> {
+  const ordered: Record<string, unknown> = {};
+  for (const k of PKG_KEY_ORDER) {
+    if (k in pkg) {
+      const v = pkg[k];
+      ordered[k] = k === "scripts" && v && typeof v === "object" && !Array.isArray(v)
+        ? Object.fromEntries(Object.entries(v as Record<string, string>).sort(([a], [b]) => a.localeCompare(b)))
+        : v;
+    }
+  }
+  for (const k of Object.keys(pkg).sort()) {
+    if (!(k in ordered)) ordered[k] = pkg[k];
+  }
+  return ordered;
+}
+
+function mergePkg(configDir: string, cwd: string, versionsFromNpm: Map<string, string>, useWorkspace: boolean): void {
   const configPkg = join(configDir, "package.json");
   if (!existsSync(configPkg)) return;
   const targetPath = join(cwd, "package.json");
@@ -215,12 +262,75 @@ function mergePkg(configDir: string, cwd: string, versionsFromNpm: Map<string, s
     : { ...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, versionsFromNpm)))
+  const pkgRootDir = join(configDir, "..");
+  for (const [k, v] of Object.entries(resolveFlowDeps(config.dependencies, pkgRootDir, versionsFromNpm, useWorkspace)))
     target.dependencies[k] = v;
-  for (const [k, v] of Object.entries(resolveFlowDeps(config.devDependencies, configDir, versionsFromNpm)))
+  for (const [k, v] of Object.entries(resolveFlowDeps(config.devDependencies, pkgRootDir, versionsFromNpm, useWorkspace)))
     target.devDependencies[k] = v;
   target.scripts = { ...target.scripts, ...config.scripts };
-  writeFileSync(targetPath, JSON.stringify(target, null, 2));
+  writeFileSync(targetPath, JSON.stringify(sortPkgKeys(target), null, 2));
+}
+
+type FlowOsInit = { dependencies?: Record<string, string>; devDependencies?: Record<string, string>; scripts?: Record<string, string>; name?: string; version?: string; type?: string };
+
+/** Merge da flow-os-init: root package.json (se in repo) oppure package (npm) */
+function mergeFlowOsInit(
+  packageRoot: string,
+  pkgName: string,
+  cwd: string,
+  versionsFromNpm: Map<string, string>,
+  useWorkspace: boolean,
+  flowOsRepoRoot: string | null
+): void {
+  let init: FlowOsInit | undefined;
+  if (flowOsRepoRoot) {
+    const rootPkgPath = join(flowOsRepoRoot, "package.json");
+    if (existsSync(rootPkgPath)) {
+      try {
+        const rootPkg = JSON.parse(readFileSync(rootPkgPath, "utf-8")) as { "flow-os-init"?: Record<string, FlowOsInit> };
+        init = rootPkg["flow-os-init"]?.[pkgName];
+      } catch {}
+    }
+  }
+  if (!init) {
+    const pkgPath = join(packageRoot, "package.json");
+    if (!existsSync(pkgPath)) return;
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as { "flow-os-init"?: FlowOsInit };
+      init = pkg["flow-os-init"];
+    } catch {
+      return;
+    }
+  }
+  if (!init) return;
+  const targetPath = join(cwd, "package.json");
+  const target = existsSync(targetPath)
+    ? JSON.parse(readFileSync(targetPath, "utf-8"))
+    : { name: init.name ?? (basename(cwd) || "flow-app"), version: init.version ?? "0.0.1", type: init.type ?? "module" };
+  target.dependencies = { ...target.dependencies, ...init.dependencies };
+  target.devDependencies = { ...target.devDependencies, ...init.devDependencies };
+  for (const [k, v] of Object.entries(resolveFlowDeps(init.dependencies, packageRoot, versionsFromNpm, useWorkspace)))
+    target.dependencies[k] = v;
+  for (const [k, v] of Object.entries(resolveFlowDeps(init.devDependencies, packageRoot, versionsFromNpm, useWorkspace)))
+    target.devDependencies[k] = v;
+  target.scripts = { ...target.scripts, ...init.scripts };
+  writeFileSync(targetPath, JSON.stringify(sortPkgKeys(target), null, 2));
+}
+
+/** Aggiunge dipendenza per pacchetti senza config (solo install) */
+function addDependencyForPackage(
+  pkgName: string,
+  cwd: string,
+  versionsFromNpm: Map<string, string>,
+  useWorkspace: boolean
+): void {
+  const targetPath = join(cwd, "package.json");
+  if (!existsSync(targetPath)) return;
+  const target = JSON.parse(readFileSync(targetPath, "utf-8"));
+  target.dependencies = target.dependencies ?? {};
+  const spec = useWorkspace ? "workspace:*" : (versionsFromNpm.get(pkgName) ? `^${versionsFromNpm.get(pkgName)}` : undefined);
+  if (spec) target.dependencies[pkgName] = spec;
+  writeFileSync(targetPath, JSON.stringify(sortPkgKeys(target), null, 2));
 }
 
 /** Assicura che versions abbia le versioni per pkgNames (fetch lazy) */
@@ -251,12 +361,17 @@ async function collectAllTemplates(
   done: Set<string>,
   order: string[],
   versionsFromNpm: Map<string, string>,
-  tmpDirs: string[]
+  tmpDirs: string[],
+  flowOsRepoRoot: string | null
 ): Promise<void> {
   for (const lib of libs) {
     const pkgName = toPkgName(lib);
     if (done.has(pkgName)) continue;
 
+    const shortName = toShortName(pkgName);
+    const localFromRepo = flowOsRepoRoot ? join(flowOsRepoRoot, "packages", shortName) : "";
+    const localConfigFromRepo = localFromRepo ? join(localFromRepo, "config") : "";
+
     let root: string;
     let configDir: string;
     try {
@@ -266,12 +381,22 @@ async function collectAllTemplates(
       root = "";
       configDir = "";
     }
+    const hasLocalFromRepo = !!localConfigFromRepo && existsSync(localConfigFromRepo);
     const hasLocal = existsSync(configDir);
 
     let pkgFiles: Map<string, string>;
     let configDirForPkg: string;
+    const useLocalRepo = hasLocalFromRepo && flowOsRepoRoot;
     const npmVer = versionsFromNpm.get(pkgName);
-    if (npmVer) {
+
+    if (useLocalRepo) {
+      configDirForPkg = localConfigFromRepo;
+      pkgFiles = collectConfigFiles(configDirForPkg);
+      const subDeps = flowDepsFromPkg(join(configDirForPkg, ".."));
+      for (const sub of subDeps) {
+        await collectAllTemplates([toShortName(sub)], combined, done, order, versionsFromNpm, tmpDirs, flowOsRepoRoot);
+      }
+    } else if (npmVer) {
       const fetched = await fetchConfigFromNpm(pkgName, npmVer, tmpDirs);
       if (fetched) {
         pkgFiles = fetched.files;
@@ -279,13 +404,13 @@ async function collectAllTemplates(
         const subDeps = flowDepsFromPkg(join(configDirForPkg, ".."));
         await ensureVersions(versionsFromNpm, subDeps);
         for (const sub of subDeps) {
-          await collectAllTemplates([toShortName(sub)], combined, done, order, versionsFromNpm, tmpDirs);
+          await collectAllTemplates([toShortName(sub)], combined, done, order, versionsFromNpm, tmpDirs, flowOsRepoRoot);
         }
       } 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);
+          await collectAllTemplates([toShortName(sub)], combined, done, order, versionsFromNpm, tmpDirs, flowOsRepoRoot);
         }
         pkgFiles = collectConfigFiles(configDir);
         configDirForPkg = configDir;
@@ -296,7 +421,7 @@ async function collectAllTemplates(
       const subDeps = flowDeps(root);
       await ensureVersions(versionsFromNpm, subDeps);
       for (const sub of subDeps) {
-        await collectAllTemplates([toShortName(sub)], combined, done, order, versionsFromNpm, tmpDirs);
+        await collectAllTemplates([toShortName(sub)], combined, done, order, versionsFromNpm, tmpDirs, flowOsRepoRoot);
       }
       pkgFiles = collectConfigFiles(configDir);
       configDirForPkg = configDir;
@@ -319,28 +444,68 @@ export async function initLib(
   onProgress?: (step: InitProgressStep) => void
 ): Promise<void> {
   const pkgNames = libs.map(toPkgName);
+  const flowOsRepoRoot = findFlowOsRepoRoot(cwd);
+  const useWorkspace = !!flowOsRepoRoot;
   const versions = versionsFromNpm ?? new Map<string, string>();
 
   onProgress?.("fetch");
-  const fetched = await fetchFlowPackageVersions(pkgNames);
-  for (const [k, v] of fetched) versions.set(k, v);
+  if (!useWorkspace) {
+    const fetched = await fetchFlowPackageVersions(pkgNames);
+    for (const [k, v] of fetched) versions.set(k, v);
+  }
 
   onProgress?.("templates");
   const combined = new Map<string, string>();
   const done = new Set<string>();
   const order: string[] = [];
   const tmpDirs: string[] = [];
-  await collectAllTemplates(libs, combined, done, order, versions, tmpDirs);
+  await collectAllTemplates(libs, combined, done, order, versions, tmpDirs, flowOsRepoRoot);
 
   for (const configDir of order) {
-    mergePkg(configDir, cwd, versions);
+    const packageRoot = join(configDir, "..");
+    const pkgName = (() => {
+      try {
+        const p = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf-8")) as { name?: string };
+        return p?.name ?? "";
+      } catch {
+        return "";
+      }
+    })();
+    if (existsSync(join(configDir, "package.json"))) {
+      mergePkg(configDir, cwd, versions, useWorkspace);
+    } else {
+      mergeFlowOsInit(packageRoot, pkgName, cwd, versions, useWorkspace, flowOsRepoRoot);
+    }
+  }
+
+  const targetPath = join(cwd, "package.json");
+  if (!existsSync(targetPath)) {
+    writeFileSync(
+      targetPath,
+      JSON.stringify(sortPkgKeys({ name: basename(cwd) || "flow-app", version: "0.0.1", private: true, type: "module" }), null, 2)
+    );
+  }
+
+  const toAdd = new Set<string>(pkgNames);
+  for (const configDir of order) {
+    const packageRoot = join(configDir, "..");
+    for (const peer of flowDepsFromPkg(packageRoot)) toAdd.add(peer);
+  }
+  for (const pkgName of pkgNames) {
+    const packageRoot = flowOsRepoRoot ? join(flowOsRepoRoot, "packages", toShortName(pkgName)) : (() => { try { return pkgRoot(pkgName); } catch { return ""; } })();
+    if (packageRoot) for (const peer of flowDepsFromPkg(packageRoot)) toAdd.add(peer);
+  }
+  await ensureVersions(versions, [...toAdd]);
+  for (const pkgName of toAdd) {
+    addDependencyForPackage(pkgName, cwd, versions, useWorkspace);
   }
 
   onProgress?.("write");
   await writeMergedWithUser(combined, cwd, (path, conflicts) => resolveConflicts(conflicts, path));
 
   onProgress?.("install");
-  const proc = Bun.spawn(["bun", "install"], { cwd, stdout: "inherit", stderr: "inherit" });
+  const installCwd = useWorkspace && flowOsRepoRoot ? flowOsRepoRoot : cwd;
+  const proc = Bun.spawn(["bun", "install"], { cwd: installCwd, stdout: "pipe", stderr: "pipe" });
   const exitCode = await proc.exited;
   if (exitCode !== 0) {
     throw new Error(`bun install exited with code ${exitCode}`);

package/src/init/ui.ts

@@ -9,6 +9,7 @@ const E = "\x1b[91m";
 const R = "\x1b[0m";
 const B = "\x1b[1m";
 const DIM = "\x1b[2m";
+const W = "\x1b[97m";  // bianco (solo per headerLogo)
 
 const FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
 
@@ -25,19 +26,24 @@ export function bannerBox(title: string, lines: string[], color: string, w = 50)
   const c = color;
   const inner = " " + c + B + title + R + " ";
   const innerLen = stripAnsi(inner).length;
-  const half = Math.max(0, Math.floor((w - 2 - innerLen) / 2));
-  const top = c + "╭" + "─".repeat(half) + inner + "─".repeat(w - 2 - half - innerLen) + "╮" + R;
-  const bottom = c + "╰" + "─".repeat(w - 2) + "╯" + R;
-  const bodyLines = lines.map((l) => c + "│" + R + "  " + pad(l, w - 2) + c + "│" + R);
-  return "\n" + top + "\n" + bodyLines.join("\n") + "\n" + bottom + "\n";
+  const innerW = w - 4;
+  const half = Math.max(0, Math.floor((innerW - innerLen) / 2));
+  const rest = innerW - half - innerLen;
+  const top = c + "╭" + "─".repeat(half) + inner + c + "─".repeat(rest) + "╮" + R;
+  const bottom = c + "╰" + "─".repeat(innerW) + "╯" + R;
+  const emptyLine = c + "│" + R + "  " + " ".repeat(innerW - 2) + c + "│" + R;
+  const bodyLines = lines.map((l) => c + "│" + R + "  " + pad(l, innerW - 2) + c + "│" + R);
+  return "\n" + top + "\n" + emptyLine + "\n" + bodyLines.join("\n") + "\n" + bottom + "\n";
 }
 
-export function box(lines: string[], color: string, w = 52): string {
+export function box(lines: string[], color: string, w = 50): string {
   const c = color;
-  const top = c + "╭" + "─".repeat(w) + "╮" + R;
-  const bottom = c + "╰" + "─".repeat(w) + "╯" + R;
-  const body = lines.map((l) => c + "│" + R + "  " + pad(l, w - 2) + c + "│" + R).join("\n");
-  return "\n" + top + "\n" + body + "\n" + bottom + "\n";
+  const innerW = w - 4;
+  const top = c + "╭" + "─".repeat(innerW) + "╮" + R;
+  const bottom = c + "╰" + "─".repeat(innerW) + "╯" + R;
+  const emptyLine = c + "│" + R + "  " + " ".repeat(innerW - 2) + c + "│" + R;
+  const body = lines.map((l) => c + "│" + R + "  " + pad(l, innerW - 2) + c + "│" + R).join("\n");
+  return "\n" + top + "\n" + emptyLine + "\n" + body + "\n" + bottom + "\n";
 }
 
 import type { InitProgressStep } from "./scaffold";
@@ -87,8 +93,6 @@ export async function withLoading<T>(
   }
 }
 
-const W = "\x1b[97m"; // bianco
-
 export const colors = { V, V_LIGHT, Y, E, R, B, DIM, W };
 
 /** Icona layers: 3 quadrati arrotondati sovrapposti, vista isometrica con shading ▓▒░ */