@awiki/cli 0.0.1-beta.2

package/internal/update/update.go

@@ -0,0 +1,368 @@
+package update
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/agentconnect/awiki-cli/internal/buildinfo"
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+)
+
+const (
+	defaultMetadataCacheTTLSeconds = 3600
+	npmLatestURL                   = "https://registry.npmjs.org/@awiki%2Fcli/latest"
+)
+
+// Metadata captures the remote version strategy state that we cache locally.
+type Metadata struct {
+	LatestVersion       string    `json:"latest_version"`
+	MinSupportedVersion string    `json:"min_supported_version"`
+	RetrievedAt         time.Time `json:"retrieved_at"`
+	Source              string    `json:"source"` // "network" | "cache" | "cache_stale"
+}
+
+// Decision describes how the CLI should behave given the current / remote versions.
+type Decision struct {
+	CurrentVersion      string `json:"current_version"`
+	LatestVersion       string `json:"latest_version"`
+	MinSupportedVersion string `json:"min_supported_version"`
+
+	StrictDisabled  bool `json:"strict_disabled"`
+	DevBuild        bool `json:"dev_build"`
+	HasNewerVersion bool `json:"has_newer_version"`
+	Blocked         bool `json:"blocked"`
+}
+
+// Check resolves the effective version policy (including config + env overrides),
+// loads remote metadata with caching, and returns the decision for the current
+// awiki-cli binary.
+//
+// This function is intentionally tolerant:
+// - Network / cache errors never crash the CLI; callers can choose how hard to fail.
+// - When metadata is missing or unparsable, the Decision falls back to "no block".
+func Check(resolved *appconfig.Resolved) (Decision, error) {
+	current := strings.TrimSpace(buildinfo.Version)
+	if current == "" {
+		current = "dev"
+	}
+	devBuild := isDevVersion(current)
+
+	strictDisabled := resolved != nil && resolved.UpdateDisableStrictVersion
+	// AWIKI_CLI_DISABLE_STRICT_VERSION is a last-resort escape hatch for debugging.
+	if raw := strings.TrimSpace(os.Getenv("AWIKI_CLI_DISABLE_STRICT_VERSION")); raw != "" {
+		strictDisabled = parseBool(raw)
+	}
+
+	ttlSeconds := defaultMetadataCacheTTLSeconds
+	if resolved != nil && resolved.UpdateMetadataCacheTTLSeconds > 0 {
+		ttlSeconds = resolved.UpdateMetadataCacheTTLSeconds
+	}
+	if raw := strings.TrimSpace(os.Getenv("AWIKI_CLI_UPDATE_CACHE_TTL")); raw != "" {
+		if parsed, err := strconv.Atoi(raw); err == nil && parsed > 0 {
+			ttlSeconds = parsed
+		}
+	}
+
+	decision := Decision{
+		CurrentVersion: current,
+		StrictDisabled: strictDisabled,
+		DevBuild:       devBuild,
+	}
+
+	meta, err := loadMetadata(resolved, ttlSeconds)
+	if err != nil {
+		// Propagate the error so callers can log or surface it, but keep the
+		// decision usable (no block by default).
+		return decision, err
+	}
+
+	decision.LatestVersion = meta.LatestVersion
+	decision.MinSupportedVersion = meta.MinSupportedVersion
+
+	// Dev builds should never be blocked, but they can still see "newer available".
+	if devBuild {
+		if newer, ok := compareVersions(meta.LatestVersion, current); ok && newer > 0 {
+			decision.HasNewerVersion = true
+		}
+		return decision, nil
+	}
+
+	// Compute "has newer" and "blocked" flags based on semantic version ordering.
+	if newer, ok := compareVersions(meta.LatestVersion, current); ok && newer > 0 {
+		decision.HasNewerVersion = true
+	}
+
+	if !strictDisabled {
+		if cmp, ok := compareVersions(current, meta.MinSupportedVersion); ok && cmp < 0 {
+			decision.Blocked = true
+		}
+	}
+
+	return decision, nil
+}
+
+func isDevVersion(v string) bool {
+	v = strings.TrimSpace(strings.ToLower(v))
+	if v == "" || v == "dev" {
+		return true
+	}
+	if strings.Contains(v, "-dev") {
+		return true
+	}
+	if strings.HasPrefix(v, "0.0.0-") {
+		return true
+	}
+	return false
+}
+
+func parseBool(raw string) bool {
+	raw = strings.TrimSpace(strings.ToLower(raw))
+	return raw == "1" || raw == "true" || raw == "yes" || raw == "on"
+}
+
+func cachePath(resolved *appconfig.Resolved) (string, error) {
+	if resolved == nil {
+		return "", errors.New("config is nil")
+	}
+	cacheDir := strings.TrimSpace(resolved.Paths.CacheDir)
+	if cacheDir == "" {
+		return "", errors.New("cache dir is empty")
+	}
+	return filepath.Join(cacheDir, "update", "metadata.json"), nil
+}
+
+func loadMetadata(resolved *appconfig.Resolved, ttlSeconds int) (Metadata, error) {
+	var zero Metadata
+
+	var cached Metadata
+	cacheFile, cacheErr := cachePath(resolved)
+	if cacheErr == nil {
+		if m, ok, err := readCache(cacheFile, ttlSeconds); err == nil {
+			if ok {
+				return m, nil
+			}
+			// ok == false -> expired or empty cache; fall through to network,
+			// but remember the last good snapshot in case the network is down.
+			cached = m
+		} else {
+			// Any cache read error is treated as soft; we still try network.
+			cached = Metadata{}
+		}
+	}
+
+	network, err := fetchFromRegistry()
+	if err != nil {
+		// If we had a usable cached value (even if TTL expired), fall back to it
+		// rather than failing hard.
+		if cached.LatestVersion != "" {
+			cached.Source = "cache_stale"
+			return cached, nil
+		}
+		return zero, err
+	}
+
+	if cacheErr == nil {
+		_ = writeCache(cacheFile, network)
+	}
+	return network, nil
+}
+
+func readCache(path string, ttlSeconds int) (Metadata, bool, error) {
+	var meta Metadata
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return meta, false, nil
+		}
+		return meta, false, err
+	}
+	if err := json.Unmarshal(raw, &meta); err != nil {
+		return Metadata{}, false, err
+	}
+	if ttlSeconds <= 0 || meta.RetrievedAt.IsZero() {
+		return meta, true, nil
+	}
+	if time.Since(meta.RetrievedAt) > time.Duration(ttlSeconds)*time.Second {
+		return Metadata{}, false, nil
+	}
+	return meta, true, nil
+}
+
+func writeCache(path string, meta Metadata) error {
+	meta.RetrievedAt = time.Now().UTC()
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return err
+	}
+	raw, err := json.MarshalIndent(meta, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(path, raw, 0o600)
+}
+
+func fetchFromRegistry() (Metadata, error) {
+	client := &http.Client{
+		Timeout: 3 * time.Second,
+	}
+	req, err := http.NewRequest(http.MethodGet, npmLatestURL, nil)
+	if err != nil {
+		return Metadata{}, err
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return Metadata{}, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return Metadata{}, fmt.Errorf("npm registry responded with status %d", resp.StatusCode)
+	}
+
+	var body struct {
+		Version  string `json:"version"`
+		AwikiCli struct {
+			MinSupportedVersion string `json:"minSupportedVersion"`
+		} `json:"awikiCli"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
+		return Metadata{}, err
+	}
+
+	latest := strings.TrimSpace(body.Version)
+	if latest == "" {
+		return Metadata{}, errors.New("npm metadata missing version")
+	}
+
+	minSupported := strings.TrimSpace(body.AwikiCli.MinSupportedVersion)
+	if minSupported == "" {
+		// If the manifest does not provide an explicit floor, default to "no floor".
+		// The decision logic will treat an empty min as "no block".
+		minSupported = ""
+	}
+
+	return Metadata{
+		LatestVersion:       latest,
+		MinSupportedVersion: minSupported,
+		RetrievedAt:         time.Now().UTC(),
+		Source:              "network",
+	}, nil
+}
+
+type semVersion struct {
+	Major int
+	Minor int
+	Patch int
+	Pre   string
+}
+
+func parseSemVersion(raw string) (semVersion, bool) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return semVersion{}, false
+	}
+	if raw[0] == 'v' || raw[0] == 'V' {
+		raw = raw[1:]
+	}
+	var pre string
+	if idx := strings.IndexByte(raw, '-'); idx >= 0 {
+		pre = raw[idx+1:]
+		raw = raw[:idx]
+	}
+	parts := strings.Split(raw, ".")
+	if len(parts) < 1 || len(parts) > 3 {
+		return semVersion{}, false
+	}
+	parsePart := func(s string) (int, bool) {
+		if s == "" {
+			return 0, true
+		}
+		n, err := strconv.Atoi(s)
+		if err != nil {
+			return 0, false
+		}
+		if n < 0 {
+			return 0, false
+		}
+		return n, true
+	}
+	major, ok := parsePart(parts[0])
+	if !ok {
+		return semVersion{}, false
+	}
+	minor := 0
+	patch := 0
+	if len(parts) >= 2 {
+		if minor, ok = parsePart(parts[1]); !ok {
+			return semVersion{}, false
+		}
+	}
+	if len(parts) == 3 {
+		if patch, ok = parsePart(parts[2]); !ok {
+			return semVersion{}, false
+		}
+	}
+	return semVersion{
+		Major: major,
+		Minor: minor,
+		Patch: patch,
+		Pre:   pre,
+	}, true
+}
+
+// compareVersions returns:
+//
+//	>0 if a > b
+//	 0 if a == b
+//	<0 if a < b
+//
+// The second return value is false if either side could not be parsed.
+func compareVersions(a, b string) (int, bool) {
+	av, okA := parseSemVersion(a)
+	bv, okB := parseSemVersion(b)
+	if !okA || !okB {
+		return 0, false
+	}
+	if av.Major != bv.Major {
+		if av.Major > bv.Major {
+			return 1, true
+		}
+		return -1, true
+	}
+	if av.Minor != bv.Minor {
+		if av.Minor > bv.Minor {
+			return 1, true
+		}
+		return -1, true
+	}
+	if av.Patch != bv.Patch {
+		if av.Patch > bv.Patch {
+			return 1, true
+		}
+		return -1, true
+	}
+	// Pre-release comparison: empty pre means stable and is considered newer than pre-release.
+	if av.Pre == bv.Pre {
+		return 0, true
+	}
+	if av.Pre == "" {
+		return 1, true
+	}
+	if bv.Pre == "" {
+		return -1, true
+	}
+	if av.Pre > bv.Pre {
+		return 1, true
+	}
+	if av.Pre < bv.Pre {
+		return -1, true
+	}
+	return 0, true
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@awiki/cli",
+  "version": "0.0.1-beta.2",
+  "description": "Awiki command-line interface (awiki-cli)",
+  "engines": {
+    "node": ">=18"
+  },
+  "awikiCli": {
+    "minSupportedVersion": "0.0.1-beta.2"
+  },
+  "bin": {
+    "awiki-cli": "scripts/run.js"
+  },
+  "scripts": {
+    "install-binary": "node scripts/install.js"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const { spawn } = require('child_process');
+
+function mapPlatform() {
+  const p = process.platform;
+  if (p === 'darwin') return 'darwin';
+  if (p === 'linux') return 'linux';
+  if (p === 'win32') return 'windows';
+  throw new Error(`Unsupported platform: ${p}`);
+}
+
+function mapArch() {
+  const a = process.arch;
+  if (a === 'x64') return 'amd64';
+  if (a === 'arm64') return 'arm64';
+  throw new Error(`Unsupported architecture: ${a}`);
+}
+
+function getVersion(pkg) {
+  const v = pkg && typeof pkg.version === 'string' ? pkg.version.trim() : '';
+  if (!v) {
+    throw new Error('version is missing in package.json');
+  }
+  return v;
+}
+
+function getDownloadUrl(version, osName, arch) {
+  const archiveBaseName = `awiki-cli-${version}-${osName}-${arch}`;
+  const ext = osName === 'windows' ? 'zip' : 'tar.gz';
+  const fileName = `${archiveBaseName}.${ext}`;
+
+  const mirror = (process.env.AWIKI_CLI_DOWNLOAD_MIRROR || '').trim();
+  const base = mirror || 'https://github.com/AgentConnect/awiki-cli/releases/download';
+  const baseNoSlash = base.replace(/\/+$/, '');
+  const tag = `v${version}`;
+
+  return {
+    url: `${baseNoSlash}/${tag}/${fileName}`,
+    fileName,
+  };
+}
+
+function download(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    let finished = false;
+
+    const req = https.get(url, res => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        // handle redirect
+        res.destroy();
+        file.close(() => fs.unlink(destPath, () => {
+          download(res.headers.location, destPath).then(resolve, reject);
+        }));
+        return;
+      }
+
+      if (res.statusCode !== 200) {
+        res.resume();
+        file.close(() => fs.unlink(destPath, () => {
+          reject(new Error(`Download failed with status code ${res.statusCode}`));
+        }));
+        return;
+      }
+
+      res.pipe(file);
+      file.on('finish', () => {
+        finished = true;
+        file.close(resolve);
+      });
+    });
+
+    req.on('error', err => {
+      if (!finished) {
+        file.close(() => fs.unlink(destPath, () => reject(err)));
+      } else {
+        reject(err);
+      }
+    });
+  });
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function extractArchive(archivePath, destDir, osName) {
+  return new Promise((resolve, reject) => {
+    let cmd;
+    let args;
+
+    if (osName === 'windows') {
+      // Use PowerShell Expand-Archive; requires PowerShell 5+ (Windows 10/11)
+      cmd = 'powershell';
+      args = [
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        `Expand-Archive -LiteralPath '${archivePath}' -DestinationPath '${destDir}' -Force`,
+      ];
+    } else {
+      cmd = 'tar';
+      args = ['-xzf', archivePath, '-C', destDir];
+    }
+
+    const child = spawn(cmd, args, { stdio: 'inherit' });
+    child.on('error', reject);
+    child.on('exit', code => {
+      if (code === 0) resolve();
+      else reject(new Error(`Extraction command ${cmd} exited with code ${code}`));
+    });
+  });
+}
+
+async function main() {
+  const rootDir = path.resolve(__dirname, '..');
+  const pkgPath = path.join(rootDir, 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+  const version = getVersion(pkg);
+  const osName = mapPlatform();
+  const arch = mapArch();
+  const { url, fileName } = getDownloadUrl(version, osName, arch);
+
+  const binDir = path.join(rootDir, 'bin');
+  ensureDir(binDir);
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'awiki-cli-'));
+  const archivePath = path.join(tmpDir, fileName);
+
+  console.log(`Downloading awiki-cli ${version} for ${osName}/${arch} from ${url} ...`);
+  await download(url, archivePath);
+
+  console.log(`Extracting to ${binDir} ...`);
+  await extractArchive(archivePath, binDir, osName);
+
+  const exeName = osName === 'windows' ? 'awiki-cli.exe' : 'awiki-cli';
+  const exePath = path.join(binDir, exeName);
+
+  if (osName !== 'windows') {
+    try {
+      fs.chmodSync(exePath, 0o755);
+    } catch (e) {
+      // best effort
+    }
+  }
+
+  console.log(`awiki-cli binary is installed at ${exePath}`);
+}
+
+if (require.main === module) {
+  main().catch(err => {
+    console.error(`[awiki-cli] Failed to install binary: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  _internal: {
+    mapPlatform,
+    mapArch,
+    getVersion,
+    getDownloadUrl,
+  },
+};

package/scripts/release/release-prerelease.sh

@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "${ROOT_DIR}"
+
+DIST_TAG="${1:-}"
+
+if [ -z "${DIST_TAG}" ]; then
+  echo "Usage: scripts/release/release-prerelease.sh <dist-tag>" >&2
+  echo "Example: scripts/release/release-prerelease.sh beta" >&2
+  exit 1
+fi
+
+if ! command -v jq >/dev/null 2>&1; then
+  echo "Error: jq is required to run scripts/release/release-prerelease.sh" >&2
+  exit 1
+fi
+
+if [ ! -f package.json ]; then
+  echo "Error: package.json not found in ${ROOT_DIR}" >&2
+  exit 1
+fi
+
+VERSION="$(jq -r '.version // empty' package.json)"
+if [ -z "${VERSION}" ]; then
+  echo "Error: .version is missing or empty in package.json" >&2
+  exit 1
+fi
+
+if [[ "${VERSION}" != *-* ]]; then
+  echo "Error: pre-release version must contain a '-' suffix (e.g. 0.2.0-beta.1), got ${VERSION}" >&2
+  exit 1
+fi
+
+TAG="v${VERSION}"
+
+if [ -n "$(git status --porcelain)" ]; then
+  echo "Error: working tree is not clean; please commit or stash changes before tagging" >&2
+  exit 1
+fi
+
+BRANCH="$(git rev-parse --abbrev-ref HEAD)"
+if [ "${BRANCH}" = "HEAD" ]; then
+  echo "Error: currently on a detached HEAD; please checkout a branch before tagging" >&2
+  exit 1
+fi
+
+if ! git rev-parse --abbrev-ref --symbolic-full-name '@{u}' >/dev/null 2>&1; then
+  echo "Error: current branch ${BRANCH} has no upstream; please set upstream and push before tagging" >&2
+  exit 1
+fi
+
+if [ -n "$(git cherry)" ]; then
+  echo "Error: there are local commits not pushed to origin; please push them before tagging" >&2
+  exit 1
+fi
+
+if git rev-parse -q --verify "refs/tags/${TAG}" >/dev/null; then
+  echo "Error: tag ${TAG} already exists locally" >&2
+  exit 1
+fi
+
+if git ls-remote --tags origin "refs/tags/${TAG}" | grep -q .; then
+  echo "Error: tag ${TAG} already exists on origin" >&2
+  exit 1
+fi
+
+echo "Creating pre-release tag ${TAG} (dist-tag: ${DIST_TAG}) on branch ${BRANCH}..."
+git tag -a "${TAG}" -m "Pre-release ${TAG} (dist-tag: ${DIST_TAG})"
+
+echo "Pushing tag ${TAG} to origin..."
+git push origin "${TAG}"
+
+cat <<EOF
+
+Pre-release tag ${TAG} has been pushed.
+
+Next steps:
+- CI will build binaries and create a GitHub pre-release for ${TAG}.
+- To publish the npm pre-release package with dist-tag "${DIST_TAG}", run:
+
+    NODE_AUTH_TOKEN=... npm publish --access public --tag ${DIST_TAG}
+
+EOF
+

package/scripts/release/tag-release.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "${ROOT_DIR}"
+
+if ! command -v jq >/dev/null 2>&1; then
+  echo "Error: jq is required to run scripts/release/tag-release.sh" >&2
+  exit 1
+fi
+
+if [ ! -f package.json ]; then
+  echo "Error: package.json not found in ${ROOT_DIR}" >&2
+  exit 1
+fi
+
+VERSION="$(jq -r '.version // empty' package.json)"
+if [ -z "${VERSION}" ]; then
+  echo "Error: .version is missing or empty in package.json" >&2
+  exit 1
+fi
+
+TAG="v${VERSION}"
+
+# Require clean working tree to避免把未提交修改发布出去
+if [ -n "$(git status --porcelain)" ]; then
+  echo "Error: working tree is not clean; please commit or stash changes before tagging" >&2
+  exit 1
+fi
+
+# Ensure we are on a named branch, not detached HEAD
+BRANCH="$(git rev-parse --abbrev-ref HEAD)"
+if [ "${BRANCH}" = "HEAD" ]; then
+  echo "Error: currently on a detached HEAD; please checkout a branch (e.g. main) before tagging" >&2
+  exit 1
+fi
+
+# Ensure the branch has an upstream and is fully pushed
+if ! git rev-parse --abbrev-ref --symbolic-full-name '@{u}' >/dev/null 2>&1; then
+  echo "Error: current branch ${BRANCH} has no upstream; please set upstream and push before tagging" >&2
+  exit 1
+fi
+
+if [ -n "$(git cherry)" ]; then
+  echo "Error: there are local commits not pushed to origin; please push them before tagging" >&2
+  exit 1
+fi
+
+# Check for existing tag locally and remotely
+if git rev-parse -q --verify "refs/tags/${TAG}" >/dev/null; then
+  echo "Error: tag ${TAG} already exists locally" >&2
+  exit 1
+fi
+
+if git ls-remote --tags origin "refs/tags/${TAG}" | grep -q .; then
+  echo "Error: tag ${TAG} already exists on origin" >&2
+  exit 1
+fi
+
+echo "Creating tag ${TAG} on branch ${BRANCH}..."
+git tag -a "${TAG}" -m "Release ${TAG}"
+
+echo "Pushing tag ${TAG} to origin..."
+git push origin "${TAG}"
+
+echo "Done. CI should pick up tag ${TAG} and run the release workflow."