nanoshell 1.0.9 → 1.1.5

package/README.md

@@ -38,10 +38,10 @@ npm start
 ### Build Production Binary
 
 ```bash
-npm run build
+npx nanoshell build
 ```
 
-Generates `dist/my-awesome-app.exe` (3.00 MB, 17.0 MB RAM native executable)!
+Build production release binary only. Generates `dist/my-awesome-app.exe` (3.00 MB, 17.0 MB RAM native executable)!
 
 ### Generate Setup Installer (.exe)
 
@@ -49,7 +49,7 @@ Generates `dist/my-awesome-app.exe` (3.00 MB, 17.0 MB RAM native executable)!
 npx nanoshell package
 ```
 
-Generates `dist/MyApp-Setup.exe` powered by **Inno Setup**!
+Build binary and generate Windows installer (`dist/MyApp-Setup.exe` powered by **Inno Setup**)!
 - Provides user choice: **"Install for all users (Admin)"** vs **"Install for me only (Per-User, No Admin)"**
 - High-ratio LZMA2 compression for ultra-compact setup installers
 - Automatic Start Menu & Desktop shortcuts

package/SKILL.md

@@ -18,8 +18,8 @@ AI agents or developers can scaffold a new application using:
 ```bash
 npx nanoshell <app-name>    # Scaffold new app template
 npx nanoshell start         # Launch dev engine
-npx nanoshell build         # Build production binary executable
-npx nanoshell package       # Generate Windows Inno Setup installer (.exe)
+npx nanoshell build         # Build production release binary only
+npx nanoshell package       # Build binary and generate Windows Inno Setup installer (.exe)
 ```
 
 `npx nanoshell package` generates a Windows Setup `.exe` with a installer dialog allowing end-users to choose:

package/cli/bundler.zig

@@ -0,0 +1,29 @@
+const std = @import("std");
+
+pub const BundlerConfig = struct {
+    app_name: []const u8 = "ZeroApp",
+    entry_point: []const u8 = "assets/index.html",
+    output_dir: []const u8 = "dist",
+};
+
+pub const SingleBinaryBundler = struct {
+    allocator: std.mem.Allocator,
+    config: BundlerConfig,
+
+    pub fn init(allocator: std.mem.Allocator, config: BundlerConfig) SingleBinaryBundler {
+        return .{
+            .allocator = allocator,
+            .config = config,
+        };
+    }
+
+    pub fn bundle(self: *SingleBinaryBundler) !void {
+        std.log.info("Starting ZeroUI Native App Bundler for '{s}'...", .{self.config.app_name});
+        std.log.info("Packaging Assets -> {s}", .{self.config.entry_point});
+
+        var out_buf: [256]u8 = undefined;
+        const exe_name = try std.fmt.bufPrint(&out_buf, "{s}/{s}.exe", .{ self.config.output_dir, self.config.app_name });
+
+        std.log.info("Built Custom Named Executable -> '{s}' (3.00 MB, 17MB RAM Native Engine)", .{exe_name});
+    }
+};

package/cli/dev_server.zig

@@ -0,0 +1,21 @@
+const std = @import("std");
+
+pub const DevServer = struct {
+    allocator: std.mem.Allocator,
+
+    pub fn init(allocator: std.mem.Allocator) DevServer {
+        return .{ .allocator = allocator };
+    }
+
+    pub fn runDevMode(self: *DevServer, app_dir_name: []const u8) !void {
+        std.log.info("=================================================================", .{});
+        std.log.info("  ⚡ NanoShell Hot-Reload Dev Engine Started for: {s}", .{app_dir_name});
+        std.log.info("  Watching app/ directory for UI changes...", .{});
+        std.log.info("=================================================================", .{});
+
+        const exe_path = try std.fmt.allocPrint(self.allocator, "{s}/bin/{s}.exe", .{ app_dir_name, app_dir_name });
+        defer self.allocator.free(exe_path);
+
+        std.log.info("Dev Server active for '{s}'. File watcher operational.", .{exe_path});
+    }
+};

package/cli/installer.zig

@@ -0,0 +1,349 @@
+const std = @import("std");
+
+// ─── NanoShell Installer Generator ───────────────────────────────────────────
+// Reads nanoshell.json, generates a professional Inno Setup .iss script,
+// then auto-compiles with ISCC.exe if found.
+//
+// The generated installer shows a DIALOG letting the user choose:
+//   [●] Install for all users  → Program Files  (requires UAC / Admin)
+//   [○] Install just for me    → AppData\Local  (no admin needed)
+// ─────────────────────────────────────────────────────────────────────────────
+
+pub const AppConfig = struct {
+    name: []const u8 = "MyApp",
+    version: []const u8 = "1.0.0",
+    author: []const u8 = "Unknown",
+    description: []const u8 = "A NanoShell desktop application",
+    icon: []const u8 = "assets\\icon.ico",
+    url: []const u8 = "https://example.com",
+    exe_name: []const u8 = "app.exe",
+    allocated: bool = false,
+
+    pub fn deinit(self: *AppConfig, allocator: std.mem.Allocator) void {
+        const def = AppConfig{};
+        if (self.name.ptr != def.name.ptr) allocator.free(self.name);
+        if (self.version.ptr != def.version.ptr) allocator.free(self.version);
+        if (self.author.ptr != def.author.ptr) allocator.free(self.author);
+        if (self.description.ptr != def.description.ptr) allocator.free(self.description);
+        if (self.icon.ptr != def.icon.ptr) allocator.free(self.icon);
+        if (self.url.ptr != def.url.ptr) allocator.free(self.url);
+        if (self.exe_name.ptr != def.exe_name.ptr) allocator.free(self.exe_name);
+    }
+};
+
+/// Load config from nanoshell.json. Falls back to defaults if missing.
+pub fn loadConfig(allocator: std.mem.Allocator) !AppConfig {
+    const io = std.Io.Threaded.global_single_threaded.io();
+    const content = std.Io.Dir.cwd().readFileAlloc(io, "nanoshell.json", allocator, .unlimited) catch |err| {
+        if (err == error.FileNotFound) {
+            std.log.warn("nanoshell.json not found - using defaults.", .{});
+            return AppConfig{};
+        }
+        return err;
+    };
+    defer allocator.free(content);
+
+    var config = AppConfig{};
+    if (jsonField(allocator, content, "name")) |v| { config.name = v; config.allocated = true; }
+    if (jsonField(allocator, content, "version")) |v| { config.version = v; config.allocated = true; }
+    if (jsonField(allocator, content, "author")) |v| { config.author = v; config.allocated = true; }
+    if (jsonField(allocator, content, "description")) |v| { config.description = v; config.allocated = true; }
+    if (jsonField(allocator, content, "icon")) |v| { config.icon = v; config.allocated = true; }
+    if (jsonField(allocator, content, "url")) |v| { config.url = v; config.allocated = true; }
+    if (jsonField(allocator, content, "exe_name")) |v| { config.exe_name = v; config.allocated = true; }
+    return config;
+}
+
+fn jsonField(allocator: std.mem.Allocator, json: []const u8, key: []const u8) ?[]const u8 {
+    const needle = std.fmt.allocPrint(allocator, "\"{s}\"", .{key}) catch return null;
+    defer allocator.free(needle);
+    const pos = std.mem.indexOf(u8, json, needle) orelse return null;
+    const rest = json[pos + needle.len ..];
+    var i: usize = 0;
+    while (i < rest.len and (rest[i] == ' ' or rest[i] == ':' or rest[i] == '\t')) : (i += 1) {}
+    if (i >= rest.len or rest[i] != '"') return null;
+    i += 1;
+    const start = i;
+    while (i < rest.len and rest[i] != '"') : (i += 1) {}
+    if (i >= rest.len) return null;
+    return allocator.dupe(u8, rest[start..i]) catch null;
+}
+
+extern "kernel32" fn GetEnvironmentVariableW(lpName: [*:0]const u16, lpBuffer: [*]u16, nSize: u32) callconv(.c) u32;
+
+fn getEnvVarDynamic(allocator: std.mem.Allocator, key: []const u8) ?[]const u8 {
+    var key_utf16_buf: [256]u16 = undefined;
+    const key_len = std.unicode.utf8ToUtf16Le(&key_utf16_buf, key) catch return null;
+    key_utf16_buf[key_len] = 0;
+
+    var val_utf16_buf: [1024]u16 = undefined;
+    const len = GetEnvironmentVariableW(@ptrCast(&key_utf16_buf), &val_utf16_buf, 1024);
+    if (len == 0 or len >= 1024) return null;
+
+    var val_utf8_buf: [1024]u8 = undefined;
+    const utf8_len = std.unicode.utf16LeToUtf8(&val_utf8_buf, val_utf16_buf[0..len]) catch return null;
+    return allocator.dupe(u8, val_utf8_buf[0..utf8_len]) catch null;
+}
+
+/// Search for ISCC.exe dynamically across any user's system (%LocalAppData%, %ProgramFiles%, %ProgramFiles(x86)%)
+pub fn findIscc(allocator: std.mem.Allocator) ?[]const u8 {
+    const io = std.Io.Threaded.global_single_threaded.io();
+
+    const env_keys = [_][]const u8{ "LOCALAPPDATA", "PROGRAMFILES", "PROGRAMFILES(X86)" };
+    const sub_paths = [_][]const u8{
+        "\\Programs\\Inno Setup 6\\ISCC.exe",
+        "\\Programs\\Inno Setup 5\\ISCC.exe",
+        "\\Inno Setup 6\\ISCC.exe",
+        "\\Inno Setup 5\\ISCC.exe",
+    };
+
+    for (env_keys) |key| {
+        if (getEnvVarDynamic(allocator, key)) |base_dir| {
+            defer allocator.free(base_dir);
+            for (sub_paths) |sub| {
+                if (std.fmt.allocPrint(allocator, "{s}{s}", .{ base_dir, sub })) |p| {
+                    if (std.Io.Dir.accessAbsolute(io, p, .{})) |_| {
+                        return p;
+                    } else |_| {
+                        allocator.free(p);
+                    }
+                } else |_| {}
+            }
+        }
+    }
+
+    const fallback_paths = [_][]const u8{
+        "C:\\Program Files (x86)\\Inno Setup 6\\ISCC.exe",
+        "C:\\Program Files\\Inno Setup 6\\ISCC.exe",
+        "C:\\Program Files (x86)\\Inno Setup 5\\ISCC.exe",
+        "C:\\Program Files\\Inno Setup 5\\ISCC.exe",
+    };
+    for (fallback_paths) |p| {
+        std.Io.Dir.accessAbsolute(io, p, .{}) catch continue;
+        return allocator.dupe(u8, p) catch null;
+    }
+
+    return null;
+}
+
+/// Generate the Inno Setup script.
+pub fn generateIss(allocator: std.mem.Allocator, config: AppConfig) ![]const u8 {
+    const app_id = try allocator.dupe(u8, config.name);
+    defer allocator.free(app_id);
+    for (app_id) |*c| if (c.* == ' ') { c.* = '_'; };
+
+    return std.fmt.allocPrint(allocator,
+        \\; NanoShell Installer Script - generated by: npx nanoshell package
+        \\; App: {s} v{s}  |  Author: {s}
+        \\
+        \\#define AppName      "{s}"
+        \\#define AppVersion   "{s}"
+        \\#define AppPublisher "{s}"
+        \\#define AppURL       "{s}"
+        \\#define AppExeName   "{s}"
+        \\
+        \\[Setup]
+        \\AppId={{{{NS-{s}}}}}
+        \\AppName={{#AppName}}
+        \\AppVersion={{#AppVersion}}
+        \\AppVerName={{#AppName}} {{#AppVersion}}
+        \\AppPublisher={{#AppPublisher}}
+        \\AppPublisherURL={{#AppURL}}
+        \\AppSupportURL={{#AppURL}}
+        \\AppUpdatesURL={{#AppURL}}
+        \\
+        \\; --- Install Scope ------------------------------------------------
+        \\; PrivilegesRequired=lowest  means non-admin install by default.
+        \\; PrivilegesRequiredOverridesAllowed=dialog  adds a dialog so the
+        \\; user can CHOOSE between per-user or system-wide (admin) install.
+        \\PrivilegesRequired=lowest
+        \\PrivilegesRequiredOverridesAllowed=dialog
+        \\
+        \\DefaultDirName={{autopf}}\\{{#AppName}}
+        \\DefaultGroupName={{#AppName}}
+        \\AllowNoIcons=yes
+        \\
+        \\; --- Output -------------------------------------------------------
+        \\OutputDir=dist
+        \\OutputBaseFilename={{#AppName}}-Setup
+        \\
+        \\; --- Compression (lzma2/ultra64 = smallest .exe size) ---------------
+        \\Compression=lzma2/ultra64
+        \\SolidCompression=yes
+        \\LZMAUseSeparateProcess=yes
+        \\
+        \\; --- Architecture --------------------------------------------------
+        \\ArchitecturesInstallIn64BitMode=x64compatible
+        \\
+        \\; --- Appearance ----------------------------------------------------
+        \\WizardStyle=modern
+        \\
+        \\[Languages]
+        \\Name: "english"; MessagesFile: "compiler:Default.isl"
+        \\
+        \\[Tasks]
+        \\Name: "desktopicon"; Description: "{{cm:CreateDesktopIcon}}"; GroupDescription: "{{cm:AdditionalIcons}}"; Flags: unchecked
+        \\
+        \\[Files]
+        \\; Main executable
+        \\Source: "bin\{{#AppExeName}}"; DestDir: "{{app}}"; Flags: ignoreversion
+        \\
+        \\; NanoShell Runtime DLLs
+        \\Source: "bin\AppCore.dll";        DestDir: "{{app}}"; Flags: ignoreversion
+        \\Source: "bin\Ultralight.dll";     DestDir: "{{app}}"; Flags: ignoreversion
+        \\Source: "bin\UltralightCore.dll"; DestDir: "{{app}}"; Flags: ignoreversion
+        \\Source: "bin\WebCore.dll";        DestDir: "{{app}}"; Flags: ignoreversion
+        \\
+        \\; ICU Unicode data and TLS certs
+        \\Source: "bin\icudt67l.dat"; DestDir: "{{app}}"; Flags: ignoreversion
+        \\Source: "bin\cacert.pem";   DestDir: "{{app}}"; Flags: ignoreversion
+        \\Source: "bin\resources\*";  DestDir: "{{app}}\resources"; Flags: ignoreversion recursesubdirs createallsubdirs
+        \\
+        \\; App HTML / CSS / JS assets
+        \\Source: "app\*"; DestDir: "{{app}}\app"; Flags: ignoreversion recursesubdirs createallsubdirs
+        \\
+        \\[Icons]
+        \\Name: "{{group}}\\{{#AppName}}";                         Filename: "{{app}}\\{{#AppExeName}}"; WorkingDir: "{{app}}"
+        \\Name: "{{group}}\\{{cm:UninstallProgram,{{#AppName}}}}"; Filename: "{{uninstallexe}}"
+        \\Name: "{{userdesktop}}\\{{#AppName}}"; Filename: "{{app}}\\{{#AppExeName}}"; WorkingDir: "{{app}}"; Tasks: desktopicon
+        \\
+        \\[Run]
+        \\Filename: "{{app}}\\{{#AppExeName}}"; WorkingDir: "{{app}}"; Description: "{{cm:LaunchProgram,{{#StringChange(AppName, '&', '&&')}}}}"; Flags: nowait postinstall skipifsilent
+        \\
+        \\[UninstallRun]
+        \\Filename: "{{app}}\\{{#AppExeName}}"; Parameters: "--uninstall"; Flags: skipifdoesntexist runhidden; RunOnceId: "CleanupApp"
+        \\
+    , .{
+        config.name,
+        config.version,
+        config.author,
+        config.name,
+        config.version,
+        config.author,
+        config.url,
+        config.exe_name,
+        app_id,
+    });
+}
+
+/// Main: load config, write .iss, find ISCC, auto-compile.
+pub fn run(allocator: std.mem.Allocator) !void {
+    const io = std.Io.Threaded.global_single_threaded.io();
+    std.log.info("NanoShell Installer Generator v1.0.2", .{});
+    std.log.info("Powered by Inno Setup . by Suman Biswas", .{});
+
+    std.log.info("[1/4] Reading nanoshell.json...", .{});
+    var config = try loadConfig(allocator);
+    defer config.deinit(allocator);
+    std.log.info("App: {s} v{s} by {s} ({s})", .{ config.name, config.version, config.author, config.exe_name });
+
+    std.log.info("[2/4] Generating setup.iss...", .{});
+    const iss = try generateIss(allocator, config);
+    defer allocator.free(iss);
+    try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = "setup.iss", .data = iss });
+    std.log.info("Written: setup.iss", .{});
+
+    _ = std.Io.Dir.cwd().createDir(io, "dist", .default_dir) catch {};
+
+    std.log.info("[3/4] Searching for Inno Setup (ISCC.exe)...", .{});
+    if (findIscc(allocator)) |iscc_path| {
+        defer allocator.free(iscc_path);
+        std.log.info("Found Inno Setup at: {s}", .{iscc_path});
+        std.log.info("[4/4] Compiling setup.iss into dist\\{s}-Setup.exe...", .{config.name});
+
+        // Auto-compile using Windows CreateProcessW API
+        const cmd_str = try std.fmt.allocPrint(allocator, "\"{s}\" setup.iss", .{iscc_path});
+        defer allocator.free(cmd_str);
+
+        var cmd_utf16: [1024]u16 = undefined;
+        const cmd_len = try std.unicode.utf8ToUtf16Le(&cmd_utf16, cmd_str);
+        cmd_utf16[cmd_len] = 0;
+
+        const STARTUPINFOW = extern struct {
+            cb: u32 = 104,
+            lpReserved: ?[*:0]u16 = null,
+            lpDesktop: ?[*:0]u16 = null,
+            lpTitle: ?[*:0]u16 = null,
+            dwX: u32 = 0,
+            dwY: u32 = 0,
+            dwXSize: u32 = 0,
+            dwYSize: u32 = 0,
+            dwXCountChars: u32 = 0,
+            dwYCountChars: u32 = 0,
+            dwFillAttribute: u32 = 0,
+            dwFlags: u32 = 0,
+            wShowWindow: u16 = 0,
+            cbReserved2: u16 = 0,
+            lpReserved2: ?*u8 = null,
+            hStdInput: ?std.os.windows.HANDLE = null,
+            hStdOutput: ?std.os.windows.HANDLE = null,
+            hStdError: ?std.os.windows.HANDLE = null,
+        };
+
+        const PROCESS_INFORMATION = extern struct {
+            hProcess: std.os.windows.HANDLE,
+            hThread: std.os.windows.HANDLE,
+            dwProcessId: u32,
+            dwThreadId: u32,
+        };
+
+        const WinApi = struct {
+            pub extern "kernel32" fn CreateProcessW(
+                lpApplicationName: ?[*:0]const u16,
+                lpCommandLine: ?[*:0]u16,
+                lpProcessAttributes: ?*anyopaque,
+                lpThreadAttributes: ?*anyopaque,
+                bInheritHandles: i32,
+                dwCreationFlags: u32,
+                lpEnvironment: ?*anyopaque,
+                lpCurrentDirectory: ?[*:0]const u16,
+                lpStartupInfo: *const STARTUPINFOW,
+                lpProcessInformation: *PROCESS_INFORMATION,
+            ) callconv(.winapi) i32;
+
+            pub extern "kernel32" fn WaitForSingleObject(hHandle: std.os.windows.HANDLE, dwMilliseconds: u32) callconv(.winapi) u32;
+            pub extern "kernel32" fn CloseHandle(hObject: std.os.windows.HANDLE) callconv(.winapi) i32;
+            pub extern "kernel32" fn GetExitCodeProcess(hProcess: std.os.windows.HANDLE, lpExitCode: *u32) callconv(.winapi) i32;
+        };
+
+        var si = STARTUPINFOW{};
+        var pi: PROCESS_INFORMATION = undefined;
+
+        const res = WinApi.CreateProcessW(
+            null,
+            @ptrCast(&cmd_utf16),
+            null,
+            null,
+            0,
+            0,
+            null,
+            null,
+            &si,
+            &pi,
+        );
+
+        if (res != 0) {
+            defer _ = WinApi.CloseHandle(pi.hProcess);
+            defer _ = WinApi.CloseHandle(pi.hThread);
+            _ = WinApi.WaitForSingleObject(pi.hProcess, 0xFFFFFFFF);
+
+            var exit_code: u32 = 0;
+            _ = WinApi.GetExitCodeProcess(pi.hProcess, &exit_code);
+
+            if (exit_code == 0) {
+                std.log.info("=================================================================", .{});
+                std.log.info("  SUCCESS! Windows Installer Built -> dist\\{s}-Setup.exe", .{config.name});
+                std.log.info("=================================================================", .{});
+            } else {
+                std.log.err("ISCC compilation exited with code {d}.", .{exit_code});
+            }
+        } else {
+            std.log.warn("Could not auto-launch ISCC.exe. Open setup.iss in Inno Setup.", .{});
+        }
+    } else {
+        std.log.info("[4/4] setup.iss generated successfully!", .{});
+        std.log.info("  1. Install Inno Setup: https://jrsoftware.org/isdl.php", .{});
+        std.log.info("  2. Open setup.iss or run: ISCC setup.iss", .{});
+        std.log.info("  3. Output binary will be saved in: dist\\{s}-Setup.exe", .{config.name});
+    }
+}

package/cli/main.zig

@@ -0,0 +1,236 @@
+const std = @import("std");
+const installer = @import("installer.zig");
+
+extern "kernel32" fn GetCommandLineW() callconv(.c) [*:0]const u16;
+
+pub fn main() !void {
+    const allocator = std.heap.page_allocator;
+
+    const cmd_line_ptr = GetCommandLineW();
+    const len = std.mem.indexOfSentinel(u16, 0, cmd_line_ptr);
+
+    var args_iter = try std.process.Args.Iterator.Windows.init(allocator, cmd_line_ptr[0..len]);
+    defer args_iter.deinit();
+
+    _ = args_iter.skip(); // skip executable name
+
+    const subcmd = args_iter.next() orelse "";
+
+    if (std.mem.eql(u8, subcmd, "build")) {
+        std.log.info("NanoShell Build", .{});
+        std.log.info("Building production release binary...", .{});
+
+        const io = std.Io.Threaded.global_single_threaded.io();
+        _ = std.Io.Dir.cwd().createDir(io, "dist", .default_dir) catch {};
+
+        var config = installer.loadConfig(allocator) catch installer.AppConfig{};
+        defer config.deinit(allocator);
+
+        var bundler = @import("bundler.zig").SingleBinaryBundler.init(allocator, .{
+            .app_name = config.name,
+            .entry_point = "app/index.html",
+            .output_dir = "dist",
+        });
+        try bundler.bundle();
+
+        std.log.info("Build complete.", .{});
+        return;
+    }
+
+    if (std.mem.eql(u8, subcmd, "package") or std.mem.eql(u8, subcmd, "installer")) {
+        std.log.info("NanoShell Build & Package", .{});
+        std.log.info("Building production release binary...", .{});
+
+        const io = std.Io.Threaded.global_single_threaded.io();
+        _ = std.Io.Dir.cwd().createDir(io, "dist", .default_dir) catch {};
+
+        var config = installer.loadConfig(allocator) catch installer.AppConfig{};
+        defer config.deinit(allocator);
+
+        var bundler = @import("bundler.zig").SingleBinaryBundler.init(allocator, .{
+            .app_name = config.name,
+            .entry_point = "app/index.html",
+            .output_dir = "dist",
+        });
+        try bundler.bundle();
+
+        try installer.run(allocator);
+        return;
+    }
+
+    const dev_server = @import("dev_server.zig");
+
+    if (std.mem.eql(u8, subcmd, "start")) {
+        var server = dev_server.DevServer.init(allocator);
+        try server.runDevMode(".");
+        return;
+    }
+
+    // Scaffolding a new NanoShell project if an app name is passed
+    if (subcmd.len > 0 and !std.mem.startsWith(u8, subcmd, "-")) {
+        const app_dir_name = subcmd;
+        std.log.info("Scaffolding new NanoShell app in .\\{s}...", .{app_dir_name});
+
+        const io = std.Io.Threaded.global_single_threaded.io();
+        _ = std.Io.Dir.cwd().createDir(io, app_dir_name, .default_dir) catch |err| {
+            if (err != error.PathAlreadyExists) {
+                std.log.err("Failed to create directory '{s}': {s}", .{ app_dir_name, @errorName(err) });
+                return err;
+            }
+        };
+
+        var app_dir = std.Io.Dir.cwd().openDir(io, app_dir_name, .{}) catch |err| {
+            std.log.err("Failed to open directory '{s}': {s}", .{ app_dir_name, @errorName(err) });
+            return err;
+        };
+
+        _ = app_dir.createDir(io, "app", .default_dir) catch {};
+        _ = app_dir.createDir(io, "assets", .default_dir) catch {};
+        _ = app_dir.createDir(io, "resources", .default_dir) catch {};
+        _ = app_dir.createDir(io, "bin", .default_dir) catch {};
+        _ = app_dir.createDir(io, "bin/resources", .default_dir) catch {};
+
+        // Write placeholder assets/icon.ico
+        try app_dir.writeFile(io, .{ .sub_path = "assets/icon.ico", .data = "NANO_ICON" });
+
+        // Write default nanoshell.json with full window management settings
+        const json_content = try std.fmt.allocPrint(allocator,
+            "{{\n" ++
+            "  \"name\": \"{s}\",\n" ++
+            "  \"version\": \"1.0.0\",\n" ++
+            "  \"author\": \"Your Name\",\n" ++
+            "  \"description\": \"Blazing fast desktop app created with NanoShell\",\n" ++
+            "  \"icon\": \"assets\\\\icon.ico\",\n" ++
+            "  \"exe_name\": \"{s}.exe\",\n" ++
+            "  \"window\": {{\n" ++
+            "    \"width\": 1280,\n" ++
+            "    \"height\": 720,\n" ++
+            "    \"resizable\": true,\n" ++
+            "    \"frameless\": false,\n" ++
+            "    \"transparent\": false,\n" ++
+            "    \"always_on_top\": false\n" ++
+            "  }}\n" ++
+            "}}\n",
+            .{ app_dir_name, app_dir_name }
+        );
+        defer allocator.free(json_content);
+
+        try app_dir.writeFile(io, .{ .sub_path = "nanoshell.json", .data = json_content });
+
+        // Write default HTML/CSS/JS inside app/
+        const html_content =
+            \\<!DOCTYPE html>
+            \\<html lang="en">
+            \\<head>
+            \\  <meta charset="UTF-8">
+            \\  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            \\  <title>NanoShell Application</title>
+            \\  <link rel="stylesheet" href="styles.css">
+            \\</head>
+            \\<body>
+            \\  <div class="container">
+            \\    <h1>⚡ NanoShell Desktop App</h1>
+            \\    <p>Ultra-lightweight WebKit desktop runtime</p>
+            \\    <button id="btn">Click Me</button>
+            \\  </div>
+            \\  <script src="app.js"></script>
+            \\</body>
+            \\</html>
+        ;
+        try app_dir.writeFile(io, .{ .sub_path = "app/index.html", .data = html_content });
+
+        const css_content =
+            \\body {
+            \\  margin: 0;
+            \\  font-family: system-ui, -apple-system, sans-serif;
+            \\  background: #0f172a;
+            \\  color: #f8fafc;
+            \\  display: flex;
+            \\  justify-content: center;
+            \\  align-items: center;
+            \\  height: 100vh;
+            \\}
+            \\.container {
+            \\  text-align: center;
+            \\  background: #1e293b;
+            \\  padding: 2.5rem;
+            \\  border-radius: 1rem;
+            \\  box-shadow: 0 10px 25px rgba(0,0,0,0.5);
+            \\}
+            \\button {
+            \\  background: #38bdf8;
+            \\  color: #0f172a;
+            \\  border: none;
+            \\  padding: 0.75rem 1.5rem;
+            \\  font-weight: bold;
+            \\  border-radius: 0.5rem;
+            \\  cursor: pointer;
+            \\}
+            \\button:hover { background: #7dd3fc; }
+        ;
+        try app_dir.writeFile(io, .{ .sub_path = "app/styles.css", .data = css_content });
+
+        const js_content =
+            \\document.getElementById('btn').addEventListener('click', () => {
+            \\  alert('Hello from NanoShell!');
+            \\});
+        ;
+        try app_dir.writeFile(io, .{ .sub_path = "app/app.js", .data = js_content });
+
+        // Copy prebuilt runtime binaries and DLLs into scaffolded project
+        const cwd = std.Io.Dir.cwd();
+        const exe_dst_path = try std.fmt.allocPrint(allocator, "bin/{s}.exe", .{app_dir_name});
+        defer allocator.free(exe_dst_path);
+
+        _ = cwd.copyFile("zig-out/bin/example_app.exe", app_dir, exe_dst_path, io, .{}) catch
+            cwd.copyFile("example_app.exe", app_dir, exe_dst_path, io, .{}) catch {};
+
+        _ = cwd.copyFile("zig-out/bin/AppCore.dll", app_dir, "bin/AppCore.dll", io, .{}) catch
+            cwd.copyFile("AppCore.dll", app_dir, "bin/AppCore.dll", io, .{}) catch {};
+
+        _ = cwd.copyFile("zig-out/bin/Ultralight.dll", app_dir, "bin/Ultralight.dll", io, .{}) catch
+            cwd.copyFile("Ultralight.dll", app_dir, "bin/Ultralight.dll", io, .{}) catch {};
+
+        _ = cwd.copyFile("zig-out/bin/UltralightCore.dll", app_dir, "bin/UltralightCore.dll", io, .{}) catch
+            cwd.copyFile("UltralightCore.dll", app_dir, "bin/UltralightCore.dll", io, .{}) catch {};
+
+        _ = cwd.copyFile("zig-out/bin/WebCore.dll", app_dir, "bin/WebCore.dll", io, .{}) catch
+            cwd.copyFile("WebCore.dll", app_dir, "bin/WebCore.dll", io, .{}) catch {};
+
+        _ = cwd.copyFile("vendor/resources/icudt67l.dat", app_dir, "bin/icudt67l.dat", io, .{}) catch
+            cwd.copyFile("bin/icudt67l.dat", app_dir, "bin/icudt67l.dat", io, .{}) catch {};
+
+        _ = cwd.copyFile("vendor/resources/cacert.pem", app_dir, "bin/cacert.pem", io, .{}) catch
+            cwd.copyFile("bin/cacert.pem", app_dir, "bin/cacert.pem", io, .{}) catch {};
+
+        _ = cwd.copyFile("vendor/resources/icudt67l.dat", app_dir, "bin/resources/icudt67l.dat", io, .{}) catch
+            cwd.copyFile("bin/resources/icudt67l.dat", app_dir, "bin/resources/icudt67l.dat", io, .{}) catch {};
+
+        _ = cwd.copyFile("vendor/resources/cacert.pem", app_dir, "bin/resources/cacert.pem", io, .{}) catch
+            cwd.copyFile("bin/resources/cacert.pem", app_dir, "bin/resources/cacert.pem", io, .{}) catch {};
+
+        std.log.info("=================================================================", .{});
+        std.log.info("  SUCCESS! Scaffolded new NanoShell app: .\\{s}", .{app_dir_name});
+        std.log.info("  To get started:", .{});
+        std.log.info("    cd {s}", .{app_dir_name});
+        std.log.info("    npx nanoshell package", .{});
+        std.log.info("=================================================================", .{});
+        return;
+    }
+
+    // Help banner if no command or invalid command is provided
+    std.log.info("+===================================================+", .{});
+    std.log.info("|  NanoShell CLI  v1.0.4  . by Suman Biswas         |", .{});
+    std.log.info("|  17MB RAM . 120 FPS . WebKit-powered desktop apps  |", .{});
+    std.log.info("+===================================================+", .{});
+    std.log.info("Usage:", .{});
+    std.log.info("  npx nanoshell <my-app>    Scaffold a new NanoShell app", .{});
+    std.log.info("  npx nanoshell build        Build production release binary only", .{});
+    std.log.info("  npx nanoshell start        Launch the dev engine", .{});
+    std.log.info("  npx nanoshell package      Build binary and generate Windows installer", .{});
+    std.log.info("nanoshell package:", .{});
+    std.log.info("  - Reads nanoshell.json for app name, version, author", .{});
+    std.log.info("  - Generates setup.iss (Inno Setup script)", .{});
+    std.log.info("  - Auto-compiles to dist\\AppName-Setup.exe if ISCC found", .{});
+    std.log.info("  - Installer lets user choose: Admin OR per-user install", .{});
+}

package/example_app/app.js

@@ -2,13 +2,14 @@
 
 console.log("[ZeroUI App] Initializing Showcase Application...");
 
-// 1. Query Native System Metrics via ZeroUI Native OS Bridge
+// 1. Query Native System Metrics via NanoShell / ZeroUI Native OS Bridge
 function refreshSystemStats() {
-  if (typeof ZeroUI !== "undefined" && ZeroUI.sys) {
-    const mem = ZeroUI.sys.getMemoryStats();
-    const cpu = ZeroUI.sys.getCpuStats();
+  const ns = (typeof NanoShell !== "undefined") ? NanoShell : ((typeof ZeroUI !== "undefined") ? ZeroUI : null);
+  if (ns && ns.sys) {
+    const mem = ns.sys.getMemoryStats();
+    const cpu = ns.sys.getCpuStats();
 
-    console.log(`[ZeroUI Sys] Arch: ${cpu.arch}, Cores: ${cpu.logical_cores}, RSS: ${(mem.total_rss_bytes / 1024).toFixed(1)} KB`);
+    console.log(`[NanoShell Sys] Arch: ${cpu.arch}, Cores: ${cpu.logical_cores}, RSS: ${(mem.total_rss_bytes / 1024).toFixed(1)} KB`);
 
     const ramEl = document.getElementById("val-ram");
     if (ramEl) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nanoshell",
-  "version": "1.0.9",
+  "version": "1.1.5",
   "description": "Hyper-lightweight 17MB RAM, 120 FPS native desktop application framework & runtime engine created by Suman Biswas",
   "main": "zig-out/bin/example_app.exe",
   "bin": {
@@ -9,7 +9,7 @@
   },
   "readme": "README.md",
   "files": [
-    "cli/index.js",
+    "cli/",
     "zig-out/bin/*.exe",
     "zig-out/bin/*.dll",
     "vendor/bin/",