@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/check-package-artifact.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, '..');
+const packageJsonPath = join(packageRoot, 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+
+const failures = [];
+
+function fail(label, message) {
+  failures.push({ label, message });
+}
+
+function walkFiles(dir, out = []) {
+  for (const name of readdirSync(dir)) {
+    if (name === 'node_modules' || name === '.git') continue;
+    const target = join(dir, name);
+    const stat = statSync(target);
+    if (stat.isDirectory()) {
+      walkFiles(target, out);
+      continue;
+    }
+    out.push(relative(packageRoot, target).replaceAll('\\', '/'));
+  }
+  return out;
+}
+
+const forbiddenPhysical = walkFiles(packageRoot).filter((path) => {
+  if (path === '.env.example') return false;
+  return (
+    path.endsWith('.tgz') ||
+    path.endsWith('.log') ||
+    path.endsWith('.jsonl') ||
+    path === 'publish-summary.json' ||
+    path === '.env' ||
+    path.startsWith('.aria/')
+  );
+});
+if (forbiddenPhysical.length > 0) {
+  fail(
+    'package.physical-forbidden-artifacts',
+    `Package tree contains release-unsafe artifacts: ${forbiddenPhysical.join(', ')}`,
+  );
+}
+
+const pack = spawnSync('npm', ['pack', '--dry-run', '--json', '--silent'], {
+  cwd: packageRoot,
+  encoding: 'utf8',
+  env: {
+    ...process.env,
+    npm_config_loglevel: 'silent',
+  },
+  maxBuffer: 32 * 1024 * 1024,
+});
+
+if (pack.status !== 0) {
+  fail('npm.pack-dry-run', `npm pack --dry-run failed with exit ${pack.status}: ${pack.stderr || pack.stdout}`);
+}
+
+let manifest = null;
+if (pack.status === 0) {
+  const stdout = String(pack.stdout || '').trim();
+  const match = stdout.match(/\[\s*\{\s*"id"[\s\S]*\]\s*$/);
+  if (!match) {
+    fail('npm.pack-dry-run-json', 'npm pack did not emit a parseable JSON manifest.');
+  } else {
+    try {
+      manifest = JSON.parse(match[0])[0] || null;
+    } catch (error) {
+      fail('npm.pack-dry-run-json', `npm pack JSON parse failed: ${error.message}`);
+    }
+  }
+}
+
+if (manifest) {
+  const files = new Set((manifest.files || []).map((file) => file.path));
+  const requiredFiles = [
+    'package.json',
+    'README.md',
+    'CLIENT-ONBOARDING.md',
+    packageJson.bin?.aria,
+    packageJson.main?.replace(/^\.\//, ''),
+    packageJson.types?.replace(/^\.\//, ''),
+  ].filter(Boolean);
+
+  for (const file of requiredFiles) {
+    if (!files.has(file)) fail('npm.pack-required-file', `Pack manifest missing required file: ${file}`);
+  }
+
+  const forbiddenPacked = [...files].filter((path) => {
+    if (path === '.env.example') return false;
+    return (
+      path.endsWith('.tgz') ||
+      path.endsWith('.log') ||
+      path.endsWith('.jsonl') ||
+      path === 'publish-summary.json' ||
+      path.startsWith('node_modules/') ||
+      path.startsWith('.aria/')
+    );
+  });
+  if (forbiddenPacked.length > 0) {
+    fail('npm.pack-forbidden-artifacts', `Pack manifest contains forbidden artifacts: ${forbiddenPacked.join(', ')}`);
+  }
+
+  if (manifest.entryCount > 1100) {
+    fail('npm.pack-entry-count', `Pack entry count ${manifest.entryCount} exceeds 1100.`);
+  }
+  if (manifest.size > 6 * 1024 * 1024) {
+    fail('npm.pack-size', `Pack size ${manifest.size} exceeds 6 MiB.`);
+  }
+  if (manifest.unpackedSize > 16 * 1024 * 1024) {
+    fail('npm.pack-unpacked-size', `Unpacked size ${manifest.unpackedSize} exceeds 16 MiB.`);
+  }
+}
+
+if (!existsSync(join(packageRoot, packageJson.bin?.aria || ''))) {
+  fail('package.bin', `Configured aria bin is missing: ${packageJson.bin?.aria || '<unset>'}`);
+}
+
+if (failures.length > 0) {
+  console.error('[check-package-artifact] FAIL');
+  for (const failure of failures) {
+    console.error(`- ${failure.label}: ${failure.message}`);
+  }
+  process.exit(1);
+}
+
+console.log(
+  JSON.stringify(
+    {
+      ok: true,
+      package: packageJson.name,
+      version: packageJson.version,
+      entryCount: manifest?.entryCount,
+      size: manifest?.size,
+      unpackedSize: manifest?.unpackedSize,
+      checked: [
+        'physical-artifact-hygiene',
+        'npm-pack-dry-run-manifest',
+        'required-entrypoints',
+        'forbidden-packed-artifacts',
+        'size-bounds',
+      ],
+    },
+    null,
+    2,
+  ),
+);

package/scripts/check-registry-mirror.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// ── doctrine-self-check-file: M0.SELFREVIEW.8 (2026-05-06) ──
+// CI guard preventing cross-package registry mirror drift.
+// File-level acks for trip-vocab the guard description names.
+// doctrine-self-check-file: \b(?:shadow|proxy|wrapper)\b ci-guard-naming-mirror-drift-class
+
+/**
+ * Cross-package runtime-rails registry mirror byte-identity guard.
+ *
+ * M0.SELFREVIEW.8 — closes the drift surface introduced when Meta-X2
+ * unified inline pattern copies into a single registry per package
+ * (apps + connector). Both packages MUST stay byte-identical or the
+ * client tier (npm-installed connector) silently drifts from the
+ * pod-side runtime.
+ *
+ * Doctrine bind:
+ *   - feedback_workaround_vs_path_fix.md — single source of truth.
+ *   - feedback_no_graceful_degradation.md — drift is silent failure.
+ *
+ * Run via: npm run check:registry-mirror
+ *
+ * Failure mode: if the two registries differ, the script exits 1 and
+ * prints a unified diff so the operator can converge them.
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+
+const repoRoot = join(import.meta.dirname, '..', '..', '..');
+const appsRegistry = join(repoRoot, 'apps/arias-soul/api/lib/runtime-rails/registry.mjs');
+const connectorRegistry = join(repoRoot, 'packages/aria-connector/runtime-src/runtime-rails/registry.mjs');
+
+if (!existsSync(appsRegistry)) {
+  console.error(`[check-registry-mirror] FAIL: apps registry missing at ${appsRegistry}`);
+  process.exit(1);
+}
+if (!existsSync(connectorRegistry)) {
+  console.error(`[check-registry-mirror] FAIL: connector registry missing at ${connectorRegistry}`);
+  process.exit(1);
+}
+
+const appsContent = readFileSync(appsRegistry, 'utf8');
+const connectorContent = readFileSync(connectorRegistry, 'utf8');
+
+if (appsContent === connectorContent) {
+  console.log('[check-registry-mirror] OK — apps + connector runtime-rails/registry.mjs byte-identical');
+  process.exit(0);
+}
+
+console.error('[check-registry-mirror] FAIL — apps + connector registries DIFFER\n');
+console.error(`  apps:      ${appsRegistry}`);
+console.error(`  connector: ${connectorRegistry}\n`);
+
+try {
+  const diff = execFileSync('diff', ['-u', appsRegistry, connectorRegistry], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  console.error(diff);
+} catch (err) {
+  // diff exits 1 when files differ; that's expected
+  if (err.stdout) console.error(err.stdout.toString());
+}
+
+console.error('\nFix: copy whichever is canonical to the other path. The package whose');
+console.error('registry was edited most recently is canonical; verify intent before sync.');
+console.error('\n  cp apps/arias-soul/api/lib/runtime-rails/registry.mjs \\');
+console.error('     packages/aria-connector/runtime-src/runtime-rails/registry.mjs\n');
+
+process.exit(1);

package/scripts/drain-owner-airtable-sync-queue.mjs

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+
+import { randomUUID } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+import { syncOwnerStatusAirtable } from './sync-owner-status-airtable.mjs';
+
+const DEFAULT_QUEUE_PATH = join(homedir(), '.aria', 'owner-airtable', 'sync-queue.jsonl');
+const DEFAULT_STATE_PATH = join(homedir(), '.aria', 'owner-airtable', 'drain-latest.json');
+const DEFAULT_HISTORY_PATH = join(homedir(), '.aria', 'owner-airtable', 'drain-run-history.jsonl');
+const DEFAULT_LOCK_DIR = join(homedir(), '.aria', 'owner-airtable', 'sync-drain.lock');
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = {
+    queuePath: DEFAULT_QUEUE_PATH,
+    statePath: DEFAULT_STATE_PATH,
+    historyPath: DEFAULT_HISTORY_PATH,
+    lockDir: DEFAULT_LOCK_DIR,
+    maxRecords: 500,
+    dryRun: false,
+    quiet: false,
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--queue-path') args.queuePath = resolve(argv[++index]);
+    else if (arg === '--state-path') args.statePath = resolve(argv[++index]);
+    else if (arg === '--history-path') args.historyPath = resolve(argv[++index]);
+    else if (arg === '--lock-dir') args.lockDir = resolve(argv[++index]);
+    else if (arg === '--max-records') args.maxRecords = Math.max(1, Number(argv[++index] || args.maxRecords));
+    else if (arg === '--dry-run') args.dryRun = true;
+    else if (arg === '--quiet') args.quiet = true;
+    else if (arg === '--help' || arg === '-h') {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return args;
+}
+
+function printHelp() {
+  console.log(`
+  node scripts/drain-owner-airtable-sync-queue.mjs [options]
+
+  Coalesces action-ledger owner Airtable queue entries and runs one owner sync.
+
+  Options:
+    --queue-path PATH   Defaults to ~/.aria/owner-airtable/sync-queue.jsonl.
+    --state-path PATH   Defaults to ~/.aria/owner-airtable/drain-latest.json.
+    --history-path PATH Defaults to ~/.aria/owner-airtable/drain-run-history.jsonl.
+    --lock-dir PATH     Defaults to ~/.aria/owner-airtable/sync-drain.lock.
+    --max-records N     Queue lines to consume per run. Defaults to 500.
+    --dry-run           Build sync plan without writing Airtable or draining queue.
+    --quiet             Suppress JSON stdout when no sync is needed.
+`);
+}
+
+function readJsonl(path) {
+  if (!existsSync(path)) return { lines: [], entries: [] };
+  const lines = readFileSync(path, 'utf8').split(/\r?\n/).filter(Boolean);
+  const entries = lines.map((line) => {
+    try { return JSON.parse(line); } catch { return { schema: 'invalid', raw: line.slice(0, 500) }; }
+  });
+  return { lines, entries };
+}
+
+function writeJsonl(path, entries) {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, entries.length ? `${entries.map((entry) => typeof entry === 'string' ? entry : JSON.stringify(entry)).join('\n')}\n` : '', { mode: 0o600 });
+}
+
+function writeState(statePath, result) {
+  mkdirSync(dirname(statePath), { recursive: true, mode: 0o700 });
+  writeFileSync(statePath, `${JSON.stringify(result, null, 2)}\n`, { mode: 0o600 });
+}
+
+function appendHistory(historyPath, result) {
+  mkdirSync(dirname(historyPath), { recursive: true, mode: 0o700 });
+  appendFileSync(historyPath, `${JSON.stringify(result)}\n`, { mode: 0o600 });
+}
+
+function takeLock(lockDir, staleAfterMs = 10 * 60 * 1000) {
+  try {
+    mkdirSync(lockDir, { recursive: false, mode: 0o700 });
+    return { ok: true, lockDir };
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error;
+  }
+  try {
+    const st = statSync(lockDir);
+    if (Date.now() - st.mtimeMs > staleAfterMs) {
+      rmSync(lockDir, { recursive: true, force: true });
+      mkdirSync(lockDir, { recursive: false, mode: 0o700 });
+      return { ok: true, lockDir, reclaimed: true };
+    }
+  } catch {
+    return { ok: false, lockDir, reason: 'lock_stat_failed' };
+  }
+  return { ok: false, lockDir, reason: 'already_running' };
+}
+
+function releaseLock(lockDir) {
+  rmSync(lockDir, { recursive: true, force: true });
+}
+
+function summarize(entries) {
+  const valid = entries.filter((entry) => entry?.schema === 'aria.owner_airtable_sync_needed.v1');
+  return {
+    queueEntries: entries.length,
+    validEntries: valid.length,
+    projectIds: Array.from(new Set(valid.map((entry) => entry.projectId).filter(Boolean))).slice(0, 25),
+    taskIds: Array.from(new Set(valid.map((entry) => entry.taskId).filter(Boolean))).slice(0, 25),
+    latestEventId: valid[valid.length - 1]?.eventId || null,
+    latestStatus: valid[valid.length - 1]?.status || null,
+  };
+}
+
+function removeConsumedPrefix(queuePath, consumedLines) {
+  const current = readJsonl(queuePath).lines;
+  let matchesPrefix = consumedLines.length <= current.length;
+  for (let index = 0; index < consumedLines.length && matchesPrefix; index += 1) {
+    matchesPrefix = current[index] === consumedLines[index];
+  }
+  if (!matchesPrefix) return { drained: 0, remaining: current.length, prefixChanged: true };
+  const remaining = current.slice(consumedLines.length);
+  writeJsonl(queuePath, remaining);
+  return { drained: consumedLines.length, remaining: remaining.length, prefixChanged: false };
+}
+
+export async function drainOwnerAirtableSyncQueue(options = {}) {
+  const queuePath = resolve(options.queuePath || DEFAULT_QUEUE_PATH);
+  const statePath = resolve(options.statePath || DEFAULT_STATE_PATH);
+  const historyPath = resolve(options.historyPath || DEFAULT_HISTORY_PATH);
+  const lockDir = resolve(options.lockDir || DEFAULT_LOCK_DIR);
+  const runId = randomUUID();
+  const startedAt = new Date().toISOString();
+  const startedMs = Date.now();
+  const lock = takeLock(lockDir);
+  if (!lock.ok) {
+    const result = {
+      ok: false,
+      skipped: true,
+      schema: 'aria.owner_airtable_sync_drain.v1',
+      runId,
+      at: new Date().toISOString(),
+      startedAt,
+      queuePath,
+      lockDir,
+      reason: lock.reason,
+      syncOk: null,
+      syncError: null,
+      drainMs: Date.now() - startedMs,
+    };
+    writeState(statePath, result);
+    appendHistory(historyPath, result);
+    return result;
+  }
+  try {
+    const { lines, entries } = readJsonl(queuePath);
+    const consumedLines = lines.slice(0, Math.max(1, Number(options.maxRecords || 500)));
+    const consumedEntries = entries.slice(0, consumedLines.length);
+    const summary = summarize(consumedEntries);
+    const invalidLines = consumedEntries.filter((entry) => entry?.schema === 'invalid').length;
+    if (!consumedLines.length) {
+      const result = {
+        ok: true,
+        schema: 'aria.owner_airtable_sync_drain.v1',
+        runId,
+        at: new Date().toISOString(),
+        startedAt,
+        queuePath,
+        consumed: 0,
+        drained: 0,
+        remaining: 0,
+        sync: null,
+        syncOk: null,
+        syncError: null,
+        invalidLines,
+        drainMs: Date.now() - startedMs,
+        summary,
+      };
+      writeState(statePath, result);
+      appendHistory(historyPath, result);
+      return result;
+    }
+
+    let sync;
+    try {
+      sync = await syncOwnerStatusAirtable({
+        ...(options.syncOptions || {}),
+        dryRun: options.dryRun === true,
+      });
+    } catch (error) {
+      const result = {
+        ok: false,
+        schema: 'aria.owner_airtable_sync_drain.v1',
+        runId,
+        at: new Date().toISOString(),
+        startedAt,
+        queuePath,
+        consumed: consumedLines.length,
+        drained: 0,
+        remaining: lines.length,
+        sync: null,
+        syncOk: false,
+        syncError: error && error.message ? error.message : String(error),
+        invalidLines,
+        drainMs: Date.now() - startedMs,
+        summary,
+      };
+      writeState(statePath, result);
+      appendHistory(historyPath, result);
+      return result;
+    }
+    const drain = options.dryRun === true
+      ? { drained: 0, remaining: lines.length, dryRun: true }
+      : removeConsumedPrefix(queuePath, consumedLines);
+    let postDrainSync = false;
+    let syncError = null;
+    if (options.dryRun !== true && drain.drained > 0 && drain.prefixChanged !== true) {
+      writeState(statePath, {
+        ok: sync.ok === true,
+        schema: 'aria.owner_airtable_sync_drain.v1',
+        runId,
+        at: new Date().toISOString(),
+        startedAt,
+        queuePath,
+        consumed: consumedLines.length,
+        ...drain,
+        sync,
+        postDrainSync: false,
+        syncOk: sync.ok === true,
+        syncError: null,
+        invalidLines,
+        drainMs: Date.now() - startedMs,
+        summary,
+        interim: true,
+      });
+      try {
+        sync = await syncOwnerStatusAirtable({
+          ...(options.syncOptions || {}),
+          dryRun: false,
+        });
+        postDrainSync = true;
+      } catch (error) {
+        syncError = error && error.message ? error.message : String(error);
+      }
+    }
+    const result = {
+      ok: sync.ok === true && drain.prefixChanged !== true && !syncError,
+      schema: 'aria.owner_airtable_sync_drain.v1',
+      runId,
+      at: new Date().toISOString(),
+      startedAt,
+      queuePath,
+      consumed: consumedLines.length,
+      ...drain,
+      sync,
+      postDrainSync,
+      syncOk: sync.ok === true,
+      syncError,
+      invalidLines,
+      drainMs: Date.now() - startedMs,
+      summary,
+    };
+    writeState(statePath, result);
+    appendHistory(historyPath, result);
+    return result;
+  } finally {
+    releaseLock(lockDir);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  try {
+    const options = parseArgs();
+    const result = await drainOwnerAirtableSyncQueue(options);
+    if (!options.quiet || result.drained || result.consumed || result.skipped) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+    if (result.ok === false && result.skipped !== true) process.exitCode = 1;
+  } catch (error) {
+    console.error(error && error.message ? error.message : String(error));
+    process.exit(1);
+  }
+}