@aria_asi/cli 0.2.26 → 0.2.30

package/src/connectors/syncd.ts

@@ -0,0 +1,488 @@
+import chokidar from 'chokidar';
+import { execFileSync } from 'child_process';
+import { createHash } from 'crypto';
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'fs';
+import { homedir } from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'node:url';
+
+const ARIA_DIR = path.join(homedir(), '.aria');
+const BIN_DIR = path.join(ARIA_DIR, 'bin');
+const SYNCD_ENV_PATH = path.join(ARIA_DIR, 'syncd.env');
+const SYNCD_STATE_PATH = path.join(ARIA_DIR, 'syncd-state.json');
+const DEFAULT_DEBOUNCE_MS = Number(process.env.ARIA_SYNCD_DEBOUNCE_MS || 2000);
+
+type SyncStatus = 'idle' | 'running' | 'watching' | 'skipped' | 'error';
+
+interface SyncState {
+  status: SyncStatus;
+  sourceRoot: string | null;
+  lastTrigger: string | null;
+  lastSourceHash: string | null;
+  lastBundleHash: string | null;
+  lastSyncedAt: string | null;
+  lastError: string | null;
+  watchedPaths: string[];
+  updatedAt: string;
+}
+
+interface SyncOptions {
+  sourceRoot?: string;
+  force?: boolean;
+  reason?: string;
+}
+
+function connectorPackageRoot(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.resolve(here, '..', '..'),
+    path.resolve(here, '..', '..', '..', '..'),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, 'bin', 'aria.js')) && existsSync(path.join(candidate, 'package.json'))) {
+      return candidate;
+    }
+  }
+
+  return candidates[candidates.length - 1];
+}
+
+function looksLikeRepoRoot(candidate: string): boolean {
+  return (
+    existsSync(path.join(candidate, 'harness', 'packages', 'harness-http-client')) &&
+    existsSync(path.join(candidate, 'packages', 'aria-connector')) &&
+    existsSync(path.join(candidate, 'packages', 'aria-gate-runtime'))
+  );
+}
+
+function findRepoRoot(startDir: string): string | null {
+  let current = path.resolve(startDir);
+  while (true) {
+    if (looksLikeRepoRoot(current)) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function resolveSourceRoot(explicit?: string): string | null {
+  if (explicit && looksLikeRepoRoot(explicit)) return path.resolve(explicit);
+
+  const fromEnv = process.env.ARIA_SYNC_SOURCE_ROOT;
+  if (fromEnv && looksLikeRepoRoot(fromEnv)) return path.resolve(fromEnv);
+
+  return findRepoRoot(process.cwd()) || findRepoRoot(connectorPackageRoot());
+}
+
+function syncWatchPaths(sourceRoot: string): string[] {
+  const candidates = [
+    path.join(sourceRoot, 'harness', 'packages', 'harness-http-client', 'src'),
+    path.join(sourceRoot, 'harness', 'packages', 'harness-http-client', 'skills'),
+    path.join(sourceRoot, 'harness', 'packages', 'harness-http-client', 'scripts'),
+    path.join(sourceRoot, 'harness', 'packages', 'harness-http-client', 'CLAUDE.md'),
+    path.join(sourceRoot, 'packages', 'aria-gate-runtime', 'src'),
+    path.join(sourceRoot, 'packages', 'aria-connector', 'src'),
+    path.join(sourceRoot, 'packages', 'aria-connector', 'package.json'),
+    path.join(sourceRoot, 'packages', 'aria-connector', 'CLIENT-ONBOARDING.md'),
+    path.join(sourceRoot, 'packages', 'aria-connector', 'skills'),
+    path.join(sourceRoot, 'packages', 'aria-connector', 'hooks'),
+    path.join(sourceRoot, 'packages', 'aria-connector', 'opencode-plugins'),
+    path.join(sourceRoot, 'packages', 'aria-connector', 'runtime-src'),
+    path.join(sourceRoot, 'packages', 'aria-connector', 'scripts', 'bundle-sdk.mjs'),
+    path.join(sourceRoot, 'packages', 'aria-connector', 'bin', 'aria.js'),
+  ];
+
+  return candidates.filter((candidate) => existsSync(candidate));
+}
+
+function readState(): SyncState {
+  try {
+    const raw = readFileSync(SYNCD_STATE_PATH, 'utf8');
+    const parsed = JSON.parse(raw) as Partial<SyncState>;
+    return {
+      status: parsed.status || 'idle',
+      sourceRoot: parsed.sourceRoot || null,
+      lastTrigger: parsed.lastTrigger || null,
+      lastSourceHash: parsed.lastSourceHash || null,
+      lastBundleHash: parsed.lastBundleHash || null,
+      lastSyncedAt: parsed.lastSyncedAt || null,
+      lastError: parsed.lastError || null,
+      watchedPaths: Array.isArray(parsed.watchedPaths) ? parsed.watchedPaths : [],
+      updatedAt: parsed.updatedAt || new Date(0).toISOString(),
+    };
+  } catch {
+    return {
+      status: 'idle',
+      sourceRoot: null,
+      lastTrigger: null,
+      lastSourceHash: null,
+      lastBundleHash: null,
+      lastSyncedAt: null,
+      lastError: null,
+      watchedPaths: [],
+      updatedAt: new Date(0).toISOString(),
+    };
+  }
+}
+
+function writeState(update: Partial<SyncState>): SyncState {
+  const next: SyncState = {
+    ...readState(),
+    ...update,
+    updatedAt: new Date().toISOString(),
+  };
+  mkdirSync(ARIA_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(SYNCD_STATE_PATH, JSON.stringify(next, null, 2) + '\n', { mode: 0o600 });
+  return next;
+}
+
+function hashTree(pathsToHash: string[]): string {
+  const hash = createHash('sha256');
+
+  function visit(entryPath: string): void {
+    const stat = statSync(entryPath);
+    if (stat.isDirectory()) {
+      const children = readdirSync(entryPath).sort();
+      for (const child of children) {
+        visit(path.join(entryPath, child));
+      }
+      return;
+    }
+    hash.update(entryPath);
+    hash.update('\0');
+    hash.update(readFileSync(entryPath));
+    hash.update('\0');
+  }
+
+  for (const entryPath of pathsToHash.filter((candidate) => existsSync(candidate)).sort()) {
+    visit(entryPath);
+  }
+
+  return hash.digest('hex');
+}
+
+function runStep(
+  command: string,
+  args: string[],
+  cwd: string,
+  env: NodeJS.ProcessEnv = {},
+): void {
+  execFileSync(command, args, {
+    cwd,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      ...env,
+    },
+  });
+}
+
+function syncBundleHash(sourceRoot: string): string {
+  return hashTree([path.join(sourceRoot, 'packages', 'aria-connector', 'dist')]);
+}
+
+function writeSyncdEnv(sourceRoot: string): string {
+  mkdirSync(ARIA_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(
+    SYNCD_ENV_PATH,
+    [
+      `ARIA_SYNC_SOURCE_ROOT=${sourceRoot}`,
+      `ARIA_SYNCD_DEBOUNCE_MS=${DEFAULT_DEBOUNCE_MS}`,
+      'ARIA_SKIP_SYNCD_INSTALL=1',
+      '',
+    ].join('\n'),
+    { mode: 0o600 },
+  );
+  return SYNCD_ENV_PATH;
+}
+
+function writeWrapper(binPath: string, args: string[]): void {
+  const ariaBin = path.join(connectorPackageRoot(), 'bin', 'aria.js');
+  writeFileSync(
+    binPath,
+    `#!/usr/bin/env bash\nexec node "${ariaBin}" ${args.join(' ')} "$@"\n`,
+    { mode: 0o755 },
+  );
+}
+
+function installSystemdUserService(sourceRoot: 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-syncd.service');
+  mkdirSync(serviceDir, { recursive: true, mode: 0o755 });
+
+  const unit = [
+    '[Unit]',
+    'Description=Aria Connector Auto Sync Daemon',
+    'After=network.target',
+    '',
+    '[Service]',
+    'Type=simple',
+    `EnvironmentFile=-${SYNCD_ENV_PATH}`,
+    `WorkingDirectory=${path.join(sourceRoot, 'packages', 'aria-connector')}`,
+    `ExecStart=${path.join(BIN_DIR, 'aria-syncd')}`,
+    '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-syncd.service'], { stdio: 'ignore' });
+    logs.push('Enabled and started systemd user service: aria-syncd.service');
+  } catch (error) {
+    logs.push(`⚠ systemd sync daemon installed but not activated: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function installLaunchAgent(sourceRoot: string, logs: string[]): void {
+  if (process.platform !== 'darwin') return;
+
+  const launchAgentDir = path.join(homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(launchAgentDir, 'com.aria.syncd.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.syncd</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${path.join(BIN_DIR, 'aria-syncd')}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${path.join(sourceRoot, 'packages', 'aria-connector')}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>ARIA_SYNC_SOURCE_ROOT</key>
+    <string>${sourceRoot}</string>
+    <key>ARIA_SYNCD_DEBOUNCE_MS</key>
+    <string>${String(DEFAULT_DEBOUNCE_MS)}</string>
+    <key>ARIA_SKIP_SYNCD_INSTALL</key>
+    <string>1</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.syncd');
+  } catch (error) {
+    logs.push(`⚠ launchd sync daemon installed but not activated: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export async function installAriaSyncDaemon(options: SyncOptions = {}): Promise<string[]> {
+  const sourceRoot = resolveSourceRoot(options.sourceRoot);
+  const logs: string[] = [];
+
+  if (!sourceRoot) {
+    logs.push('Skipped sync daemon install: canonical Aria source repo not detected from this environment.');
+    return logs;
+  }
+
+  mkdirSync(BIN_DIR, { recursive: true, mode: 0o755 });
+  const envPath = writeSyncdEnv(sourceRoot);
+  writeWrapper(path.join(BIN_DIR, 'aria-syncd'), ['syncd', 'start']);
+  writeWrapper(path.join(BIN_DIR, 'aria-syncd-once'), ['syncd', 'once']);
+
+  installSystemdUserService(sourceRoot, logs);
+  installLaunchAgent(sourceRoot, logs);
+
+  logs.push(`Installed sync daemon wrapper → ${path.join(BIN_DIR, 'aria-syncd')}`);
+  logs.push(`Installed one-shot sync wrapper → ${path.join(BIN_DIR, 'aria-syncd-once')}`);
+  logs.push(`Installed sync daemon env → ${envPath}`);
+  logs.push(`Sync daemon source root → ${sourceRoot}`);
+  return logs;
+}
+
+export async function runSyncOnce(options: SyncOptions = {}): Promise<{ changed: boolean; bundleHash: string; sourceRoot: string; }> {
+  const sourceRoot = resolveSourceRoot(options.sourceRoot);
+  if (!sourceRoot) {
+    writeState({
+      status: 'error',
+      sourceRoot: null,
+      lastTrigger: options.reason || 'manual',
+      lastError: 'Canonical Aria source repo not detected',
+      watchedPaths: [],
+    });
+    throw new Error('Canonical Aria source repo not detected');
+  }
+
+  const watchPaths = syncWatchPaths(sourceRoot);
+  const sourceHash = hashTree(watchPaths);
+  writeState({
+    status: 'running',
+    sourceRoot,
+    lastTrigger: options.reason || 'manual',
+    lastError: null,
+    watchedPaths: watchPaths,
+  });
+
+  try {
+    const prior = readState();
+    if (!options.force && prior.lastSourceHash === sourceHash) {
+      writeState({
+        status: 'skipped',
+        sourceRoot,
+        lastTrigger: options.reason || 'manual',
+        lastSourceHash: sourceHash,
+        lastSyncedAt: new Date().toISOString(),
+        lastError: null,
+        watchedPaths: watchPaths,
+      });
+      return { changed: false, bundleHash: prior.lastBundleHash || 'unchanged', sourceRoot };
+    }
+
+    runStep('npm', ['run', 'build'], path.join(sourceRoot, 'harness', 'packages', 'harness-http-client'));
+    runStep('npm', ['run', 'build'], path.join(sourceRoot, 'packages', 'aria-gate-runtime'));
+    runStep('npm', ['run', 'build'], path.join(sourceRoot, 'packages', 'aria-connector'));
+
+    const bundleHash = syncBundleHash(sourceRoot);
+
+    runStep(
+      'node',
+      ['bin/aria.js', 'connect', '--force'],
+      path.join(sourceRoot, 'packages', 'aria-connector'),
+      { ARIA_SKIP_SYNCD_INSTALL: '1' },
+    );
+
+    writeState({
+      status: 'watching',
+      sourceRoot,
+      lastTrigger: options.reason || 'manual',
+      lastSourceHash: sourceHash,
+      lastBundleHash: bundleHash,
+      lastSyncedAt: new Date().toISOString(),
+      lastError: null,
+      watchedPaths: watchPaths,
+    });
+    return { changed: true, bundleHash, sourceRoot };
+  } catch (error) {
+    writeState({
+      status: 'error',
+      sourceRoot,
+      lastTrigger: options.reason || 'manual',
+      lastError: error instanceof Error ? error.message : String(error),
+      watchedPaths: watchPaths,
+    });
+    throw error;
+  }
+}
+
+export function readSyncDaemonState(): SyncState {
+  return readState();
+}
+
+export async function startSyncDaemon(options: SyncOptions = {}): Promise<void> {
+  const sourceRoot = resolveSourceRoot(options.sourceRoot);
+  if (!sourceRoot) {
+    throw new Error('Canonical Aria source repo not detected');
+  }
+
+  const watchPaths = syncWatchPaths(sourceRoot);
+  writeState({
+    status: 'watching',
+    sourceRoot,
+    lastTrigger: options.reason || 'daemon-start',
+    lastError: null,
+    watchedPaths: watchPaths,
+  });
+
+  await runSyncOnce({
+    sourceRoot,
+    force: options.force,
+    reason: options.reason || 'daemon-startup',
+  });
+
+  const watcher = chokidar.watch(watchPaths, {
+    ignoreInitial: true,
+    ignored: [
+      /(^|[/\\])\../,
+      /[/\\]dist[/\\]/,
+      /[/\\]node_modules[/\\]/,
+      /[/\\]\.git[/\\]/,
+    ],
+    awaitWriteFinish: {
+      stabilityThreshold: 500,
+      pollInterval: 100,
+    },
+  });
+
+  let timer: NodeJS.Timeout | null = null;
+  let active = false;
+  let queuedReason: string | null = null;
+
+  const kick = (reason: string) => {
+    queuedReason = reason;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(async () => {
+      if (active) return;
+      active = true;
+      const nextReason = queuedReason || 'watch';
+      queuedReason = null;
+      try {
+        await runSyncOnce({ sourceRoot, reason: nextReason });
+      } catch (error) {
+        console.error(`[aria syncd] sync failed: ${error instanceof Error ? error.message : String(error)}`);
+      } finally {
+        active = false;
+        if (queuedReason) kick(queuedReason);
+      }
+    }, DEFAULT_DEBOUNCE_MS);
+  };
+
+  watcher.on('all', (eventName, changedPath) => {
+    const rel = path.relative(sourceRoot, changedPath);
+    console.log(`[aria syncd] ${eventName}: ${rel}`);
+    kick(`${eventName}:${rel}`);
+  });
+
+  const shutdown = async () => {
+    if (timer) clearTimeout(timer);
+    await watcher.close();
+    writeState({
+      status: 'idle',
+      sourceRoot,
+      lastTrigger: 'shutdown',
+      watchedPaths: watchPaths,
+    });
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+  console.log(`[aria syncd] watching ${watchPaths.length} paths under ${sourceRoot}`);
+  await new Promise(() => {});
+}