@owear/linux-x64-gnu 0.1.0

package/include/ow/Window.h

@@ -0,0 +1,112 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+//
+// ow/Window.h — ventanas multiplataforma con titlebar custom/overlay.
+// Contrato compartido: window_win.cpp / window_mac.mm / window_linux.cpp
+//
+
+#include "ow/Common.h"
+
+namespace ow {
+
+enum class TitleBarStyle {
+    Default,   // decoraciones del sistema tal cual
+    Hidden,    // sin titlebar; la ventana completa es contenido (frameless)
+    Custom     // titlebar custom + botones nativos overlay (donde el SO lo permite)
+};
+
+struct TitleBarOverlay {
+    bool enabled = false;
+    std::string color = "#00000000";       // fondo bajo los botones nativos
+    std::string symbolColor = "#ffffff";   // color de glifos (min/max/close)
+    int height = 36;                       // alto en px lógicos
+};
+
+struct WindowOptions {
+    std::string title = "Owear";
+    int width = 1024;
+    int height = 768;
+    int minWidth = 0, minHeight = 0;
+    int maxWidth = 0, maxHeight = 0;
+    bool resizable = true;
+    bool center = true;
+    bool show = true;
+    bool frameless = false;
+
+    TitleBarStyle titleBarStyle = TitleBarStyle::Default;
+    TitleBarOverlay titleBarOverlay;
+
+    /// URL inicial: http(s):// (dev server), app://<bundle>/... o file://
+    std::string url = "app://index.html";
+
+    /// Argumentos extra para el proceso del WebView (debug flags, etc).
+    std::vector<std::string> webviewArgs;
+};
+
+/// Payload de evento como JSON serializado ("null" si el evento no lleva datos).
+using EventPayload = std::string_view;
+using ListenerId = uint64_t;
+
+class Window : NonCopyable {
+public:
+    explicit Window(const WindowOptions& options);
+    ~Window();
+
+    WindowId Id() const;
+
+    // ── ciclo de vida ──────────────────────────────────────────────
+    void Show();
+    void Hide();
+    void Close();          // dispara closeRequested; puede ser vetado por listeners
+    void Destroy();        // cierre inmediato sin veto
+    void Focus();
+
+    // ── estado ─────────────────────────────────────────────────────
+    void Minimize();
+    void Maximize();
+    void Unmaximize();
+    void Restore();
+    void SetFullScreen(bool enabled);
+    bool IsMaximized() const;
+    bool IsMinimized() const;
+    bool IsFullScreen() const;
+
+    // ── geometría ──────────────────────────────────────────────────
+    struct Bounds { int x = 0, y = 0, w = 0, h = 0; };
+    Bounds GetBounds() const;
+    void SetBounds(const Bounds&);
+    void Center();
+
+    // ── apariencia / titlebar ───────────────────────────────────────
+    void SetTitle(const std::string& title);
+    std::string Title() const;
+    void SetTitleBarStyle(TitleBarStyle style);
+    void SetTitleBarOverlay(const TitleBarOverlay& overlay);
+
+    // ── webview ────────────────────────────────────────────────────
+    void LoadURL(const std::string& url);
+    /// Evalúa JS en la página. callback recibe el resultado JSON o null.
+    void EvalJS(const std::string& js,
+                std::function<void(std::string_view resultJson)> callback = nullptr);
+
+    // ── eventos hacia JS (bridge) y C++ ─────────────────────────────
+    /// Emite un evento a todos los suscriptores JS de esta ventana.
+    void EmitToJS(const std::string& name, std::string_view jsonPayload);
+    /// Suscriptor nativo. Los eventos nativos se reenvían a JS automáticamente.
+    ListenerId On(const std::string& name, std::function<void(EventPayload)> cb);
+    void Off(ListenerId id);
+
+    /// Referencia cruda al backend de plataforma (solo para src/ interno).
+    void* NativeHandle() const;
+
+    /// Detrás de este puntero vive el estado de plataforma.
+    class Impl;  // definido en src/Window/Window_p.hpp
+    std::unique_ptr<Impl> impl_;
+
+  public:
+    /// Interno (ControlServer): respuesta del SDK al closeRequested.
+    class Impl* impl() { return impl_.get(); }
+};
+
+} // namespace ow

package/include/ow/detail/minjson.hpp

@@ -0,0 +1,419 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// ow/detail/minjson.hpp — JSON minimalista, header-only, sin excepciones.
+// Usado por el kernel (bridge/control) y disponible para módulos vía ow/Json.h.
+//
+// Diseño: Value inmutable tras parse; objetos preservan orden de inserción.
+//
+
+#pragma once
+
+#include <cstdint>
+#include <cmath>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <utility>
+#include <optional>
+
+namespace ow::json {
+
+class Value;
+using Array  = std::vector<Value>;
+using Member = std::pair<std::string, Value>;
+using Object = std::vector<Member>;
+
+enum class Type : uint8_t { Null, Bool, Int, Double, String, ArrayT, ObjectT };
+
+class Value {
+public:
+    Value() : type_(Type::Null) {}
+    Value(std::nullptr_t) : type_(Type::Null) {}
+    Value(bool b) : type_(Type::Bool), bool_(b) {}
+    Value(int v) : type_(Type::Int), int_(v) {}
+    Value(int64_t v) : type_(Type::Int), int_(v) {}
+    Value(uint32_t v) : type_(Type::Int), int_(v) {}
+    Value(double v) : type_(IsIntegral(v) ? Type::Int : Type::Double),
+                      int_(static_cast<int64_t>(v)) {}
+    Value(const char* s) : type_(Type::String), str_(s) {}
+    Value(std::string s) : type_(Type::String), str_(std::move(s)) {}
+    Value(Array a) : type_(Type::ArrayT), arr_(std::move(a)) {}
+    Value(Object o) : type_(Type::ObjectT), obj_(std::move(o)) {}
+
+    Type GetType() const { return type_; }
+    bool IsNull()   const { return type_ == Type::Null; }
+    bool IsBool()   const { return type_ == Type::Bool; }
+    bool IsNumber() const { return type_ == Type::Int || type_ == Type::Double; }
+    bool IsString() const { return type_ == Type::String; }
+    bool IsArray()  const { return type_ == Type::ArrayT; }
+    bool IsObject() const { return type_ == Type::ObjectT; }
+
+    bool        AsBool(bool def = false) const { return IsBool() ? bool_ : def; }
+    int64_t     AsInt(int64_t def = 0) const {
+        if (type_ == Type::Int) return int_;
+        if (type_ == Type::Double) return static_cast<int64_t>(dbl_);
+        return def;
+    }
+    double      AsDouble(double def = 0) const {
+        if (type_ == Type::Double) return dbl_;
+        if (type_ == Type::Int) return static_cast<double>(int_);
+        return def;
+    }
+    const std::string& AsString() const { return str_; }
+
+    const Array&  AsArray()  const { return arr_; }
+    const Object& AsObject() const { return obj_; }
+
+    /// Acceso a miembro de objeto. nullptr si no existe o no es objeto.
+    const Value* Find(std::string_view key) const {
+        if (type_ != Type::ObjectT) return nullptr;
+        for (const auto& m : obj_)
+            if (m.first == key) return &m.second;
+        return nullptr;
+    }
+
+    std::string Serialize() const {
+        std::string out;
+        out.reserve(64);
+        Write(out);
+        return out;
+    }
+
+private:
+    static bool IsIntegral(double v) {
+        return std::isfinite(v) && v >= -9.007199254740992e15 && v <= 9.007199254740992e15
+            && v == static_cast<double>(static_cast<int64_t>(v));
+    }
+
+    void Write(std::string& out) const {
+        switch (type_) {
+        case Type::Null:   out += "null"; break;
+        case Type::Bool:   out += bool_ ? "true" : "false"; break;
+        case Type::Int: {
+            char tmp[24];
+            int n = std::snprintf(tmp, sizeof(tmp), "%lld",
+                                  static_cast<long long>(int_));
+            out.append(tmp, static_cast<size_t>(n));
+            break;
+        }
+        case Type::Double: {
+            char tmp[36];
+            int n = std::snprintf(tmp, sizeof(tmp), "%.17g", dbl_);
+            // recorta precisión redundante con %g corto cuando es exacto
+            char tmp2[36];
+            int n2 = std::snprintf(tmp2, sizeof(tmp2), "%.15g", dbl_);
+            if (n > 0 && n2 > 0 && std::strtod(tmp2, nullptr) == dbl_)
+                out.append(tmp2, static_cast<size_t>(n2));
+            else
+                out.append(tmp, static_cast<size_t>(n));
+            break;
+        }
+        case Type::String:
+            WriteEscaped(out, str_);
+            break;
+        case Type::ArrayT: {
+            out += '[';
+            bool first = true;
+            for (const auto& v : arr_) {
+                if (!first) out += ',';
+                first = false;
+                v.Write(out);
+            }
+            out += ']';
+            break;
+        }
+        case Type::ObjectT: {
+            out += '{';
+            bool first = true;
+            for (const auto& m : obj_) {
+                if (!first) out += ',';
+                first = false;
+                WriteEscaped(out, m.first);
+                out += ':';
+                m.second.Write(out);
+            }
+            out += '}';
+            break;
+        }
+        }
+    }
+
+    static void WriteEscaped(std::string& out, std::string_view s) {
+        out += '"';
+        for (unsigned char c : s) {
+            switch (c) {
+            case '"':  out += "\\\""; break;
+            case '\\': out += "\\\\"; break;
+            case '\b': out += "\\b";  break;
+            case '\f': out += "\\f";  break;
+            case '\n': out += "\\n";  break;
+            case '\r': out += "\\r";  break;
+            case '\t': out += "\\t";  break;
+            default:
+                if (c < 0x20) {
+                    char tmp[8];
+                    std::snprintf(tmp, sizeof(tmp), "\\u%04x", c);
+                    out += tmp;
+                } else {
+                    out += static_cast<char>(c);
+                }
+            }
+        }
+        out += '"';
+    }
+
+    Type type_;
+    bool bool_ = false;
+    int64_t int_ = 0;
+    double dbl_ = 0;
+    std::string str_;
+    Array arr_;
+    Object obj_;
+};
+
+/// Parser recursivo descendente. Devuelve nullopt y `error` en fallo.
+struct ParseResult {
+    std::optional<Value> value;
+    std::string error;
+};
+
+inline ParseResult Parse(std::string_view text) {
+    size_t pos = 0;
+    ParseResult r;
+
+    // Límite de anidamiento (objetos/arrays): evita stack overflow con JSON
+    // adversarial profundamente anidado en entradas externas (bridge/control).
+    static constexpr int kMaxDepth = 128;
+
+    struct Parser {
+        std::string_view t;
+        size_t& pos;
+        std::string err;
+        int depth = 0;
+
+        void SkipWs() {
+            while (pos < t.size()) {
+                char c = t[pos];
+                if (c == ' ' || c == '\t' || c == '\n' || c == '\r') ++pos;
+                else break;
+            }
+        }
+        bool Fail(std::string msg) { if (err.empty()) err = std::move(msg); return false; }
+
+        bool ParseValue(Value& out) {
+            SkipWs();
+            if (pos >= t.size()) return Fail("fin inesperado");
+            char c = t[pos];
+            switch (c) {
+            case '{': return ParseObject(out);
+            case '[': return ParseArray(out);
+            case '"': {
+                std::string s;
+                if (!ParseString(s)) return false;
+                out = Value(std::move(s));
+                return true;
+            }
+            case 't':
+                return Literal("true") ? (out = Value(true), true) : false;
+            case 'f':
+                return Literal("false") ? (out = Value(false), true) : false;
+            case 'n':
+                return Literal("null") ? (out = Value(nullptr), true) : false;
+            default:
+                return ParseNumber(out);
+            }
+        }
+
+        bool Literal(std::string_view lit) {
+            if (t.compare(pos, lit.size(), lit) != 0)
+                return Fail("literal inválido");
+            pos += lit.size();
+            return true;
+        }
+
+        bool ParseNumber(Value& out) {
+            size_t start = pos;
+            bool isDouble = false;
+            if (pos < t.size() && (t[pos] == '-' || t[pos] == '+')) ++pos;
+            while (pos < t.size()) {
+                char c = t[pos];
+                if (c >= '0' && c <= '9') { ++pos; continue; }
+                if (c == '.' || c == 'e' || c == 'E' || c == '+' || c == '-') {
+                    if (c == '.' || c == 'e' || c == 'E') isDouble = true;
+                    ++pos; continue;
+                }
+                break;
+            }
+            if (pos == start) return Fail("número inválido");
+            std::string num(t.substr(start, pos - start));
+            if (isDouble) {
+                out = Value(std::strtod(num.c_str(), nullptr));
+            } else {
+                errno = 0;
+                long long v = std::strtoll(num.c_str(), nullptr, 10);
+                out = Value(static_cast<int64_t>(v));
+            }
+            return true;
+        }
+
+        bool ParseHex4(unsigned& out) {
+            if (pos + 4 > t.size()) return Fail("\\u truncado");
+            unsigned v = 0;
+            for (int i = 0; i < 4; ++i) {
+                char c = t[pos++];
+                v <<= 4;
+                if (c >= '0' && c <= '9') v |= static_cast<unsigned>(c - '0');
+                else if (c >= 'a' && c <= 'f') v |= static_cast<unsigned>(c - 'a' + 10);
+                else if (c >= 'A' && c <= 'F') v |= static_cast<unsigned>(c - 'A' + 10);
+                else return Fail("\\u inválido");
+            }
+            out = v;
+            return true;
+        }
+
+        void AppendUtf8(std::string& s, unsigned cp) {
+            if (cp < 0x80) {
+                s += static_cast<char>(cp);
+            } else if (cp < 0x800) {
+                s += static_cast<char>(0xC0 | (cp >> 6));
+                s += static_cast<char>(0x80 | (cp & 0x3F));
+            } else if (cp < 0x10000) {
+                s += static_cast<char>(0xE0 | (cp >> 12));
+                s += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+                s += static_cast<char>(0x80 | (cp & 0x3F));
+            } else {
+                s += static_cast<char>(0xF0 | (cp >> 18));
+                s += static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
+                s += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+                s += static_cast<char>(0x80 | (cp & 0x3F));
+            }
+        }
+
+        bool ParseString(std::string& out) {
+            ++pos; // comilla inicial ya validada por caller
+            out.clear();
+            while (pos < t.size()) {
+                char c = t[pos++];
+                if (c == '"') return true;
+                if (c != '\\') { out += c; continue; }
+                if (pos >= t.size()) return Fail("escape truncado");
+                char e = t[pos++];
+                switch (e) {
+                case '"':  out += '"';  break;
+                case '\\': out += '\\'; break;
+                case '/':  out += '/';  break;
+                case 'b':  out += '\b'; break;
+                case 'f':  out += '\f'; break;
+                case 'n':  out += '\n'; break;
+                case 'r':  out += '\r'; break;
+                case 't':  out += '\t'; break;
+                case 'u': {
+                    unsigned u;
+                    if (!ParseHex4(u)) return false;
+                    if (u >= 0xD800 && u <= 0xDBFF &&
+                        pos + 1 < t.size() && t[pos] == '\\' && t[pos + 1] == 'u') {
+                        pos += 2;
+                        unsigned lo;
+                        if (!ParseHex4(lo)) return false;
+                        if (lo >= 0xDC00 && lo <= 0xDFFF)
+                            u = 0x10000 + ((u - 0xD800) << 10) + (lo - 0xDC00);
+                        else
+                            AppendUtf8(out, u), u = lo; // par inválido: emite ambos
+                    }
+                    AppendUtf8(out, u);
+                    break;
+                }
+                default: return Fail("escape desconocido");
+                }
+            }
+            return Fail("string sin cerrar");
+        }
+
+        bool ParseArray(Value& out) {
+            if (++depth > kMaxDepth) return Fail("JSON demasiado anidado");
+            ++pos;
+            Array arr;
+            SkipWs();
+            if (pos < t.size() && t[pos] == ']') { ++pos; --depth; out = Value(std::move(arr)); return true; }
+            while (true) {
+                Value item;
+                if (!ParseValue(item)) return false;
+                arr.push_back(std::move(item));
+                SkipWs();
+                if (pos >= t.size()) return Fail("array sin cerrar");
+                if (t[pos] == ',') { ++pos; continue; }
+                if (t[pos] == ']') { ++pos; break; }
+                return Fail("',' o ']' esperado");
+            }
+            --depth;
+            out = Value(std::move(arr));
+            return true;
+        }
+
+        bool ParseObject(Value& out) {
+            if (++depth > kMaxDepth) return Fail("JSON demasiado anidado");
+            ++pos;
+            Object obj;
+            SkipWs();
+            if (pos < t.size() && t[pos] == '}') { ++pos; --depth; out = Value(std::move(obj)); return true; }
+            while (true) {
+                SkipWs();
+                if (pos >= t.size() || t[pos] != '"')
+                    return Fail("clave string esperada");
+                std::string key;
+                if (!ParseString(key)) return false;
+                SkipWs();
+                if (pos >= t.size() || t[pos] != ':')
+                    return Fail("':' esperado");
+                ++pos;
+                Value val;
+                if (!ParseValue(val)) return false;
+                obj.emplace_back(std::move(key), std::move(val));
+                SkipWs();
+                if (pos >= t.size()) return Fail("objeto sin cerrar");
+                if (t[pos] == ',') { ++pos; continue; }
+                if (t[pos] == '}') { ++pos; break; }
+                return Fail("',' o '}' esperado");
+            }
+            --depth;
+            out = Value(std::move(obj));
+            return true;
+        }
+    };
+
+    Parser p{text, pos};
+    Value root;
+    if (!p.ParseValue(root)) {
+        r.error = p.err.empty() ? "JSON inválido" : p.err;
+        return r;
+    }
+    r.value = std::move(root);
+    return r;
+}
+
+/// Escape de un string para incrustarlo como literal JS entre comillas simples.
+/// Se usa para inyectar payloads vía evaluate_javascript/postMessage roundtrips.
+inline std::string JsLiteral(std::string_view s) {
+    std::string out = "'";
+    for (char c : s) {
+        switch (c) {
+        case '\'': out += "\\'"; break;
+        case '\\': out += "\\\\"; break;
+        case '\n': out += "\\n"; break;
+        case '\r': out += "\\r"; break;
+        default:
+            if (static_cast<unsigned char>(c) < 0x20) {
+                char tmp[8];
+                std::snprintf(tmp, sizeof(tmp), "\\u%04x", c);
+                out += tmp;
+            } else {
+                out += c;
+            }
+        }
+    }
+    out += '\'';
+    return out;
+}
+
+} // namespace ow::json

package/include/ow_api.h

@@ -0,0 +1,103 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// api/ow_api.h — ABI-C estable del sistema de módulos Owear (.owm).
+//
+// Cada API vive en su propio folder (api/fs, api/process, …) y compila a una
+// shared library independiente (.so/.dll/.dylib) que el kernel carga con
+// dlopen. Actualización modular por API.
+//
+// Un módulo exporta EXACTAMENTE un símbolo obligatorio:
+//     const ow_module_desc_t* ow_module_descriptor(void);
+// y opcionalmente recibe el host con:
+//     void ow_module_set_host(const ow_module_host_t* host);
+//
+// Contrato de memoria:
+//  - Los buffers apuntados por res viven SOLO durante la llamada; el host
+//    copia inmediatamente después de retornar.
+//  - Prohibido lanzar excepciones hacia el host.
+//
+#pragma once
+
+#include <stdint.h>
+#include <stddef.h>
+
+#if defined(_WIN32)
+  #if defined(OW_MODULE_BUILD)
+    #define OW_MODULE_EXPORT __declspec(dllexport)
+  #else
+    #define OW_MODULE_EXPORT
+  #endif
+#else
+  #if defined(OW_MODULE_BUILD)
+    #define OW_MODULE_EXPORT __attribute__((visibility("default")))
+  #else
+    #define OW_MODULE_EXPORT
+  #endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ow_request {
+    const char*  json;        ///< argumentos como array JSON. Nunca null ("[]").
+    uint32_t     json_len;
+    const uint8_t* bin;       ///< binario adjunto (puede ser null)
+    uint32_t     bin_len;
+    uint32_t     window_id;   ///< ventana invocante (0 = sin ventana)
+    uint32_t     reserved;
+    void*        host;        ///< contexto del kernel (opaco para el módulo)
+} ow_request_t;
+
+typedef struct ow_response {
+    int32_t      status;      ///< 0 = ok; != 0 = error
+    const char*  error;       ///< mensaje de error (si status != 0)
+    const char*  json;        ///< resultado JSON ("null" permitido)
+    uint32_t     json_len;
+    const uint8_t* bin;       ///< binario de salida (opcional)
+    uint32_t     bin_len;
+} ow_response_t;
+
+typedef void (*ow_fn_t)(const ow_request_t* req, ow_response_t* res);
+
+typedef struct ow_fn_entry {
+    const char* name;
+    ow_fn_t     fn;
+} ow_fn_entry_t;
+
+typedef struct ow_module_desc {
+    const char*          name;     ///< "fs", "process", "dialog", …
+    const char*          version;
+    const ow_fn_entry_t* fns;
+    uint32_t             fn_count;
+} ow_module_desc_t;
+
+/// Único símbolo que un .owm debe exportar.
+typedef const ow_module_desc_t* (*ow_module_entry_t)(void);
+
+// ── Host callbacks (F-infra) ────────────────────────────────────────────────
+// El kernel pasa esta tabla vía ow_module_set_host() justo después del dlopen.
+// Permite a los módulos emitir eventos (watchers, PTY stdout, tray clicks…).
+
+#define OW_HOST_ABI_VERSION 1
+
+typedef void (*ow_host_emit_event_t)(void* ctx, uint32_t window_id,
+                                     const char* name, const char* json);
+typedef void (*ow_host_log_t)(void* ctx, int level, const char* msg);
+
+typedef struct ow_module_host {
+    uint32_t version;              ///< OW_HOST_ABI_VERSION
+    void*    ctx;                  ///< contexto opaco del kernel
+    ow_host_emit_event_t emit_event;
+    ///<  window_id == 0 → broadcast (todas las ventanas + SDK por control socket)
+    ow_host_log_t log;             ///< level: 0 debug · 1 info · 2 warn · 3 error
+    void*    reserved[4];
+} ow_module_host_t;
+
+/// Opcional: el módulo guarda la tabla si quiere emitir eventos.
+typedef void (*ow_module_set_host_t)(const ow_module_host_t* host);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@owear/linux-x64-gnu",
+  "version": "0.1.0",
+  "description": "Owear runtime — kernel nativo + módulos stock (.owm) + headers. Linux x64 (glibc).",
+  "license": "Apache-2.0",
+  "homepage": "https://owear.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/owear/owear.git",
+    "directory": "packages/runtime-linux-x64-gnu"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "os": ["linux"],
+  "cpu": ["x64"],
+  "libc": ["glibc"],
+  "engines": { "node": ">=20" },
+  "bin": { "owear": "bin/owear" },
+  "files": ["bin", "include", "README.md", "LICENSE"],
+  "scripts": {
+    "prepack": "node ../../tools/pack-runtime.mjs --target linux-x64-gnu"
+  }
+}