@claweditor/cli 0.1.0

package/README.md

@@ -0,0 +1,45 @@
+# @claweditor/cli
+
+Install and launch the [ClawEditor](https://github.com/i1see1you/ClawEditor) desktop app from GitHub Releases.
+
+## Install CLI
+
+```bash
+npm install -g @claweditor/cli
+```
+
+## Usage
+
+```bash
+# Download (if needed) and launch
+claw-editor
+
+# Install only
+claw-editor install
+
+# Re-download latest release
+claw-editor update
+
+# Install a specific version
+claw-editor install --tag 0.1.0
+
+# Show versions
+claw-editor version
+```
+
+Install location:
+
+| OS | Path |
+|----|------|
+| macOS | `~/Library/Application Support/claweditor/` |
+| Linux | `~/.local/share/claweditor/` |
+| Windows | `%LOCALAPPDATA%\claweditor\` |
+
+## Publish (maintainers)
+
+```bash
+cd packages/cli
+npm publish --access public
+```
+
+Desktop bundles must be uploaded to [GitHub Releases](https://github.com/i1see1you/ClawEditor/releases) first (see `.github/workflows/release.yml`).

package/bin/claw-editor.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { install, runApp } from '../lib/install.js'
+import { readInstallMeta, resolveLaunchPath } from '../lib/paths.js'
+import { GITHUB_OWNER, GITHUB_REPO } from '../lib/config.js'
+
+const pkg = JSON.parse(
+  readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8'),
+)
+
+function printHelp() {
+  process.stdout.write(`ClawEditor desktop launcher (@claweditor/cli)
+
+Usage:
+  claw-editor                 Download (if needed) and launch ClawEditor
+  claw-editor install         Install from GitHub Releases
+  claw-editor update          Re-download and install latest release
+  claw-editor run             Same as default (launch)
+  claw-editor version         Show CLI and installed app version
+  claw-editor help            Show this help
+
+Options:
+  --tag <version>             Install a specific release (e.g. 0.1.0 or v0.1.0)
+  --force                     Force re-download
+
+Releases: https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/releases
+`)
+}
+
+function parseArgs(argv) {
+  /** @type {{ command: string, tag?: string, force: boolean }} */
+  const out = { command: 'run', force: false }
+  const args = [...argv]
+  while (args.length) {
+    const a = args.shift()
+    if (a === '--tag') {
+      out.tag = args.shift()
+      continue
+    }
+    if (a === '--force') {
+      out.force = true
+      continue
+    }
+    if (a === '--help' || a === '-h') {
+      out.command = 'help'
+      continue
+    }
+    if (!a.startsWith('-')) {
+      out.command = a
+    }
+  }
+  return out
+}
+
+async function main() {
+  const { command, tag, force } = parseArgs(process.argv.slice(2))
+
+  if (command === 'help') {
+    printHelp()
+    return
+  }
+
+  if (command === 'version' || command === '--version' || command === '-v') {
+    const meta = readInstallMeta()
+    const launchPath = resolveLaunchPath(meta)
+    process.stdout.write(`@claweditor/cli ${pkg.version}\n`)
+    if (meta?.version) {
+      process.stdout.write(`ClawEditor ${meta.version}${launchPath ? ` (${launchPath})` : ''}\n`)
+    } else {
+      process.stdout.write('ClawEditor: not installed\n')
+    }
+    return
+  }
+
+  if (command === 'install') {
+    await install({ tag, force })
+    return
+  }
+
+  if (command === 'update') {
+    await install({ tag, force: true })
+    return
+  }
+
+  if (command === 'run' || command === 'start') {
+    await runApp({ tag, force })
+    return
+  }
+
+  process.stderr.write(`Unknown command: ${command}\n\n`)
+  printHelp()
+  process.exit(1)
+}
+
+main().catch((err) => {
+  process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}\n`)
+  process.exit(1)
+})

package/lib/config.js

@@ -0,0 +1,20 @@
+/** @typedef {'darwin-arm64' | 'darwin-x64' | 'linux-x64' | 'linux-arm64' | 'win32-x64' | 'win32-arm64'} PlatformKey */
+
+export const GITHUB_OWNER = 'i1see1you'
+export const GITHUB_REPO = 'ClawEditor'
+export const PRODUCT_NAME = 'ClawEditor'
+export const APP_BINARY_NAME = process.platform === 'win32' ? 'claw-editor.exe' : 'claw-editor'
+
+/**
+ * GitHub Release asset name patterns (Tauri bundle naming).
+ * First matching asset wins.
+ * @type {Record<PlatformKey, RegExp[]>}
+ */
+export const ASSET_PATTERNS = {
+  'darwin-arm64': [/aarch64\.app\.tar\.gz$/i, /aarch64\.dmg$/i],
+  'darwin-x64': [/x64\.app\.tar\.gz$/i, /x64\.dmg$/i],
+  'linux-x64': [/amd64\.AppImage$/i, /amd64\.deb$/i],
+  'linux-arm64': [/aarch64\.AppImage$/i, /arm64\.deb$/i],
+  'win32-x64': [/x64-setup\.exe$/i, /x64\.msi$/i],
+  'win32-arm64': [/arm64-setup\.exe$/i, /arm64\.msi$/i],
+}

package/lib/github.js

@@ -0,0 +1,71 @@
+import { GITHUB_OWNER, GITHUB_REPO } from './config.js'
+
+const API = `https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}`
+
+/**
+ * @param {string | undefined} tag `latest` or `v0.1.0`
+ */
+export async function fetchRelease(tag) {
+  const url = tag && tag !== 'latest'
+    ? `${API}/releases/tags/${tag.startsWith('v') ? tag : `v${tag}`}`
+    : `${API}/releases/latest`
+
+  const res = await fetch(url, {
+    headers: {
+      Accept: 'application/vnd.github+json',
+      'User-Agent': '@claweditor/cli',
+    },
+  })
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => '')
+    throw new Error(
+      `GitHub release not found (${res.status}): ${url}${body ? `\n${body.slice(0, 200)}` : ''}`,
+    )
+  }
+
+  return /** @type {Promise<{ tag_name: string, assets: Array<{ name: string, browser_download_url: string, size: number }> }>} */ (res.json())
+}
+
+/**
+ * @param {Array<{ name: string, browser_download_url: string }>} assets
+ * @param {RegExp[]} patterns
+ */
+export function pickAsset(assets, patterns) {
+  for (const pattern of patterns) {
+    const hit = assets.find((a) => pattern.test(a.name))
+    if (hit) return hit
+  }
+  return null
+}
+
+/**
+ * @param {string} url
+ * @param {string} dest
+ * @param {(received: number, total: number) => void} [onProgress]
+ */
+export async function downloadFile(url, dest, onProgress) {
+  const res = await fetch(url, {
+    headers: { 'User-Agent': '@claweditor/cli' },
+    redirect: 'follow',
+  })
+  if (!res.ok || !res.body) {
+    throw new Error(`Download failed (${res.status}): ${url}`)
+  }
+
+  const total = Number(res.headers.get('content-length') || 0)
+  const reader = res.body.getReader()
+  const chunks = []
+  let received = 0
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    chunks.push(value)
+    received += value.byteLength
+    onProgress?.(received, total)
+  }
+
+  const { writeFileSync } = await import('node:fs')
+  writeFileSync(dest, Buffer.concat(chunks))
+}

package/lib/install.js

@@ -0,0 +1,209 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { APP_BINARY_NAME, ASSET_PATTERNS, PRODUCT_NAME } from './config.js'
+import { downloadFile, fetchRelease, pickAsset } from './github.js'
+import {
+  ensureDir,
+  getCacheDir,
+  getDataDir,
+  readInstallMeta,
+  resolveLaunchPath,
+  writeInstallMeta,
+} from './paths.js'
+import { detectPlatformKey } from './platform.js'
+
+function log(msg) {
+  process.stderr.write(`${msg}\n`)
+}
+
+function formatProgress(received, total) {
+  if (!total) return ''
+  const pct = Math.min(100, Math.round((received / total) * 100))
+  return ` ${pct}%`
+}
+
+/**
+ * @param {string} cmd
+ * @param {string[]} args
+ * @param {import('node:child_process').SpawnOptions} [opts]
+ */
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit', ...opts })
+    child.on('error', reject)
+    child.on('close', (code) => {
+      if (code === 0) resolve(undefined)
+      else reject(new Error(`Command failed (${code}): ${cmd} ${args.join(' ')}`))
+    })
+  })
+}
+
+/**
+ * @param {string} archivePath
+ * @param {string} destDir
+ */
+async function extractTarGz(archivePath, destDir) {
+  ensureDir(destDir)
+  await run('tar', ['-xzf', archivePath, '-C', destDir])
+}
+
+function findAppBundle(rootDir) {
+  const direct = path.join(rootDir, `${PRODUCT_NAME}.app`)
+  if (fs.existsSync(direct)) return direct
+
+  const entries = fs.readdirSync(rootDir, { withFileTypes: true })
+  for (const e of entries) {
+    if (e.isDirectory() && e.name.endsWith('.app')) {
+      return path.join(rootDir, e.name)
+    }
+  }
+  return null
+}
+
+/**
+ * @param {string} assetPath
+ * @param {string} assetName
+ * @param {string} version
+ */
+async function installFromAsset(assetPath, assetName, version) {
+  const dataDir = getDataDir()
+  ensureDir(dataDir)
+  const lower = assetName.toLowerCase()
+
+  if (lower.endsWith('.app.tar.gz')) {
+    const extractDir = path.join(dataDir, 'current')
+    if (fs.existsSync(extractDir)) {
+      fs.rmSync(extractDir, { recursive: true, force: true })
+    }
+    ensureDir(extractDir)
+    await extractTarGz(assetPath, extractDir)
+    const appBundle = findAppBundle(extractDir)
+    if (!appBundle) {
+      throw new Error(`Could not find ${PRODUCT_NAME}.app after extracting ${assetName}`)
+    }
+    const launchPath = path.join(appBundle, 'Contents', 'MacOS', APP_BINARY_NAME)
+    if (!fs.existsSync(launchPath)) {
+      throw new Error(`Missing binary in app bundle: ${launchPath}`)
+    }
+    writeInstallMeta({ version, assetName, launchPath, installedAt: new Date().toISOString() })
+    return launchPath
+  }
+
+  if (lower.endsWith('.appimage')) {
+    const dest = path.join(dataDir, 'ClawEditor.AppImage')
+    fs.copyFileSync(assetPath, dest)
+    fs.chmodSync(dest, 0o755)
+    writeInstallMeta({ version, assetName, launchPath: dest, installedAt: new Date().toISOString() })
+    return dest
+  }
+
+  if (lower.endsWith('-setup.exe') || lower.endsWith('.msi')) {
+    log(`Running Windows installer: ${assetName}`)
+    log('Complete the installer dialog, then run `claw-editor` again.')
+    await run(assetPath, [], { shell: true, stdio: 'inherit' })
+    const launchPath = path.join(
+      process.env.LOCALAPPDATA || '',
+      PRODUCT_NAME,
+      APP_BINARY_NAME,
+    )
+    writeInstallMeta({
+      version,
+      assetName,
+      launchPath,
+      installedAt: new Date().toISOString(),
+      note: 'Windows GUI installer',
+    })
+    return launchPath
+  }
+
+  if (lower.endsWith('.dmg')) {
+    throw new Error(
+      `Automatic install for .dmg is not supported yet. Download ${assetName} from GitHub Releases and drag ${PRODUCT_NAME} to Applications.`,
+    )
+  }
+
+  throw new Error(`Unsupported release asset: ${assetName}`)
+}
+
+/**
+ * @param {{ tag?: string, force?: boolean }} [opts]
+ */
+export async function install(opts = {}) {
+  const platformKey = detectPlatformKey()
+  const patterns = ASSET_PATTERNS[platformKey]
+  if (!patterns) {
+    throw new Error(`No release asset mapping for ${platformKey}`)
+  }
+
+  const release = await fetchRelease(opts.tag)
+  const asset = pickAsset(release.assets, patterns)
+  if (!asset) {
+    const names = release.assets.map((a) => a.name).join(', ')
+    throw new Error(
+      `No matching asset for ${platformKey} in ${release.tag_name}. Available: ${names || '(none)'}`,
+    )
+  }
+
+  const version = release.tag_name.replace(/^v/, '')
+  ensureDir(getCacheDir())
+  const cachePath = path.join(getCacheDir(), asset.name)
+
+  if (!opts.force && fs.existsSync(cachePath)) {
+    log(`Using cached ${asset.name}`)
+  } else {
+    log(`Downloading ${asset.name} from ${release.tag_name}…`)
+    await downloadFile(asset.browser_download_url, cachePath, (received, total) => {
+      process.stderr.write(`\rDownloading${formatProgress(received, total)}`)
+    })
+    process.stderr.write('\n')
+  }
+
+  const launchPath = await installFromAsset(cachePath, asset.name, version)
+  log(`Installed ${PRODUCT_NAME} ${version}`)
+  return { version, launchPath, assetName: asset.name }
+}
+
+/**
+ * @param {string} launchPath
+ */
+export function launchApp(launchPath) {
+  if (process.platform === 'darwin') {
+    if (launchPath.endsWith('.app') || launchPath.includes('.app/')) {
+      const appPath = launchPath.includes('.app/')
+        ? launchPath.split('.app/')[0] + '.app'
+        : launchPath
+      spawn('open', ['-a', appPath], { detached: true, stdio: 'ignore' }).unref()
+      return
+    }
+  }
+
+  if (launchPath.endsWith('.AppImage')) {
+    spawn(launchPath, [], { detached: true, stdio: 'ignore' }).unref()
+    return
+  }
+
+  spawn(launchPath, [], { detached: true, stdio: 'ignore', shell: process.platform === 'win32' }).unref()
+}
+
+/**
+ * Ensure app is installed and launch it.
+ * @param {{ tag?: string, force?: boolean }} [opts]
+ */
+export async function runApp(opts = {}) {
+  let launchPath = resolveLaunchPath(opts.force ? null : readInstallMeta())
+
+  if (!launchPath || opts.force) {
+    const result = await install({ tag: opts.tag, force: opts.force })
+    launchPath = result.launchPath
+  }
+
+  if (!launchPath || !fs.existsSync(launchPath)) {
+    throw new Error(
+      `${PRODUCT_NAME} is not installed. Run: npm install -g @claweditor/cli && claw-editor install`,
+    )
+  }
+
+  launchApp(launchPath)
+  log(`Launched ${PRODUCT_NAME}`)
+}

package/lib/paths.js

@@ -0,0 +1,81 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { APP_BINARY_NAME, PRODUCT_NAME } from './config.js'
+
+export function getDataDir() {
+  const home = os.homedir()
+  if (process.platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'claweditor')
+  }
+  if (process.platform === 'win32') {
+    return path.join(process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'), 'claweditor')
+  }
+  return path.join(process.env.XDG_DATA_HOME || path.join(home, '.local', 'share'), 'claweditor')
+}
+
+export function getInstallMetaPath() {
+  return path.join(getDataDir(), 'install.json')
+}
+
+export function getCacheDir() {
+  return path.join(getDataDir(), 'cache')
+}
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true })
+}
+
+/**
+ * Resolve the executable path from an install record or common install locations.
+ * @param {{ version?: string, launchPath?: string, assetName?: string } | null} meta
+ */
+export function resolveLaunchPath(meta) {
+  if (meta?.launchPath && fs.existsSync(meta.launchPath)) {
+    return meta.launchPath
+  }
+
+  if (process.platform === 'darwin') {
+    const appBundle = path.join(getDataDir(), `${PRODUCT_NAME}.app`, 'Contents', 'MacOS', APP_BINARY_NAME)
+    if (fs.existsSync(appBundle)) return appBundle
+  }
+
+  if (process.platform === 'linux') {
+    const appImage = path.join(getDataDir(), 'ClawEditor.AppImage')
+    if (fs.existsSync(appImage)) return appImage
+    const bin = path.join(getDataDir(), 'bin', APP_BINARY_NAME)
+    if (fs.existsSync(bin)) return bin
+  }
+
+  if (process.platform === 'win32') {
+    const candidates = [
+      path.join(getDataDir(), APP_BINARY_NAME),
+      path.join(getDataDir(), `${PRODUCT_NAME}.exe`),
+      path.join(process.env.LOCALAPPDATA || '', PRODUCT_NAME, `${PRODUCT_NAME}.exe`),
+      path.join(process.env.LOCALAPPDATA || '', PRODUCT_NAME, APP_BINARY_NAME),
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', PRODUCT_NAME, `${PRODUCT_NAME}.exe`),
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', PRODUCT_NAME, APP_BINARY_NAME),
+    ]
+    for (const c of candidates) {
+      if (c && fs.existsSync(c)) return c
+    }
+  }
+
+  return null
+}
+
+export function readInstallMeta() {
+  const metaPath = getInstallMetaPath()
+  if (!fs.existsSync(metaPath)) return null
+  try {
+    return JSON.parse(fs.readFileSync(metaPath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/** @param {Record<string, unknown>} meta */
+export function writeInstallMeta(meta) {
+  ensureDir(getDataDir())
+  fs.writeFileSync(getInstallMetaPath(), JSON.stringify(meta, null, 2) + '\n')
+}

package/lib/platform.js

@@ -0,0 +1,21 @@
+/** @typedef {import('./config.js').PlatformKey} PlatformKey */
+
+/**
+ * @returns {PlatformKey}
+ */
+export function detectPlatformKey() {
+  const arch = process.arch === 'x64' ? 'x64' : process.arch === 'arm64' ? 'arm64' : process.arch
+  if (process.platform === 'darwin') {
+    if (arch === 'arm64') return 'darwin-arm64'
+    if (arch === 'x64') return 'darwin-x64'
+  }
+  if (process.platform === 'linux') {
+    if (arch === 'arm64') return 'linux-arm64'
+    return 'linux-x64'
+  }
+  if (process.platform === 'win32') {
+    if (arch === 'arm64') return 'win32-arm64'
+    return 'win32-x64'
+  }
+  throw new Error(`Unsupported platform: ${process.platform} ${process.arch}`)
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@claweditor/cli",
+  "version": "0.1.0",
+  "description": "Install and launch the ClawEditor desktop app from GitHub Releases",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "claw-editor": "bin/claw-editor.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/i1see1you/ClawEditor.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "claweditor",
+    "tauri",
+    "openclaw",
+    "installer"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}