nanoshell 1.2.1 → 1.3.5

package/README.md

@@ -136,3 +136,5 @@ NanoShell includes a built-in AI Agent Skill definition (`SKILL.md`). Any AI cod
 **Created & Engineered by Suman Biswas**
 
 MIT License © Suman Biswas (NanoShell Creator)
+"# nanoshell" 
+# nanoshell

package/cli/bundler.zig

@@ -21,9 +21,60 @@ pub const SingleBinaryBundler = struct {
         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 });
+        const io = std.Io.Threaded.global_single_threaded.io();
+        _ = std.Io.Dir.cwd().createDir(io, self.config.output_dir, .default_dir) catch {};
 
-        std.log.info("Built Custom Named Executable -> '{s}' (3.00 MB, 17MB RAM Native Engine)", .{exe_name});
+        var dist_dir = std.Io.Dir.cwd().openDir(io, self.config.output_dir, .{}) catch |err| {
+            std.log.err("Failed to open output dir: {s}", .{@errorName(err)});
+            return err;
+        };
+
+        _ = dist_dir.createDir(io, "app", .default_dir) catch {};
+        _ = dist_dir.createDir(io, "resources", .default_dir) catch {};
+
+        const cwd = std.Io.Dir.cwd();
+
+        // Copy Main Executable bin/<app_name>.exe -> dist/<app_name>.exe
+        const src_exe_path = try std.fmt.allocPrint(self.allocator, "bin/{s}.exe", .{self.config.app_name});
+        defer self.allocator.free(src_exe_path);
+        const dst_exe_path = try std.fmt.allocPrint(self.allocator, "{s}/{s}.exe", .{ self.config.output_dir, self.config.app_name });
+        defer self.allocator.free(dst_exe_path);
+
+        _ = cwd.copyFile(src_exe_path, dist_dir, try std.fmt.allocPrint(self.allocator, "{s}.exe", .{self.config.app_name}), io, .{}) catch |err| {
+            std.log.warn("Executable copy warning: {s}", .{@errorName(err)});
+        };
+
+        // Copy DLLs
+        const dlls = [_][]const u8{ "AppCore.dll", "Ultralight.dll", "UltralightCore.dll", "WebCore.dll", "vcruntime140.dll", "msvcp140.dll", "vcruntime140_1.dll" };
+        for (dlls) |dll| {
+            const src_dll = try std.fmt.allocPrint(self.allocator, "bin/{s}", .{dll});
+            defer self.allocator.free(src_dll);
+            _ = cwd.copyFile(src_dll, dist_dir, dll, io, .{}) catch {};
+        }
+
+        // Copy Resource Files
+        const res_files = [_][]const u8{ "icudt67l.dat", "cacert.pem" };
+        for (res_files) |file| {
+            const src_res = try std.fmt.allocPrint(self.allocator, "bin/{s}", .{file});
+            defer self.allocator.free(src_res);
+            _ = cwd.copyFile(src_res, dist_dir, file, io, .{}) catch {};
+            _ = cwd.copyFile(src_res, dist_dir, try std.fmt.allocPrint(self.allocator, "resources/{s}", .{file}), io, .{}) catch {};
+        }
+
+        // Copy app/* files to dist/app/*
+        var app_dir_opt = cwd.openDir(io, "app", .{ .iterate = true }) catch null;
+        if (app_dir_opt) |*app_dir| {
+            var dist_app_dir = dist_dir.openDir(io, "app", .{}) catch null;
+            if (dist_app_dir) |*dst_app| {
+                var iter = app_dir.iterate();
+                while (iter.next(io) catch null) |entry| {
+                    if (entry.kind == .file) {
+                        _ = app_dir.copyFile(entry.name, dst_app.*, entry.name, io, .{}) catch {};
+                    }
+                }
+            }
+        }
+
+        std.log.info("Built Custom Named Executable -> '{s}' (Self-contained release package)", .{dst_exe_path});
     }
 };

package/cli/dev_server.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const installer = @import("installer.zig");
 
 pub const DevServer = struct {
     allocator: std.mem.Allocator,
@@ -8,14 +9,184 @@ pub const DevServer = struct {
     }
 
     pub fn runDevMode(self: *DevServer, app_dir_name: []const u8) !void {
+        _ = app_dir_name;
         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("  ⚡ NanoShell Dev Server Started", .{});
+        std.log.info("  Watching app/ directory & nanoshell.json for live 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);
+        var config = installer.loadConfig(self.allocator) catch installer.AppConfig{};
+        defer config.deinit(self.allocator);
 
-        std.log.info("Dev Server active for '{s}'. File watcher operational.", .{exe_path});
+        // Find executable inside bin/ or zig-out/bin/
+        const io = std.Io.Threaded.global_single_threaded.io();
+        const cwd = std.Io.Dir.cwd();
+
+        var found_exe: ?[]const u8 = null;
+
+        const candidate_paths = [_][]const u8{
+            "zig-out/bin/example_app.exe",
+            "bin/example_app.exe",
+            "zig-out/bin/nanoshell.exe",
+        };
+
+        for (candidate_paths) |p| {
+            if (cwd.openFile(io, p, .{})) |f| {
+                f.close(io);
+                found_exe = p;
+                break;
+            } else |_| {}
+        }
+
+        if (found_exe == null) {
+            // Search bin/ for any .exe
+            var bin_dir = cwd.openDir(io, "bin", .{ .iterate = true }) catch null;
+            if (bin_dir) |*d| {
+                defer d.close(io);
+                var iter = d.iterate();
+                while (iter.next(io) catch null) |entry| {
+                    if (entry.kind == .file and std.mem.endsWith(u8, entry.name, ".exe")) {
+                        found_exe = try std.fmt.allocPrint(self.allocator, "bin/{s}", .{entry.name});
+                        break;
+                    }
+                }
+            }
+        }
+
+        var win_exe_buf: [256]u8 = undefined;
+        const exe_to_run = found_exe orelse "bin\\app.exe";
+        var pos: usize = 0;
+        for (exe_to_run) |ch| {
+            if (ch == '/') {
+                win_exe_buf[pos] = '\\';
+            } else {
+                win_exe_buf[pos] = ch;
+            }
+            pos += 1;
+        }
+        win_exe_buf[pos] = 0;
+        const win_path = win_exe_buf[0..pos];
+
+        var dev_cmd_buf: [300]u8 = undefined;
+        const dev_cmd = std.fmt.bufPrintZ(&dev_cmd_buf, "{s} --dev", .{win_path}) catch win_path;
+
+        std.log.info("Launching NanoShell runtime in DEV mode: {s}", .{dev_cmd});
+
+        // Launch app process once - native engine handles smooth in-window hot reload in dev mode
+        var child = try self.spawnChildProcess(dev_cmd);
+        defer _ = child.kill();
+
+        std.log.info("App running! In-window hot reload active for app/index.html, styles.css, app.js.", .{});
+
+        const WinApi = struct {
+            pub extern "kernel32" fn Sleep(dwMilliseconds: u32) callconv(.winapi) void;
+            pub extern "kernel32" fn GetExitCodeProcess(hProcess: std.os.windows.HANDLE, lpExitCode: *u32) callconv(.winapi) i32;
+        };
+
+        var exit_code: u32 = 259; // STILL_ACTIVE
+        while (exit_code == 259) {
+            WinApi.Sleep(500);
+            _ = WinApi.GetExitCodeProcess(child.hProcess, &exit_code);
+        }
+    }
+
+    fn spawnChildProcess(self: *DevServer, exe_path: []const u8) !ChildProcess {
+        _ = self;
+        var cmd_utf16: [1024]u16 = undefined;
+        const len = try std.unicode.utf8ToUtf16Le(&cmd_utf16, exe_path);
+        cmd_utf16[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 TerminateProcess(hProcess: std.os.windows.HANDLE, uExitCode: u32) callconv(.winapi) i32;
+            pub extern "kernel32" fn CloseHandle(hObject: std.os.windows.HANDLE) 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) return error.ProcessCreationFailed;
+
+        return ChildProcess{
+            .hProcess = pi.hProcess,
+            .hThread = pi.hThread,
+        };
+    }
+
+    fn getAppModTime(self: *DevServer) i128 {
+        _ = self;
+        const io = std.Io.Threaded.global_single_threaded.io();
+        const cwd = std.Io.Dir.cwd();
+        var max_mtime: i128 = 0;
+
+        var app_dir = cwd.openDir(io, "app", .{ .iterate = true }) catch return 0;
+        defer app_dir.close(io);
+
+        var iter = app_dir.iterate();
+        while (iter.next(io) catch null) |entry| {
+            if (entry.kind == .file) {
+                if (app_dir.statFile(io, entry.name, .{})) |st| {
+                    const ns = st.mtime.toNanoseconds();
+                    if (ns > max_mtime) max_mtime = ns;
+                } else |_| {}
+            }
+        }
+        return max_mtime;
+    }
+};
+
+pub const ChildProcess = struct {
+    hProcess: std.os.windows.HANDLE,
+    hThread: std.os.windows.HANDLE,
+
+    pub fn kill(self: *ChildProcess) void {
+        const WinApi = struct {
+            pub extern "kernel32" fn TerminateProcess(hProcess: std.os.windows.HANDLE, uExitCode: u32) callconv(.winapi) i32;
+            pub extern "kernel32" fn CloseHandle(hObject: std.os.windows.HANDLE) callconv(.winapi) i32;
+        };
+        _ = WinApi.TerminateProcess(self.hProcess, 1);
+        _ = WinApi.CloseHandle(self.hProcess);
+        _ = WinApi.CloseHandle(self.hThread);
     }
 };

package/cli/installer.zig

@@ -193,9 +193,9 @@ pub fn generateIss(allocator: std.mem.Allocator, config: AppConfig) ![]const u8
         \\Source: "bin\Ultralight.dll";     DestDir: "{{app}}"; Flags: ignoreversion
         \\Source: "bin\UltralightCore.dll"; DestDir: "{{app}}"; Flags: ignoreversion
         \\Source: "bin\WebCore.dll";        DestDir: "{{app}}"; Flags: ignoreversion
-        \\Source: "bin\vcruntime140.dll";   DestDir: "{{app}}"; Flags: ignoreversion skipifdoesntexist
-        \\Source: "bin\msvcp140.dll";       DestDir: "{{app}}"; Flags: ignoreversion skipifdoesntexist
-        \\Source: "bin\vcruntime140_1.dll"; DestDir: "{{app}}"; Flags: ignoreversion skipifdoesntexist
+        \\Source: "bin\vcruntime140.dll";   DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\msvcp140.dll";       DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
+        \\Source: "bin\vcruntime140_1.dll"; DestDir: "{{app}}"; Flags: ignoreversion skipifsourcedoesntexist
         \\
         \\; ICU Unicode data and TLS certs
         \\Source: "bin\icudt67l.dat"; DestDir: "{{app}}"; Flags: ignoreversion
@@ -349,4 +349,4 @@ pub fn run(allocator: std.mem.Allocator) !void {
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nanoshell",
-  "version": "1.2.1",
+  "version": "1.3.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": {