@aria_asi/cli 0.2.26 → 0.2.30

package/src/connectors/runtime.ts

@@ -0,0 +1,374 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  copyFileSync,
+  chmodSync,
+  rmSync,
+  writeFileSync,
+} from 'fs';
+import { execFileSync } from 'child_process';
+import { homedir } from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'node:url';
+import { loadConfig, saveConfig } from '../config.js';
+
+function packageRuntimeDir(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', '..', '..', 'runtime');
+}
+
+function packageSdkDir(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', '..', '..', 'sdk');
+}
+
+function copyTree(srcDir: string, dstDir: string): void {
+  mkdirSync(dstDir, { recursive: true, mode: 0o755 });
+  for (const name of readdirSync(srcDir)) {
+    const src = path.join(srcDir, name);
+    const dst = path.join(dstDir, name);
+    const stat = statSync(src);
+    if (stat.isDirectory()) {
+      copyTree(src, dst);
+      continue;
+    }
+    copyFileSync(src, dst);
+    if (name.endsWith('.mjs') || name.endsWith('.js') || !name.includes('.')) {
+      try { chmodSync(dst, 0o755); } catch {}
+    }
+  }
+}
+
+function writeWrapper(binPath: string, targetScript: string): void {
+  writeFileSync(
+    binPath,
+    `#!/usr/bin/env bash\nexec node "${targetScript}" "$@"\n`,
+    { mode: 0o755 },
+  );
+  try { chmodSync(binPath, 0o755); } catch {}
+}
+
+function writeRuntimeEnv(runtimeDst: string): string {
+  const envPath = path.join(runtimeDst, 'runtime.env');
+  const config = loadConfig();
+  const runtimeProfiles = config.runtimeProfiles || {};
+  const defaultProvider = config.defaultProvider || config.model?.provider || 'deepseek';
+  const chatModel = runtimeProfiles.chatModel || 'deepseek-v4-flash';
+  const deepModel = runtimeProfiles.deepModel || 'deepseek-v4-pro';
+  const xaiFallbackModel = runtimeProfiles.xaiFallbackModel || 'grok-4-2-reasoning';
+  const nimFallbackModel = runtimeProfiles.nimFallbackModel || 'qwen/qwen3.5-122b-a10b';
+  const harnessUrl =
+    process.env.ARIA_HIVE_RUNTIME_URL ||
+    process.env.ARIA_HARNESS_BASE_URL ||
+    process.env.ARIA_HARNESS_URL ||
+    'https://harness.ariasos.com';
+  const forgeServiceUrl =
+    process.env.ARIA_FORGE_SERVICE_URL ||
+    process.env.FORGE_SERVICE_URL ||
+    `${harnessUrl.replace(/\/$/, '')}/api/forge/psi`;
+  writeFileSync(
+    envPath,
+    [
+      'ARIA_RUNTIME_HOST=127.0.0.1',
+      'ARIA_RUNTIME_PORT=4319',
+      'ARIA_RUNTIME_URL=http://127.0.0.1:4319',
+      `ARIA_HIVE_RUNTIME_URL=${harnessUrl}`,
+      `ARIA_HARNESS_URL=${harnessUrl}`,
+      `ARIA_FORGE_SERVICE_URL=${forgeServiceUrl}`,
+      'ARIA_QDRANT_URL=http://127.0.0.1:6333',
+      'ARIA_QDRANT_COLLECTION=aria_garden_memory',
+      `ARIA_RUNTIME_DEFAULT_PROVIDER=${defaultProvider}`,
+      `ARIA_CHAT_MODEL=${chatModel}`,
+      `ARIA_DEEP_MODEL=${deepModel}`,
+      `ARIA_XAI_FALLBACK_MODEL=${xaiFallbackModel}`,
+      `ARIA_NIM_FALLBACK_MODEL=${nimFallbackModel}`,
+      'OPENAI_BASE_URL=http://127.0.0.1:4319/v1',
+      'ANTHROPIC_BASE_URL=http://127.0.0.1:4319/v1',
+      '',
+    ].join('\n'),
+    { mode: 0o600 },
+  );
+  return envPath;
+}
+
+function installSharedSdk(ariaDir: string, logs: string[]): void {
+  const sdkSrc = packageSdkDir();
+  if (!existsSync(sdkSrc)) {
+    logs.push(`⚠ shared SDK bundle missing: ${sdkSrc} (run npm run build)`);
+    return;
+  }
+
+  const sdkDst = path.join(ariaDir, 'sdk');
+  mkdirSync(sdkDst, { recursive: true, mode: 0o700 });
+
+  let copied = 0;
+  for (const name of readdirSync(sdkSrc)) {
+    const src = path.join(sdkSrc, name);
+    const stat = statSync(src);
+    if (!stat.isFile()) continue;
+    copyFileSync(src, path.join(sdkDst, name));
+    copied++;
+  }
+
+  logs.push(`Installed shared Aria SDK (${copied} files) → ${sdkDst}`);
+}
+
+function ensureRuntimeProviderDefaults(): void {
+  const config = loadConfig();
+  saveConfig({
+    ...config,
+    defaultProvider: config.defaultProvider || config.model?.provider || 'deepseek',
+    runtimeProfiles: {
+      chatModel: config.runtimeProfiles?.chatModel || 'deepseek-v4-flash',
+      deepModel: config.runtimeProfiles?.deepModel || 'deepseek-v4-pro',
+      xaiFallbackModel: config.runtimeProfiles?.xaiFallbackModel || 'grok-4-2-reasoning',
+      nimFallbackModel: config.runtimeProfiles?.nimFallbackModel || 'qwen/qwen3.5-122b-a10b',
+      xaiApiKey: config.runtimeProfiles?.xaiApiKey || '',
+      nimApiKey: config.runtimeProfiles?.nimApiKey || '',
+      xaiBaseUrl: config.runtimeProfiles?.xaiBaseUrl || 'https://api.x.ai/v1/chat/completions',
+      nimBaseUrl: config.runtimeProfiles?.nimBaseUrl || 'https://integrate.api.nvidia.com/v1/chat/completions',
+    },
+  });
+}
+
+function installLocalQdrantService(ariaDir: string, logs: string[]): void {
+  const systemctlPath = '/bin/systemctl';
+  const dockerPath = '/usr/bin/docker';
+  if (process.platform !== 'linux' || !existsSync(systemctlPath) || !existsSync(dockerPath)) {
+    logs.push('Skipped local Qdrant service install: requires Linux systemd user services and Docker.');
+    return;
+  }
+
+  const qdrantDir = path.join(ariaDir, 'qdrant');
+  const qdrantStorage = path.join(qdrantDir, 'storage');
+  mkdirSync(qdrantStorage, { recursive: true, mode: 0o700 });
+
+  const serviceDir = path.join(homedir(), '.config', 'systemd', 'user');
+  const servicePath = path.join(serviceDir, 'aria-qdrant.service');
+  mkdirSync(serviceDir, { recursive: true, mode: 0o755 });
+
+  const unit = [
+    '[Unit]',
+    'Description=Aria Local Qdrant Memory',
+    'After=network.target docker.service',
+    '',
+    '[Service]',
+    'Type=simple',
+    `ExecStartPre=-${dockerPath} rm -f aria-qdrant`,
+    `${'ExecStart='}${dockerPath} run --rm --name aria-qdrant -p 127.0.0.1:6333:6333 -v ${qdrantStorage}:/qdrant/storage qdrant/qdrant:v1.17.0`,
+    `ExecStop=${dockerPath} stop -t 10 aria-qdrant`,
+    'Restart=always',
+    'RestartSec=5',
+    '',
+    '[Install]',
+    'WantedBy=default.target',
+    '',
+  ].join('\n');
+
+  writeFileSync(servicePath, unit, { mode: 0o644 });
+  logs.push(`Installed systemd user unit → ${servicePath}`);
+
+  try {
+    execFileSync(systemctlPath, ['--user', 'daemon-reload'], { stdio: 'ignore' });
+    execFileSync(systemctlPath, ['--user', 'enable', '--now', 'aria-qdrant.service'], { stdio: 'ignore' });
+    logs.push('Enabled and started systemd user service: aria-qdrant.service');
+  } catch (error) {
+    logs.push(`⚠ local Qdrant service installed but not activated: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function installDisciplinePack(runtimeDst: string, logs: string[]): void {
+  const harnessSkillsSrc = path.join(runtimeDst, 'discipline', 'skills', 'aria-harness');
+  const cognitionSkillsSrc = path.join(runtimeDst, 'discipline', 'skills', 'aria-cognition');
+
+  if (existsSync(harnessSkillsSrc)) {
+    const harnessTargets = [
+      path.join(homedir(), '.claude', 'skills', 'aria-harness'),
+      path.join(homedir(), '.codex', 'skills', 'aria-harness'),
+    ];
+
+    for (const target of harnessTargets) {
+      copyTree(harnessSkillsSrc, target);
+      logs.push(`Installed Aria harness discipline pack → ${target}`);
+    }
+  }
+
+  if (existsSync(cognitionSkillsSrc)) {
+    const nestedTargets = [
+      path.join(homedir(), '.claude', 'skills', 'aria-cognition'),
+      path.join(homedir(), '.codex', 'skills', 'aria-cognition'),
+    ];
+    for (const target of nestedTargets) {
+      copyTree(cognitionSkillsSrc, target);
+      logs.push(`Installed Aria cognition discipline pack → ${target}`);
+    }
+
+    const agentSkillsRoot = path.join(homedir(), '.agents', 'skills');
+    mkdirSync(agentSkillsRoot, { recursive: true, mode: 0o755 });
+    for (const skillName of readdirSync(cognitionSkillsSrc)) {
+      const src = path.join(cognitionSkillsSrc, skillName);
+      if (!statSync(src).isDirectory()) continue;
+      const target = path.join(agentSkillsRoot, skillName);
+      copyTree(src, target);
+      logs.push(`Installed Aria cognition skill → ${target}`);
+    }
+  }
+}
+
+function installSystemdUserService(ariaDir: string, logs: string[]): void {
+  const systemctlPath = '/bin/systemctl';
+  if (process.platform !== 'linux' || !existsSync(systemctlPath)) {
+    return;
+  }
+
+  const serviceDir = path.join(homedir(), '.config', 'systemd', 'user');
+  const servicePath = path.join(serviceDir, 'aria-mounted-runtime.service');
+  mkdirSync(serviceDir, { recursive: true, mode: 0o755 });
+
+  const unit = [
+    '[Unit]',
+    'Description=Aria Mounted Runtime',
+    'After=network.target',
+    '',
+    '[Service]',
+    'Type=simple',
+    `EnvironmentFile=-${path.join(ariaDir, 'runtime', 'runtime.env')}`,
+    `ExecStart=${path.join(ariaDir, 'bin', 'aria-runtime')}`,
+    'Restart=always',
+    'RestartSec=2',
+    '',
+    '[Install]',
+    'WantedBy=default.target',
+    '',
+  ].join('\n');
+
+  writeFileSync(servicePath, unit, { mode: 0o644 });
+  logs.push(`Installed systemd user unit → ${servicePath}`);
+
+  try {
+    execFileSync(systemctlPath, ['--user', 'daemon-reload'], { stdio: 'ignore' });
+    execFileSync(systemctlPath, ['--user', 'enable', '--now', 'aria-mounted-runtime.service'], { stdio: 'ignore' });
+    logs.push('Enabled and started systemd user service: aria-mounted-runtime.service');
+  } catch (error) {
+    logs.push(`⚠ systemd user service install present but not activated: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function installLaunchAgent(ariaDir: string, logs: string[]): void {
+  if (process.platform !== 'darwin') return;
+  const harnessUrl =
+    process.env.ARIA_HIVE_RUNTIME_URL ||
+    process.env.ARIA_HARNESS_BASE_URL ||
+    process.env.ARIA_HARNESS_URL ||
+    'https://harness.ariasos.com';
+
+  const launchAgentDir = path.join(homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(launchAgentDir, 'com.aria.mounted-runtime.plist');
+  mkdirSync(launchAgentDir, { recursive: true, mode: 0o755 });
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.aria.mounted-runtime</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${path.join(ariaDir, 'bin', 'aria-runtime')}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>ARIA_RUNTIME_HOST</key>
+    <string>127.0.0.1</string>
+    <key>ARIA_RUNTIME_PORT</key>
+    <string>4319</string>
+    <key>ARIA_RUNTIME_URL</key>
+    <string>http://127.0.0.1:4319</string>
+  <key>ARIA_HIVE_RUNTIME_URL</key>
+    <string>${harnessUrl}</string>
+  <key>ARIA_HARNESS_URL</key>
+    <string>${harnessUrl}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+</dict>
+</plist>
+`;
+
+  writeFileSync(plistPath, plist, { mode: 0o644 });
+  logs.push(`Installed launchd agent → ${plistPath}`);
+
+  try {
+    execFileSync('/bin/launchctl', ['unload', plistPath], { stdio: 'ignore' });
+  } catch {}
+  try {
+    execFileSync('/bin/launchctl', ['load', plistPath], { stdio: 'ignore' });
+    logs.push('Loaded launchd agent: com.aria.mounted-runtime');
+  } catch (error) {
+    logs.push(`⚠ launchd agent installed but not activated: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export async function installSharedRuntime(): Promise<string[]> {
+  const logs: string[] = [];
+  const runtimeSrc = packageRuntimeDir();
+  if (!existsSync(runtimeSrc)) {
+    logs.push(`⚠ bundled runtime missing: ${runtimeSrc} (run npm run build)`);
+    return logs;
+  }
+
+  const ariaDir = path.join(homedir(), '.aria');
+  const runtimeDst = path.join(ariaDir, 'runtime');
+  const binDir = path.join(ariaDir, 'bin');
+
+  mkdirSync(ariaDir, { recursive: true, mode: 0o700 });
+  mkdirSync(binDir, { recursive: true, mode: 0o755 });
+  ensureRuntimeProviderDefaults();
+  installSharedSdk(ariaDir, logs);
+
+  const runtimeStateBackup = path.join(ariaDir, 'runtime-state-backup');
+  if (existsSync(runtimeStateBackup)) {
+    rmSync(runtimeStateBackup, { recursive: true, force: true });
+  }
+  const existingStateDir = path.join(runtimeDst, 'state');
+  if (existsSync(existingStateDir)) {
+    copyTree(existingStateDir, runtimeStateBackup);
+    logs.push(`Preserved runtime state → ${existingStateDir}`);
+  }
+
+  if (existsSync(runtimeDst)) {
+    rmSync(runtimeDst, { recursive: true, force: true });
+  }
+  copyTree(runtimeSrc, runtimeDst);
+  if (existsSync(runtimeStateBackup)) {
+    copyTree(runtimeStateBackup, path.join(runtimeDst, 'state'));
+    rmSync(runtimeStateBackup, { recursive: true, force: true });
+    logs.push('Restored runtime state into refreshed runtime bundle');
+  }
+
+  const startWrapper = path.join(binDir, 'aria-runtime');
+  const doctorWrapper = path.join(binDir, 'aria-runtime-doctor');
+  writeWrapper(startWrapper, path.join(runtimeDst, 'service.mjs'));
+  writeWrapper(doctorWrapper, path.join(runtimeDst, 'doctor.mjs'));
+  const envPath = writeRuntimeEnv(runtimeDst);
+  installDisciplinePack(runtimeDst, logs);
+  installLocalQdrantService(ariaDir, logs);
+  installSystemdUserService(ariaDir, logs);
+  installLaunchAgent(ariaDir, logs);
+
+  logs.push(`Installed shared Aria runtime → ${runtimeDst}`);
+  logs.push(`Installed runtime wrapper → ${startWrapper}`);
+  logs.push(`Installed runtime doctor → ${doctorWrapper}`);
+  logs.push(`Installed runtime env → ${envPath}`);
+  logs.push('Mount any client against ARIA_RUNTIME_URL=http://127.0.0.1:4319');
+  logs.push('Local Qdrant memory is mounted at http://127.0.0.1:6333 for garden pulse persistence.');
+  logs.push('Runtime lease is encrypted at rest and revalidated against /api/license/heartbeat');
+  logs.push('Forge synthesis is relayed through the canonical Aria endpoint unless ARIA_FORGE_SERVICE_URL overrides it.');
+  logs.push('Start it with: aria-runtime');
+  logs.push('Health-check it with: aria-runtime-doctor');
+  return logs;
+}

package/src/connectors/shell.ts

@@ -1,43 +1,112 @@
-import { existsSync, mkdirSync, writeFileSync, chmodSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, chmodSync, unlinkSync, readFileSync } from 'fs';
 import { execSync } from 'child_process';
 import { homedir } from 'os';
 import * as path from 'path';
 import type { AriaConfig } from '../config.js';
 
+const ARIA_DIR = path.join(homedir(), '.aria');
+const WRAPPER_DIR = path.join(ARIA_DIR, 'wrappers');
+const SHELL_DIR = path.join(ARIA_DIR, 'shell');
+const SHELL_HOOK_PATH = path.join(SHELL_DIR, 'runtime-client-env.sh');
+const SHELL_RC_FILES = ['.bashrc', '.bash_profile', '.profile', '.zshrc', '.zprofile'];
+const SHELL_HOOK_LINE = '[ -f "$HOME/.aria/shell/runtime-client-env.sh" ] && . "$HOME/.aria/shell/runtime-client-env.sh"';
+
+function resolveToolPath(toolName: string): string | null {
+  try {
+    const lines = execSync(`which -a ${toolName}`, { encoding: 'utf-8' })
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+    const preferred = lines.find((candidate) => !candidate.startsWith(`${WRAPPER_DIR}/`));
+    return preferred || lines[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+function ensureWrapperShellHook(logs: string[]): void {
+  if (!existsSync(SHELL_DIR)) {
+    mkdirSync(SHELL_DIR, { recursive: true, mode: 0o700 });
+  }
+
+  const shellHook = `#!/usr/bin/env bash
+if [ -d "$HOME/.aria/wrappers" ]; then
+  case ":$PATH:" in
+    *":$HOME/.aria/wrappers:"*) ;;
+    *) export PATH="$HOME/.aria/wrappers:$PATH" ;;
+  esac
+fi
+`;
+  writeFileSync(SHELL_HOOK_PATH, shellHook, { mode: 0o755 });
+  chmodSync(SHELL_HOOK_PATH, 0o755);
+  logs.push(`Installed shell hook → ${SHELL_HOOK_PATH}`);
+
+  for (const rcFile of SHELL_RC_FILES) {
+    const rcPath = path.join(homedir(), rcFile);
+    const existing = existsSync(rcPath) ? readFileSync(rcPath, 'utf8') : '';
+    if (existing.includes(SHELL_HOOK_LINE)) continue;
+    const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+    writeFileSync(rcPath, `${existing}${prefix}${SHELL_HOOK_LINE}\n`, { mode: 0o644 });
+    logs.push(`Added Aria wrapper PATH hook → ${rcPath}`);
+  }
+}
+
+function buildRuntimeInjectionBlock(): string {
+  return `
+RUNTIME_ENV="$HOME/.aria/runtime/runtime.env"
+if [ -f "$RUNTIME_ENV" ]; then
+  set -a
+  . "$RUNTIME_ENV"
+  set +a
+fi
+export ARIA_RUNTIME_URL="\${ARIA_RUNTIME_URL:-http://127.0.0.1:4319}"
+export OPENAI_BASE_URL="\${OPENAI_BASE_URL:-$ARIA_RUNTIME_URL/v1}"
+export ANTHROPIC_BASE_URL="\${ANTHROPIC_BASE_URL:-$ARIA_RUNTIME_URL/v1}"
+if [ -z "\${ARIA_API_KEY:-}" ]; then
+  if [ -f "$HOME/.aria/owner-token" ]; then
+    export ARIA_API_KEY="$(tr -d '\\n' < "$HOME/.aria/owner-token")"
+  elif [ -f "$HOME/.aria/license.json" ]; then
+    export ARIA_API_KEY="$(sed -n 's/.*"harnessToken"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p' "$HOME/.aria/license.json" | head -n 1)"
+    if [ -z "$ARIA_API_KEY" ]; then
+      export ARIA_API_KEY="$(sed -n 's/.*"token"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p' "$HOME/.aria/license.json" | head -n 1)"
+    fi
+  fi
+fi
+`;
+}
+
 export async function connectShell(
   toolName: string,
   config: AriaConfig,
 ): Promise<string[]> {
   const logs: string[] = [];
 
-  let toolPath: string;
-  try {
-    toolPath = execSync(`which ${toolName}`, { encoding: 'utf-8' }).trim();
-  } catch {
+  const toolPath = resolveToolPath(toolName);
+  if (!toolPath) {
     logs.push(`Tool "${toolName}" not found in PATH`);
     return logs;
   }
 
-  const wrapperDir = path.join(homedir(), '.aria', 'wrappers');
-  const wrapperPath = path.join(wrapperDir, toolName);
-
-  if (!existsSync(wrapperDir)) {
-    mkdirSync(wrapperDir, { recursive: true });
+  if (!existsSync(WRAPPER_DIR)) {
+    mkdirSync(WRAPPER_DIR, { recursive: true });
   }
 
   const ariaBlock = buildShellWrapperBlock(config, toolName);
+  const runtimeBlock = buildRuntimeInjectionBlock();
+  const wrapperPath = path.join(WRAPPER_DIR, toolName);
   const script = `#!/usr/bin/env bash
 # ARIA HARNESS WRAPPER — generated by @aria/connector
 # Wraps ${toolName} with Aria's cognitive harness
 ${ariaBlock}
-exec ${toolPath} "$@"
+${runtimeBlock}
+exec "${toolPath}" "$@"
 `;
 
   writeFileSync(wrapperPath, script);
   chmodSync(wrapperPath, 0o755);
+  ensureWrapperShellHook(logs);
   logs.push(`Created wrapper: ${wrapperPath}`);
-  logs.push(`Add ~/.aria/wrappers to your PATH to use it:`);
-  logs.push(`  export PATH="$HOME/.aria/wrappers:$PATH"`);
+  logs.push(`${toolName} will route through the mounted Aria runtime on new shell sessions.`);
 
   return logs;
 }
@@ -61,7 +130,7 @@ function buildShellWrapperBlock(config: AriaConfig, toolName: string): string {
 
 export async function disconnectShell(toolName: string): Promise<string[]> {
   const logs: string[] = [];
-  const wrapperPath = path.join(homedir(), '.aria', 'wrappers', toolName);
+  const wrapperPath = path.join(WRAPPER_DIR, toolName);
 
   if (existsSync(wrapperPath)) {
     unlinkSync(wrapperPath);