capix-code 2.2.4 → 2.2.5

package/scripts/build.sh

@@ -1,154 +0,0 @@
-#!/usr/bin/env bash
-# build.sh — produce packaged capix-code binaries.
-set -euo pipefail
-
-DIR="$(cd "$(dirname "$0")/.." && pwd)"
-CAPIX_CODE_DIR="${CAPIX_CODE_DIR:-$DIR/upstream}"
-BUN="${BUN_BIN:-$(command -v bun || true)}"
-if [ -z "$BUN" ] && [ -x "$DIR/node_modules/.bin/bun" ]; then BUN="$DIR/node_modules/.bin/bun"; fi
-[ -n "$BUN" ] || { echo "✗ Bun 1.3.14 is required"; exit 1; }
-[ "$($BUN --version)" = "1.3.14" ] || { echo "✗ Expected Bun 1.3.14"; exit 1; }
-
-if [ ! -d "$CAPIX_CODE_DIR" ]; then
-  echo "✗ No $CAPIX_CODE_DIR. Run ./scripts/bootstrap.sh first."
-  exit 1
-fi
-
-cd "$CAPIX_CODE_DIR"
-
-echo "▸ Building capix-code standalone binary…"
-"$BUN" install
-
-# The embedded engine otherwise falls back to a timestamped 0.0.0 development
-# identifier. Stamp it with the immutable Capix Code package version so the TUI,
-# API metadata and diagnostics all report the customer release.
-CAPIX_RELEASE_VERSION="${CAPIX_CODE_VERSION:-$(node -p 'require(process.argv[1]).version' "$DIR/package.json")}"
-export CAPIX_CODE_VERSION="$CAPIX_RELEASE_VERSION"
-export CAPIX_CODE_CHANNEL="latest"
-export OPENCODE_VERSION="$CAPIX_RELEASE_VERSION"
-
-# Write default config if the init script exists.
-if [ -f "packages/capix-code/scripts/init-capix-config.ts" ]; then
-  "$BUN" run packages/capix-code/scripts/init-capix-config.ts 2>/dev/null || true
-fi
-
-# Build using the upstream build script.
-if [ -f "packages/capix-code/script/build.ts" ]; then
-  "$BUN" run --cwd packages/capix-code script/build.ts --single
-fi
-
-# Find the output — handle both renamed and original patterns.
-EXE_SUFFIX=""
-case "$(uname -s)" in MINGW*|MSYS*|CYGWIN*) EXE_SUFFIX=".exe";; esac
-OUTPUT=$(find packages/capix-code/dist -name "capix-code$EXE_SUFFIX" -type f 2>/dev/null | head -1)
-if [ -z "$OUTPUT" ]; then
-  OUTPUT=$(find packages/capix-code/dist -name "opencode$EXE_SUFFIX" -type f 2>/dev/null | head -1)
-  if [ -n "$OUTPUT" ]; then
-    NEW_OUTPUT="$(dirname "$OUTPUT")/capix-code$EXE_SUFFIX"
-    mv "$OUTPUT" "$NEW_OUTPUT"
-    OUTPUT="$NEW_OUTPUT"
-  fi
-fi
-
-if [ -n "$OUTPUT" ]; then
-  ARTIFACT="$DIR/dist/customer"
-  rm -rf "$ARTIFACT"
-  mkdir -p "$ARTIFACT/bin" "$ARTIFACT/engine" "$ARTIFACT/runtime/packages" "$ARTIFACT/config" "$ARTIFACT/mcp"
-  cp "$OUTPUT" "$ARTIFACT/engine/capix-engine$EXE_SUFFIX"
-  cp -R "$DIR/src" "$ARTIFACT/runtime/src"
-  # Create tsconfig.json so path aliases (@/*) resolve when the engine imports providers
-  cat > "$ARTIFACT/runtime/tsconfig.json" << 'TCSONFIG'
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  }
-}
-TCSONFIG
-  cp -R "$DIR/packages/runtime-provider" "$ARTIFACT/runtime/packages/runtime-provider"
-  cp "$DIR/config/runtime-package.json" "$ARTIFACT/runtime/package.json"
-  cp "$DIR/config/capix-defaults.json" "$DIR/config/defaults.json" "$ARTIFACT/config/"
-  cp -R "$DIR/commands" "$ARTIFACT/commands"
-  # Build and bundle the MCP server from the capix-mcp npm package
-  mkdir -p "$ARTIFACT/mcp" "$ARTIFACT/mcp/node_modules"
-  npm install capix-mcp@2.1.0 --prefix "$DIR/dist/mcp-tmp" 2>/dev/null
-  cp -R "$DIR/dist/mcp-tmp/node_modules/capix-mcp/dist/"* "$ARTIFACT/mcp/" 2>/dev/null
-  cp "$DIR/dist/mcp-tmp/node_modules/capix-mcp/package.json" "$ARTIFACT/mcp/" 2>/dev/null
-  # Copy ALL dependencies needed by capix-mcp
-  for dep in @modelcontextprotocol zod; do
-    if [ -d "$DIR/dist/mcp-tmp/node_modules/$dep" ]; then
-      cp -R "$DIR/dist/mcp-tmp/node_modules/$dep" "$ARTIFACT/mcp/node_modules/" 2>/dev/null
-    fi
-  done
-  if [ -d "$DIR/dist/mcp-tmp/node_modules/capix-mcp/node_modules" ]; then
-    cp -R "$DIR/dist/mcp-tmp/node_modules/capix-mcp/node_modules/"* "$ARTIFACT/mcp/node_modules/" 2>/dev/null
-  fi
-  # Copy capix-mcp's dependencies (SDK, zod, etc.)
-  mkdir -p "$ARTIFACT/mcp/node_modules"
-  if [ -d "$DIR/dist/mcp-tmp/node_modules/capix-mcp/node_modules" ]; then
-    cp -R "$DIR/dist/mcp-tmp/node_modules/capix-mcp/node_modules/"* "$ARTIFACT/mcp/node_modules/" 2>/dev/null
-  fi
-  for dep in @modelcontextprotocol zod; do
-    if [ -d "$DIR/dist/mcp-tmp/node_modules/$dep" ]; then
-      cp -R "$DIR/dist/mcp-tmp/node_modules/$dep" "$ARTIFACT/mcp/node_modules/" 2>/dev/null
-    fi
-  done
-  # Create entry point wrapper that shares credentials with capix-code
-  cat > "$ARTIFACT/mcp/capix-mcp.js" << 'MCPWRAPPER'
-#!/usr/bin/env node
-const { readFileSync, writeFileSync, chmodSync, existsSync } = require("node:fs");
-const { join } = require("node:path");
-const { homedir } = require("node:os");
-const credPath = join(homedir(), ".capix-code", "credentials.json");
-async function loadMcp() {
-  require(join(__dirname, "index.js"));
-}
-(async () => {
-  try {
-    if (existsSync(credPath)) {
-      const creds = JSON.parse(readFileSync(credPath, "utf8"));
-      const rt = creds["capix-code:oauth-refresh-token"];
-      if (rt) {
-        const res = await fetch("https://www.capix.network/oauth/token", {
-          method: "POST",
-          headers: { "Content-Type": "application/x-www-form-urlencoded" },
-          body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: rt, client_id: "capix-code" }).toString(),
-        });
-        const body = await res.json();
-        if (body.access_token) {
-          process.env.CAPIX_API_KEY = body.access_token;
-          creds["capix-code:oauth-refresh-token"] = body.refresh_token;
-          writeFileSync(credPath, JSON.stringify(creds, null, 2), { mode: 0o600 });
-          chmodSync(credPath, 0o600);
-        }
-      }
-    }
-  } catch {}
-  loadMcp();
-})();
-MCPWRAPPER
-  chmod 0755 "$ARTIFACT/mcp/capix-mcp.js"
-  rm -rf "$DIR/dist/mcp-tmp"
-  chmod 0755 "$ARTIFACT/engine/capix-engine$EXE_SUFFIX"
-  # Install from the dedicated runtime manifest. The outer npm package has
-  # platform selectors which do not belong inside the embedded runtime.
-  (cd "$ARTIFACT/runtime" && npm install --omit=dev --ignore-scripts)
-  (cd "$DIR/launcher" && cargo build --release)
-  cp "$DIR/launcher/target/release/capix-code$EXE_SUFFIX" "$ARTIFACT/bin/capix-code$EXE_SUFFIX"
-  chmod 0755 "$ARTIFACT/bin/capix-code$EXE_SUFFIX"
-
-  "$DIR/scripts/assert-artifact.sh" "$ARTIFACT"
-  "$DIR/scripts/assert-customer-brand.sh" "$ARTIFACT"
-  echo "✓ Customer artifact staged: $ARTIFACT"
-else
-  echo "✗ No binary found in dist/ — build may have failed."
-  exit 1
-fi

package/scripts/checksum.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-DIST_DIR="${1:-dist}"
-for f in "$DIST_DIR"/*.tar.gz "$DIST_DIR"/*.zip; do
-  [ -f "$f" ] || continue
-  shasum -a 256 "$f" > "$f.sha256"
-  echo "  $(basename $f): $(cat "$f.sha256" | awk '{print $1}')"
-done

package/scripts/dev-install.sh

@@ -1,30 +0,0 @@
-#!/bin/bash
-# Local development installation of Capix Code
-# This is NOT a production installer — for development only
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-SOURCE_DIR="$(dirname "$SCRIPT_DIR")"
-
-echo "=== Capix Code Development Install ==="
-echo "Path: $SOURCE_DIR"
-echo ""
-
-# Install dependencies
-cd "$SOURCE_DIR"
-if [ ! -d "node_modules" ]; then
-  echo "Installing dependencies..."
-  npm install
-fi
-
-# Type check
-echo "Running type check..."
-npx tsc --noEmit
-
-# Run tests
-echo "Running tests..."
-npx vitest run
-
-echo ""
-echo "✅ Development environment ready."
-echo "Run: npx tsx src/plugin.ts  # to start the Capix Code agent"

package/scripts/dev.sh

@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-#
-# dev.sh — launch capix-code in dev mode.
-#
-# Requires the repository-pinned Bun 1.3.14 runtime.
-set -euo pipefail
-
-DIR="$(cd "$(dirname "$0")/.." && pwd)"
-CAPIX_CODE_DIR="${CAPIX_CODE_DIR:-$DIR/upstream}"
-BUN="${BUN_BIN:-$(command -v bun || true)}"
-if [ -z "$BUN" ] && [ -x "$DIR/node_modules/.bin/bun" ]; then BUN="$DIR/node_modules/.bin/bun"; fi
-[ -n "$BUN" ] || { echo "✗ Bun 1.3.14 is required; install the pinned runtime first"; exit 1; }
-[ "$($BUN --version)" = "1.3.14" ] || { echo "✗ Expected Bun 1.3.14"; exit 1; }
-
-if [ ! -d "$CAPIX_CODE_DIR" ]; then
-  echo "✗ No $CAPIX_CODE_DIR. Run ./scripts/bootstrap.sh first."
-  exit 1
-fi
-
-cd "$CAPIX_CODE_DIR"
-
-echo "▸ Installing dependencies (Bun)…"
-"$BUN" install
-
-echo "▸ Writing default Capix config (if missing)…"
-"$BUN" run packages/capix-code/scripts/init-capix-config.ts 2>/dev/null || true
-
-echo "▸ Launching capix-code (dev mode)…"
-echo ""
-echo "  Set your Capix env vars before starting:"
-echo "    export CAPIX_BASE_URL=https://capix.network/api/v1"
-echo "    export CAPIX_API_KEY=cpk_...   (or your deployed cpxllm_... key)"
-echo "    export CAPIX_MODEL=capix/auto   (optional — defaults to auto)"
-echo ""
-"$BUN" run --cwd packages/capix-code --conditions=browser src/index.ts "$@"

package/scripts/install-config.sh

@@ -1,66 +0,0 @@
-#!/usr/bin/env bash
-# install-config.sh — drop the Capix provider config as the default.
-set -uo pipefail
-
-DIR="$(cd "$(dirname "$0")/.." && pwd)"
-CAPIX_CODE_DIR="${CAPIX_CODE_DIR:-$DIR/upstream}"
-CONFIG_SRC="$DIR/config/defaults.json"
-
-if [ ! -f "$CONFIG_SRC" ]; then
-  echo "✗ Missing $CONFIG_SRC"
-  exit 1
-fi
-
-# 1. Bundle the config into the capix-code package as a default.
-DEST_DIR="$CAPIX_CODE_DIR/packages/capix-code/config"
-mkdir -p "$DEST_DIR"
-cp "$CONFIG_SRC" "$DEST_DIR/capix-defaults.json"
-echo "  ✓ bundled capix-defaults.json"
-
-# 2. Create the init script that writes the default config on first run.
-WRAPPER="$CAPIX_CODE_DIR/packages/capix-code/scripts/init-capix-config.ts"
-mkdir -p "$(dirname "$WRAPPER")"
-cat > "$WRAPPER" << 'WRAPPER_EOF'
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-function getConfigDir(): string {
-  switch (process.platform) {
-    case "darwin": return join(homedir(), "Library", "Application Support", "capix-code");
-    case "win32": return join(homedir(), "AppData", "Roaming", "capix-code");
-    default: return join(homedir(), ".config", "capix-code");
-  }
-}
-
-const configDir = getConfigDir();
-const configFile = join(configDir, "capix-code.json");
-
-if (!existsSync(configFile)) {
-  let defaults = "{}";
-  try {
-    defaults = readFileSync(join(import.meta.dir, "..", "config", "capix-defaults.json"), "utf-8");
-  } catch {}
-  mkdirSync(configDir, { recursive: true });
-  writeFileSync(configFile, defaults, "utf-8");
-}
-WRAPPER_EOF
-echo "  ✓ created init-capix-config.ts wrapper"
-
-# 3. Install the TUI theme + brand assets.
-if [ -d "$DIR/themes" ]; then
-  THEME_DEST="$CAPIX_CODE_DIR/packages/capix-code/config/themes"
-  mkdir -p "$THEME_DEST"
-  cp "$DIR/themes/capix.toml" "$THEME_DEST/capix.toml" 2>/dev/null || true
-  cp "$DIR/tui-capix.json" "$CAPIX_CODE_DIR/packages/capix-code/config/tui-capix.json" 2>/dev/null || true
-  echo "  ✓ TUI theme installed"
-fi
-
-if [ -d "$DIR/brand" ]; then
-  BRAND_DEST="$CAPIX_CODE_DIR/packages/capix-code/config/brand"
-  mkdir -p "$BRAND_DEST"
-  cp -R "$DIR/brand/"* "$BRAND_DEST/" 2>/dev/null || true
-  echo "  ✓ brand assets installed"
-fi
-
-echo "✓ Capix config + branding installed."

package/scripts/install.sh

@@ -1,115 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-VERSION="${CAPIX_CODE_VERSION:-${1:-}}"
-RELEASE_BASE_URL="${CAPIX_RELEASE_BASE_URL:-https://github.com/CapIX-Protocol/Capix-Code/releases/download}"
-INSTALL_DIR="${CAPIX_INSTALL_DIR:-${CAPIX_CODE_INSTALL_DIR:-${HOME}/.local/bin}}"
-RUNTIME_DIR="${CAPIX_CODE_RUNTIME_DIR:-${HOME}/.local/share/capix-code}"
-
-# "latest" is permitted only by resolving it to an immutable version BEFORE any
-# download — never by trusting mutable content. The release pipeline pins the
-# current stable version in CAPIX_STABLE_VERSION (the single source of truth
-# that also populates manifest/release-manifest.json#stableVersion). Without a
-# pin, "latest" fails closed so the installer never proceeds unbounded.
-if [ -z "$VERSION" ] || [ "$VERSION" = "latest" ]; then
-  if [ -n "${CAPIX_STABLE_VERSION:-}" ]; then
-    VERSION="$CAPIX_STABLE_VERSION"
-    echo "Resolved latest -> ${VERSION} (CAPIX_STABLE_VERSION)" >&2
-  else
-    echo "ERROR: 'latest' requires CAPIX_STABLE_VERSION to be set to an immutable release (e.g. v1.2.3)." >&2
-    echo "The release pipeline pins the current stable version there; do not pin to mutable content." >&2
-    exit 2
-  fi
-fi
-
-if [[ ! "$VERSION" =~ ^v[0-9]+\.[0-9]+\.[0-9]+([.-][0-9A-Za-z.-]+)?$ ]]; then
-  echo "ERROR: invalid version '$VERSION' (expected vMAJOR.MINOR.PATCH)" >&2
-  exit 2
-fi
-
-OS="${CAPIX_INSTALL_OS:-$(uname -s | tr '[:upper:]' '[:lower:]')}"
-ARCH="${CAPIX_INSTALL_ARCH:-$(uname -m)}"
-case "$OS" in
-  darwin|linux) ;;
-  mingw*|msys*|cygwin*|win32*|windows*)
-    echo "ERROR: Windows is not supported by this shell installer." >&2
-    echo "Download the Windows binary from:" >&2
-    echo "  https://github.com/CapIX-Protocol/Capix-Code/releases" >&2
-    echo "Or use PowerShell:" >&2
-    echo "  iwr -UseBasicParsing https://github.com/CapIX-Protocol/Capix-Code/releases/download/${VERSION}/capix-code-windows-x64.exe -OutFile capix-code.exe" >&2
-    exit 2
-    ;;
-  *)
-    echo "ERROR: unsupported operating system '$OS'" >&2
-    echo "Download a binary from: https://github.com/CapIX-Protocol/Capix-Code/releases" >&2
-    exit 2
-    ;;
-esac
-case "$ARCH" in
-  x86_64) ARCH="x64" ;;
-  arm64|aarch64) ARCH="arm64" ;;
-  *) echo "ERROR: unsupported architecture '$ARCH'" >&2; exit 2 ;;
-esac
-
-RELEASE_VERSION="${VERSION#v}"
-ARTIFACT="capix-code-${RELEASE_VERSION}-${OS}-${ARCH}-unsigned.tar.gz"
-BASE_URL="${RELEASE_BASE_URL}/${VERSION}"
-WORK_DIR=$(mktemp -d "${TMPDIR:-/tmp}/capix-code-install.XXXXXX")
-trap 'rm -rf "$WORK_DIR"' EXIT INT TERM
-
-if [[ "$BASE_URL" == https://* ]]; then
-  curl --proto '=https' --tlsv1.2 -fsSL "${BASE_URL}/${ARTIFACT}.sha256" -o "${WORK_DIR}/${ARTIFACT}.sha256"
-  curl --proto '=https' --tlsv1.2 -fsSL "${BASE_URL}/${ARTIFACT}" -o "${WORK_DIR}/${ARTIFACT}"
-else
-  curl -fsSL "${BASE_URL}/${ARTIFACT}.sha256" -o "${WORK_DIR}/${ARTIFACT}.sha256"
-  curl -fsSL "${BASE_URL}/${ARTIFACT}" -o "${WORK_DIR}/${ARTIFACT}"
-fi
-
-CHECKSUM_LINES=$(awk 'NF { count++ } END { print count + 0 }' "${WORK_DIR}/${ARTIFACT}.sha256")
-EXPECTED=$(awk 'NF { print $1 }' "${WORK_DIR}/${ARTIFACT}.sha256")
-RECORDED_ARTIFACT=$(awk 'NF { print $2 }' "${WORK_DIR}/${ARTIFACT}.sha256")
-RECORDED_ARTIFACT="${RECORDED_ARTIFACT#\*}"
-RECORDED_ARTIFACT="${RECORDED_ARTIFACT##*/}"
-if [ "$CHECKSUM_LINES" -ne 1 ] || [ "$RECORDED_ARTIFACT" != "$ARTIFACT" ] || [[ ! "$EXPECTED" =~ ^[0-9a-fA-F]{64}$ ]]; then
-  echo "ERROR: adjacent checksum must contain exactly one valid SHA-256 entry for ${ARTIFACT}" >&2
-  exit 1
-fi
-
-if command -v shasum >/dev/null 2>&1; then
-  ACTUAL=$(shasum -a 256 "${WORK_DIR}/${ARTIFACT}" | awk '{print $1}')
-elif command -v sha256sum >/dev/null 2>&1; then
-  ACTUAL=$(sha256sum "${WORK_DIR}/${ARTIFACT}" | awk '{print $1}')
-else
-  echo "ERROR: neither shasum nor sha256sum is available" >&2
-  exit 1
-fi
-
-if [ "$EXPECTED" != "$ACTUAL" ]; then
-  echo "ERROR: checksum verification failed for ${ARTIFACT}" >&2
-  exit 1
-fi
-
-mkdir -p "$INSTALL_DIR" "$(dirname "$RUNTIME_DIR")"
-
-if [ ! -w "$INSTALL_DIR" ]; then
-  echo "ERROR: ${INSTALL_DIR} is not writable. Re-run with a user-owned CAPIX_CODE_INSTALL_DIR; this installer does not invoke sudo." >&2
-  exit 1
-fi
-
-tar -xzf "${WORK_DIR}/${ARTIFACT}" -C "$WORK_DIR"
-test -x "${WORK_DIR}/customer/bin/capix-code" || {
-  echo "ERROR: verified archive does not contain customer/bin/capix-code" >&2
-  exit 1
-}
-
-STAGED_RUNTIME="${RUNTIME_DIR}.${VERSION}.new"
-rm -rf "$STAGED_RUNTIME"
-mkdir -p "$STAGED_RUNTIME"
-cp -a "${WORK_DIR}/customer/." "$STAGED_RUNTIME/"
-rm -rf "$RUNTIME_DIR"
-mv "$STAGED_RUNTIME" "$RUNTIME_DIR"
-ln -sfn "${RUNTIME_DIR}/bin/capix-code" "${INSTALL_DIR}/capix-code"
-TARGET="${INSTALL_DIR}/capix-code"
-
-echo "Installed verified Capix Code ${VERSION} at ${TARGET}"
-echo "This artifact is unsigned. Verification used the release's exact SHA-256 manifest entry."

package/scripts/package-customer.sh

@@ -1,28 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-VERSION="${1:?version required}"
-PLATFORM="${2:?platform required}"
-ARCH="${3:?architecture required}"
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-CUSTOMER="$ROOT/dist/customer"
-OUT="$ROOT/release-artifacts"
-NAME="capix-code-$VERSION-$PLATFORM-$ARCH-unsigned"
-
-"$ROOT/scripts/assert-artifact.sh" "$CUSTOMER"
-"$ROOT/scripts/assert-customer-brand.sh" "$CUSTOMER"
-mkdir -p "$OUT"
-if [ "$PLATFORM" = win32 ]; then
-  ARCHIVE="$OUT/$NAME.zip"
-  (cd "$ROOT/dist" && 7z a -tzip "$ARCHIVE" customer)
-else
-  ARCHIVE="$OUT/$NAME.tar.gz"
-  tar -C "$ROOT/dist" -czf "$ARCHIVE" customer
-fi
-if command -v sha256sum >/dev/null 2>&1; then
-  sha256sum "$ARCHIVE" > "$ARCHIVE.sha256"
-else
-  shasum -a 256 "$ARCHIVE" > "$ARCHIVE.sha256"
-fi
-printf '%s\n' "$(git -C "$ROOT" rev-parse HEAD)" > "$OUT/$NAME.source-commit.txt"
-node "$ROOT/scripts/write-release-entry.mjs" "$VERSION" "$PLATFORM" "$ARCH" "$ARCHIVE"
-echo "Verified release artifact: $ARCHIVE"

package/scripts/package.sh

@@ -1,84 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-VERSION="${1:-0.1.0-dev}"
-ARCH="$(uname -m)"
-OUTPUT_DIR="dist"
-ARTIFACT_NAME="capix-code-$VERSION-darwin-$ARCH"
-
-echo "=== Packaging Capix Code $VERSION ($ARCH) ==="
-
-mkdir -p "$OUTPUT_DIR"
-
-# 1. Build the TypeScript
-npm run compile || true  # tsc --noEmit for now — no separate build step yet
-
-# 2. Create tarball with src/, config/, manifest/
-echo "Creating tarball..."
-tar -czf "$OUTPUT_DIR/$ARTIFACT_NAME.tar.gz" \
-  src/ \
-  config/ \
-  manifest/ \
-  package.json \
-  package-lock.json \
-  tui-capix.json \
-  tsconfig.json \
-  LICENSE \
-  NOTICE \
-  README.md
-
-# 3. Generate SHA-256
-echo "Generating SHA-256..."
-shasum -a 256 "$OUTPUT_DIR/$ARTIFACT_NAME.tar.gz" > "$OUTPUT_DIR/$ARTIFACT_NAME.tar.gz.sha256"
-
-# 4. Provenance
-cat > "$OUTPUT_DIR/$ARTIFACT_NAME.provenance.json" << EOF
-{
-  "artifact": "$ARTIFACT_NAME.tar.gz",
-  "version": "$VERSION",
-  "platform": "darwin-$ARCH",
-  "signed": false,
-  "sourceCommit": "$(git rev-parse HEAD)",
-  "builtAt": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-  "builder": "$(whoami)@$(hostname)",
-  "checksum": "$(cat "$OUTPUT_DIR/$ARTIFACT_NAME.tar.gz.sha256" | awk '{print $1}')"
-}
-EOF
-
-# 5. Minimal SBOM
-cat > "$OUTPUT_DIR/$ARTIFACT_NAME.sbom.json" << EOF
-{
-  "sbomFormat": "CapIX-minimal",
-  "version": "0.1.0",
-  "generatedAt": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-  "dependencies": "See package-lock.json",
-  "sourceCommit": "$(git rev-parse HEAD)",
-  "unsigned": true
-}
-EOF
-
-# 6. Installation instructions
-cat << INST
-
-=== Capix Code $VERSION (UNSIGNED) ===
-
-Artifact: $OUTPUT_DIR/$ARTIFACT_NAME.tar.gz
-SHA-256:  $(cat "$OUTPUT_DIR/$ARTIFACT_NAME.tar.gz.sha256" | awk '{print $1}')
-
-## Installation (UNSIGNED)
-
-1. Verify checksum:
-   shasum -a 256 $OUTPUT_DIR/$ARTIFACT_NAME.tar.gz
-
-2. Extract:
-   tar -xzf $OUTPUT_DIR/$ARTIFACT_NAME.tar.gz -C ~/capix-code
-
-3. Install dependencies:
-   cd ~/capix-code && npm install --production
-
-4. Run:
-   node ~/capix-code/src/index.ts  # or after tsc: node dist/index.js
-
-Source commit: $(git rev-parse HEAD)
-
-INST

package/scripts/prepare-npm-meta.mjs

@@ -1,12 +0,0 @@
-import { chmodSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-
-const root = new URL('..', import.meta.url).pathname;
-const launcher = join(root, 'bin', 'capix-code.cjs');
-
-if (!existsSync(launcher)) {
-  console.error('Capix Code npm launcher is missing.');
-  process.exit(1);
-}
-
-chmodSync(launcher, 0o755);

package/scripts/prepare-npm-platform.mjs

@@ -1,59 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { cpSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const [platform, arch, source = 'dist/customer', destination = 'npm-platform'] =
-  process.argv.slice(2);
-const supported = new Set([
-  'darwin-arm64',
-  'darwin-x64',
-  'linux-arm64',
-  'linux-x64',
-  'windows-x64',
-]);
-const id = `${platform}-${arch}`;
-
-if (!supported.has(id)) {
-  console.error(`Unsupported Capix Code npm platform: ${id}`);
-  process.exit(2);
-}
-
-const root = resolve(fileURLToPath(new URL('..', import.meta.url)));
-const artifact = resolve(root, source);
-const output = resolve(root, destination, id);
-const isWindows = process.platform === 'win32';
-const assertScript = join(root, 'scripts', 'assert-artifact.sh');
-const brandScript = join(root, 'scripts', 'assert-customer-brand.sh');
-if (!isWindows) {
-  execFileSync(assertScript, [artifact], { stdio: 'inherit' });
-  execFileSync(brandScript, [artifact], { stdio: 'inherit' });
-} else {
-  // On Windows, run via bash if available; otherwise skip shell-script assertions
-  try {
-    execFileSync('bash', [assertScript, artifact], { stdio: 'inherit' });
-    execFileSync('bash', [brandScript, artifact], { stdio: 'inherit' });
-  } catch {
-    console.warn('Skipping shell-script assertions on Windows (bash not available)');
-  }
-}
-rmSync(output, { recursive: true, force: true });
-mkdirSync(output, { recursive: true });
-cpSync(artifact, join(output, 'customer'), { recursive: true });
-writeFileSync(
-  join(output, 'package.json'),
-  `${JSON.stringify(
-    {
-      name: `@capix-code/${id}`,
-      version: '1.2.7',
-      description: `Capix Code native runtime for ${id}`,
-      license: 'Apache-2.0',
-      os: [platform === 'windows' ? 'win32' : platform],
-      cpu: [arch],
-      files: ['customer/'],
-    },
-    null,
-    2
-  )}\n`
-);
-console.log(output);