@owear/cli 0.1.2 → 0.1.4

package/tools/owear-sign.mjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// tools/owear-sign.mjs — firma de artefactos de Owear.
+//
+// Dos mecanismos, combinables:
+//
+//   1. Authenticode (Windows PE, .exe/.msi): firma del binario con un
+//      certificado (PFX/P12). Requiere `osslsigncode` (Linux/macOS) o
+//      `signtool` (Windows). Da confianza de **editor** ante el SO
+//      (SmartScreen, "Unknown publisher").
+//
+//   2. Ed25519 desprendida (cualquier plataforma): escribe `<file>.sig` con la
+//      firma del fichero completo. La clave pública (misma que el updater)
+//      permite verificar el artefacto de forma independiente del feed.
+//
+// Nunca rompe un build: si no hay material de firma o falta la herramienta,
+// omite con un aviso (salvo `--require`, que lo convierte en error).
+//
+// Uso:
+//   node tools/owear-sign.mjs --file release/MiApp \
+//     [--ed25519-key owear-signing.pem] \
+//     [--pfx cert.p12 --pfx-password-env OW_PFX_PASS] \
+//     [--timestamp http://timestamp.digicert.com] \
+//     [--name "Mi App" --url https://miapp.dev] \
+//     [--require] [--dry-run]
+//
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as crypto from 'node:crypto'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const C = { reset: '\x1b[0m', dim: '\x1b[2m', green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m' }
+const info = (m) => console.log(`${C.dim}[owear-sign]${C.reset} ${m}`)
+const warn = (m) => console.warn(`${C.yellow}[owear-sign] ⚠${C.reset} ${m}`)
+const fail = (m) => console.error(`${C.red}[owear-sign] ✗${C.reset} ${m}`)
+
+const isPE = (file) => {
+  try {
+    const fd = fs.openSync(file, 'r')
+    const b = Buffer.alloc(2)
+    fs.readSync(fd, b, 0, 2, 0)
+    fs.closeSync(fd)
+    return b[0] === 0x4d && b[1] === 0x5a // "MZ"
+  } catch {
+    return false
+  }
+}
+
+const PE_EXT = new Set(['.exe', '.dll', '.msi', '.sys', '.ocx', '.scr'])
+
+/** ¿Es un PE/MSI firmable con Authenticode? (por extensión o cabecera MZ). */
+export function isAuthenticodeTarget(file) {
+  if (PE_EXT.has(path.extname(file).toLowerCase())) return true
+  return isPE(file)
+}
+
+/** Comando de firma Authenticode según la herramienta disponible. */
+export function buildAuthenticodeInvocation({ tool, file, pfx, password, timestamp, name, url }) {
+  if (tool === 'osslsigncode') {
+    const args = ['sign', '-pkcs12', pfx, '-in', file, '-out', `${file}.signed`]
+    if (password) args.push('-pass', password)
+    if (name) args.push('-n', name)
+    if (url) args.push('-i', url)
+    if (timestamp) args.push('-t', timestamp)
+    return { cmd: 'osslsigncode', args, out: `${file}.signed`, inPlace: true }
+  }
+  if (tool === 'signtool') {
+    const args = ['sign', '/f', pfx, '/fd', 'SHA256', '/d', name || path.basename(file)]
+    if (password) args.push('/p', password)
+    if (timestamp) args.push('/tr', timestamp, '/td', 'SHA256')
+    args.push(file)
+    return { cmd: 'signtool', args, out: file, inPlace: false }
+  }
+  throw new Error(`herramienta de firma desconocida: ${tool}`)
+}
+
+/** ¿Está la herramienta en el PATH? */
+export function hasTool(cmd) {
+  const probe = process.platform === 'win32' ? 'where' : 'which'
+  return spawnSync(probe, [cmd], { stdio: 'ignore' }).status === 0
+}
+
+/** Firma Ed25519 desprendida: escribe `<file>.sig` (base64) y devuelve la firma. */
+export function signEd25519(file, keyPath) {
+  const data = fs.readFileSync(file)
+  const key = crypto.createPrivateKey(fs.readFileSync(keyPath))
+  const sig = crypto.sign(null, data, key)
+  fs.writeFileSync(`${file}.sig`, sig.toString('base64') + '\n')
+  return sig
+}
+
+/** Verifica una firma Ed25519 desprendida contra `pub` (PEM o SPKI base64). */
+export function verifyEd25519(file, sigPath, pub) {
+  const key = pub.includes('BEGIN')
+    ? crypto.createPublicKey(pub)
+    : crypto.createPublicKey({ key: Buffer.from(pub, 'base64'), format: 'der', type: 'spki' })
+  const data = fs.readFileSync(file)
+  const sig = Buffer.from(fs.readFileSync(sigPath, 'utf8').trim(), 'base64')
+  return crypto.verify(null, data, key, sig)
+}
+
+/** Firma Authenticode (in-place si es posible). Devuelve 'signed'|'skipped'|'failed'. */
+export function signAuthenticode({ file, pfx, password, timestamp, name, url, require = false }) {
+  const tool = hasTool('osslsigncode') ? 'osslsigncode' : hasTool('signtool') ? 'signtool' : null
+  if (!tool) {
+    const msg = 'ni osslsigncode ni signtool están en el PATH'
+    if (require) throw new Error(msg)
+    warn(`${msg} — Authenticode omitido`)
+    return 'skipped'
+  }
+  if (!pfx || !fs.existsSync(pfx)) {
+    const msg = `certificado no encontrado: ${pfx ?? '(sin --pfx)'}`
+    if (require) throw new Error(msg)
+    warn(`${msg} — Authenticode omitido`)
+    return 'skipped'
+  }
+  const inv = buildAuthenticodeInvocation({ tool, file, pfx, password, timestamp, name, url })
+  const r = spawnSync(inv.cmd, inv.args, { stdio: 'inherit' })
+  if (r.status !== 0) {
+    if (require) throw new Error(`${inv.cmd} falló (${r.status})`)
+    warn(`${inv.cmd} falló (${r.status})`)
+    return 'failed'
+  }
+  if (inv.inPlace) {
+    fs.renameSync(inv.out, file)
+    info(`Authenticode OK (${tool})`)
+  } else {
+    info(`Authenticode OK (${tool})`)
+  }
+  return 'signed'
+}
+
+function main() {
+  const argv = process.argv.slice(2)
+  const arg = (n, def = null) => (argv.includes(n) ? argv[argv.indexOf(n) + 1] : def)
+  const flag = (n) => argv.includes(n)
+
+  const file = arg('--file')
+  if (!file) {
+    fail('--file es obligatorio')
+    process.exit(1)
+  }
+  if (!fs.existsSync(file)) {
+    fail(`no existe: ${file}`)
+    process.exit(1)
+  }
+
+  const edKey = arg('--ed25519-key')
+  const pfx = arg('--pfx')
+  const pwEnv = arg('--pfx-password-env')
+  const password = arg('--password', pwEnv ? process.env[pwEnv] ?? '' : '')
+  const timestamp = arg('--timestamp')
+  const name = arg('--name')
+  const url = arg('--url')
+  const require = flag('--require')
+  const dryRun = flag('--dry-run')
+  const isWin = process.platform === 'win32'
+
+  let did = 0
+
+  // 1) Authenticode (solo PE/MSI y solo en Windows o con osslsigncode)
+  if (pfx) {
+    if (!isAuthenticodeTarget(file)) {
+      info(`${path.basename(file)} no es PE/MSI — Authenticode no aplica`)
+    } else if (dryRun) {
+      const tool = hasTool('osslsigncode') ? 'osslsigncode' : 'signtool'
+      const inv = buildAuthenticodeInvocation({ tool, file, pfx, password, timestamp, name, url })
+      console.log(JSON.stringify({ authenticode: { cmd: inv.cmd, args: inv.args } }))
+      did++
+    } else {
+      if (signAuthenticode({ file, pfx, password, timestamp, name, url, require }) === 'signed') did++
+    }
+  }
+
+  // 2) Ed25519 desprendida (siempre disponible)
+  if (edKey) {
+    if (!fs.existsSync(edKey)) {
+      fail(`clave no encontrada: ${edKey}`)
+      process.exit(1)
+    }
+    if (dryRun) {
+      console.log(JSON.stringify({ ed25519: { file, key: edKey, out: `${file}.sig` } }))
+    } else {
+      signEd25519(file, edKey)
+      info(`Ed25519 OK → ${path.basename(file)}.sig`)
+      did++
+    }
+  }
+
+  if (!did) {
+    if (require) {
+      fail('no se firmó nada (--require)')
+      process.exit(1)
+    }
+    warn('sin material de firma (--ed25519-key / --pfx) — nada que hacer')
+  }
+  void isWin
+}
+
+// Ejecuta main solo como script (permite importarlo en tests).
+if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) main()

package/tools/owear-update.mjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// tools/owear-update.mjs — publica un update de Owear: calcula el blockmap
+// (delta por bloques), genera el manifiesto YAML del canal y lo firma con
+// Ed25519.
+//
+// Salidas (en --out-dir, por defecto junto al artefacto):
+//   <file>.blockmap   { blockSize, size, blocks:[sha256…] }
+//   <channel>.yml     manifiesto YAML (version, sha256, sha512, blockSize,
+//                     blockmap, path, releaseDate, notes, signature)
+//
+// El SDK (autoUpdater) verifica `signature` con la clave pública del bridge
+// (Ed25519 sobre "<version>:<sha256>") y descarga solo los bloques cambiados.
+//
+// Uso:
+//   node tools/owear-update.mjs --file release/MiApp-1.4.0 --version 1.4.0 \
+//     --channel latest --url https://up.miapp.dev --key private.pem \
+//     [--notes "…"|--notes @notes.md] [--block-size 262144] [--mandatory] \
+//     [--out-dir release]
+//
+//   # claves (una vez):
+//   node tools/owear-update.mjs --gen-key ./owear-signing
+//       → owear-signing.pem (privada, Ed25519 PKCS8)
+//         owear-signing.pub.b64 (pública SPKI base64 — va en el bridge)
+//
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as crypto from 'node:crypto'
+
+function die(m) {
+  console.error(`[owear-update] ✗ ${m}`)
+  process.exit(1)
+}
+const argv = process.argv.slice(2)
+const arg = (n, def = null) => (argv.includes(n) ? argv[argv.indexOf(n) + 1] : def)
+const flag = (n) => argv.includes(n)
+
+// ── generación de claves ────────────────────────────────────────────────────
+const genKey = arg('--gen-key')
+if (genKey) {
+  if (fs.existsSync(`${genKey}.pem`)) die(`ya existe ${genKey}.pem`)
+  const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519')
+  fs.writeFileSync(`${genKey}.pem`, privateKey.export({ format: 'pem', type: 'pkcs8' }), { mode: 0o600 })
+  fs.writeFileSync(`${genKey}.pub.b64`, publicKey.export({ format: 'der', type: 'spki' }).toString('base64'))
+  console.log(`[owear-update] ✓ clave privada: ${genKey}.pem`)
+  console.log(`[owear-update] ✓ clave pública: ${genKey}.pub.b64 (ponla en el bridge: updater.publicKey)`)
+  process.exit(0)
+}
+
+// ── validación de argumentos ────────────────────────────────────────────────
+const file = arg('--file')
+const version = arg('--version')
+if (!file || !version) die('--file y --version son obligatorios (o usa --gen-key)')
+if (!fs.existsSync(file)) die(`no existe el artefacto: ${file}`)
+if (!/^\d+\.\d+\.\d+/.test(version)) die(`versión inválida: ${version} (semver esperado)`)
+
+const channel = arg('--channel', 'latest')
+const blockSize = parseInt(arg('--block-size', '262144'), 10)
+if (!Number.isFinite(blockSize) || blockSize <= 0) die('--block-size inválido')
+const baseUrl = (arg('--url', '') || '').replace(/\/+$/, '')
+const outDir = arg('--out-dir', path.dirname(file))
+const keyPath = arg('--key')
+const mandatory = flag('--mandatory')
+
+let notes = arg('--notes', '')
+if (notes.startsWith('@')) {
+  const nf = notes.slice(1)
+  if (!fs.existsSync(nf)) die(`no existe el fichero de notas: ${nf}`)
+  notes = fs.readFileSync(nf, 'utf8').trimEnd()
+}
+
+// ── integridad + blockmap ───────────────────────────────────────────────────
+const data = fs.readFileSync(file)
+const sha256 = crypto.createHash('sha256').update(data).digest('hex')
+const sha512 = crypto.createHash('sha512').update(data).digest('hex')
+
+const blocks = []
+for (let off = 0; off < data.length; off += blockSize) {
+  blocks.push(crypto.createHash('sha256').update(data.subarray(off, Math.min(off + blockSize, data.length))).digest('hex'))
+}
+if (data.length === 0) blocks.push(crypto.createHash('sha256').update(Buffer.alloc(0)).digest('hex'))
+
+fs.mkdirSync(outDir, { recursive: true })
+const artifactName = path.basename(file)
+const blockmapPath = path.join(outDir, `${artifactName}.blockmap`)
+fs.writeFileSync(blockmapPath, JSON.stringify({ blockSize, size: data.length, sha256, blocks }))
+
+// ── firma Ed25519 (del manifiesto y del binario) ────────────────────────────
+//   signature:  sobre "<version>:<sha256>" (autentica metadata)
+//   binarySig:  sobre los bytes del artefacto (autentica el payload)
+let signature = ''
+let binarySig = ''
+if (keyPath) {
+  if (!fs.existsSync(keyPath)) die(`no existe la clave: ${keyPath}`)
+  const privateKey = crypto.createPrivateKey(fs.readFileSync(keyPath))
+  signature = crypto
+    .sign(null, Buffer.from(`${version}:${sha256}`), privateKey)
+    .toString('base64')
+  binarySig = crypto.sign(null, data, privateKey).toString('base64')
+}
+
+// ── manifiesto YAML ─────────────────────────────────────────────────────────
+const blockmapUrl = baseUrl ? `${baseUrl}/${path.basename(blockmapPath)}` : path.basename(blockmapPath)
+const releaseDate = new Date().toISOString()
+const yamlEscape = (s) => (/[:#'"@|>{}\[\],&*!?%`-]|^\s|\s$|\n/.test(s) ? `'${s.replace(/'/g, "''")}'` : s)
+// las notas van como bloque literal
+const notesBlock = notes
+  ? `notes: |\n${notes
+      .split('\n')
+      .map((l) => `  ${l}`)
+      .join('\n')}\n`
+  : ''
+
+const manifest = [
+  `version: ${version}`,
+  `releaseDate: '${releaseDate}'`,
+  `path: ${yamlEscape(artifactName)}`,
+  // hashes y firmas se citan siempre: un valor "numérico" (p. ej. un hash solo
+  // de dígitos) no debe reinterpretarse como número al parsear el YAML.
+  `sha256: '${sha256}'`,
+  `sha512: '${sha512}'`,
+  `size: ${data.length}`,
+  `blockSize: ${blockSize}`,
+  `blockmap: ${yamlEscape(blockmapUrl)}`,
+  mandatory ? 'mandatory: true' : null,
+  signature ? `signature: '${signature}'` : null,
+  binarySig ? `binarySig: '${binarySig}'` : null,
+  notesBlock || null,
+  '',
+]
+  .filter((l) => l !== null)
+  .join('\n')
+
+const manifestPath = path.join(outDir, `${channel}.yml`)
+fs.writeFileSync(manifestPath, manifest)
+
+// ── resumen ─────────────────────────────────────────────────────────────────
+const mb = (n) => (n / 1024 / 1024).toFixed(1)
+console.log(`[owear-update] ✓ artefacto  ${artifactName}  ${mb(data.length)} MB`)
+console.log(`[owear-update] ✓ blockmap   ${path.basename(blockmapPath)}  (${blocks.length} bloques × ${(blockSize / 1024).toFixed(0)} KiB)`)
+console.log(`[owear-update] ✓ manifiesto ${manifestPath}`)
+console.log(`[owear-update] ${signature ? '✓ firmado' : '⚠ sin firma (--key)'}  sha256=${sha256.slice(0, 16)}…`)
+if (baseUrl) {
+  console.log(`[owear-update] feed: ${baseUrl}`)
+  console.log(`[owear-update]   ${baseUrl}/${channel}.yml`)
+  console.log(`[owear-update]   ${baseUrl}/${artifactName}`)
+  console.log(`[owear-update]   ${baseUrl}/${path.basename(blockmapPath)}`)
+}

package/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.