windowpp 0.1.1

package/framework/src/FileSystem/API/FileSystem.ts

@@ -0,0 +1,389 @@
+// ============================================================================
+//  FileSystem.ts — WindowPP FileSystem API
+//
+//  Frontend (TypeScript) side of the cross-platform file-system bridge.
+//
+//  All calls are async and resolve/reject against the same __response__
+//  callback used by every other WindowPP bridge module.
+//
+//  Methods surfaced:
+//    fs.readFile(path)                   → string   (UTF-8 text)
+//    fs.readBinaryFile(path)             → Uint8Array
+//    fs.writeFile(path, text)            → void
+//    fs.writeBinaryFile(path, data)      → void
+//    fs.appendFile(path, text)           → void
+//    fs.copyFile(src, dest)              → void
+//    fs.moveFile(src, dest)              → void
+//    fs.deleteFile(path)                 → void
+//    fs.openPath(path)                   → void
+//    fs.revealPath(path)                 → void
+//    fs.listApplications()               → ApplicationEntry[]
+//    fs.launchApplication(target)        → void
+//    fs.exists(path)                     → boolean
+//    fs.stat(path)                       → FileStat
+//    fs.readDir(path)                    → DirEntry[]
+//    fs.createDir(path, recursive?)      → void
+//    fs.removeDir(path, recursive?)      → void
+//    fs.searchFiles(dir, pattern, opts?) → string[]
+// ============================================================================
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface FileStat {
+  /** Full path */
+  path: string;
+  /** File name with extension */
+  name: string;
+  /** Size in bytes */
+  size: number;
+  /** True when this entry is a directory */
+  isDir: boolean;
+  /** True when this entry is a symlink */
+  isSymlink: boolean;
+  /** Last-modified timestamp (ms since Unix epoch) */
+  modifiedMs: number;
+  /** Created-at timestamp (ms since Unix epoch); −1 if unsupported */
+  createdMs: number;
+  /** POSIX permission bits, e.g. 0o644; −1 on Windows */
+  mode: number;
+}
+
+export interface DirEntry {
+  name: string;
+  path: string;
+  isDir: boolean;
+  isSymlink: boolean;
+}
+
+export interface ApplicationEntry {
+  id: string;
+  name: string;
+  path: string;
+  launchTarget: string;
+}
+
+export interface SearchOptions {
+  /** Match filenames with glob patterns, e.g. "*.ts". Default: "*" */
+  pattern?: string;
+  /** Recurse into sub-directories. Default: false */
+  recursive?: boolean;
+  /** Include hidden files/dirs (name starts with "."). Default: false */
+  includeHidden?: boolean;
+  /** Include matching directories in results. Default: false */
+  includeDirectories?: boolean;
+  /** Maximum results to return. 0 = unlimited. Default: 0 */
+  maxResults?: number;
+}
+
+export interface SearchStreamSummary {
+  scannedEntries: number;
+  matchedEntries: number;
+  cancelled: boolean;
+  truncated: boolean;
+  error: string;
+}
+
+export interface SearchStreamCallbacks {
+  onBatch?: (results: string[]) => void;
+  onDone?: (summary: SearchStreamSummary) => void;
+}
+
+export interface SearchStreamHandle {
+  id: string;
+  cancel: () => Promise<void>;
+}
+
+// ─── Internal bridge helpers ─────────────────────────────────────────────────
+
+interface PendingCall {
+  resolve: (value: any) => void;
+  reject: (reason: Error) => void;
+}
+
+let _callId = 0;
+let _searchStreamId = 0;
+const _pending = new Map<string, PendingCall>();
+
+function _getGlobal(): any {
+  if (typeof window !== "undefined") return window;
+  if (typeof globalThis !== "undefined") return globalThis;
+  return {};
+}
+
+const _g = _getGlobal();
+const _streams = new Map<string, SearchStreamCallbacks>();
+
+// Hook into the shared __response__ dispatcher (same one used by filedrop, etc.)
+const _prevResponse = _g.__response__;
+_g.__response__ = function (id: string, result: any, error?: string) {
+  const p = _pending.get(id);
+  if (p) {
+    _pending.delete(id);
+    if (error) {
+      p.reject(new Error(error));
+    } else {
+      p.resolve(result);
+    }
+    return;
+  }
+  // Fall through to any previously registered handler.
+  if (_prevResponse) _prevResponse(id, result, error);
+};
+
+function _invoke<T>(method: string, params: unknown[] = []): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const id = String(++_callId);
+    _pending.set(id, { resolve, reject });
+    const payload = JSON.stringify({ id, method, params });
+
+    if (_g.__native_invoke__) {
+      _g.__native_invoke__(payload);
+    } else if (_g.chrome?.webview?.postMessage) {
+      _g.chrome.webview.postMessage(payload);
+    } else {
+      _pending.delete(id);
+      console.warn("[WindowPP/fs] Native bridge not available");
+      reject(new Error("Native bridge not available"));
+    }
+  });
+}
+
+_g.__wpp_fs_stream__ = function (searchId: string, eventName: string, payload: any) {
+  const stream = _streams.get(searchId);
+  if (!stream) return;
+
+  if (eventName === 'batch') {
+    stream.onBatch?.(Array.isArray(payload) ? payload : []);
+    return;
+  }
+
+  if (eventName === 'done') {
+    _streams.delete(searchId);
+    stream.onDone?.(payload as SearchStreamSummary);
+  }
+};
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Read a file as UTF-8 text.
+ * @param path Absolute path to the file.
+ */
+export function readFile(path: string): Promise<string> {
+  return _invoke<string>("fs:readFile", [path]);
+}
+
+/**
+ * Read a file as raw bytes.
+ * The native side returns a Base64 string which is decoded here.
+ * @param path Absolute path to the file.
+ */
+export async function readBinaryFile(path: string): Promise<Uint8Array> {
+  const b64 = await _invoke<string>("fs:readBinaryFile", [path]);
+  return _b64ToBytes(b64);
+}
+
+/**
+ * Write UTF-8 text to a file, creating or overwriting it.
+ * @param path    Absolute destination path.
+ * @param content Text to write.
+ */
+export function writeFile(path: string, content: string): Promise<void> {
+  return _invoke<void>("fs:writeFile", [path, content]);
+}
+
+/**
+ * Write raw bytes to a file, creating or overwriting it.
+ * @param path Absolute destination path.
+ * @param data Bytes to write.
+ */
+export function writeBinaryFile(path: string, data: Uint8Array): Promise<void> {
+  return _invoke<void>("fs:writeBinaryFile", [path, _bytesToB64(data)]);
+}
+
+/**
+ * Append UTF-8 text to a file (creates the file if it does not exist).
+ * @param path    Absolute destination path.
+ * @param content Text to append.
+ */
+export function appendFile(path: string, content: string): Promise<void> {
+  return _invoke<void>("fs:appendFile", [path, content]);
+}
+
+/**
+ * Copy a file.
+ * @param src  Source path.
+ * @param dest Destination path. Overwrites if it already exists.
+ */
+export function copyFile(src: string, dest: string): Promise<void> {
+  return _invoke<void>("fs:copyFile", [src, dest]);
+}
+
+/**
+ * Move (rename) a file or directory.
+ * @param src  Source path.
+ * @param dest Destination path.
+ */
+export function moveFile(src: string, dest: string): Promise<void> {
+  return _invoke<void>("fs:moveFile", [src, dest]);
+}
+
+/**
+ * Delete a file.
+ * @param path Absolute path to the file.
+ */
+export function deleteFile(path: string): Promise<void> {
+  return _invoke<void>("fs:deleteFile", [path]);
+}
+
+/**
+ * Open a file with the default app, or open a directory in the OS file manager.
+ * @param path Absolute path to a file or directory.
+ */
+export function openPath(path: string): Promise<void> {
+  return _invoke<void>("fs:openPath", [path]);
+}
+
+/**
+ * Reveal a file or directory in the OS file manager.
+ * @param path Absolute path to a file or directory.
+ */
+export function revealPath(path: string): Promise<void> {
+  return _invoke<void>("fs:revealPath", [path]);
+}
+
+/**
+ * List installed applications discoverable on the current OS.
+ */
+export function listApplications(): Promise<ApplicationEntry[]> {
+  return _invoke<ApplicationEntry[]>("fs:listApplications");
+}
+
+/**
+ * Launch an installed application using its platform-specific target.
+ */
+export function launchApplication(target: string): Promise<void> {
+  return _invoke<void>("fs:launchApplication", [target]);
+}
+
+/**
+ * Check whether a path exists (file or directory).
+ * @param path Absolute path to test.
+ */
+export function exists(path: string): Promise<boolean> {
+  return _invoke<boolean>("fs:exists", [path]);
+}
+
+/**
+ * Retrieve metadata for a file or directory.
+ * @param path Absolute path.
+ */
+export function stat(path: string): Promise<FileStat> {
+  return _invoke<FileStat>("fs:stat", [path]);
+}
+
+/**
+ * List the entries in a directory (non-recursive).
+ * @param path Absolute path to the directory.
+ */
+export function readDir(path: string): Promise<DirEntry[]> {
+  return _invoke<DirEntry[]>("fs:readDir", [path]);
+}
+
+/**
+ * Create a directory.
+ * @param path      Absolute path of the directory to create.
+ * @param recursive Create parent directories as needed. Default: false.
+ */
+export function createDir(path: string, recursive = false): Promise<void> {
+  return _invoke<void>("fs:createDir", [path, recursive]);
+}
+
+/**
+ * Remove a directory.
+ * @param path      Absolute path of the directory to remove.
+ * @param recursive Remove contents recursively. Default: false.
+ */
+export function removeDir(path: string, recursive = false): Promise<void> {
+  return _invoke<void>("fs:removeDir", [path, recursive]);
+}
+
+/**
+ * Search for files under a directory.
+ * @param dir     Root directory to search in.
+ * @param options Search options (pattern, recursive, etc.).
+ */
+export function searchFiles(
+  dir: string,
+  options: SearchOptions = {}
+): Promise<string[]> {
+  return _invoke<string[]>("fs:searchFiles", [dir, options]);
+}
+
+export function listRoots(): Promise<string[]> {
+  return _invoke<string[]>("fs:listRoots");
+}
+
+export async function searchFilesStream(
+  roots: string | string[],
+  options: SearchOptions = {},
+  callbacks: SearchStreamCallbacks = {}
+): Promise<SearchStreamHandle> {
+  const normalizedRoots = Array.isArray(roots) ? roots : [roots];
+  const id = `fs-stream-${++_searchStreamId}`;
+  _streams.set(id, callbacks);
+  await _invoke<string>("fs:searchFilesStreamStart", [normalizedRoots, options, id]);
+  return {
+    id,
+    cancel: async () => {
+      _streams.delete(id);
+      await _invoke<void>("fs:searchFilesStreamCancel", [id]);
+    },
+  };
+}
+
+// ─── Default export ───────────────────────────────────────────────────────────
+
+const fs = {
+  readFile,
+  readBinaryFile,
+  writeFile,
+  writeBinaryFile,
+  appendFile,
+  copyFile,
+  moveFile,
+  deleteFile,
+  openPath,
+  revealPath,
+  listApplications,
+  launchApplication,
+  exists,
+  stat,
+  readDir,
+  createDir,
+  removeDir,
+  listRoots,
+  searchFiles,
+  searchFilesStream,
+};
+
+export default fs;
+
+// ─── Base64 helpers (no dependencies) ────────────────────────────────────────
+
+function _bytesToB64(bytes: Uint8Array): string {
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+function _b64ToBytes(b64: string): Uint8Array {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}

package/framework/src/FileSystem/Linux/filesearch.cpp

@@ -0,0 +1,148 @@
+// ============================================================================
+//  FileSystem/Linux/filesearch.cpp
+//  Handles:  fs:exists, fs:stat, fs:readDir, fs:searchFiles
+// ============================================================================
+
+#include <dirent.h>
+#include <fnmatch.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../filesystem_handler.h"
+
+namespace wpp::fs {
+
+// ─── fs:exists ───────────────────────────────────────────────────────────────
+
+bool handleExists(const std::string& path) {
+    struct stat st{};
+    return stat(path.c_str(), &st) == 0;
+}
+
+// ─── fs:stat ─────────────────────────────────────────────────────────────────
+
+FileStat handleStat(const std::string& path) {
+    struct stat st{};
+    if (::stat(path.c_str(), &st) != 0)
+        throw std::runtime_error("stat failed for '" + path + "': " +
+                                 std::string(strerror(errno)));
+
+    std::string name = path;
+    auto slash = path.rfind('/');
+    if (slash != std::string::npos) name = path.substr(slash + 1);
+
+    bool isDir  = S_ISDIR(st.st_mode);
+    bool isLink = S_ISLNK(st.st_mode);
+
+    // Linux: use st_mtim / st_ctim (POSIX.1-2008)
+    int64_t modifiedMs = static_cast<int64_t>(st.st_mtim.tv_sec) * 1000 +
+                         st.st_mtim.tv_nsec / 1000000;
+    // Linux does not expose birthtime in struct stat; return -1
+    int64_t createdMs = -1;
+
+    return FileStat{
+        path,
+        name,
+        static_cast<int64_t>(st.st_size),
+        isDir,
+        isLink,
+        modifiedMs,
+        createdMs,
+        static_cast<int>(st.st_mode & 0777)
+    };
+}
+
+// ─── fs:readDir ──────────────────────────────────────────────────────────────
+
+std::vector<DirEntry> handleReadDir(const std::string& path) {
+    DIR* dir = opendir(path.c_str());
+    if (!dir)
+        throw std::runtime_error("readDir failed for '" + path + "': " +
+                                 std::string(strerror(errno)));
+
+    std::vector<DirEntry> entries;
+    struct dirent* ent;
+    while ((ent = readdir(dir)) != nullptr) {
+        std::string name = ent->d_name;
+        if (name == "." || name == "..") continue;
+        std::string full = path + "/" + name;
+        bool isDir  = ent->d_type == DT_DIR;
+        bool isLink = ent->d_type == DT_LNK;
+        if (ent->d_type == DT_UNKNOWN) {
+            struct stat st{};
+            ::stat(full.c_str(), &st);
+            isDir  = S_ISDIR(st.st_mode);
+            isLink = S_ISLNK(st.st_mode);
+        }
+        entries.push_back(DirEntry{name, full, isDir, isLink});
+    }
+    closedir(dir);
+    return entries;
+}
+
+std::vector<std::string> handleListRoots() {
+    return {"/"};
+}
+
+// ─── fs:searchFiles ──────────────────────────────────────────────────────────
+
+static void searchRecursive(const std::string& dir,
+                             const std::string& pattern,
+                             bool recursive,
+                             bool includeHidden,
+                             bool includeDirectories,
+                             size_t maxResults,
+                             std::vector<std::string>& results) {
+    if (maxResults > 0 && results.size() >= maxResults) return;
+
+    DIR* d = opendir(dir.c_str());
+    if (!d) return;
+
+    struct dirent* ent;
+    while ((ent = readdir(d)) != nullptr) {
+        if (maxResults > 0 && results.size() >= maxResults) break;
+        std::string name = ent->d_name;
+        if (name == "." || name == "..") continue;
+        bool hidden = (!name.empty() && name[0] == '.');
+        if (hidden && !includeHidden) continue;
+
+        std::string full = dir + "/" + name;
+        bool isDir = ent->d_type == DT_DIR;
+        if (ent->d_type == DT_UNKNOWN) {
+            struct stat st{};
+            ::stat(full.c_str(), &st);
+            isDir = S_ISDIR(st.st_mode);
+        }
+
+        if (isDir) {
+            if (includeDirectories && fnmatch(pattern.c_str(), name.c_str(), 0) == 0)
+                results.push_back(full);
+            if (recursive) {
+                searchRecursive(full, pattern, recursive,
+                                includeHidden, includeDirectories, maxResults, results);
+            }
+        } else {
+            if (fnmatch(pattern.c_str(), name.c_str(), 0) == 0)
+                results.push_back(full);
+        }
+    }
+    closedir(d);
+}
+
+std::vector<std::string> handleSearchFiles(const std::string& dir,
+                                           const SearchOptions& opts) {
+    std::string pat = opts.pattern.empty() ? "*" : opts.pattern;
+    std::vector<std::string> results;
+    searchRecursive(dir, pat, opts.recursive, opts.includeHidden,
+                    opts.includeDirectories,
+                    opts.maxResults, results);
+    return results;
+}
+
+} // namespace wpp::fs

package/framework/src/FileSystem/Linux/readfile.cpp

@@ -0,0 +1,79 @@
+// ============================================================================
+//  FileSystem/Linux/readfile.cpp
+//  Handles:  fs:readFile, fs:readBinaryFile
+// ============================================================================
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../filesystem_handler.h"
+
+namespace wpp::fs {
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+static const std::string kB64Chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static std::string base64Encode(const std::vector<uint8_t>& bytes) {
+    std::string out;
+    out.reserve(((bytes.size() + 2) / 3) * 4);
+    size_t i = 0;
+    for (; i + 2 < bytes.size(); i += 3) {
+        uint32_t v = (bytes[i] << 16) | (bytes[i+1] << 8) | bytes[i+2];
+        out += kB64Chars[(v >> 18) & 0x3F];
+        out += kB64Chars[(v >> 12) & 0x3F];
+        out += kB64Chars[(v >>  6) & 0x3F];
+        out += kB64Chars[(v      ) & 0x3F];
+    }
+    if (i < bytes.size()) {
+        uint32_t v = bytes[i] << 16;
+        if (i + 1 < bytes.size()) v |= bytes[i+1] << 8;
+        out += kB64Chars[(v >> 18) & 0x3F];
+        out += kB64Chars[(v >> 12) & 0x3F];
+        out += (i + 1 < bytes.size()) ? kB64Chars[(v >> 6) & 0x3F] : '=';
+        out += '=';
+    }
+    return out;
+}
+
+static std::vector<uint8_t> readAllBytes(const std::string& path) {
+    int fd = open(path.c_str(), O_RDONLY);
+    if (fd < 0)
+        throw std::runtime_error("Cannot open '" + path + "': " +
+                                 std::string(strerror(errno)));
+    struct stat st{};
+    if (fstat(fd, &st) < 0) {
+        close(fd);
+        throw std::runtime_error("stat failed for '" + path + "'");
+    }
+    std::vector<uint8_t> buf(static_cast<size_t>(st.st_size));
+    ssize_t n = read(fd, buf.data(), buf.size());
+    close(fd);
+    if (n < 0)
+        throw std::runtime_error("Read failed for '" + path + "'");
+    buf.resize(static_cast<size_t>(n));
+    return buf;
+}
+
+// ─── fs:readFile ─────────────────────────────────────────────────────────────
+
+std::string handleReadFile(const std::string& path) {
+    auto bytes = readAllBytes(path);
+    return std::string(bytes.begin(), bytes.end());
+}
+
+// ─── fs:readBinaryFile ───────────────────────────────────────────────────────
+
+std::string handleReadBinaryFile(const std::string& path) {
+    return base64Encode(readAllBytes(path));
+}
+
+} // namespace wpp::fs