@glass-sdk/cli 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 0.0.1
+
+Breaking internal rewrite: one binary file-picker capability, source-independent
+release configuration, target/mode-isolated generation, explicit signing, and
+packed-consumer verification. See the repository README for the current contract.

package/README.md

@@ -0,0 +1,10 @@
+# @glass-sdk/cli
+
+Commands: `glass setup`, `glass run <target>`, `glass package <target>`.
+Targets: desktop, ios, android. `--app-dir` selects the consumer directory;
+`--url` explicitly overrides the configured URL. Use `--help` for arguments.
+
+All project configuration and build orchestration lives here. Hosts receive
+resolved files, and generated workspaces are independent of published runtime
+artifacts. The CLI never installs dependencies or manages the web server.
+See the root README for the configuration and build contracts.

package/bin/glass.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { setupApp } from "../lib/assembly.mjs";
+import { TARGETS } from "../lib/config.mjs";
+import { nativeAction } from "../lib/workflow.mjs";
+
+const usage = `Usage:
+  glass setup [--app-dir <directory>]
+  glass run <desktop|ios|android> [--app-dir <directory>] [--url <URL>] [-- <native arguments>]
+  glass package <desktop|ios|android> [--app-dir <directory>] [--url <HTTPS URL>] [--unsigned] [-- <desktop builder arguments>]`;
+try {
+  const args = process.argv.slice(2);
+  const separator = args.indexOf("--");
+  const forwarded = separator < 0 ? [] : args.slice(separator + 1);
+  const { values, positionals } = parseArgs({
+    args: separator < 0 ? args : args.slice(0, separator),
+    allowPositionals: true,
+    strict: true,
+    options: {
+      "app-dir": { type: "string" },
+      url: { type: "string" },
+      unsigned: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+    },
+  });
+  if (values.help || args.length === 0) console.log(usage);
+  else {
+    const [action, target, ...extra] = positionals;
+    const appDirectory = path.resolve(values["app-dir"] ?? process.cwd());
+    if (
+      action === "setup" &&
+      !target &&
+      !extra.length &&
+      !values.url &&
+      !values.unsigned &&
+      !forwarded.length
+    )
+      console.log(
+        `Prepared native projects from ${await setupApp(appDirectory)}`,
+      );
+    else if (
+      ["run", "package"].includes(action) &&
+      TARGETS.includes(target) &&
+      !extra.length &&
+      !(action === "run" && values.unsigned)
+    ) {
+      if (target === "desktop" && values.unsigned)
+        throw new Error(
+          "Desktop signing uses CSC_NAME or CSC_LINK; omit --unsigned",
+        );
+      const host = await nativeAction(
+        appDirectory,
+        target,
+        action,
+        values,
+        forwarded,
+      );
+      if (action === "package") console.log(`Artifacts: ${host.artifacts}`);
+    } else throw new Error(usage);
+  }
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/glass.config.example.json

@@ -0,0 +1,12 @@
+{
+  "appName": "My Glass App",
+  "appId": "com.example.myapp",
+  "buildNumber": 1,
+  "urls": {
+    "development": {
+      "desktop": "http://localhost:3000",
+      "ios": "http://localhost:3000",
+      "android": "http://10.0.2.2:3000"
+    }
+  }
+}

package/lib/assembly.mjs

@@ -0,0 +1,274 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { withTargetLock } from "./lock.mjs";
+import { readJSON, readApplication, resolveURL } from "./config.mjs";
+
+export function installedPackage(appDirectory, name) {
+  const require = createRequire(path.join(appDirectory, "package.json"));
+  try {
+    return fs.realpathSync(
+      path.dirname(require.resolve(`${name}/package.json`)),
+    );
+  } catch {
+    throw new Error(
+      `Install ${name} in the application with your package manager`,
+    );
+  }
+}
+const xml = (value) =>
+  String(value)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+const groovy = (value) =>
+  `'${String(value).replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+
+// Only SDK-owned files are synchronized. Native build caches and tools' generated
+// files are never interpreted as templates or recursively deleted.
+export function synchronize(directory, entries) {
+  fs.mkdirSync(directory, { recursive: true });
+  const statePath = path.join(directory, ".glass-source.json");
+  const previous = fs.existsSync(statePath) ? readJSON(statePath) : {};
+  for (const name of Object.keys(previous)) {
+    if (path.isAbsolute(name) || name.split(/[\\/]/u).includes(".."))
+      throw new Error("Invalid generated-source manifest");
+    if (!entries.has(name))
+      fs.rmSync(path.join(directory, name), { force: true });
+  }
+  const managed = {};
+  for (const [name, bytes] of entries) {
+    const file = path.join(directory, name);
+    const data = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
+    managed[name] = true;
+    if (fs.existsSync(file) && fs.readFileSync(file).equals(data)) continue;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, data);
+  }
+  fs.writeFileSync(statePath, JSON.stringify(managed, null, 2) + "\n");
+}
+function collect(root, relative = "", entries = new Map()) {
+  for (const item of fs.readdirSync(path.join(root, relative), {
+    withFileTypes: true,
+  })) {
+    if (
+      [
+        "node_modules",
+        "build",
+        "dist",
+        "DerivedData",
+        "generated",
+        "Generated",
+        "xcuserdata",
+        ".gradle",
+        ".git",
+        ".DS_Store",
+        "local.properties",
+      ].includes(item.name)
+    )
+      continue;
+    const name = path.join(relative, item.name);
+    if (item.isDirectory()) collect(root, name, entries);
+    else if (item.isFile())
+      entries.set(name, fs.readFileSync(path.join(root, name)));
+  }
+  return entries;
+}
+function linkDependencies(source, destination) {
+  const require = createRequire(path.join(source, "package.json"));
+  for (const name of Object.keys(
+    readJSON(path.join(source, "package.json")).dependencies ?? {},
+  )) {
+    const resolved = path.dirname(require.resolve(`${name}/package.json`));
+    const link = path.join(destination, "node_modules", name);
+    fs.mkdirSync(path.dirname(link), { recursive: true });
+    if (
+      fs.existsSync(link) &&
+      fs.realpathSync(link) === fs.realpathSync(resolved)
+    )
+      continue;
+    fs.rmSync(link, { recursive: true, force: true });
+    fs.symlinkSync(resolved, link, "junction");
+  }
+}
+export function prepareHost(appDirectory, target, mode = "dev", override) {
+  const config = readApplication(appDirectory);
+  const url = resolveURL(config, target, mode, override);
+  const root = path.join(config.appDirectory, ".glass");
+  const directory = path.join(root, "hosts", target, mode);
+  const artifacts = path.join(
+    root,
+    "artifacts",
+    target,
+    `${config.version}-${config.buildNumber}`,
+  );
+  const source = installedPackage(
+    config.appDirectory,
+    target === "desktop" ? "@glass-sdk/host-desktop" : "@glass-sdk/host-mobile",
+  );
+  const capability = installedPackage(
+    config.appDirectory,
+    "@glass-sdk/file-picker",
+  );
+  const entries = new Map();
+  const addTree = (from, prefix = "") => {
+    for (const [name, data] of collect(from))
+      entries.set(path.join(prefix, name), data);
+  };
+  const defaultIcon =
+    target === "desktop"
+      ? path.join(source, "icon.png")
+      : path.join(
+          source,
+          "ios/App/App/Assets.xcassets/AppIcon.appiconset/AppIcon-512@2x.png",
+        );
+  const iconPath = config.icon
+    ? path.resolve(config.appDirectory, config.icon)
+    : defaultIcon;
+  const icon = fs.readFileSync(iconPath);
+  if (
+    icon.length < 24 ||
+    icon.subarray(0, 8).toString("hex") !== "89504e470d0a1a0a" ||
+    icon.readUInt32BE(16) !== 1024 ||
+    icon.readUInt32BE(20) !== 1024
+  )
+    throw new Error("icon must be a 1024 × 1024 PNG");
+  const runtime = {
+    appName: config.appName,
+    appId: config.appId,
+    version: config.version,
+    buildNumber: config.buildNumber,
+    url,
+  };
+  const manifest = readJSON(path.join(source, "package.json"));
+  manifest.private = true;
+  delete manifest.bin;
+  if (target === "desktop") {
+    for (const name of [
+      "main.cjs",
+      "preload.cjs",
+      "navigation.cjs",
+      "electron-builder.config.cjs",
+      "error.html",
+    ])
+      entries.set(name, fs.readFileSync(path.join(source, name)));
+    entries.set(
+      "file-picker.cjs",
+      fs.readFileSync(path.join(capability, "native/desktop/file-picker.cjs")),
+    );
+    entries.set("icon.png", icon);
+    entries.set("runtime.json", JSON.stringify(runtime));
+    manifest.name = config.appId;
+    manifest.version = config.version;
+    manifest.devDependencies = manifest.dependencies;
+    delete manifest.dependencies;
+  } else {
+    addTree(path.join(source, target), target);
+    addTree(path.join(source, "web"), "web");
+    entries.set(
+      "web/error.html",
+      entries.get("web/error.html").toString().replace("{{APP_URL}}", xml(url)),
+    );
+    entries.set(
+      "capacitor.config.json",
+      JSON.stringify(
+        {
+          appId: config.appId,
+          appName: config.appName,
+          webDir: "web",
+          plugins: { SystemBars: { insetsHandling: "disable" } },
+          server: {
+            url: new URL(url).origin,
+            appStartPath:
+              target === "ios"
+                ? decodeURIComponent(new URL(url).pathname)
+                : new URL(url).pathname,
+            cleartext: mode === "dev" && url.startsWith("http:"),
+            errorPath: "error.html",
+          },
+        },
+        null,
+        2,
+      ),
+    );
+    if (target === "ios") {
+      entries.set(
+        "ios/App/App/GlassFilePickerPlugin.swift",
+        fs.readFileSync(
+          path.join(capability, "native/ios/GlassFilePickerPlugin.swift"),
+        ),
+      );
+      entries.set(
+        "ios/App/App/Assets.xcassets/AppIcon.appiconset/AppIcon-512@2x.png",
+        icon,
+      );
+      entries.set(
+        "ios/App/App/Generated/GlassConfig.xcconfig",
+        `GLASS_IOS_BUNDLE_ID = ${config.appId}\nGLASS_APP_VERSION = ${config.nativeVersion}\nGLASS_BUILD_NUMBER = ${config.buildNumber}\n`,
+      );
+      entries.set(
+        "ios/App/App/Info.plist",
+        entries
+          .get("ios/App/App/Info.plist")
+          .toString()
+          .replaceAll("$(GLASS_APP_NAME)", xml(config.appName)),
+      );
+    } else {
+      entries.set(
+        "android/app/src/main/kotlin/com/glass/host/filepicker/GlassFilePickerPlugin.kt",
+        fs.readFileSync(
+          path.join(capability, "native/android/GlassFilePickerPlugin.kt"),
+        ),
+      );
+      entries.set(
+        "android/app/src/main/generated/kotlin/MainActivity.kt",
+        fs
+          .readFileSync(
+            path.join(source, "resources/android/MainActivity.kt.in"),
+            "utf8",
+          )
+          .replaceAll("{{PACKAGE_NAME}}", config.appId),
+      );
+      entries.set(
+        "android/app/src/main/generated/glass-config.gradle",
+        `ext.glassAppName = ${groovy(config.appName)}\next.glassAppId = ${groovy(config.appId)}\next.glassAppVersion = ${groovy(config.nativeVersion)}\next.glassBuildNumber = ${config.buildNumber}\n`,
+      );
+      entries.set("android/app/src/main/res/mipmap/ic_launcher.png", icon);
+    }
+  }
+  entries.set("package.json", JSON.stringify(manifest, null, 2));
+  synchronize(directory, entries);
+  if (target === "android")
+    fs.chmodSync(path.join(directory, "android/gradlew"), 0o755);
+  linkDependencies(source, directory);
+  return { config, directory, artifacts, source, root, runtime, target, mode };
+}
+export async function setupApp(appDirectory) {
+  const directory = path.resolve(appDirectory);
+  const manifest = readJSON(path.join(directory, "package.json"));
+  if (!manifest.name || !manifest.version)
+    throw new Error(
+      "Create an application with a package name and version first",
+    );
+  const configPath = path.join(directory, "glass.config.json");
+  if (!fs.existsSync(configPath))
+    fs.copyFileSync(
+      new URL("../glass.config.example.json", import.meta.url),
+      configPath,
+    );
+  const ignore = path.join(directory, ".gitignore");
+  const content = fs.existsSync(ignore) ? fs.readFileSync(ignore, "utf8") : "";
+  if (!content.split(/\r?\n/u).includes("/.glass/"))
+    fs.writeFileSync(
+      ignore,
+      `${content}${content.endsWith("\n") || !content ? "" : "\n"}/.glass/\n`,
+    );
+  const config = readApplication(directory);
+  for (const target of Object.keys(config.urls.development))
+    await withTargetLock(directory, target, "dev", () =>
+      prepareHost(directory, target),
+    );
+  return configPath;
+}

package/lib/config.mjs

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const TARGETS = ["desktop", "ios", "android"];
+function object(value, keys, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object`);
+  for (const key of Object.keys(value))
+    if (!keys.includes(key))
+      throw new Error(`${label}.${key} is not supported`);
+}
+function text(value, label) {
+  if (typeof value !== "string" || !value.trim() || /[\x00-\x1f]/u.test(value))
+    throw new Error(`${label} must be nonempty, single-line text`);
+}
+export function appURL(value, release = false) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Application URL must be an absolute HTTP(S) URL");
+  }
+  if (
+    !["http:", "https:"].includes(url.protocol) ||
+    url.username ||
+    url.password
+  )
+    throw new Error("Application URL must be HTTP(S) without credentials");
+  if (url.search || url.hash)
+    throw new Error(
+      "Application URLs must not contain query parameters or fragments",
+    );
+  if (release && url.protocol !== "https:")
+    throw new Error("Release URLs must use HTTPS");
+  return url.href;
+}
+export function readJSON(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new Error(`Cannot read ${file}: ${error.message}`);
+  }
+}
+export function validateConfig(value) {
+  object(
+    value,
+    ["appName", "appId", "buildNumber", "urls", "icon", "ios"],
+    "glass.config.json",
+  );
+  text(value.appName, "appName");
+  if (!/^[A-Za-z][A-Za-z0-9]*(?:\.[A-Za-z][A-Za-z0-9]*)+$/u.test(value.appId))
+    throw new Error(
+      "appId must be a reverse-domain identifier, for example com.example.myapp",
+    );
+  if (
+    !Number.isSafeInteger(value.buildNumber) ||
+    value.buildNumber < 1 ||
+    value.buildNumber > 2100000000
+  )
+    throw new Error("buildNumber must be an integer from 1 to 2100000000");
+  object(value.urls, ["development", "release"], "urls");
+  object(value.urls.development, TARGETS, "urls.development");
+  if (Object.keys(value.urls.development).length === 0)
+    throw new Error("Configure at least one development target");
+  for (const url of Object.values(value.urls.development)) appURL(url);
+  if (value.urls.release !== undefined) appURL(value.urls.release, true);
+  if (value.icon !== undefined) text(value.icon, "icon");
+  if (value.ios !== undefined) {
+    object(value.ios, ["teamId", "exportOptions"], "ios");
+    if (
+      value.ios.teamId !== undefined &&
+      !/^[A-Z0-9]{10}$/u.test(value.ios.teamId)
+    )
+      throw new Error("ios.teamId must be a 10-character Apple team ID");
+    if (value.ios.exportOptions !== undefined)
+      text(value.ios.exportOptions, "ios.exportOptions");
+  }
+  return value;
+}
+export function readApplication(directory) {
+  const appDirectory = path.resolve(directory);
+  const manifest = readJSON(path.join(appDirectory, "package.json"));
+  text(manifest.name, "package.json name");
+  const version =
+    /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u.exec(
+      manifest.version,
+    );
+  if (!version)
+    throw new Error("package.json version must be a semantic version");
+  const config = validateConfig(
+    readJSON(path.join(appDirectory, "glass.config.json")),
+  );
+  return {
+    ...config,
+    appDirectory,
+    version: manifest.version,
+    nativeVersion: version.slice(1, 4).join("."),
+  };
+}
+export function resolveURL(config, target, mode, override) {
+  if (!TARGETS.includes(target))
+    throw new Error(`Choose ${TARGETS.join(", ")}`);
+  if (!["dev", "release"].includes(mode))
+    throw new Error("Mode must be dev or release");
+  const url =
+    override ??
+    (mode === "release"
+      ? config.urls.release
+      : config.urls.development[target]);
+  if (!url)
+    throw new Error(
+      `Configure ${mode === "release" ? "urls.release" : `urls.development.${target}`} or pass --url`,
+    );
+  return appURL(url, mode === "release");
+}

package/lib/java.mjs

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+export function environmentForGradle(environment = process.env) {
+  if (!environment.JAVA_HOME)
+    throw new Error(
+      "Set JAVA_HOME to a JDK 21–24 installation before building Android",
+    );
+  const home = path.resolve(environment.JAVA_HOME);
+  const java = path.join(
+    home,
+    "bin",
+    process.platform === "win32" ? "java.exe" : "java",
+  );
+  if (!fs.existsSync(java))
+    throw new Error(`JAVA_HOME does not contain a Java executable: ${home}`);
+  const result = spawnSync(java, ["-version"], { encoding: "utf8" });
+  const version = /version\s+"(\d+)/u.exec(
+    `${result.stdout ?? ""}\n${result.stderr ?? ""}`,
+  )?.[1];
+  if (
+    result.status !== 0 ||
+    !version ||
+    Number(version) < 21 ||
+    Number(version) > 24
+  )
+    throw new Error(
+      "Glass Android requires JDK 21–24 with Gradle 8.14.3; update JAVA_HOME",
+    );
+  return {
+    ...environment,
+    JAVA_HOME: home,
+    PATH: `${path.join(home, "bin")}${path.delimiter}${environment.PATH ?? ""}`,
+  };
+}

package/lib/lock.mjs

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import path from "node:path";
+export async function withTargetLock(appDirectory, target, mode, action) {
+  const locks = path.join(path.resolve(appDirectory), ".glass", "locks");
+  fs.mkdirSync(locks, { recursive: true });
+  const lock = path.join(locks, `${target}-${mode}`);
+  try {
+    fs.mkdirSync(lock);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    throw new Error(
+      `Another ${target} ${mode} operation owns ${lock}. If it was terminated, remove this lock before retrying.`,
+    );
+  }
+  fs.writeFileSync(
+    path.join(lock, "owner.json"),
+    JSON.stringify({ pid: process.pid }),
+  );
+  try {
+    return await action();
+  } finally {
+    fs.rmSync(lock, { recursive: true, force: true });
+  }
+}

package/lib/workflow.mjs

@@ -0,0 +1,181 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { prepareHost } from "./assembly.mjs";
+import { withTargetLock } from "./lock.mjs";
+export { withTargetLock } from "./lock.mjs";
+import { environmentForGradle } from "./java.mjs";
+
+export function run(command, args, { cwd, env = process.env } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env,
+      stdio: "inherit",
+      shell: process.platform === "win32" && command.endsWith(".bat"),
+    });
+    const interrupt = () => child.kill("SIGINT");
+    const terminate = () => child.kill("SIGTERM");
+    process.on("SIGINT", interrupt);
+    process.on("SIGTERM", terminate);
+    const cleanup = () => {
+      process.off("SIGINT", interrupt);
+      process.off("SIGTERM", terminate);
+    };
+    child.once("error", (error) => {
+      cleanup();
+      reject(error);
+    });
+    child.once("exit", (code, signal) => {
+      cleanup();
+      code === 0
+        ? resolve()
+        : reject(
+            new Error(
+              `${path.basename(command)} exited with ${signal ?? code}`,
+            ),
+          );
+    });
+  });
+}
+export async function nativeAction(
+  appDirectory,
+  target,
+  action,
+  options = {},
+  forwarded = [],
+) {
+  const mode = action === "run" ? "dev" : "release";
+  if (target === "ios" && process.platform !== "darwin")
+    throw new Error("iOS requires macOS and Xcode");
+  return withTargetLock(appDirectory, target, mode, async () => {
+    const host = prepareHost(appDirectory, target, mode, options.url);
+    const require = createRequire(path.join(host.source, "package.json"));
+    const context = { cwd: host.directory };
+    if (target === "desktop") {
+      if (action === "run") {
+        await run(require("electron"), [host.directory, ...forwarded], context);
+      } else {
+        await run(
+          process.execPath,
+          [
+            require.resolve("electron-builder/cli.js"),
+            "--projectDir",
+            host.directory,
+            "--config",
+            path.join(host.directory, "electron-builder.config.cjs"),
+            ...forwarded,
+          ],
+          { ...context, env: { ...process.env, GLASS_OUTPUT: host.artifacts } },
+        );
+      }
+      return host;
+    }
+    if (target === "android") context.env = environmentForGradle(process.env);
+    const capacitor = require.resolve("@capacitor/cli/bin/capacitor");
+    if (action === "run") {
+      await run(
+        process.execPath,
+        [capacitor, "run", target, ...forwarded],
+        context,
+      );
+      return host;
+    }
+    if (forwarded.length)
+      throw new Error(
+        "Mobile packaging does not accept forwarded arguments; use --unsigned or ios.exportOptions",
+      );
+    if (
+      target === "ios" &&
+      !options.unsigned &&
+      (!host.config.ios?.teamId || !host.config.ios?.exportOptions)
+    )
+      throw new Error(
+        "Signed iOS packaging requires ios.teamId and ios.exportOptions; use --unsigned for a build-only archive",
+      );
+    if (target === "android" && !options.unsigned) {
+      for (const key of [
+        "GLASS_ANDROID_KEYSTORE",
+        "GLASS_ANDROID_STORE_PASSWORD",
+        "GLASS_ANDROID_KEY_ALIAS",
+        "GLASS_ANDROID_KEY_PASSWORD",
+      ])
+        if (!process.env[key])
+          throw new Error(
+            `Signed Android packaging requires ${key}; use --unsigned for a build-only bundle`,
+          );
+    }
+    await run(process.execPath, [capacitor, "sync", target], context);
+    fs.mkdirSync(host.artifacts, { recursive: true });
+    if (target === "ios") {
+      const archive = path.join(host.artifacts, "App.xcarchive");
+      await run(
+        "xcodebuild",
+        [
+          "-project",
+          "ios/App/App.xcodeproj",
+          "-scheme",
+          "App",
+          "-configuration",
+          "Release",
+          "-destination",
+          "generic/platform=iOS",
+          "-derivedDataPath",
+          path.join(host.directory, "DerivedData"),
+          "-archivePath",
+          archive,
+          ...(options.unsigned
+            ? ["CODE_SIGNING_ALLOWED=NO"]
+            : [`DEVELOPMENT_TEAM=${host.config.ios.teamId}`]),
+          "archive",
+        ],
+        context,
+      );
+      if (!options.unsigned)
+        await run(
+          "xcodebuild",
+          [
+            "-exportArchive",
+            "-archivePath",
+            archive,
+            "-exportPath",
+            host.artifacts,
+            "-exportOptionsPlist",
+            path.resolve(
+              host.config.appDirectory,
+              host.config.ios.exportOptions,
+            ),
+          ],
+          context,
+        );
+    } else {
+      const env = {
+        ...context.env,
+        GLASS_UNSIGNED: options.unsigned ? "1" : "0",
+      };
+      if (env.GLASS_ANDROID_KEYSTORE)
+        env.GLASS_ANDROID_KEYSTORE = path.resolve(
+          host.config.appDirectory,
+          env.GLASS_ANDROID_KEYSTORE,
+        );
+      await run(
+        process.platform === "win32" ? "gradlew.bat" : "sh",
+        [
+          ...(process.platform === "win32" ? [] : ["./gradlew"]),
+          "--no-daemon",
+          ":app:bundleRelease",
+        ],
+        { cwd: path.join(host.directory, "android"), env },
+      );
+      fs.copyFileSync(
+        path.join(
+          host.directory,
+          "android/app/build/outputs/bundle/release/app-release.aab",
+        ),
+        path.join(host.artifacts, "app-release.aab"),
+      );
+    }
+    return host;
+  });
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@glass-sdk/cli",
+  "version": "0.0.1",
+  "description": "The Glass consumer command for preparing, running, and packaging native app targets.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Glass-HQ/Glass-SDK.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "bin",
+    "lib",
+    "glass.config.example.json",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node --check bin/glass.mjs"
+  },
+  "dependencies": {
+    "@glass-sdk/host-desktop": "workspace:*",
+    "@glass-sdk/host-mobile": "workspace:*",
+    "@glass-sdk/file-picker": "workspace:*"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "bin": {
+    "glass": "bin/glass.mjs"
+  }
+}