@owear/cli 0.1.2 → 0.1.4

package/template-installer/uninstaller/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "__PKG_NAME__-uninstaller",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Desinstalador de __APP_NAME__ — app Owear en modo uninstaller.",
+  "scripts": {
+    "build": "ow build uninstaller",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@owear/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@owear/cli": "^0.1.0",
+    "@owear/vite-plugin": "^0.1.0",
+    "@types/node": "^20.14.0",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.6.0",
+    "vite": "^6.0.0"
+  }
+}

package/template-installer/uninstaller/src/uninstaller.ts

@@ -0,0 +1,101 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// src/uninstaller.ts — UI del desinstalador (vanilla). Mismo bridge, pero
+// invoca `installer.uninstall`. Detecta la instalación por el REGISTRO de Owear
+// (no hace falta escribir la ruta ni usar módulos .owm).
+// Estilos: tokens del Starter (ver ../../src/style.css).
+
+import '../../src/style.css'
+
+interface OwBridge {
+  invoke<T = unknown>(module: string, fn: string, ...args: unknown[]): Promise<T>
+}
+const ow = (window as unknown as { ow: OwBridge }).ow
+const wid = (window as unknown as { __owWindowId: number }).__owWindowId
+
+const $ = <T extends HTMLElement = HTMLElement>(sel: string): T =>
+  document.querySelector(sel) as T
+const invoke = <T = unknown>(module: string, fn: string, ...args: unknown[]): Promise<T> =>
+  ow.invoke<T>(module, fn, ...args)
+
+interface StateResult {
+  installed: boolean
+  version?: string
+  app?: string
+  dir?: string
+}
+interface Info {
+  appName?: string
+  version?: string
+  dir?: string
+  installed?: boolean
+}
+
+function setStatus(msg: string, kind: 'ok' | 'err' | '' = ''): void {
+  const el = $('#status')
+  el.textContent = msg
+  el.dataset.kind = kind
+}
+
+async function boot(): Promise<void> {
+  $('#win-min').addEventListener('click', () => void invoke('ow-window', 'minimize', wid))
+  $('#win-close').addEventListener('click', () => void invoke('ow-window', 'close', wid))
+
+  const info = await invoke<Info>('installer', 'info').catch(() => ({}))
+  const st = await invoke<StateResult>('installer', 'state', {}).catch(() => ({
+    installed: false,
+  }))
+  const name = st.app ?? info.appName ?? 'La app'
+  const dir = st.dir ?? info.dir ?? ''
+
+  if (st.installed) {
+    const v = st.version ?? info.version ?? ''
+    $('#summary').textContent = `${name}${v ? ' ' + v : ''} está instalada${
+      dir ? ' en ' + dir : ''
+    }.`
+  } else {
+    $('#summary').textContent =
+      'No se detectó ninguna instalación registrada. Elige la carpeta donde se instaló.'
+  }
+  ;($('#dir') as HTMLInputElement).value = dir
+  $('#uninstall').removeAttribute('disabled')
+}
+
+async function pickDir(): Promise<void> {
+  const current = ($('#dir') as HTMLInputElement).value.trim()
+  try {
+    // Selector NATIVO del builtin installer (no usa el módulo `dialog`).
+    const dir = await invoke<string | null>('installer', 'chooseDir', {
+      title: 'Elegir carpeta de instalación',
+      defaultPath: current,
+    })
+    if (dir) ($('#dir') as HTMLInputElement).value = dir
+  } catch {
+    /* cancelado */
+  }
+}
+
+async function doUninstall(): Promise<void> {
+  const dir = ($('#dir') as HTMLInputElement).value.trim()
+  const keepData = ($('#keepData') as HTMLInputElement).checked
+  $('#uninstall').setAttribute('disabled', 'true')
+  setStatus('Desinstalando…')
+  try {
+    // Si no hay dir, el builtin usa el registrado.
+    const res = await invoke<{ removed: number }>(
+      'installer',
+      'uninstall',
+      dir ? { dir, keepData } : { keepData },
+    )
+    setStatus(`Eliminados ${res.removed} ficheros.`, 'ok')
+    setTimeout(() => void invoke('ow-window', 'close', wid), 900)
+  } catch (e) {
+    setStatus(e instanceof Error ? e.message : String(e), 'err')
+    $('#uninstall').removeAttribute('disabled')
+  }
+}
+
+$('#pick').addEventListener('click', () => void pickDir())
+$('#uninstall').addEventListener('click', () => void doUninstall())
+void boot()

package/template-installer/uninstaller/vite.config.ts

@@ -0,0 +1,10 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { defineConfig } from 'vite'
+import owear from '@owear/vite-plugin'
+
+export default defineConfig({
+  plugins: [owear()],
+  base: './',
+  build: { outDir: 'ui-dist', emptyOutDir: true },
+})

package/template-installer/vite.config.ts

@@ -0,0 +1,15 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+import { defineConfig } from 'vite'
+import owear from '@owear/vite-plugin'
+
+export default defineConfig({
+  plugins: [owear()],
+  base: './',
+  build: {
+    // `ow build installer` recoge este directorio como `ui/` del instalador.
+    outDir: 'ui-dist',
+    emptyOutDir: true,
+  },
+})

package/tools/owear-installer.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// tools/owear-installer.mjs — ensambla el payload del INSTALADOR y lo empaqueta
+// dentro del binario instalador (kernel + footer OWPK1).
+//
+// El instalador es un binario Owear aparte: al arrancar detecta `installer.json`
+// (o `uninstaller.json`) y entra en modo installer/uninstaller (ver
+// src/Core/App/Internal.cpp), sirviendo `ui/` como assets y exponiendo la API
+// `installer` (src/api/installer).
+//
+// Layout del payload del instalador:
+//   installer.json   metadatos de la app + modo/orden (del bridge)
+//   bridge.json      contrato embebido (owear.bridge.ts compilado)
+//   ui/              renderer + sidecar del instalador
+//   payload/         lo que se instala (binario único [minimal] o árbol [layout])
+//   modules/         módulos .owm extra (opcional)
+//
+// Uso:
+//   node tools/owear-installer.mjs --kernel <owear> --out <MiAppInstaller> \
+//     --ui <distUI> --payload <dir> [--bridge <bridge.json>] [--meta <installer.json>] \
+//     [--modules <dir>] [--name <slug>]
+//
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+function die(m) {
+  console.error(`[owear-installer] ✗ ${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 kernel = arg('--kernel')
+const out = arg('--out')
+const ui = arg('--ui')
+const payload = arg('--payload')
+const bridge = arg('--bridge')
+const meta = arg('--meta')
+const modules = arg('--modules')
+const icon = arg('--icon')
+const name = arg('--name', 'app')
+
+if (!kernel || !out || !ui) die('uso: --kernel <owear> --out <bin> --ui <distUI> [--payload <dir>]')
+if (!fs.existsSync(kernel)) die(`no existe el kernel: ${kernel}`)
+if (!fs.existsSync(ui)) die(`no existe el ui: ${ui}`)
+
+const stage = fs.mkdtempSync(path.join(os.tmpdir(), 'owear-installer-'))
+const copyInto = (src, dstRel) => {
+  const dst = path.join(stage, dstRel)
+  fs.mkdirSync(path.dirname(dst), { recursive: true })
+  fs.cpSync(src, dst, { recursive: true })
+}
+
+copyInto(ui, 'ui')
+if (payload && fs.existsSync(payload)) copyInto(payload, 'payload')
+if (bridge && fs.existsSync(bridge)) fs.copyFileSync(bridge, path.join(stage, 'bridge.json'))
+if (meta && fs.existsSync(meta)) fs.copyFileSync(meta, path.join(stage, 'installer.json'))
+if (modules && fs.existsSync(modules)) copyInto(modules, 'modules')
+// icono de la app (para el .desktop / acceso directo del instalado)
+if (icon && fs.existsSync(icon)) {
+  fs.copyFileSync(icon, path.join(stage, 'icon' + path.extname(icon)))
+}
+
+// manifiesto mínimo del payload del instalador (informativo)
+fs.writeFileSync(
+  path.join(stage, 'manifest.json'),
+  JSON.stringify({ kind: 'installer', name, createdAt: Date.now() }, null, 2) + '\n',
+)
+
+// Empaqueta con el empaquetador existente (mismo formato OWPK1).
+const packer = path.join(__dirname, 'owear-pack.mjs')
+const r = spawnSync(
+  process.execPath,
+  [packer, '--kernel', kernel, '--in', stage, '--out', out],
+  { stdio: 'inherit' },
+)
+fs.rmSync(stage, { recursive: true, force: true })
+if (r.status !== 0) die('falló owear-pack')
+console.log(`[owear-installer] instalador: ${out}`)

package/tools/owear-linux.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// tools/owear-linux.mjs — empaquetado Linux de la app (D1).
+//
+//   deb        → .deb (ar + control.tar.gz + data.tar.gz), sin deps externas.
+//   appimage   → AppDir + appimagetool (si está en PATH).
+//
+// Uso:
+//   node tools/owear-linux.mjs deb --stage <dataRoot> --out <x.deb> \
+//     --name <slug> --version <v> [--arch amd64] [--maintainer <m>] [--description <d>]
+//   node tools/owear-linux.mjs appimage --appdir <AppDir> --out <x.AppImage>
+//
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as zlib from 'node:zlib'
+import { spawnSync } from 'node:child_process'
+
+function die(m) {
+  console.error(`[owear-linux] ✗ ${m}`)
+  process.exit(1)
+}
+const argv = process.argv.slice(2)
+const cmd = argv[0]
+const arg = (n, def = null) => (argv.includes(n) ? argv[argv.indexOf(n) + 1] : def)
+
+// ── tar (ustar) + gzip ──────────────────────────────────────────────────────
+function oct(n, len) {
+  return n.toString(8).padStart(len - 1, '0') + '\0'
+}
+function tarHeader(name, size, mode, typeflag, mtime = 0) {
+  const h = Buffer.alloc(512, 0)
+  const nm = name.length > 100 ? name.slice(0, 100) : name
+  h.write(nm, 0, 100, 'utf8')
+  h.write(oct(mode, 8), 100)
+  h.write(oct(0, 8), 108)
+  h.write(oct(0, 8), 116)
+  h.write(oct(size, 12), 124)
+  h.write(oct(mtime, 12), 136)
+  h.write('        ', 148)
+  h.write(typeflag, 156)
+  h.write('ustar\0', 257)
+  h.write('00', 263)
+  let sum = 0
+  for (const b of h) sum += b
+  h.write(sum.toString(8).padStart(6, '0') + '\0 ', 148)
+  return h
+}
+function tarDir(dir) {
+  const chunks = []
+  const walk = (d, base) => {
+    for (const e of fs.readdirSync(d, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const p = path.join(d, e.name)
+      const rel = base ? `${base}/${e.name}` : e.name
+      const st = fs.lstatSync(p)
+      if (st.isSymbolicLink()) {
+        chunks.push(tarHeader(rel, 0, 0o777, '2', Math.floor(st.mtimeMs / 1000)))
+        const link = fs.readlinkSync(p)
+        const b = Buffer.from(link)
+        chunks.push(b)
+        const pad = (512 - (b.length % 512)) % 512
+        if (pad) chunks.push(Buffer.alloc(pad, 0))
+      } else if (e.isDirectory()) {
+        chunks.push(tarHeader(rel + '/', 0, st.mode & 0o777, '5', Math.floor(st.mtimeMs / 1000)))
+        walk(p, rel)
+      } else if (e.isFile()) {
+        const data = fs.readFileSync(p)
+        chunks.push(tarHeader(rel, data.length, st.mode & 0o777, '0', Math.floor(st.mtimeMs / 1000)), data)
+        const pad = (512 - (data.length % 512)) % 512
+        if (pad) chunks.push(Buffer.alloc(pad, 0))
+      }
+    }
+  }
+  walk(dir, '')
+  chunks.push(Buffer.alloc(1024, 0))
+  return Buffer.concat(chunks)
+}
+const tarGz = (dir) => zlib.gzipSync(tarDir(dir), { level: 9 })
+
+// ── ar (formato .deb) ───────────────────────────────────────────────────────
+function ar(entries) {
+  const parts = [Buffer.from('!<arch>\n')]
+  for (const e of entries) {
+    const data = e.data
+    const h = Buffer.alloc(60, 0x20)
+    const name = (e.name + '/').slice(0, 16)
+    h.write(name, 0)
+    h.write(String(Math.floor(Date.now() / 1000)).padEnd(12), 16)
+    h.write('0'.padEnd(6), 28)
+    h.write('0'.padEnd(6), 34)
+    h.write('100644'.padEnd(8), 40)
+    h.write(String(data.length).padEnd(10), 48)
+    h.write('`\n', 58)
+    parts.push(h, data)
+    if (data.length % 2) parts.push(Buffer.from('\n'))
+  }
+  return Buffer.concat(parts)
+}
+
+function buildDeb() {
+  const stage = arg('--stage')
+  const out = arg('--out')
+  const name = arg('--name', 'app')
+  const version = arg('--version', '0.0.0')
+  const arch = arg('--arch', 'amd64')
+  const maintainer = arg('--maintainer', 'unknown <unknown@example.com>')
+  const description = arg('--description', name)
+  if (!stage || !out) die('uso: deb --stage <dataRoot> --out <x.deb> --name <slug> --version <v>')
+  if (!fs.existsSync(stage)) die(`no existe el stage: ${stage}`)
+
+  const controlDir = fs.mkdtempSync('/tmp/owear-deb-')
+  fs.writeFileSync(
+    path.join(controlDir, 'control'),
+    `Package: ${name}\nVersion: ${version}\nArchitecture: ${arch}\n` +
+      `Maintainer: ${maintainer}\nDescription: ${description}\n`,
+  )
+  fs.writeFileSync(
+    path.join(controlDir, 'postinst'),
+    `#!/bin/sh\nset -e\nif command -v update-desktop-database >/dev/null 2>&1; then update-desktop-database -q || true; fi\nexit 0\n`,
+  )
+  fs.chmodSync(path.join(controlDir, 'postinst'), 0o755)
+
+  const deb = ar([
+    { name: 'debian-binary', data: Buffer.from('2.0\n') },
+    { name: 'control.tar.gz', data: tarGz(controlDir) },
+    { name: 'data.tar.gz', data: tarGz(stage) },
+  ])
+  fs.mkdirSync(path.dirname(out), { recursive: true })
+  fs.writeFileSync(out, deb)
+  fs.rmSync(controlDir, { recursive: true, force: true })
+  const mb = (deb.length / 1024 / 1024).toFixed(2)
+  console.log(`[owear-linux] .deb: ${out} (${mb} MB)`)
+}
+
+function buildAppImage() {
+  const appDir = arg('--appdir')
+  const out = arg('--out')
+  if (!appDir || !out) die('uso: appimage --appdir <AppDir> --out <x.AppImage>')
+  if (!fs.existsSync(appDir)) die(`no existe el AppDir: ${appDir}`)
+  const tool = ['appimagetool', 'appimagetool-x86_64.AppImage'].find((t) => {
+    const r = spawnSync('sh', ['-c', `command -v ${t}`], { stdio: 'ignore' })
+    return r.status === 0
+  })
+  if (!tool) {
+    die(
+      'appimagetool no está en PATH. Instálalo (https://github.com/AppImage/appimagetool) ' +
+        `y reintenta. El AppDir queda listo en: ${appDir}`,
+    )
+  }
+  const r = spawnSync(tool, [appDir, out], { stdio: 'inherit', env: { ...process.env, ARCH: arg('--arch', 'x86_64') } })
+  if (r.status !== 0) die('appimagetool falló')
+  console.log(`[owear-linux] AppImage: ${out}`)
+}
+
+if (cmd === 'deb') buildDeb()
+else if (cmd === 'appimage') buildAppImage()
+else die('uso: owear-linux <deb|appimage> …')

package/tools/owear-msi.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// tools/owear-msi.mjs — genera un .MSI de la app (D1) desde un stage dir.
+//
+// Genera un fuente WiX v3 y lo compila con `wixl` (msitools, Linux) o
+// `wix`/`candle`+`light` (Windows). Si no hay toolchain, deja el .wxs listo.
+//
+// Uso:
+//   node tools/owear-msi.mjs --stage <dir> --out <x.msi> --name <slug> \
+//     --version <v> [--publisher <p>] [--appId <id>]
+//
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as crypto from 'node:crypto'
+import { spawnSync } from 'node:child_process'
+
+function die(m) {
+  console.error(`[owear-msi] ✗ ${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 stage = arg('--stage')
+const out = arg('--out')
+const name = arg('--name', 'app')
+const version = arg('--version', '0.0.0')
+const publisher = arg('--publisher', 'unknown')
+const appId = arg('--appId', name)
+if (!stage || !out) die('uso: --stage <dir> --out <x.msi> --name <slug> --version <v>')
+if (!fs.existsSync(stage)) die(`no existe el stage: ${stage}`)
+
+/** GUID estable a partir de un string (UpgradeCode). */
+function guidFrom(seed) {
+  const h = crypto.createHash('sha1').update(seed).digest()
+  const b = Buffer.from(h.subarray(0, 16))
+  b[6] = (b[6] & 0x0f) | 0x40 // version 4
+  b[8] = (b[8] & 0x3f) | 0x80 // variant
+  const s = b.toString('hex')
+  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20, 32)}`.toUpperCase()
+}
+
+const xmlEsc = (s) =>
+  String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')
+
+// ── construye el árbol WiX ──────────────────────────────────────────────────
+let idSeq = 0
+const nextId = (p) => `${p}${++idSeq}`
+
+function buildTree(dir, dirId, indent) {
+  let xml = ''
+  for (const e of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const p = path.join(dir, e.name)
+    if (e.isDirectory()) {
+      const childId = nextId('dir')
+      xml += `${indent}<Directory Id="${childId}" Name="${xmlEsc(e.name)}">\n`
+      xml += buildTree(p, childId, indent + '  ')
+      xml += `${indent}</Directory>\n`
+    } else if (e.isFile()) {
+      const compId = nextId('cmp')
+      const fileId = nextId('fil')
+      xml +=
+        `${indent}<Component Id="${compId}" Guid="*">\n` +
+        `${indent}  <File Id="${fileId}" Source="${xmlEsc(p)}" KeyPath="yes" />\n` +
+        `${indent}</Component>\n`
+    }
+  }
+  return xml
+}
+
+const wxsPath = out.replace(/\.msi$/, '.wxs')
+const wxs =
+  `<?xml version="1.0" encoding="UTF-8"?>\n` +
+  `<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">\n` +
+  `  <Product Id="*" Name="${xmlEsc(name)}" Language="1033" Version="${xmlEsc(version)}"\n` +
+  `           Manufacturer="${xmlEsc(publisher)}" UpgradeCode="${guidFrom(appId)}">\n` +
+  `    <Package InstallerVersion="500" Compressed="yes" InstallScope="perUser" />\n` +
+  `    <MajorUpgrade DowngradeErrorMessage="Ya hay una version mas reciente instalada." />\n` +
+  `    <MediaTemplate EmbedCab="yes" />\n` +
+  `    <Directory Id="TARGETDIR" Name="SourceDir">\n` +
+  `      <Directory Id="LocalAppDataFolder">\n` +
+  `        <Directory Id="INSTALLFOLDER" Name="${xmlEsc(name)}">\n` +
+  buildTree(stage, 'INSTALLFOLDER', '          ') +
+  `        </Directory>\n` +
+  `      </Directory>\n` +
+  `    </Directory>\n` +
+  `  </Product>\n` +
+  `</Wix>\n`
+
+fs.mkdirSync(path.dirname(wxsPath), { recursive: true })
+fs.writeFileSync(wxsPath, wxs)
+
+const has = (cmd) => spawnSync('sh', ['-c', `command -v ${cmd}`], { stdio: 'ignore' }).status === 0
+
+let ok = false
+if (has('wixl')) {
+  const r = spawnSync('wixl', ['-o', out, wxsPath], { stdio: 'inherit' })
+  ok = r.status === 0
+} else if (has('wix')) {
+  const r = spawnSync('wix', ['build', wxsPath, '-o', out], { stdio: 'inherit' })
+  ok = r.status === 0
+}
+
+if (!ok) {
+  console.error(
+    `[owear-msi] sin toolchain (wixl/wix). Fuente WiX lista en: ${wxsPath}\n` +
+      `  · Linux: sudo apt install msitools   → wixl -o "${out}" "${wxsPath}"\n` +
+      `  · Windows: dotnet tool install --global wix → wix build "${wxsPath}" -o "${out}"`,
+  )
+  process.exit(0) // no es un error fatal: el .wxs queda generado
+}
+console.log(`[owear-msi] MSI: ${out}`)

package/tools/owear-pack.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// tools/owear-pack.mjs — empaqueta un directorio (bundle) DENTRO del binario del
+// kernel → single binary. Formato:
+//   [ kernel ][ payload.tar.gz ][ "OWPK1\0\0\0" + offset(u64) + size(u64) ]
+//
+//   node tools/owear-pack.mjs --kernel <owear> --in <bundleDir> --out <MiApp>
+//
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as zlib from 'node:zlib'
+
+function die(m) {
+  console.error(`[owear-pack] ✗ ${m}`)
+  process.exit(1)
+}
+const argv = process.argv.slice(2)
+const arg = (n) => (argv.includes(n) ? argv[argv.indexOf(n) + 1] : null)
+const kernel = arg('--kernel')
+const inDir = arg('--in')
+const out = arg('--out')
+if (!kernel || !inDir || !out) die('uso: --kernel <owear> --in <bundle> --out <MiApp>')
+
+// ── tar (ustar) mínimo ──────────────────────────────────────────────────────
+function oct(n, len) {
+  return n.toString(8).padStart(len - 1, '0') + '\0'
+}
+function tarHeader(name, size, mode, typeflag) {
+  const h = Buffer.alloc(512, 0)
+  h.write(name.slice(0, 100), 0, 100, 'utf8')
+  h.write(oct(mode, 8), 100)
+  h.write(oct(0, 8), 108) // uid
+  h.write(oct(0, 8), 116) // gid
+  h.write(oct(size, 12), 124)
+  h.write(oct(0, 12), 136) // mtime
+  h.write('        ', 148) // checksum (espacios)
+  h.write(typeflag, 156)
+  h.write('ustar\0', 257)
+  h.write('00', 263)
+  let sum = 0
+  for (const b of h) sum += b
+  h.write(sum.toString(8).padStart(6, '0') + '\0 ', 148)
+  return h
+}
+function walk(dir, base = '') {
+  const out = []
+  for (const e of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const p = path.join(dir, e.name)
+    const rel = base ? `${base}/${e.name}` : e.name
+    if (e.isDirectory()) {
+      out.push({ name: rel + '/', dir: true })
+      out.push(...walk(p, rel))
+    } else if (e.isFile()) {
+      out.push({ name: rel, dir: false, path: p })
+    }
+  }
+  return out
+}
+function makeTar(dir) {
+  const chunks = []
+  for (const e of walk(dir)) {
+    if (e.dir) {
+      chunks.push(tarHeader(e.name, 0, 0o755, '5'))
+    } else {
+      const data = fs.readFileSync(e.path)
+      chunks.push(tarHeader(e.name, data.length, 0o644, '0'), data)
+      const pad = (512 - (data.length % 512)) % 512
+      if (pad) chunks.push(Buffer.alloc(pad, 0))
+    }
+  }
+  chunks.push(Buffer.alloc(1024, 0)) // 2 bloques fin
+  return Buffer.concat(chunks)
+}
+
+// ── ensambla ────────────────────────────────────────────────────────────────
+if (!fs.existsSync(kernel)) die(`no existe el kernel: ${kernel}`)
+if (!fs.existsSync(inDir)) die(`no existe el bundle: ${inDir}`)
+
+const payload = zlib.gzipSync(makeTar(inDir), { level: 9 })
+const ker = fs.readFileSync(kernel)
+const footer = Buffer.alloc(24)
+footer.write('OWPK1\0\0\0', 0, 'binary')
+footer.writeBigUInt64LE(BigInt(ker.length), 8)
+footer.writeBigUInt64LE(BigInt(payload.length), 16)
+fs.writeFileSync(out, Buffer.concat([ker, payload, footer]))
+fs.chmodSync(out, 0o755)
+
+const mb = (b) => (b / 1024 / 1024).toFixed(2)
+console.log(
+  `[owear-pack] ${out}  kernel=${mb(ker.length)}MB + payload=${mb(payload.length)}MB (${fs.readdirSync(inDir).length} items)`,
+)