@aria_asi/cli 0.2.26 → 0.2.29

package/src/github-connect.ts

@@ -0,0 +1,143 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const NPMRC_PATH = join(homedir(), '.npmrc');
+const GH_SCOPE_LINE = '@aria_asi:registry=https://npm.pkg.github.com';
+const GH_TOKEN_PREFIX = '//npm.pkg.github.com/:_authToken=';
+const GH_ALWAYS_AUTH = 'always-auth=true';
+
+export interface GitHubConnectResult {
+  ok: boolean;
+  authenticated: boolean;
+  npmrcConfigured: boolean;
+  gitConfigured: boolean;
+  logs: string[];
+  error?: string;
+}
+
+export interface GitHubStatusResult {
+  ghInstalled: boolean;
+  authenticated: boolean;
+  npmrcConfigured: boolean;
+}
+
+function hasGhCli(): boolean {
+  try {
+    execFileSync('gh', ['--version'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isGhAuthenticated(): boolean {
+  try {
+    execFileSync('gh', ['auth', 'status', '--hostname', 'github.com'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function tryExec(args: string[], stdio: 'ignore' | 'inherit' = 'ignore'): boolean {
+  try {
+    execFileSync('gh', args, { stdio });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function upsertNpmrc(token: string): void {
+  const dir = homedir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+
+  const existing = existsSync(NPMRC_PATH) ? readFileSync(NPMRC_PATH, 'utf8') : '';
+  const lines = existing
+    .split(/\r?\n/)
+    .filter((line) => line.trim() && !line.startsWith('@aria_asi:registry=') && !line.startsWith(GH_TOKEN_PREFIX) && line.trim() !== GH_ALWAYS_AUTH);
+
+  lines.push(GH_SCOPE_LINE, `${GH_TOKEN_PREFIX}${token}`, GH_ALWAYS_AUTH);
+  writeFileSync(NPMRC_PATH, `${lines.join('\n')}\n`, { mode: 0o600 });
+}
+
+function readGhToken(): string {
+  return execFileSync('gh', ['auth', 'token'], { encoding: 'utf8' }).trim();
+}
+
+export function getGitHubStatus(): GitHubStatusResult {
+  const ghInstalled = hasGhCli();
+  const authenticated = ghInstalled ? isGhAuthenticated() : false;
+  const npmrcConfigured = existsSync(NPMRC_PATH)
+    && readFileSync(NPMRC_PATH, 'utf8').includes(GH_SCOPE_LINE);
+  return { ghInstalled, authenticated, npmrcConfigured };
+}
+
+export function connectGitHub(options: { interactive?: boolean } = {}): GitHubConnectResult {
+  const interactive = options.interactive !== false;
+  const logs: string[] = [];
+
+  if (!hasGhCli()) {
+    return {
+      ok: false,
+      authenticated: false,
+      npmrcConfigured: false,
+      gitConfigured: false,
+      logs,
+      error: 'GitHub CLI (gh) is not installed. Install gh first, then run `aria github connect` again.',
+    };
+  }
+
+  let authenticated = isGhAuthenticated();
+  if (!authenticated) {
+    if (!interactive) {
+      return {
+        ok: false,
+        authenticated: false,
+        npmrcConfigured: false,
+        gitConfigured: false,
+        logs,
+        error: 'GitHub CLI is installed but not authenticated. Run `aria github connect` interactively.',
+      };
+    }
+
+    logs.push('Launching GitHub browser login...');
+    execFileSync('gh', ['auth', 'login', '--web', '--hostname', 'github.com', '--git-protocol', 'https', '--scopes', 'read:packages'], {
+      stdio: 'inherit',
+    });
+    authenticated = isGhAuthenticated();
+  } else if (interactive) {
+    tryExec(['auth', 'refresh', '--hostname', 'github.com', '--scopes', 'read:packages'], 'inherit');
+  }
+
+  if (!authenticated) {
+    return {
+      ok: false,
+      authenticated: false,
+      npmrcConfigured: false,
+      gitConfigured: false,
+      logs,
+      error: 'GitHub authentication did not complete successfully.',
+    };
+  }
+
+  const gitConfigured = tryExec(['auth', 'setup-git'], interactive ? 'inherit' : 'ignore');
+  const token = readGhToken();
+  upsertNpmrc(token);
+
+  logs.push('GitHub auth is active.');
+  logs.push('Configured ~/.npmrc for @aria_asi on GitHub Packages.');
+  if (gitConfigured) logs.push('Configured git to use GitHub CLI credentials.');
+
+  return {
+    ok: true,
+    authenticated: true,
+    npmrcConfigured: true,
+    gitConfigured,
+    logs,
+  };
+}

package/src/harness-client.ts

@@ -55,6 +55,12 @@ export interface HarnessPacket {
 
 interface HarnessClientOptions {
   baseUrl?: string;
+  runtimeBaseUrl?: string;
+}
+
+interface RuntimeContext extends Record<string, unknown> {
+  sessionId?: string;
+  parentReceiptId?: string | null;
 }
 
 interface GateContext {
@@ -67,11 +73,21 @@ interface GateContext {
 
 export class HarnessClient {
   private baseUrl: string;
+  private runtimeBaseUrl: string;
   private token: string | null = null;
   private tokenPromise: Promise<string | null> | null = null;
 
   constructor(options: HarnessClientOptions = {}) {
-    this.baseUrl = options.baseUrl ?? process.env.ARIA_HARNESS_BASE_URL ?? 'https://harness.ariasos.com';
+    this.baseUrl =
+      options.baseUrl ??
+      process.env.ARIA_HIVE_RUNTIME_URL ??
+      process.env.ARIA_HARNESS_BASE_URL ??
+      process.env.ARIA_HARNESS_URL ??
+      'https://harness.ariasos.com';
+    this.runtimeBaseUrl =
+      options.runtimeBaseUrl ??
+      process.env.ARIA_RUNTIME_URL ??
+      'http://127.0.0.1:4319';
   }
 
   /**
@@ -245,6 +261,61 @@ export class HarnessClient {
     return this.request<T>('PUT', path, body, gateContext);
   }
 
+  async runtimeRequest<T = unknown>(path: string, body?: unknown): Promise<T> {
+    const token = await this.getToken();
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (token) headers['Authorization'] = `Bearer ${token}`;
+    if (fs.existsSync(OWNER_TOKEN_PATH)) {
+      const ownerJWT = fs.readFileSync(OWNER_TOKEN_PATH, 'utf-8').trim();
+      if (ownerJWT) {
+        headers['Authorization'] = `Bearer ${ownerJWT}`;
+        headers['x-aria-owner'] = 'true';
+      }
+    }
+    const response = await fetch(`${this.runtimeBaseUrl.replace(/\/+$/, '')}${path}`, {
+      method: 'POST',
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!response.ok) {
+      const detail = await this.tryExtractError(response);
+      throw new Error(`Runtime request failed (${response.status}) ${path}: ${detail}`);
+    }
+    return response.json() as Promise<T>;
+  }
+
+  async mizanPlan(context: RuntimeContext) {
+    return this.runtimeRequest('/mizan/plan', context);
+  }
+
+  async mizanPre(context: RuntimeContext, packet?: unknown) {
+    return this.runtimeRequest('/mizan/pre', { context, packet, sessionId: context.sessionId || 'runtime' });
+  }
+
+  async mizanMid(message: string, plannedApproach: string, context: RuntimeContext = {}, packet?: unknown) {
+    return this.runtimeRequest('/mizan/mid', {
+      context,
+      packet,
+      message,
+      plannedApproach,
+      sessionId: context.sessionId || 'runtime',
+      parentReceiptId: context.parentReceiptId || null,
+    });
+  }
+
+  async mizanPost(text: string, evidence: Record<string, unknown>, context: RuntimeContext = {}, packet?: unknown) {
+    return this.runtimeRequest('/mizan/post', {
+      context,
+      packet,
+      text,
+      evidence,
+      sessionId: context.sessionId || 'runtime',
+      parentReceiptId: context.parentReceiptId || null,
+    });
+  }
+
   // ── Helpers ──────────────────────────────────────────────────────
 
   private async tryExtractError(response: Response): Promise<string> {
@@ -302,14 +373,22 @@ function ownerHeaders(): Record<string, string> {
 
 export const harnessClient = {
   get(path: string, init?: { headers?: Record<string, string> }): Promise<Response> {
-    const baseUrl = process.env.ARIA_HARNESS_BASE_URL ?? 'https://harness.ariasos.com';
+    const baseUrl =
+      process.env.ARIA_HIVE_RUNTIME_URL ??
+      process.env.ARIA_HARNESS_BASE_URL ??
+      process.env.ARIA_HARNESS_URL ??
+      'https://harness.ariasos.com';
     return fetch(`${baseUrl}${path}`, {
       method: 'GET',
       headers: { 'Content-Type': 'application/json', ...ownerHeaders(), ...(init?.headers ?? {}) },
     });
   },
   post(path: string, init?: { body?: unknown; headers?: Record<string, string> }): Promise<Response> {
-    const baseUrl = process.env.ARIA_HARNESS_BASE_URL ?? 'https://harness.ariasos.com';
+    const baseUrl =
+      process.env.ARIA_HIVE_RUNTIME_URL ??
+      process.env.ARIA_HARNESS_BASE_URL ??
+      process.env.ARIA_HARNESS_URL ??
+      'https://harness.ariasos.com';
     return fetch(`${baseUrl}${path}`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json', ...ownerHeaders(), ...(init?.headers ?? {}) },
@@ -457,6 +536,52 @@ export async function validateOutput(args: {
   }
 }
 
+export async function mizanPlan(context: RuntimeContext): Promise<unknown | null> {
+  try {
+    const client = getDefaultClient();
+    return await client.mizanPlan(context);
+  } catch {
+    return null;
+  }
+}
+
+export async function mizanPre(context: RuntimeContext, packet?: unknown): Promise<unknown | null> {
+  try {
+    const client = getDefaultClient();
+    return await client.mizanPre(context, packet);
+  } catch {
+    return null;
+  }
+}
+
+export async function mizanMid(
+  message: string,
+  plannedApproach: string,
+  context: RuntimeContext = {},
+  packet?: unknown,
+): Promise<unknown | null> {
+  try {
+    const client = getDefaultClient();
+    return await client.mizanMid(message, plannedApproach, context, packet);
+  } catch {
+    return null;
+  }
+}
+
+export async function mizanPost(
+  text: string,
+  evidence: Record<string, unknown>,
+  context: RuntimeContext = {},
+  packet?: unknown,
+): Promise<unknown | null> {
+  try {
+    const client = getDefaultClient();
+    return await client.mizanPost(text, evidence, context, packet);
+  } catch {
+    return null;
+  }
+}
+
 // ── getRecentTurns ────────────────────────────────────────────────────
 
 /**

package/src/hive-client.ts

@@ -22,9 +22,50 @@
 // internal-only) so external customers ship the connector with their
 // CLI/app and get hive integration with no internal Aria deps.
 
-const HARNESS_URL = process.env.ARIA_HARNESS_URL || 'http://192.168.4.25:30080';
+const HARNESS_URL =
+  process.env.ARIA_HIVE_RUNTIME_URL ||
+  process.env.ARIA_HARNESS_BASE_URL ||
+  process.env.ARIA_HARNESS_URL ||
+  'https://harness.ariasos.com';
 const HARNESS_TOKEN = process.env.ARIA_HARNESS_TOKEN || '';
 
+export interface RuntimeProofEmitConfig {
+  sessionId: string;
+  platform: string;
+  provider?: string;
+  model?: string;
+  surface?: string;
+  actor?: string;
+  promptTokens?: number;
+  completionTokens?: number;
+  totalTokens?: number;
+  latencyMs?: number;
+  turnCount?: number;
+  llmDispatches?: number;
+  toolDispatches?: number;
+  mcpToolCalls?: number;
+  gateSeverity?: string;
+  qualityScore?: number;
+  qualityStatus?: string;
+  complianceState?: string;
+  packetHash?: string;
+  blockedUnsafeActions?: number;
+  interceptions?: number;
+  hallucinationStops?: number;
+  passRatePercentToday?: number;
+  hiveRuntimeStatus?: string;
+  hiveCycleCount?: number;
+  hiveTasksCompleted?: number;
+  hiveTasksFailed?: number;
+}
+
+function authHeaders(): Record<string, string> {
+  return {
+    'Content-Type': 'application/json',
+    ...(HARNESS_TOKEN ? { Authorization: `Bearer ${HARNESS_TOKEN}` } : {}),
+  };
+}
+
 // Schema matches apps/arias-soul/api/hive/register.ts:
 //   POST { session_id, platform, user_id?, context?, capabilities? }
 //   → { status, session, hive: { active_sessions, message }, aria: { greeting } }
@@ -58,10 +99,7 @@ export async function registerWithHive(
   try {
     const resp = await fetch(`${HARNESS_URL}/api/hive/register`, {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...(HARNESS_TOKEN ? { Authorization: `Bearer ${HARNESS_TOKEN}` } : {}),
-      },
+      headers: authHeaders(),
       body: JSON.stringify({
         session_id: cfg.sessionId,
         platform: cfg.platform,
@@ -77,6 +115,128 @@ export async function registerWithHive(
   }
 }
 
+export async function emitRuntimeProofMetric(
+  cfg: RuntimeProofEmitConfig,
+): Promise<void> {
+  const totalTokens =
+    cfg.totalTokens ??
+    ((cfg.promptTokens ?? undefined) !== undefined || (cfg.completionTokens ?? undefined) !== undefined
+      ? (cfg.promptTokens ?? 0) + (cfg.completionTokens ?? 0)
+      : undefined);
+  const gateSeverity = (cfg.gateSeverity || '').trim().toLowerCase();
+  const qualityGateStatus =
+    gateSeverity === 'block' ? 'block' :
+    gateSeverity === 'warn' ? 'warn' :
+    gateSeverity === 'pass' ? 'pass' :
+    (cfg.qualityStatus || '').trim().toLowerCase() === 'block' ? 'block' :
+    (cfg.qualityStatus || '').trim().toLowerCase() === 'warn' ? 'warn' :
+    'pass';
+  const qualityScore =
+    typeof cfg.qualityScore === 'number'
+      ? cfg.qualityScore
+      : typeof cfg.passRatePercentToday === 'number'
+        ? Math.max(0, Math.min(1, cfg.passRatePercentToday / 100))
+        : undefined;
+
+  const runtimePayload = {
+    event_type: 'connector_turn_completed',
+    source: 'aria-connector',
+    session_id: cfg.sessionId,
+    actor: cfg.actor || cfg.platform,
+    surface: cfg.surface || cfg.platform,
+    provider: cfg.provider,
+    model: cfg.model,
+    success: qualityGateStatus !== 'block',
+    latency_ms: cfg.latencyMs,
+    token_usage: {
+      prompt_tokens: cfg.promptTokens,
+      completion_tokens: cfg.completionTokens,
+      total_tokens: totalTokens,
+    },
+    quality_gate: {
+      name: 'aria_runtime_proof',
+      passed: qualityGateStatus !== 'block',
+      hard_block: qualityGateStatus === 'block',
+      score: qualityScore,
+      reasons: [
+        cfg.qualityStatus,
+        cfg.complianceState,
+        cfg.hiveRuntimeStatus,
+      ].filter((value): value is string => typeof value === 'string' && value.trim().length > 0),
+    },
+    harness: {
+      packet_hash: cfg.packetHash,
+      packet_compliant: cfg.complianceState ? cfg.complianceState.toLowerCase() !== 'block' : undefined,
+      quality_gated_output: cfg.qualityStatus ? cfg.qualityStatus.toLowerCase() !== 'block' : undefined,
+      blocked_actions: cfg.blockedUnsafeActions,
+      interceptions: cfg.interceptions,
+      hallucinations_stopped: cfg.hallucinationStops,
+      public_proof_eligible: true,
+    },
+    payload: {
+      runtime_origin: 'connector',
+      platform: cfg.platform,
+      turn_count: cfg.turnCount,
+      llm_dispatches: cfg.llmDispatches,
+      tool_dispatches: cfg.toolDispatches,
+      mcp_tool_calls: cfg.mcpToolCalls,
+      hive_runtime_status: cfg.hiveRuntimeStatus,
+      hive_cycle_count: cfg.hiveCycleCount,
+      hive_tasks_completed: cfg.hiveTasksCompleted,
+      hive_tasks_failed: cfg.hiveTasksFailed,
+      pass_rate_percent_today: cfg.passRatePercentToday,
+    },
+  };
+
+  const proofPayload = {
+    source_service: 'aria-connector',
+    actor: cfg.actor || cfg.platform,
+    delivery_surface: cfg.surface || cfg.platform,
+    session_id: cfg.sessionId,
+    turn_count: cfg.turnCount,
+    model_provider: cfg.provider,
+    model_name: cfg.model,
+    harness_packet_hash: cfg.packetHash,
+    quality_score: qualityScore,
+    quality_gate_status: qualityGateStatus,
+    hallucination_stopped: (cfg.hallucinationStops ?? 0) > 0,
+    blocked_action: (cfg.blockedUnsafeActions ?? 0) > 0,
+    intercepted_action: (cfg.interceptions ?? 0) > 0,
+    prompt_tokens: cfg.promptTokens,
+    completion_tokens: cfg.completionTokens,
+    total_tokens: totalTokens,
+    latency_ms: cfg.latencyMs,
+    metadata: {
+      platform: cfg.platform,
+      llm_dispatches: cfg.llmDispatches,
+      tool_dispatches: cfg.toolDispatches,
+      mcp_tool_calls: cfg.mcpToolCalls,
+      gate_severity: cfg.gateSeverity,
+      quality_status: cfg.qualityStatus,
+      compliance_state: cfg.complianceState,
+      hive_runtime_status: cfg.hiveRuntimeStatus,
+      hive_cycle_count: cfg.hiveCycleCount,
+      hive_tasks_completed: cfg.hiveTasksCompleted,
+      hive_tasks_failed: cfg.hiveTasksFailed,
+      pass_rate_percent_today: cfg.passRatePercentToday,
+    },
+  };
+
+  const headers = authHeaders();
+  await Promise.allSettled([
+    fetch(`${HARNESS_URL}/runtime/ingest`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(runtimePayload),
+    }),
+    fetch(`${HARNESS_URL}/runtime-proof/ingest`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(proofPayload),
+    }),
+  ]);
+}
+
 // Heartbeat = re-register the same payload. The hive endpoint is
 // idempotent (ON CONFLICT … DO UPDATE in the SQL). Default cadence
 // matches openclaw-shared's 45s — short enough for liveness, long

package/src/index.ts

@@ -1,14 +1,26 @@
 export { loadConfig, saveConfig, updateConfig, getDefaultConfig, getConfigPath, getConfigDir } from './config.js';
 export type { AriaConfig, ModelConfig, LinkedRepo, DatabaseConfig, ConnectorState } from './config.js';
 
-export { scanCodebase, schemaImageToText } from './codebase-scanner.js';
-export type { SchemaImage, DirectoryNode, Dependency } from './codebase-scanner.js';
+export { scanCodebase, schemaImageToText, watchCodebase } from './codebase-scanner.js';
+export type { SchemaImage, DirectoryNode, Dependency, WatchHandle, WatchOptions, WatchMode } from './codebase-scanner.js';
 
 export { runSetupWizard } from './setup-wizard.js';
+export { connectGitHub, getGitHubStatus } from './github-connect.js';
 
 export { connectClaudeCode, disconnectClaudeCode } from './connectors/claude-code.js';
+export { connectCodex } from './connectors/codex.js';
 export { connectCursor, disconnectCursor } from './connectors/cursor.js';
 export { connectOpenCode, disconnectOpenCode } from './connectors/opencode.js';
+export {
+  installCodebaseAwarenessDaemon,
+  startCodebaseAwarenessDaemon,
+  runCodebaseAwarenessScan,
+  readCodebaseAwarenessState,
+} from './connectors/codebase-awareness.js';
+export { installRepoGuardDaemon, startRepoGuardDaemon, readGuardState } from './connectors/repo-guard.js';
+export { installRepoDoctrineGitHooks } from './connectors/repo-git-hooks.js';
+export { installSharedRuntime } from './connectors/runtime.js';
+export { installAriaSyncDaemon, runSyncOnce, startSyncDaemon, readSyncDaemonState } from './connectors/syncd.js';
 export { connectShell, disconnectShell } from './connectors/shell.js';
 
 export { GardenClient } from './garden-client.js';
@@ -21,6 +33,33 @@ export { AriaChat } from './chat.js';
 
 export { fetchHarness, combineHarnessContext, checkHarnessHealth, validateOutput, getRecentTurns } from './harness-client.js';
 export type { HarnessPacket, HarnessChunk } from './harness-client.js';
+export { enrichRuntimeProof, fetchRuntimeProofTelemetry, formatRuntimeProofLine } from './runtime-proof.js';
+export type { RuntimeProofSnapshot, RuntimeProofTelemetry } from './runtime-proof.js';
 
 export { loadPersona, savePersona, updatePersona, buildPersonaBlock } from './persona.js';
 export type { PersonaContext } from './persona.js';
+
+export {
+  recordDalio,
+  evaluatePendingDecisions,
+  getBlockingIncidents,
+  claimSessionLock,
+  releaseSessionLock,
+  heartbeatSessionLock,
+  checkSessionLockDrift,
+  postSessionMessage,
+  readSessionMessages,
+} from './decisions.js';
+export type {
+  ExpectedOutcomePredicate,
+  RecordDalioArgs,
+  RecordDalioResult,
+  EvaluatePendingResult,
+  BlockingIncident,
+  SessionLockArgs,
+  SessionLockResult,
+  SessionLockHeartbeatResult,
+  SessionLockDriftResult,
+  SessionMessageArgs,
+  SessionMessageResult,
+} from './decisions.js';