ancoder-skill-cli 0.13.27 → 0.13.28

package/README.md

@@ -22,6 +22,115 @@ The npm package is self-contained and includes prebuilt binaries for:
 
 After install, the wrapper selects the correct bundled binary for the current platform automatically.
 
+## One-line install (Gitee or intranet)
+
+For users who cannot access GitHub, mirror this repository to Gitee or copy these files to an intranet static file server:
+
+- `scripts/install.ps1`
+- `scripts/install.sh`
+- `bin/targets/skill-cli-win32-x64.exe`
+- `bin/targets/skill-cli-linux-x64`
+- `bin/targets/skill-cli-linux-arm64`
+- `bin/targets/skill-cli-darwin-arm64`
+- `bin/targets/skill-cli-darwin-x64`
+
+Windows users can install from Gitee with PowerShell. The most stable command pins both the script and binary to the same release tag:
+
+```powershell
+irm https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/scripts/install.ps1 | iex
+```
+
+macOS/Linux users can install from Gitee with curl:
+
+```bash
+curl -fsSL https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/scripts/install.sh | bash
+```
+
+The installer downloads the matching prebuilt binary, installs it as `skill-cli`, runs `skill-cli install`, then runs a lite `doctor` check. No Go toolchain is required.
+
+Before sharing the Gitee command externally, make sure the Gitee mirror contains the `v0.13.28` tag. The installer downloads the version-pinned `v0.13.28` binary by default.
+
+Gitee release checklist:
+
+1. Run `go test ./...`, `bash scripts/build-all.sh`, `node scripts/check-bin.js`, and `npm pack --dry-run`.
+2. Commit `bin/targets/`, `scripts/install.ps1`, `scripts/install.sh`, `scripts/make-install-bundle.js`, `scripts/check-install-host.js`, `scripts/check-bin.js`, `scripts/build-all.sh`, `package.json`, `package-lock.json`, `.gitattributes`, and `README.md`.
+3. Push `main` and the release tag to Gitee, or mirror them from GitHub.
+4. Verify these URLs return `200` before sending the install command:
+   - `https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/scripts/install.ps1`
+   - `https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/scripts/install.sh`
+   - `https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/bin/targets/skill-cli-win32-x64.exe`
+   Or run:
+
+   ```bash
+   node scripts/check-install-host.js \
+     --script-root https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28 \
+     --base-url https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/bin/targets
+   ```
+
+5. Share the tag-pinned install command only after the check above passes.
+
+For private intranet hosting, generate a static install bundle and upload the generated `dist/install/` directory as-is:
+
+```bash
+npm run install-bundle -- --root https://intranet.example.com/skill-cli
+```
+
+That directory contains:
+
+- `scripts/install.ps1`
+- `scripts/install.sh`
+- `bin/targets/skill-cli-*`
+- `manifest.json`
+- `README.txt`
+
+After uploading `dist/install/` to `https://intranet.example.com/skill-cli/`, users can run:
+
+```bash
+node scripts/check-install-host.js --root https://intranet.example.com/skill-cli --all-binaries
+```
+
+```powershell
+irm https://intranet.example.com/skill-cli/scripts/install.ps1 | iex
+```
+
+```bash
+curl -fsSL https://intranet.example.com/skill-cli/scripts/install.sh | bash
+```
+
+If binaries are hosted somewhere else, point the installer at the directory containing the `skill-cli-*` files:
+
+```powershell
+$env:SKILL_CLI_BASE_URL = "https://intranet.example.com/skill-cli/bin/targets"
+irm https://intranet.example.com/skill-cli/scripts/install.ps1 | iex
+```
+
+```bash
+curl -fsSL https://intranet.example.com/skill-cli/scripts/install.sh | \
+  bash -s -- --base-url https://intranet.example.com/skill-cli/bin/targets
+```
+
+Useful options:
+
+```powershell
+# Install the binary only, without writing ~/.claude components
+$env:SKILL_CLI_NO_INSTALL = "1"
+irm https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/scripts/install.ps1 | iex
+
+# For a clean smoke test against a temporary Claude directory
+$env:SKILL_CLI_NO_INSTALL = $null
+$env:SKILL_CLI_CLAUDE_DIR = "$PWD\.skill-cli-test-claude"
+irm https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/scripts/install.ps1 | iex
+```
+
+```bash
+# Install the binary only, without writing ~/.claude components
+curl -fsSL https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/scripts/install.sh | bash -s -- --no-install
+
+# For a clean smoke test against a temporary Claude directory
+curl -fsSL https://gitee.com/marvin-dev/skill-cli-creator/raw/v0.13.28/scripts/install.sh | \
+  bash -s -- --claude-dir "$PWD/.skill-cli-test-claude"
+```
+
 ## Build from source (Go)
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ancoder-skill-cli",
-  "version": "0.13.27",
+  "version": "0.13.28",
   "description": "CLI for managing everything-claude-code (ECC) components — agents, skills, commands, rules, hooks, MCP configs. Single binary, all assets embedded.",
   "bin": {
     "skill-cli": "bin/skill-cli.js"
@@ -8,7 +8,8 @@
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
     "prepublishOnly": "node scripts/check-bin.js",
-    "build": "bash scripts/build-all.sh"
+    "build": "bash scripts/build-all.sh",
+    "install-bundle": "node scripts/make-install-bundle.js"
   },
   "repository": {
     "type": "git",
@@ -38,6 +39,10 @@
   "files": [
     "bin/skill-cli.js",
     "bin/targets",
+    "scripts/install.sh",
+    "scripts/install.ps1",
+    "scripts/make-install-bundle.js",
+    "scripts/check-install-host.js",
     "scripts/postinstall.js",
     "scripts/check-bin.js",
     "README.md",

package/scripts/check-bin.js

@@ -4,8 +4,10 @@
 const path = require('path');
 const fs = require('fs');
 
+const rootDir = path.join(__dirname, '..');
 const binDir = path.join(__dirname, '..', 'bin');
 const targetsDir = path.join(binDir, 'targets');
+const packageJSONPath = path.join(rootDir, 'package.json');
 const expected = [
   'skill-cli-darwin-arm64',
   'skill-cli-darwin-x64',
@@ -13,6 +15,12 @@ const expected = [
   'skill-cli-linux-x64',
   'skill-cli-win32-x64.exe',
 ];
+const expectedInstallers = [
+  'scripts/install.ps1',
+  'scripts/install.sh',
+  'scripts/make-install-bundle.js',
+  'scripts/check-install-host.js',
+];
 
 const missing = expected.filter((name) => !fs.existsSync(path.join(targetsDir, name)));
 
@@ -24,3 +32,50 @@ if (missing.length > 0) {
   console.error('Run: bash scripts/build-all.sh');
   process.exit(1);
 }
+
+const pkg = JSON.parse(fs.readFileSync(packageJSONPath, 'utf8'));
+const files = new Set(pkg.files || []);
+const missingInstallers = expectedInstallers.filter((name) => !fs.existsSync(path.join(rootDir, name)));
+const missingInstallerFilesEntries = expectedInstallers.filter((name) => !files.has(name));
+
+if (missingInstallers.length > 0) {
+  console.error('skill-cli: missing one-line installer scripts:');
+  for (const name of missingInstallers) {
+    console.error('  - ' + name);
+  }
+  process.exit(1);
+}
+
+if (missingInstallerFilesEntries.length > 0) {
+  console.error('skill-cli: package.json files is missing installer scripts:');
+  for (const name of missingInstallerFilesEntries) {
+    console.error('  - ' + name);
+  }
+  process.exit(1);
+}
+
+const expectedVersion = `v${pkg.version}`;
+const installerVersionPatterns = [
+  {
+    file: 'scripts/install.sh',
+    pattern: /DEFAULT_VERSION="([^"]+)"/,
+  },
+  {
+    file: 'scripts/install.ps1',
+    pattern: /\$Version = "([^"]+)"/,
+  },
+];
+
+for (const item of installerVersionPatterns) {
+  const installerPath = path.join(rootDir, item.file);
+  const content = fs.readFileSync(installerPath, 'utf8');
+  const match = content.match(item.pattern);
+  if (!match) {
+    console.error(`skill-cli: could not find default version in ${item.file}`);
+    process.exit(1);
+  }
+  if (match[1] !== expectedVersion) {
+    console.error(`skill-cli: ${item.file} default version is ${match[1]}, expected ${expectedVersion}`);
+    process.exit(1);
+  }
+}

package/scripts/check-install-host.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = path.join(__dirname, '..');
+const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+const version = `v${pkg.version}`;
+
+const targets = [
+  'skill-cli-darwin-arm64',
+  'skill-cli-darwin-x64',
+  'skill-cli-linux-arm64',
+  'skill-cli-linux-x64',
+  'skill-cli-win32-x64.exe',
+];
+
+const args = process.argv.slice(2);
+let rootURL = '';
+let scriptRoot = '';
+let binaryBaseURL = '';
+let includeAllBinaries = false;
+
+function usage() {
+  console.log(`Usage:
+  node scripts/check-install-host.js --root URL [--all-binaries]
+  node scripts/check-install-host.js --script-root URL --base-url URL [--all-binaries]
+
+Examples:
+  node scripts/check-install-host.js --root https://intranet.example.com/skill-cli
+  node scripts/check-install-host.js \\
+    --script-root https://gitee.com/marvin-dev/skill-cli-creator/raw/${version} \\
+    --base-url https://gitee.com/marvin-dev/skill-cli-creator/raw/${version}/bin/targets
+
+Checks installer scripts and the Windows binary by default. Pass --all-binaries
+to verify every bundled platform binary.`);
+}
+
+for (let i = 0; i < args.length; i += 1) {
+  const arg = args[i];
+  if (arg === '--root') {
+    rootURL = args[i + 1] || '';
+    i += 1;
+  } else if (arg === '--script-root') {
+    scriptRoot = args[i + 1] || '';
+    i += 1;
+  } else if (arg === '--base-url') {
+    binaryBaseURL = args[i + 1] || '';
+    i += 1;
+  } else if (arg === '--all-binaries') {
+    includeAllBinaries = true;
+  } else if (arg === '-h' || arg === '--help') {
+    usage();
+    process.exit(0);
+  } else {
+    console.error(`unknown option: ${arg}`);
+    usage();
+    process.exit(2);
+  }
+}
+
+function trimSlash(value) {
+  return value.replace(/\/+$/, '');
+}
+
+if (rootURL) {
+  rootURL = trimSlash(rootURL);
+  scriptRoot = `${rootURL}`;
+  binaryBaseURL = `${rootURL}/bin/targets`;
+}
+
+if (!scriptRoot || !binaryBaseURL) {
+  console.error('missing --root, or both --script-root and --base-url');
+  usage();
+  process.exit(2);
+}
+
+scriptRoot = trimSlash(scriptRoot);
+binaryBaseURL = trimSlash(binaryBaseURL);
+
+const checks = [
+  `${scriptRoot}/scripts/install.ps1`,
+  `${scriptRoot}/scripts/install.sh`,
+];
+
+const binaryNames = includeAllBinaries ? targets : ['skill-cli-win32-x64.exe'];
+for (const target of binaryNames) {
+  checks.push(`${binaryBaseURL}/${target}`);
+}
+
+function request(url, method, redirectsRemaining = 5) {
+  return new Promise((resolve) => {
+    const lib = url.startsWith('https:') ? https : http;
+    const req = lib.request(url, { method, timeout: 15000 }, (res) => {
+      if (
+        res.statusCode >= 300 &&
+        res.statusCode < 400 &&
+        res.headers.location &&
+        redirectsRemaining > 0
+      ) {
+        res.resume();
+        const redirectedURL = new URL(res.headers.location, url).toString();
+        resolve(request(redirectedURL, method, redirectsRemaining - 1));
+        return;
+      }
+
+      res.resume();
+      res.on('end', () => {
+        resolve({
+          url,
+          statusCode: res.statusCode || 0,
+          contentLength: res.headers['content-length'] || '',
+          ok: res.statusCode >= 200 && res.statusCode < 300,
+        });
+      });
+    });
+    req.on('timeout', () => {
+      req.destroy(new Error('timeout'));
+    });
+    req.on('error', (err) => {
+      resolve({ url, statusCode: 0, contentLength: '', ok: false, error: err.message });
+    });
+    req.end();
+  });
+}
+
+async function checkURL(url) {
+  const head = await request(url, 'HEAD');
+  if (head.ok) {
+    return head;
+  }
+  const get = await request(url, 'GET');
+  return get.ok ? get : head;
+}
+
+(async () => {
+  let failed = false;
+  for (const url of checks) {
+    const result = await checkURL(url);
+    if (result.ok) {
+      const size = result.contentLength ? ` (${result.contentLength} bytes)` : '';
+      console.log(`OK   ${url}${size}`);
+    } else {
+      failed = true;
+      const detail = result.error ? result.error : `HTTP ${result.statusCode}`;
+      console.error(`FAIL ${url} - ${detail}`);
+    }
+  }
+  process.exit(failed ? 1 : 0);
+})();

package/scripts/install.ps1

@@ -0,0 +1,150 @@
+param(
+  [string]$BaseUrl = $env:SKILL_CLI_BASE_URL,
+  [string]$Version = $env:SKILL_CLI_VERSION,
+  [string]$InstallDir = $env:SKILL_CLI_INSTALL_DIR,
+  [string]$ClaudeDir = $env:SKILL_CLI_CLAUDE_DIR,
+  [ValidateSet("lite", "full", "none")]
+  [string]$Doctor = $(if ($env:SKILL_CLI_DOCTOR) { $env:SKILL_CLI_DOCTOR } else { "lite" }),
+  [switch]$NoInstall,
+  [switch]$NoPathUpdate,
+  [switch]$DryRun
+)
+
+$ErrorActionPreference = "Stop"
+
+function Test-TruthyEnv {
+  param([string]$Value)
+  if (-not $Value) {
+    return $false
+  }
+  return @("1", "true", "yes", "on") -contains $Value.ToLowerInvariant()
+}
+
+if (Test-TruthyEnv $env:SKILL_CLI_NO_INSTALL) {
+  $NoInstall = $true
+}
+
+if (Test-TruthyEnv $env:SKILL_CLI_NO_PATH_UPDATE) {
+  $NoPathUpdate = $true
+}
+
+if (Test-TruthyEnv $env:SKILL_CLI_DRY_RUN) {
+  $DryRun = $true
+}
+
+$baseUrlWasProvided = [bool]$BaseUrl
+
+if (-not $Version) {
+  $Version = "v0.13.28"
+}
+
+if (-not $BaseUrl) {
+  $BaseUrl = "https://gitee.com/marvin-dev/skill-cli-creator/raw/$Version/bin/targets"
+}
+
+if (-not $InstallDir) {
+  $InstallDir = Join-Path $env:LOCALAPPDATA "Programs\skill-cli"
+}
+
+if (-not [Environment]::Is64BitOperatingSystem) {
+  throw "skill-cli currently provides a Windows x64 binary only."
+}
+
+$asset = "skill-cli-win32-x64.exe"
+$url = ($BaseUrl.TrimEnd("/")) + "/" + $asset
+$target = Join-Path $InstallDir "skill-cli.exe"
+
+Write-Host "skill-cli installer"
+Write-Host "  asset:      $asset"
+Write-Host "  source:     $url"
+Write-Host "  target:     $target"
+if (-not $baseUrlWasProvided) {
+  Write-Host "  version:    $Version"
+}
+if ($ClaudeDir) {
+  Write-Host "  claude dir: $ClaudeDir"
+}
+
+if ($DryRun) {
+  Write-Host "dry run: no files written"
+  return
+}
+
+$tmp = Join-Path ([System.IO.Path]::GetTempPath()) ("skill-cli-install-" + [Guid]::NewGuid().ToString("N"))
+New-Item -ItemType Directory -Path $tmp -Force | Out-Null
+
+try {
+  $downloaded = Join-Path $tmp $asset
+  $downloadedOk = $false
+  for ($attempt = 1; $attempt -le 3; $attempt++) {
+    try {
+      Invoke-WebRequest -Uri $url -OutFile $downloaded -UseBasicParsing
+      $downloadedOk = $true
+      break
+    } catch {
+      if ($attempt -eq 3) {
+        throw
+      }
+      Start-Sleep -Seconds (2 * $attempt)
+    }
+  }
+  if (-not $downloadedOk) {
+    throw "download failed: $url"
+  }
+  New-Item -ItemType Directory -Path $InstallDir -Force | Out-Null
+  Copy-Item -LiteralPath $downloaded -Destination $target -Force
+
+  try {
+    Unblock-File -LiteralPath $target
+  } catch {
+    # Unblock-File can fail on filesystems without Zone.Identifier streams.
+  }
+
+  if (-not $NoPathUpdate) {
+    $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    $parts = @()
+    if ($userPath) {
+      $parts = $userPath -split ';' | Where-Object { $_ }
+    }
+    $alreadyInPath = $false
+    foreach ($part in $parts) {
+      if ([string]::Equals($part.TrimEnd('\'), $InstallDir.TrimEnd('\'), [StringComparison]::OrdinalIgnoreCase)) {
+        $alreadyInPath = $true
+        break
+      }
+    }
+    if (-not $alreadyInPath) {
+      $newPath = if ($userPath) { "$userPath;$InstallDir" } else { $InstallDir }
+      [Environment]::SetEnvironmentVariable("Path", $newPath, "User")
+      $env:Path = "$env:Path;$InstallDir"
+      Write-Host "  PATH:       added to current user PATH"
+    }
+  }
+
+  Write-Host ""
+  & $target version
+
+  $claudeArgs = @()
+  if ($ClaudeDir) {
+    $claudeArgs += @("--claude-dir", $ClaudeDir)
+  }
+
+  if (-not $NoInstall) {
+    Write-Host ""
+    & $target install @claudeArgs
+  }
+
+  if ($Doctor -eq "lite") {
+    Write-Host ""
+    & $target doctor @claudeArgs --check-adversarial=false
+  } elseif ($Doctor -eq "full") {
+    Write-Host ""
+    & $target doctor @claudeArgs
+  }
+
+  Write-Host ""
+  Write-Host "skill-cli install complete."
+  Write-Host "Open a new terminal and run: skill-cli doctor"
+} finally {
+  Remove-Item -LiteralPath $tmp -Recurse -Force -ErrorAction SilentlyContinue
+}

package/scripts/install.sh

@@ -0,0 +1,217 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+DEFAULT_VERSION="v0.13.28"
+VERSION="${SKILL_CLI_VERSION:-$DEFAULT_VERSION}"
+DEFAULT_BASE_URL="https://gitee.com/marvin-dev/skill-cli-creator/raw/${VERSION}/bin/targets"
+DEFAULT_BASE_URL_USES_VERSION=1
+BASE_URL="${SKILL_CLI_BASE_URL:-$DEFAULT_BASE_URL}"
+BASE_URL_EXPLICIT=0
+if [ -n "${SKILL_CLI_BASE_URL:-}" ]; then
+  BASE_URL_EXPLICIT=1
+fi
+INSTALL_DIR="${SKILL_CLI_INSTALL_DIR:-$HOME/.local/bin}"
+CLAUDE_DIR="${SKILL_CLI_CLAUDE_DIR:-}"
+RUN_COMPONENT_INSTALL=1
+DOCTOR_MODE="${SKILL_CLI_DOCTOR:-lite}"
+DRY_RUN=0
+
+usage() {
+  cat <<'EOF'
+Install skill-cli from a prebuilt binary URL.
+
+Usage:
+  curl -fsSL <install.sh-url> | bash
+  curl -fsSL <install.sh-url> | bash -s -- [options]
+
+Options:
+  --base-url URL       Base URL containing skill-cli-* binaries.
+  --version VERSION    Gitee ref/tag used by the default Gitee base URL.
+  --install-dir DIR    Directory to install skill-cli into.
+  --claude-dir DIR     Pass --claude-dir to skill-cli install/doctor.
+  --no-install         Only install the skill-cli binary.
+  --doctor MODE        Doctor mode: lite, full, none. Default: lite.
+  --dry-run            Print what would happen without downloading or writing.
+  -h, --help           Show this help.
+
+Environment:
+  SKILL_CLI_BASE_URL      Same as --base-url.
+  SKILL_CLI_VERSION       Same as --version. Default: v0.13.28.
+  SKILL_CLI_INSTALL_DIR   Same as --install-dir.
+  SKILL_CLI_CLAUDE_DIR    Same as --claude-dir.
+  SKILL_CLI_DOCTOR        Same as --doctor.
+EOF
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --base-url)
+      BASE_URL="${2:?missing value for --base-url}"
+      BASE_URL_EXPLICIT=1
+      shift 2
+      ;;
+    --version)
+      VERSION="${2:?missing value for --version}"
+      if [ "$BASE_URL_EXPLICIT" = "0" ] && [ "$DEFAULT_BASE_URL_USES_VERSION" = "1" ]; then
+        BASE_URL="https://gitee.com/marvin-dev/skill-cli-creator/raw/${VERSION}/bin/targets"
+      fi
+      shift 2
+      ;;
+    --install-dir)
+      INSTALL_DIR="${2:?missing value for --install-dir}"
+      shift 2
+      ;;
+    --claude-dir)
+      CLAUDE_DIR="${2:?missing value for --claude-dir}"
+      shift 2
+      ;;
+    --no-install)
+      RUN_COMPONENT_INSTALL=0
+      shift
+      ;;
+    --doctor)
+      DOCTOR_MODE="${2:?missing value for --doctor}"
+      shift 2
+      ;;
+    --dry-run)
+      DRY_RUN=1
+      shift
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "skill-cli install: unknown option: $1" >&2
+      usage >&2
+      exit 2
+      ;;
+  esac
+done
+
+case "$DOCTOR_MODE" in
+  lite|full|none) ;;
+  *)
+    echo "skill-cli install: --doctor must be one of: lite, full, none" >&2
+    exit 2
+    ;;
+esac
+
+detect_asset() {
+  local os arch
+  os="$(uname -s | tr '[:upper:]' '[:lower:]')"
+  arch="$(uname -m | tr '[:upper:]' '[:lower:]')"
+
+  case "$os" in
+    linux*) os="linux" ;;
+    darwin*) os="darwin" ;;
+    mingw*|msys*|cygwin*) os="win32" ;;
+    *)
+      echo "unsupported OS: $os" >&2
+      return 1
+      ;;
+  esac
+
+  case "$arch" in
+    x86_64|amd64) arch="x64" ;;
+    aarch64|arm64) arch="arm64" ;;
+    *)
+      echo "unsupported architecture: $arch" >&2
+      return 1
+      ;;
+  esac
+
+  if [ "$os" = "win32" ]; then
+    if [ "$arch" != "x64" ]; then
+      echo "unsupported Windows architecture: $arch" >&2
+      return 1
+    fi
+    printf '%s\n' "skill-cli-win32-x64.exe"
+    return 0
+  fi
+
+  printf 'skill-cli-%s-%s\n' "$os" "$arch"
+}
+
+download_file() {
+  local url="$1" out="$2"
+  if command -v curl >/dev/null 2>&1; then
+    curl -fL --retry 3 --connect-timeout 15 -o "$out" "$url"
+  elif command -v wget >/dev/null 2>&1; then
+    wget -O "$out" "$url"
+  else
+    echo "skill-cli install: curl or wget is required" >&2
+    return 1
+  fi
+}
+
+ASSET="$(detect_asset)"
+URL="${BASE_URL%/}/$ASSET"
+TARGET_NAME="skill-cli"
+case "$ASSET" in
+  *.exe) TARGET_NAME="skill-cli.exe" ;;
+esac
+TARGET_PATH="$INSTALL_DIR/$TARGET_NAME"
+
+echo "skill-cli installer"
+echo "  asset:      $ASSET"
+echo "  source:     $URL"
+echo "  target:     $TARGET_PATH"
+if [ -z "${SKILL_CLI_BASE_URL:-}" ]; then
+  echo "  version:    $VERSION"
+fi
+if [ -n "$CLAUDE_DIR" ]; then
+  echo "  claude dir: $CLAUDE_DIR"
+fi
+
+if [ "$DRY_RUN" = "1" ]; then
+  echo "dry run: no files written"
+  exit 0
+fi
+
+TMP_DIR="$(mktemp -d)"
+trap 'rm -rf "$TMP_DIR"' EXIT
+
+download_file "$URL" "$TMP_DIR/$ASSET"
+chmod +x "$TMP_DIR/$ASSET" || true
+mkdir -p "$INSTALL_DIR"
+cp "$TMP_DIR/$ASSET" "$TARGET_PATH"
+chmod +x "$TARGET_PATH" || true
+
+echo ""
+"$TARGET_PATH" version
+
+claude_args=()
+if [ -n "$CLAUDE_DIR" ]; then
+  claude_args=(--claude-dir "$CLAUDE_DIR")
+fi
+
+if [ "$RUN_COMPONENT_INSTALL" = "1" ]; then
+  echo ""
+  "$TARGET_PATH" install "${claude_args[@]}"
+fi
+
+case "$DOCTOR_MODE" in
+  lite)
+    echo ""
+    "$TARGET_PATH" doctor "${claude_args[@]}" --check-adversarial=false
+    ;;
+  full)
+    echo ""
+    "$TARGET_PATH" doctor "${claude_args[@]}"
+    ;;
+  none)
+    ;;
+esac
+
+case ":$PATH:" in
+  *":$INSTALL_DIR:"*) ;;
+  *)
+    echo ""
+    echo "Add this directory to PATH if 'skill-cli' is not found in new shells:"
+    echo "  $INSTALL_DIR"
+    ;;
+esac
+
+echo ""
+echo "skill-cli install complete."

package/scripts/make-install-bundle.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = path.join(__dirname, '..');
+const outDir = path.join(rootDir, 'dist', 'install');
+const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+const version = `v${pkg.version}`;
+const targets = [
+  'skill-cli-darwin-arm64',
+  'skill-cli-darwin-x64',
+  'skill-cli-linux-arm64',
+  'skill-cli-linux-x64',
+  'skill-cli-win32-x64.exe',
+];
+
+const args = process.argv.slice(2);
+let baseURL = '';
+let rootURL = '';
+for (let i = 0; i < args.length; i += 1) {
+  if (args[i] === '--base-url') {
+    baseURL = args[i + 1] || '';
+    i += 1;
+  } else if (args[i] === '--root') {
+    rootURL = args[i + 1] || '';
+    i += 1;
+  } else if (args[i] === '-h' || args[i] === '--help') {
+    console.log(`Usage:
+  node scripts/make-install-bundle.js [--root URL]
+  node scripts/make-install-bundle.js [--base-url URL]
+
+Creates dist/install/ with one-line installer scripts and prebuilt binaries.
+When --root is provided, generated installer copies default to ROOT/bin/targets.
+When --base-url is provided, generated installer copies default to that URL
+for binary downloads, which is useful for intranet static hosting.`);
+    process.exit(0);
+  } else {
+    console.error(`unknown option: ${args[i]}`);
+    process.exit(2);
+  }
+}
+
+function trimSlash(value) {
+  return value.replace(/\/+$/, '');
+}
+
+if (rootURL && baseURL) {
+  console.error('use either --root or --base-url, not both');
+  process.exit(2);
+}
+
+if (rootURL) {
+  rootURL = trimSlash(rootURL);
+  baseURL = `${rootURL}/bin/targets`;
+}
+
+function copyFile(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function writeFile(dest, content) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, content);
+}
+
+fs.rmSync(outDir, { recursive: true, force: true });
+
+for (const target of targets) {
+  const src = path.join(rootDir, 'bin', 'targets', target);
+  if (!fs.existsSync(src)) {
+    console.error(`missing binary: ${src}`);
+    process.exit(1);
+  }
+  copyFile(src, path.join(outDir, 'bin', 'targets', target));
+}
+
+let installSH = fs.readFileSync(path.join(rootDir, 'scripts', 'install.sh'), 'utf8');
+let installPS1 = fs.readFileSync(path.join(rootDir, 'scripts', 'install.ps1'), 'utf8');
+
+if (baseURL) {
+  const normalizedBaseURL = trimSlash(baseURL);
+  installSH = installSH.replace(
+    /DEFAULT_BASE_URL="https:\/\/gitee\.com\/marvin-dev\/skill-cli-creator\/raw\/\$\{VERSION\}\/bin\/targets"/,
+    `DEFAULT_BASE_URL="${normalizedBaseURL}"`
+  ).replace(
+    /DEFAULT_BASE_URL_USES_VERSION=1/,
+    'DEFAULT_BASE_URL_USES_VERSION=0'
+  );
+  installPS1 = installPS1.replace(
+    /\$BaseUrl = "https:\/\/gitee\.com\/marvin-dev\/skill-cli-creator\/raw\/\$Version\/bin\/targets"/,
+    `$BaseUrl = "${normalizedBaseURL}"`
+  );
+}
+
+writeFile(path.join(outDir, 'scripts', 'install.sh'), installSH);
+writeFile(path.join(outDir, 'scripts', 'install.ps1'), installPS1);
+
+const manifest = {
+  package: pkg.name,
+  version: pkg.version,
+  tag: version,
+  generatedAt: new Date().toISOString(),
+  rootURL: rootURL || null,
+  baseURL: baseURL || null,
+  files: [
+    'scripts/install.ps1',
+    'scripts/install.sh',
+    ...targets.map((target) => `bin/targets/${target}`),
+  ],
+};
+writeFile(path.join(outDir, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+
+function inferInstallRootFromBaseURL(value) {
+  const normalized = trimSlash(value);
+  if (normalized.endsWith('/bin/targets')) {
+    return normalized.slice(0, -'/bin/targets'.length);
+  }
+  return '<your-hosted-root>';
+}
+
+const installRoot = rootURL || (baseURL ? inferInstallRootFromBaseURL(baseURL) : `https://gitee.com/marvin-dev/skill-cli-creator/raw/${version}`);
+const psURL = baseURL ? `${installRoot}/scripts/install.ps1` : `${installRoot}/scripts/install.ps1`;
+const shURL = baseURL ? `${installRoot}/scripts/install.sh` : `${installRoot}/scripts/install.sh`;
+
+writeFile(path.join(outDir, 'README.txt'), `skill-cli ${version} install bundle
+
+Host this directory as a static tree. Required layout:
+  scripts/install.ps1
+  scripts/install.sh
+  bin/targets/skill-cli-*
+
+Windows PowerShell:
+  irm ${psURL} | iex
+
+macOS/Linux:
+  curl -fsSL ${shURL} | bash
+
+If --base-url was not used to generate this bundle, set SKILL_CLI_BASE_URL
+to the hosted bin/targets URL before running the installer.
+`);
+
+console.log(`Created ${outDir}`);
+console.log(`Version: ${version}`);
+if (baseURL) {
+  console.log(`Default binary base URL: ${baseURL}`);
+}