@aria_asi/cli 0.2.26 → 0.2.29

package/scripts/bundle-sdk.mjs

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+// Copies the harness-http-client SDK dist into this package's dist/sdk/ at
+// build time so the published @aria_asi/cli npm package ships the SDK
+// inline. Hooks resolve the SDK from ~/.claude/aria-sdk/ (installed by
+// connectClaudeCode) — this script is the build-time half.
+//
+// Hamza 2026-04-27 directive: "isnt http harness client the fucking harness
+// we hsve been wprking on? YOU ARENT USING THAT AND BUILDING SPMETHING
+// SEPERATE WHY???!! FUCKING WIRE IT THE FUCK TOGETHER NOW - ALL OF IT".
+// Ending the SDK fragmentation: every hook fetch now goes through the SDK.
+
+import { existsSync, mkdirSync, readdirSync, copyFileSync, statSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { dirname, resolve, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, '..');
+const REPO_ROOT = resolve(PKG_ROOT, '..', '..');
+
+const SDK_SRC = resolve(REPO_ROOT, 'harness', 'packages', 'harness-http-client', 'dist');
+const SDK_DST = resolve(PKG_ROOT, 'dist', 'sdk');
+const RUNTIME_TEMPLATE_SRC = resolve(PKG_ROOT, 'runtime-src');
+const RUNTIME_DST = resolve(PKG_ROOT, 'dist', 'runtime');
+const RUNTIME_SDK_DST = resolve(RUNTIME_DST, 'sdk');
+const DIST_ASSETS_DST = resolve(PKG_ROOT, 'dist', 'assets');
+const GATE_RUNTIME_SRC = resolve(REPO_ROOT, 'packages', 'aria-gate-runtime', 'dist');
+const GATE_RUNTIME_DST = resolve(RUNTIME_DST, 'vendor', 'aria-gate-runtime');
+const SDK_GUIDE_SRC = resolve(REPO_ROOT, 'harness', 'packages', 'harness-http-client', 'CLAUDE.md');
+const SDK_SKILLS_SRC = resolve(REPO_ROOT, 'harness', 'packages', 'harness-http-client', 'skills');
+const COGNITIVE_SKILLS_SRC = resolve(PKG_ROOT, 'skills', 'aria-cognition');
+const RUNTIME_DISCIPLINE_DST = resolve(RUNTIME_DST, 'discipline');
+const CONNECTOR_HOOKS_SRC = resolve(PKG_ROOT, 'hooks');
+const OPENCODE_PLUGINS_SRC = resolve(PKG_ROOT, 'opencode-plugins');
+const CLIENT_ONBOARDING_SRC = resolve(PKG_ROOT, 'CLIENT-ONBOARDING.md');
+const REQUIRED_HOOK_FILES = [
+  'aria-harness-via-sdk.mjs',
+  'aria-pre-tool-gate.mjs',
+  'aria-preturn-memory-gate.mjs',
+  'aria-stop-gate.mjs',
+  'aria-preprompt-consult.mjs',
+  'aria-trigger-autolearn.mjs',
+  'aria-userprompt-abandon-detect.mjs',
+  'aria-agent-handoff.mjs',
+  'aria-agent-ledger-merge.mjs',
+  'aria-pre-text-gate.mjs',
+  'aria-discovery-record.mjs',
+  'aria-outcome-record.mjs',
+  'aria-cognition-substrate-binding.mjs',
+  'aria-repo-doctrine-gate.mjs',
+  'aria-pre-emit-dryrun.mjs',
+  'doctrine_trigger_map.json',
+];
+const REQUIRED_HOOK_HELPERS = [
+  'lib/canonical-lenses.mjs',
+  'lib/gate-audit.mjs',
+];
+const REQUIRED_OPENCODE_PLUGINS = [
+  'harness-context',
+  'harness-role',
+  'harness-gate',
+  'harness-stop',
+  'harness-outcome',
+];
+
+if (!existsSync(SDK_SRC)) {
+  console.error(`[bundle-sdk] SDK dist not found at ${SDK_SRC}`);
+  console.error('[bundle-sdk] Build the SDK first: cd ../../harness/packages/harness-http-client && npm run build');
+  process.exit(1);
+}
+for (const relativePath of REQUIRED_HOOK_FILES) {
+  requirePathExists(join(CONNECTOR_HOOKS_SRC, relativePath), `required hook asset ${relativePath}`);
+}
+for (const relativePath of REQUIRED_HOOK_HELPERS) {
+  requirePathExists(join(CONNECTOR_HOOKS_SRC, relativePath), `required hook helper ${relativePath}`);
+}
+for (const pluginName of REQUIRED_OPENCODE_PLUGINS) {
+  requirePathExists(join(OPENCODE_PLUGINS_SRC, pluginName), `required OpenCode plugin ${pluginName}`);
+}
+requirePathExists(CLIENT_ONBOARDING_SRC, 'client onboarding guide');
+
+// Staleness guard — newest src mtime must not exceed newest dist mtime.
+// Without this, a developer who edits src/ but forgets to `npm run build`
+// silently bundles a previous-generation dist, shipping a broken SDK to
+// every client. Caught in production once (Hamza 2026-04-27): opencode
+// crashed on open because dist was missing spawnSubAgent / mergeSubAgentLedger
+// that existed in src.
+const SDK_SRC_DIR = resolve(REPO_ROOT, 'harness', 'packages', 'harness-http-client', 'src');
+function newestMtimeMs(dir) {
+  let newest = 0;
+  for (const name of readdirSync(dir)) {
+    const p = join(dir, name);
+    const s = statSync(p);
+    if (s.isDirectory()) {
+      const sub = newestMtimeMs(p);
+      if (sub > newest) newest = sub;
+    } else if (s.mtimeMs > newest) {
+      newest = s.mtimeMs;
+    }
+  }
+  return newest;
+}
+if (existsSync(SDK_SRC_DIR)) {
+  const srcNewest = newestMtimeMs(SDK_SRC_DIR);
+  const distNewest = newestMtimeMs(SDK_SRC);
+  if (srcNewest > distNewest) {
+    console.error(`[bundle-sdk] SDK dist is older than src (src: ${new Date(srcNewest).toISOString()}, dist: ${new Date(distNewest).toISOString()})`);
+    console.error('[bundle-sdk] Refusing to bundle a stale dist. Build the SDK first:');
+    console.error('[bundle-sdk]   cd ../../harness/packages/harness-http-client && npm run build');
+    process.exit(1);
+  }
+}
+
+if (!existsSync(SDK_DST)) {
+  mkdirSync(SDK_DST, { recursive: true });
+}
+if (existsSync(RUNTIME_DST)) {
+  rmSync(RUNTIME_DST, { recursive: true, force: true });
+}
+mkdirSync(RUNTIME_DST, { recursive: true });
+
+function copyTree(srcDir, dstDir) {
+  mkdirSync(dstDir, { recursive: true });
+  for (const name of readdirSync(srcDir)) {
+    const src = join(srcDir, name);
+    const stat = statSync(src);
+    const dst = join(dstDir, name);
+    if (stat.isDirectory()) {
+      copyTree(src, dst);
+      continue;
+    }
+    copyFileSync(src, dst);
+  }
+}
+
+function requirePathExists(targetPath, label) {
+  if (!existsSync(targetPath)) {
+    console.error(`[bundle-sdk] ${label} missing at ${targetPath}`);
+    process.exit(1);
+  }
+}
+
+function countFilesRecursive(dir) {
+  let count = 0;
+  for (const name of readdirSync(dir)) {
+    const target = join(dir, name);
+    const stat = statSync(target);
+    if (stat.isDirectory()) {
+      count += countFilesRecursive(target);
+    } else {
+      count++;
+    }
+  }
+  return count;
+}
+
+let copied = 0;
+for (const name of readdirSync(SDK_SRC)) {
+  const src = join(SDK_SRC, name);
+  if (!statSync(src).isFile()) continue;
+  const dst = join(SDK_DST, name);
+  copyFileSync(src, dst);
+  mkdirSync(RUNTIME_SDK_DST, { recursive: true });
+  copyFileSync(src, join(RUNTIME_SDK_DST, name));
+  copied++;
+}
+
+// Sanity-check: the SDK is ESM with a top-level export of HTTPHarnessClient.
+// If the bundled index.js doesn't export the class name, something's wrong.
+const indexJsPath = join(SDK_DST, 'index.js');
+if (!existsSync(indexJsPath)) {
+  console.error(`[bundle-sdk] index.js missing in bundled SDK at ${indexJsPath}`);
+  process.exit(1);
+}
+const indexJs = readFileSync(indexJsPath, 'utf8');
+if (!/export\s+class\s+HTTPHarnessClient/.test(indexJs)) {
+  console.error('[bundle-sdk] bundled SDK does not export HTTPHarnessClient — abort');
+  process.exit(1);
+}
+
+// Symbol-coverage guard — every public async method declared in src/index.ts
+// must appear in the bundled dist. Catches "tsc emitted, but emitted from a
+// stale TS state and skipped new methods" or "src has new method, dist
+// doesn't". Pairs with the staleness mtime guard above.
+const SDK_SRC_INDEX = resolve(REPO_ROOT, 'harness', 'packages', 'harness-http-client', 'src', 'index.ts');
+if (existsSync(SDK_SRC_INDEX)) {
+  const srcTs = readFileSync(SDK_SRC_INDEX, 'utf8');
+  const publicAsyncRx = /^\s{2}async\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*[(<]/gm;
+  const expected = new Set();
+  for (const m of srcTs.matchAll(publicAsyncRx)) {
+    expected.add(m[1]);
+  }
+  const missing = [];
+  for (const name of expected) {
+    const memberRx = new RegExp(`\\basync\\s+${name}\\s*\\(`);
+    if (!memberRx.test(indexJs)) missing.push(name);
+  }
+  if (missing.length > 0) {
+    console.error(`[bundle-sdk] bundled SDK missing methods present in src: ${missing.join(', ')}`);
+    console.error('[bundle-sdk] Rebuild the SDK before bundling: cd ../../harness/packages/harness-http-client && npm run build');
+    process.exit(1);
+  }
+}
+
+// Write a tiny package marker so hooks can detect "yes, the SDK is here"
+// without false-positiving on an empty directory.
+writeFileSync(
+  join(SDK_DST, 'BUNDLED.json'),
+  JSON.stringify({
+    bundledAt: new Date().toISOString(),
+    sdkSource: SDK_SRC,
+    files: copied,
+  }, null, 2) + '\n',
+);
+writeFileSync(
+  join(RUNTIME_SDK_DST, 'BUNDLED.json'),
+  JSON.stringify({
+    bundledAt: new Date().toISOString(),
+    sdkSource: SDK_SRC,
+    files: copied,
+  }, null, 2) + '\n',
+);
+
+// package.json with type=module so Node loads index.js as ESM without
+// the "MODULE_TYPELESS_PACKAGE_JSON" perf warning when hooks dynamic-
+// import the SDK from outside any node_modules tree.
+writeFileSync(
+  join(SDK_DST, 'package.json'),
+  JSON.stringify({
+    name: '@aria/harness-http-client-bundled',
+    version: '0.0.0-bundled',
+    type: 'module',
+    main: 'index.js',
+    types: 'index.d.ts',
+    private: true,
+  }, null, 2) + '\n',
+);
+writeFileSync(
+  join(RUNTIME_SDK_DST, 'package.json'),
+  JSON.stringify({
+    name: '@aria/harness-http-client-bundled',
+    version: '0.0.0-bundled',
+    type: 'module',
+    main: 'index.js',
+    types: 'index.d.ts',
+    private: true,
+  }, null, 2) + '\n',
+);
+writeFileSync(
+  join(RUNTIME_DST, 'package.json'),
+  JSON.stringify({
+    name: '@aria/runtime-bundled',
+    version: '0.0.0-bundled',
+    type: 'module',
+    private: true,
+  }, null, 2) + '\n',
+);
+
+if (!existsSync(RUNTIME_TEMPLATE_SRC)) {
+  console.error(`[bundle-sdk] runtime-src missing at ${RUNTIME_TEMPLATE_SRC}`);
+  process.exit(1);
+}
+copyTree(RUNTIME_TEMPLATE_SRC, RUNTIME_DST);
+
+if (!existsSync(GATE_RUNTIME_SRC)) {
+  console.error(`[bundle-sdk] gate-runtime dist not found at ${GATE_RUNTIME_SRC}`);
+  console.error('[bundle-sdk] Build the gate runtime first: cd ../aria-gate-runtime && npm run build');
+  process.exit(1);
+}
+copyTree(GATE_RUNTIME_SRC, GATE_RUNTIME_DST);
+writeFileSync(
+  join(GATE_RUNTIME_DST, 'package.json'),
+  JSON.stringify({
+    name: '@aria/gate-runtime-bundled',
+    version: '0.0.0-bundled',
+    main: 'index.js',
+    private: true,
+  }, null, 2) + '\n',
+);
+
+mkdirSync(RUNTIME_DISCIPLINE_DST, { recursive: true });
+if (existsSync(SDK_GUIDE_SRC)) {
+  copyFileSync(SDK_GUIDE_SRC, join(RUNTIME_DISCIPLINE_DST, 'CLAUDE.md'));
+}
+if (existsSync(SDK_SKILLS_SRC)) {
+  copyTree(SDK_SKILLS_SRC, join(RUNTIME_DISCIPLINE_DST, 'skills', 'aria-harness'));
+}
+if (existsSync(COGNITIVE_SKILLS_SRC)) {
+  copyTree(COGNITIVE_SKILLS_SRC, join(RUNTIME_DISCIPLINE_DST, 'skills', 'aria-cognition'));
+}
+if (existsSync(CONNECTOR_HOOKS_SRC)) {
+  copyTree(CONNECTOR_HOOKS_SRC, join(DIST_ASSETS_DST, 'hooks'));
+}
+if (existsSync(OPENCODE_PLUGINS_SRC)) {
+  copyTree(OPENCODE_PLUGINS_SRC, join(DIST_ASSETS_DST, 'opencode-plugins'));
+}
+
+writeFileSync(
+  join(RUNTIME_DST, 'manifest.json'),
+  JSON.stringify({
+    bundledAt: new Date().toISOString(),
+    sdkFiles: copied,
+    runtimeTemplate: RUNTIME_TEMPLATE_SRC,
+    gateRuntimeSource: GATE_RUNTIME_SRC,
+    sdkGuideSource: existsSync(SDK_GUIDE_SRC) ? SDK_GUIDE_SRC : null,
+    sdkSkillsSource: existsSync(SDK_SKILLS_SRC) ? SDK_SKILLS_SRC : null,
+    cognitionSkillsSource: existsSync(COGNITIVE_SKILLS_SRC) ? COGNITIVE_SKILLS_SRC : null,
+    packagedAssets: {
+      hooks: existsSync(CONNECTOR_HOOKS_SRC) ? join(DIST_ASSETS_DST, 'hooks') : null,
+      opencodePlugins: existsSync(OPENCODE_PLUGINS_SRC) ? join(DIST_ASSETS_DST, 'opencode-plugins') : null,
+    },
+    licenseHeartbeat: '/api/license/heartbeat',
+    defaultRuntimeUrl: 'http://127.0.0.1:4319',
+  }, null, 2) + '\n',
+);
+
+console.log(`[bundle-sdk] copied ${copied} files from ${SDK_SRC} → ${SDK_DST}`);
+console.log(`[bundle-sdk] bundled runtime payload → ${RUNTIME_DST}`);

package/scripts/install-client.sh

@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PACKAGE_NAME="${ARIA_CLI_PACKAGE_NAME:-@aria_asi/cli}"
+PUBLIC_REGISTRY="https://registry.npmjs.org"
+GITHUB_REGISTRY="https://npm.pkg.github.com"
+SOURCE="auto"
+TOKEN="${ARIA_ONBOARDING_TOKEN:-}"
+TARBALL_URL="${ARIA_CLI_TARBALL_URL:-}"
+
+usage() {
+  cat <<'EOF'
+Usage:
+  install-client.sh [--token <aria-token>] [--source auto|npm|github|tarball] [--tarball-url <url>]
+
+Examples:
+  bash install-client.sh --token <aria-token>
+  bash install-client.sh --source github --token <aria-token>
+  ARIA_CLI_TARBALL_URL=https://example.com/aria_asi-cli.tgz bash install-client.sh --source tarball --token <aria-token>
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --token)
+      TOKEN="${2:-}"
+      shift 2
+      ;;
+    --source)
+      SOURCE="${2:-}"
+      shift 2
+      ;;
+    --tarball-url)
+      TARBALL_URL="${2:-}"
+      shift 2
+      ;;
+    --help|-h)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      usage
+      exit 1
+      ;;
+  esac
+done
+
+need_cmd() {
+  if ! command -v "$1" >/dev/null 2>&1; then
+    echo "Missing required command: $1" >&2
+    exit 1
+  fi
+}
+
+need_cmd npm
+need_cmd node
+
+if [[ -z "${TOKEN}" ]]; then
+  printf 'Aria onboarding token: '
+  IFS= read -r TOKEN
+fi
+
+if [[ -z "${TOKEN}" ]]; then
+  echo "Aria token is required." >&2
+  exit 1
+fi
+
+configure_npmrc_from_gh() {
+  need_cmd gh
+  if ! gh auth status --hostname github.com >/dev/null 2>&1; then
+    gh auth login --web --hostname github.com --git-protocol https --scopes read:packages
+  else
+    gh auth refresh --hostname github.com --scopes read:packages || true
+  fi
+
+  local gh_token
+  gh_token="$(gh auth token)"
+  local npmrc="${HOME}/.npmrc"
+  local tmp
+  tmp="$(mktemp)"
+  if [[ -f "${npmrc}" ]]; then
+    grep -v '^@aria_asi:registry=' "${npmrc}" | grep -v '^//npm.pkg.github.com/:_authToken=' | grep -v '^always-auth=true$' > "${tmp}" || true
+  fi
+  {
+    cat "${tmp}" 2>/dev/null || true
+    echo "@aria_asi:registry=${GITHUB_REGISTRY}"
+    echo "//npm.pkg.github.com/:_authToken=${gh_token}"
+    echo "always-auth=true"
+  } > "${npmrc}"
+  chmod 600 "${npmrc}"
+  rm -f "${tmp}"
+}
+
+install_from_npm() {
+  npm install -g "${PACKAGE_NAME}" --registry "${PUBLIC_REGISTRY}"
+}
+
+install_from_github() {
+  configure_npmrc_from_gh
+  npm install -g "${PACKAGE_NAME}" --registry "${GITHUB_REGISTRY}"
+}
+
+install_from_tarball() {
+  if [[ -z "${TARBALL_URL}" ]]; then
+    echo "Tarball source selected, but no --tarball-url or ARIA_CLI_TARBALL_URL was provided." >&2
+    exit 1
+  fi
+  need_cmd curl
+  local tmp_tgz
+  tmp_tgz="$(mktemp /tmp/aria_asi-cli-XXXXXX.tgz)"
+  curl -fsSL "${TARBALL_URL}" -o "${tmp_tgz}"
+  npm install -g "${tmp_tgz}"
+  rm -f "${tmp_tgz}"
+}
+
+prompt_github_connect() {
+  if [[ ! -t 0 ]]; then
+    return 0
+  fi
+  if ! command -v gh >/dev/null 2>&1; then
+    return 0
+  fi
+
+  printf '\nOptional: connect GitHub now for repo workflows and private package access? [y/N] '
+  local answer
+  IFS= read -r answer
+  case "${answer,,}" in
+    y|yes)
+      aria github connect
+      ;;
+    *)
+      echo "Skipping GitHub for now. You can run: aria github connect"
+      ;;
+  esac
+}
+
+if [[ "${SOURCE}" == "auto" ]]; then
+  if npm view "${PACKAGE_NAME}" version --registry "${PUBLIC_REGISTRY}" >/dev/null 2>&1; then
+    SOURCE="npm"
+  elif command -v gh >/dev/null 2>&1; then
+    SOURCE="github"
+  elif [[ -n "${TARBALL_URL}" ]]; then
+    SOURCE="tarball"
+  else
+    echo "I couldn't find a public npm release, GitHub CLI auth, or tarball URL." >&2
+    echo "Use --source github if you have gh, or pass --tarball-url." >&2
+    exit 1
+  fi
+fi
+
+case "${SOURCE}" in
+  npm) install_from_npm ;;
+  github) install_from_github ;;
+  tarball) install_from_tarball ;;
+  *)
+    echo "Unknown source: ${SOURCE}" >&2
+    exit 1
+    ;;
+esac
+
+aria login "${TOKEN}"
+aria connect --force
+prompt_github_connect
+
+cat <<'EOF'
+
+Aria is installed and connected.
+
+Next:
+  1. Restart your shell: exec $SHELL -l
+  2. Open a brand-new Claude/Codex session
+
+Optional GitHub setup later:
+  aria github connect
+EOF