@flare-desktop/cli 0.1.1 → 0.1.3

package/src/lib/embedded-config.js

@@ -0,0 +1,181 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+
+import { loadProject, mergeConfig, parseConfig } from "./project.js";
+
+function cppString(value) {
+  const bytes = Buffer.from(value, "utf8");
+  let output = '"';
+  for (const byte of bytes) {
+    if (byte === 34) output += '\\"';
+    else if (byte === 92) output += "\\\\";
+    else if (byte >= 32 && byte <= 126) output += String.fromCharCode(byte);
+    else output += `\\${byte.toString(8).padStart(3, "0")}`;
+  }
+  return `${output}"`;
+}
+
+function cppJson(value) {
+  if (value === null) return "Flare::JSON(nullptr)";
+  if (Array.isArray(value)) return `Flare::JSON::array({${value.map(cppJson).join(", ")}})`;
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([key, item]) => `{${cppString(key)}, ${cppJson(item)}}`);
+    return `Flare::JSON::object({${entries.join(", ")}})`;
+  }
+  if (typeof value === "string") return `Flare::JSON(${cppString(value)})`;
+  if (typeof value === "boolean") return `Flare::JSON(${value})`;
+  if (typeof value === "number" && Number.isFinite(value)) return `Flare::JSON(${value})`;
+  throw new TypeError("unsupported JSON value in configuration");
+}
+
+function scalar(value, kind) {
+  if (kind === "string" && typeof value === "string") return cppString(value);
+  if (kind === "bool" && typeof value === "boolean") return `${value}`;
+  if (kind === "number" && typeof value === "number" && Number.isFinite(value)) return `${value}`;
+  if (kind === "int" && Number.isSafeInteger(value)) return `${value}`;
+  if (kind === "strings" && Array.isArray(value)) {
+    return `{${value.filter((item) => typeof item === "string").map(cppString).join(", ")}}`;
+  }
+  return null;
+}
+
+const FIELDS = {
+  package: { productName: "string", version: "string" },
+  app: { productName: "string", mainBinaryName: "string", version: "string", identifier: "string" },
+  build: {
+    beforeDevCommand: "string", afterDevCommand: "string", beforeBuildCommand: "string",
+    afterBuildCommand: "string", frontendDist: "string", devUrl: "string", removeUnusedCommands: "strings"
+  },
+  "build.features": { customProtocol: "bool", devtools: "bool", isolation: "bool", systemTray: "bool" },
+  bundle: {
+    active: "bool", identifier: "string", icon: "string", version: "string", publisher: "string",
+    homepage: "string", longDescription: "string", copyright: "string", category: "string",
+    shortDescription: "string", licenseFile: "string", targets: "strings", resources: "strings",
+    externalBin: "strings"
+  },
+  "bundle.linuxBundle": { depends: "string", desktopTemplate: "string", section: "string", priority: "string", files: "strings" },
+  "bundle.windows": { language: "string", installerIcon: "string", installMode: "int", webviewInstallModeOffline: "bool" },
+  "bundle.macos": { minimumSystemVersion: "string", frameworks: "bool", signingIdentity: "string" },
+  security: {
+    freezePrototype: "bool", dangerousDisableAssetCspModification: "bool", dangerousUseHttpScheme: "bool",
+    dangerousAcceptInvalidCertificates: "bool", capabilities: "strings", dangerousRemoteDomainIpcAccess: "strings"
+  },
+  window: {
+    label: "string", title: "string", resizable: "bool", maximized: "bool", fullscreen: "bool",
+    alwaysOnTop: "bool", decorations: "bool", transparent: "bool", visible: "bool", center: "bool",
+    devtools: "bool", url: "string"
+  }
+};
+
+function emitFields(lines, target, input, fields) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return;
+  for (const [key, kind] of Object.entries(fields)) {
+    const result = scalar(input[key], kind);
+    if (result !== null) lines.push(`${target}.${key} = ${result};`);
+  }
+}
+
+function emitSize(lines, target, input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return;
+  for (const key of ["width", "height"]) {
+    const result = scalar(input[key], "number");
+    if (result !== null) lines.push(`${target}.${key} = ${result};`);
+  }
+}
+
+function emitCsp(lines, input) {
+  if (typeof input === "string") {
+    const directives = input.split(";").map((statement) => statement.trim()).filter(Boolean);
+    lines.push(`config.security.csp.enabled = ${input.trim() ? "true" : "false"};`);
+    for (const statement of directives) {
+      const [name, ...sources] = statement.split(/\s+/);
+      lines.push(`config.security.csp.directives.push_back(Flare::CspDirective{${cppString(name)}, ${scalar(sources, "strings")}});`);
+    }
+  } else if (input && typeof input === "object" && !Array.isArray(input)) {
+    lines.push("config.security.csp.enabled = true;");
+    for (const [name, sources] of Object.entries(input).sort(([a], [b]) => a.localeCompare(b))) {
+      const values = typeof sources === "string" ? sources.trim().split(/\s+/).filter(Boolean) : sources;
+      lines.push(`config.security.csp.directives.push_back(Flare::CspDirective{${cppString(name)}, ${scalar(values, "strings") ?? "{}"}});`);
+    }
+  }
+}
+
+export function generateEmbeddedConfig(config, raw = config, namespace = "FlareGenerated") {
+  if (!/^[A-Za-z_][A-Za-z_0-9]*$/.test(namespace)) throw new Error("invalid C++ namespace");
+  config = structuredClone(config);
+  const lines = [
+    "#pragma once", "", "#include <flare/config/config.h>", "", `namespace ${namespace} {`,
+    "inline Flare::Config EmbeddedConfig() {", "Flare::Config config;"
+  ];
+  if (raw.package && typeof raw.package === "object" && !Array.isArray(raw.package)) {
+    config.package.version ??= "0.1.0";
+  }
+  if (raw.build && typeof raw.build === "object" && !Array.isArray(raw.build)) {
+    config.build.frontendDist ??= "../dist";
+  }
+  if (raw.bundle && typeof raw.bundle === "object" && !Array.isArray(raw.bundle)) {
+    config.bundle.active ??= true;
+    config.bundle.icon ??= "icons/icon.png";
+    config.bundle.category ??= "DeveloperTool";
+  }
+  if (raw.bundle?.linux && typeof raw.bundle.linux === "object") {
+    config.bundle.linux.section ??= "utils";
+    config.bundle.linux.priority ??= "optional";
+  }
+  if (raw.bundle?.windows && typeof raw.bundle.windows === "object") {
+    config.bundle.windows.language ??= "en-US";
+  }
+  emitFields(lines, "config.package", config.package, FIELDS.package);
+  emitFields(lines, "config.app", config.app, FIELDS.app);
+  emitFields(lines, "config.build", config.build, FIELDS.build);
+  emitFields(lines, "config.build.features", config.build?.features, FIELDS["build.features"]);
+  emitFields(lines, "config.bundle", config.bundle, FIELDS.bundle);
+  emitFields(lines, "config.bundle.linuxBundle", config.bundle?.linux, FIELDS["bundle.linuxBundle"]);
+  emitFields(lines, "config.bundle.windows", config.bundle?.windows, FIELDS["bundle.windows"]);
+  emitFields(lines, "config.bundle.macos", config.bundle?.macos, FIELDS["bundle.macos"]);
+  emitFields(lines, "config.security", config.security, FIELDS.security);
+  emitCsp(lines, config.security?.csp);
+  if (typeof config.$schema === "string") lines.push(`config.schema = ${cppString(config.$schema)};`);
+  const windows = Array.isArray(config.windows) && config.windows.length ? config.windows : [{}];
+  for (const value of windows) {
+    lines.push("{ Flare::WindowConfig window;");
+    emitFields(lines, "window", value, FIELDS.window);
+    emitSize(lines, "window.size", value);
+    emitSize(lines, "window.size", value.size);
+    lines.push("window.minimumSize = Flare::WindowSize{0.0, 0.0};");
+    lines.push("window.maximumSize = Flare::WindowSize{0.0, 0.0};");
+    emitSize(lines, "window.minimumSize", value.minimumSize);
+    emitSize(lines, "window.maximumSize", value.maximumSize);
+    if (value.position && typeof value.position === "object" && !Array.isArray(value.position)) {
+      const x = scalar(value.position.x, "number") ?? "0.0";
+      const y = scalar(value.position.y, "number") ?? "0.0";
+      lines.push(`window.position = Flare::WindowPosition{${x}, ${y}};`);
+    }
+    if (typeof value.theme === "string") {
+      const theme = { light: "Light", dark: "Dark", automatic: "Automatic", system: "Automatic", auto: "Automatic" }[value.theme.toLowerCase()];
+      if (theme) lines.push(`window.theme = Flare::WindowTheme::${theme};`);
+    }
+    lines.push("config.windows.push_back(window); }");
+  }
+  if (config.plugins && typeof config.plugins === "object" && !Array.isArray(config.plugins)) {
+    for (const [name, value] of Object.entries(config.plugins).sort(([a], [b]) => a.localeCompare(b))) {
+      lines.push(`config.plugins.push_back(Flare::PluginConfig{${cppString(name)}, ${cppJson(value)}});`);
+    }
+  }
+  lines.push(`config.raw = ${cppJson(raw)};`);
+  lines.push("return config;", "}", "}", "");
+  return lines.join("\n");
+}
+
+export function writeEmbeddedConfig({ projectDirectory, configFile = "flare.config.json", environment = "production", output }) {
+  const { config, files } = loadProject({ projectDirectory, configFile, environment });
+  let raw = {};
+  for (const file of files) raw = mergeConfig(raw, parseConfig(readFileSync(file, "utf8"), file));
+  writeFileSync(output, generateEmbeddedConfig(config, raw), "utf8");
+  const result = spawnSync("clang-format", ["-style=file", "-i", output], { cwd: projectDirectory });
+  if (result.error && result.error.code !== "ENOENT") throw result.error;
+  if (!result.error && result.status !== 0) {
+    throw new Error(`clang-format failed: ${result.stderr.toString("utf8")}`);
+  }
+  return files;
+}

package/src/lib/icons.js

@@ -1,23 +1,13 @@
+import { readFileSync } from "node:fs";
+
 import { FlareError } from "./errors.js";
-import { resizePng, writePng } from "./png.js";
+import { readPng, resizePng, writePng } from "./png.js";
+
+let defaultMark;
 
 export function placeholderIcon(size = 512) {
-  const data = Buffer.alloc(size * size * 4);
-  const center = (size - 1) / 2;
-  const radius = size * 0.46;
-  for (let y = 0; y < size; y += 1) {
-    for (let x = 0; x < size; x += 1) {
-      const target = (y * size + x) * 4;
-      const distance = Math.hypot(x - center, y - center) / radius;
-      const glow = Math.max(0, Math.min(1, 1 - Math.abs(distance - 0.55) * 1.6));
-      const edge = distance <= 1 ? 1 : 0;
-      data[target] = edge ? Math.round(44 + 172 * glow) : 0;
-      data[target + 1] = edge ? Math.round(35 + 132 * glow) : 0;
-      data[target + 2] = edge ? Math.round(40 + 137 * glow) : 0;
-      data[target + 3] = edge ? 255 : 0;
-    }
-  }
-  return { width: size, height: size, data };
+  defaultMark ??= readPng(readFileSync(new URL("../assets/flare-mark.png", import.meta.url)));
+  return resizePng(defaultMark, size, size);
 }
 
 const ICO_SIZES = [16, 24, 32, 48, 64, 128, 256];

package/src/lib/project.js

@@ -175,8 +175,8 @@ export function mergeConfig(base, overlay) {
 function normalizeWindow(window, fallbackTitle) {
   const value = isObject(window) ? { ...window } : {};
   const title = value.title ?? fallbackTitle;
-  const width = value.width ?? value.size?.width ?? 800;
-  const height = value.height ?? value.size?.height ?? 600;
+  const width = value.size?.width ?? value.width ?? 800;
+  const height = value.size?.height ?? value.height ?? 600;
   return {
     ...value,
     label: value.label ?? "main",
@@ -212,7 +212,8 @@ export function normalizeConfig(raw) {
   if (!config.app.mainBinaryName) config.app.mainBinaryName = config.app.productName;
 
   const fallbackTitle = config.app.productName || "flare-app";
-  const windows = Array.isArray(config.windows) && config.windows.length > 0 ? config.windows : [{}];
+  const sourceWindows = Array.isArray(config.windows) ? config.windows : config.app.windows;
+  const windows = Array.isArray(sourceWindows) && sourceWindows.length > 0 ? sourceWindows : [{}];
   config.windows = windows.map((window) => normalizeWindow(window, fallbackTitle));
 
   return config;

package/src/lib/sdk.js

@@ -0,0 +1,54 @@
+import { mkdtempSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { extract } from "tar";
+
+import { FlareError } from "./errors.js";
+
+export function sdkTarget(platform = process.platform, arch = process.arch) {
+  if (!(["x64", "arm64"].includes(arch))) throw new FlareError(`prebuilt SDK is not available for ${arch}; choose source mode`);
+  if (platform === "win32") {
+    if (arch !== "x64") throw new FlareError("prebuilt Windows SDK supports x64 MSVC only; choose source mode");
+    return { platform: "windows-x64", runtimes: ["md", "mt"] };
+  }
+  if (platform === "darwin") return { platform: `macos-${arch}`, runtimes: ["default"] };
+  if (platform === "linux" && arch === "x64") return { platform: "linux-x64", runtimes: ["default"] };
+  throw new FlareError(`prebuilt SDK is not available for ${platform}-${arch}; choose source mode`);
+}
+
+export async function installSdk({ destination, version, platform = process.platform, arch = process.arch, fetchImpl = fetch }) {
+  const target = sdkTarget(platform, arch);
+  mkdirSync(path.dirname(destination), { recursive: true });
+  const temporary = mkdtempSync(path.join(path.dirname(destination), ".flare-sdk-"));
+  const sdk = path.join(temporary, "flare");
+  mkdirSync(sdk);
+  try {
+    const checksumsUrl = `https://github.com/flare-desktop/flare/releases/download/v${version}/SHA256SUMS.txt`;
+    const checksumsResponse = await fetchImpl(checksumsUrl);
+    if (!checksumsResponse.ok) throw new FlareError(`SDK checksums are unavailable (HTTP ${checksumsResponse.status}); publish core v${version} first`);
+    const sums = new Map((await checksumsResponse.text()).split("\n").map((line) => /^(\w{64})\s+\*?(\S+)$/.exec(line)).filter(Boolean).map((match) => [match[2], match[1].toLowerCase()]));
+    for (const runtime of target.runtimes) {
+      const file = `flare-sdk-v${version}-${target.platform}-${runtime}.tar.gz`;
+      const url = `https://github.com/flare-desktop/flare/releases/download/v${version}/${file}`;
+      let response;
+      try { response = await fetchImpl(url); } catch (error) { throw new FlareError(`failed to download ${file}: ${error.message}`); }
+      if (!response.ok) throw new FlareError(`SDK archive ${file} is unavailable (HTTP ${response.status}); publish core v${version} SDK release first, or choose source mode`);
+      const archive = path.join(temporary, file);
+      const data = Buffer.from(await response.arrayBuffer());
+      const digest = createHash("sha256").update(data).digest("hex");
+      if (!sums.has(file) || sums.get(file) !== digest) throw new FlareError(`SDK checksum mismatch for ${file}`);
+      writeFileSync(archive, data);
+      await extract({ file: archive, cwd: temporary, strict: true, filter: (entry) => entry === "flare" || entry.startsWith("flare/") });
+      const manifest = JSON.parse(readFileSync(path.join(sdk, "sdk-manifest.json"), "utf8"));
+      if (manifest.version !== version || manifest.target !== target.platform || manifest.crt !== runtime) {
+        throw new FlareError(`SDK archive ${file} has incorrect platform or version metadata`);
+      }
+    }
+    rmSync(destination, { recursive: true, force: true });
+    mkdirSync(path.dirname(destination), { recursive: true });
+    renameSync(sdk, destination);
+  } finally {
+    rmSync(temporary, { recursive: true, force: true });
+  }
+  return target;
+}

package/src/release-versions.js

@@ -0,0 +1,2 @@
+export const CORE_VERSION = "0.1.1";
+export const MIN_CLI_VERSION = "0.1.2";

package/src/templates/clang-format.txt

@@ -0,0 +1,32 @@
+BasedOnStyle: Google
+Standard: c++20
+ColumnLimit: 120
+IndentWidth: 4
+TabWidth: 4
+ContinuationIndentWidth: 4
+ConstructorInitializerIndentWidth: 4
+AccessModifierOffset: -4
+NamespaceIndentation: All
+UseTab: Never
+PointerAlignment: Left
+DerivePointerAlignment: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLoopsOnASingleLine: false
+RemoveBracesLLVM: true
+SortIncludes: Never
+FixNamespaceComments: false
+AlignAfterOpenBracket: BlockIndent
+AlignOperands: DontAlign
+AlignTrailingComments: false
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: NonAssignment
+BreakConstructorInitializers: BeforeColon
+PackConstructorInitializers: Never
+LambdaBodyIndentation: OuterScope
+PenaltyBreakBeforeFirstCallParameter: 10
+AlwaysBreakAfterReturnType: None
+PenaltyReturnTypeOnItsOwnLine: 1000

package/src/templates/core.d.ts

@@ -0,0 +1,135 @@
+export type Payload = Record<string, unknown> | unknown[] | string | number | boolean | null;
+
+export interface InvokeOptions {
+    id?: string;
+    window?: string;
+    webview?: string;
+}
+
+export interface ListenOptions {
+    window?: string;
+}
+
+export interface IpcErrorShape {
+    code: string;
+    message: string;
+    details?: Payload;
+}
+
+export interface IpcFailure extends Error {
+    code: string;
+    details?: Payload;
+}
+
+export interface ChannelMessage {
+    sequence: number;
+    payload: Payload;
+    state: 'open' | 'closed';
+}
+
+export interface Channel {
+    identifier: number;
+    name: string;
+    send(payload?: Payload): Promise<void>;
+    deliver(message: ChannelMessage): void;
+    close(): void;
+}
+
+export interface Metadata {
+    readonly protocol: string;
+    readonly host: string;
+    readonly version: string;
+}
+
+export function isFlare(): boolean;
+export function metadata(): Metadata;
+export function invoke<T = unknown>(command: string, payload?: Payload, options?: InvokeOptions): Promise<T>;
+export function listen(event: string, handler: (payload: Payload) => void, options?: ListenOptions): Promise<() => Promise<void>>;
+export function once(event: string, handler: (payload: Payload) => void, options?: ListenOptions): Promise<() => Promise<void>>;
+export function unlisten(event: string, id: number): Promise<void>;
+export function emit(event: string, payload?: Payload): Promise<void>;
+export function dispatch(event: string, payload?: Payload): number;
+export function createChannel(onMessage: (message: ChannelMessage) => void): Channel;
+export function currentWindow(): {
+    label: string;
+    close(): Promise<unknown>;
+    setTitle(title: string): Promise<unknown>;
+    show(): Promise<unknown>;
+    hide(): Promise<unknown>;
+};
+
+export const app: {
+    version(): Promise<string>;
+    describe(): Promise<Payload>;
+    config(): Promise<Payload>;
+    platform(): Promise<Payload>;
+    exit(): Promise<unknown>;
+};
+
+export const window: {
+    list(): Promise<string[]>;
+    emit(event: string, payload?: Payload): Promise<unknown>;
+};
+
+export const plugins: { list(): Promise<Payload> };
+export interface MenuItem {
+    id?: string;
+    kind?: 'text' | 'check' | 'radio' | 'separator' | 'submenu' | 'predefined';
+    text?: string;
+    accelerator?: string;
+    enabled?: boolean;
+    checked?: boolean;
+    icon?: string;
+    items?: MenuItem[];
+}
+
+export const menu: {
+    describe(): Promise<{ id: string; items: MenuItem[] }>;
+    set(items: MenuItem[]): Promise<boolean>;
+    dispatch(id: string): Promise<boolean>;
+    onCommand(handler: (id: string, payload: { id: string }) => void): () => Promise<boolean>;
+};
+export const commands: {
+    register(name: string, handler: (payload: Payload) => Payload): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    names(): string[];
+};
+export const log: {
+    trace(message: string): Promise<void>;
+    debug(message: string): Promise<void>;
+    info(message: string): Promise<void>;
+    warn(message: string): Promise<void>;
+    error(message: string): Promise<void>;
+};
+
+export type DirectoryName =
+    | 'appData'
+    | 'appLocalData'
+    | 'appConfig'
+    | 'appCache'
+    | 'appLog'
+    | 'home'
+    | 'documents'
+    | 'downloads'
+    | 'desktop'
+    | 'pictures'
+    | 'temp'
+    | 'executable'
+    | 'resource'
+    | 'current';
+
+export const path: {
+    resolve(name: DirectoryName | string): Promise<{ name: string; path: string }>;
+    all(): Promise<Record<DirectoryName, string>>;
+};
+
+export const tray: {
+    describe(): Promise<Payload & { menu: { id: string; items: MenuItem[] } }>;
+    setIcon(icon: string): Promise<Payload>;
+    setTooltip(tooltip: string): Promise<Payload>;
+    setTitle(title: string): Promise<Payload>;
+    setVisible(visible: boolean): Promise<Payload>;
+    setMenu(items: MenuItem[]): Promise<Payload>;
+    dispatch(id: string): Promise<boolean>;
+};