agent-orchestrator-kit 0.7.0 → 0.9.0

package/bin/amp-usage.js

@@ -0,0 +1,63 @@
+function numOrNull(value) {
+  if (value == null || value === '') return null;
+  const n = Number(String(value).replace(/,/g, ''));
+  return Number.isFinite(n) ? n : null;
+}
+
+export function parseAmpUsageDetails(text) {
+  const raw = String(text || '');
+  const costMatch = /(?:^|\n)Cost:\s*\$([0-9]+(?:\.[0-9]+)?)/.exec(raw);
+  const totalMatch = /Total tokens:\s*([\d,]+)/i.exec(raw);
+  const inputMatch = /Input tokens:\s*([\d,]+)(?:\s*\(([\d,]+)\s*cache reads\))?/i.exec(raw);
+  const outputMatch = /Output tokens:\s*([\d,]+)/i.exec(raw);
+  const models = [];
+  const tableStart = raw.search(/##\s*Models\b/i);
+  if (tableStart >= 0) {
+    const section = raw.slice(tableStart);
+    const rowRe = /^\|\s*(?!Model\b|[-: ]+)([^|]+?)\s*\|\s*([\d,]+)\s*\|\s*([\d,]+)\s*\|\s*([\d,]+)\s*\|\s*\$([0-9]+(?:\.[0-9]+)?)\s*\|/gim;
+    let row;
+    while ((row = rowRe.exec(section))) {
+      models.push({
+        model: row[1].trim(),
+        requests: numOrNull(row[2]),
+        inputTokens: numOrNull(row[3]),
+        outputTokens: numOrNull(row[4]),
+        costUsd: numOrNull(row[5]),
+      });
+    }
+  }
+  return {
+    costUsd: costMatch ? numOrNull(costMatch[1]) : null,
+    totalTokens: totalMatch ? numOrNull(totalMatch[1]) : null,
+    inputTokens: inputMatch ? numOrNull(inputMatch[1]) : null,
+    cacheReadTokens: inputMatch && inputMatch[2] ? numOrNull(inputMatch[2]) : null,
+    outputTokens: outputMatch ? numOrNull(outputMatch[1]) : null,
+    models,
+  };
+}
+
+export function ampAgentMode(thread) {
+  if (!thread || typeof thread !== 'object') return null;
+  const direct = thread.agentMode || (thread.meta && thread.meta.agentMode);
+  if (direct == null || String(direct).trim() === '') return null;
+  return String(direct).trim();
+}
+
+function compactModel(value) {
+  return String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, '').replace(/(\d)p(\d)/g, '$1$2');
+}
+
+export function matchAmpUsageModel(displayName, sourceModels) {
+  const wanted = compactModel(displayName);
+  if (!wanted) return displayName;
+  let best = null;
+  for (const id of sourceModels || []) {
+    const compact = compactModel(id);
+    if (!compact) continue;
+    if (compact === wanted || compact.includes(wanted) || wanted.includes(compact.replace(/^accountsfireworkmodels/, ''))) {
+      best = id;
+      break;
+    }
+  }
+  return best || displayName;
+}

package/bin/cursor-cost-estimate.js

@@ -0,0 +1,50 @@
+function numOrNull(value) {
+  if (value == null || value === '') return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+const GROK_46 = {
+  inputPerM: 2,
+  cachedPerM: 0.5,
+  outputPerM: 6,
+  longInputPerM: 4,
+  longCachedPerM: 1,
+  longOutputPerM: 12,
+  longAt: 200000,
+};
+
+function ratesForModel(model) {
+  const id = String(model || '').toLowerCase();
+  if (!id) return null;
+  let rates = null;
+  if (id.includes('grok-4.6') || id.includes('grok-4-6')) rates = { ...GROK_46 };
+  else if (id.includes('grok-4.5') || id.includes('grok-4-5')) {
+    rates = { ...GROK_46, cachedPerM: 0.3, longCachedPerM: 0.6 };
+  } else {
+    return null;
+  }
+  if (id.includes('fast')) {
+    for (const key of ['inputPerM', 'cachedPerM', 'outputPerM', 'longInputPerM', 'longCachedPerM', 'longOutputPerM']) {
+      rates[key] *= 2;
+    }
+  }
+  return rates;
+}
+
+export function estimateCursorCostUsd({ model, inputTokens, outputTokens, cacheReadTokens } = {}) {
+  const rates = ratesForModel(model);
+  if (!rates) return null;
+  const input = numOrNull(inputTokens);
+  const output = numOrNull(outputTokens) ?? 0;
+  if (input == null && output == 0) return null;
+  const totalInput = input ?? 0;
+  const cached = Math.min(numOrNull(cacheReadTokens) ?? 0, totalInput);
+  const fresh = Math.max(0, totalInput - cached);
+  const long = totalInput >= rates.longAt;
+  const inputRate = long ? rates.longInputPerM : rates.inputPerM;
+  const cachedRate = long ? rates.longCachedPerM : rates.cachedPerM;
+  const outputRate = long ? rates.longOutputPerM : rates.outputPerM;
+  const usd = (fresh * inputRate + cached * cachedRate + output * outputRate) / 1e6;
+  return Math.round(usd * 10000) / 10000;
+}

package/bin/metrics-time.js

@@ -0,0 +1,99 @@
+const DISPLAY_TIMEZONE = 'Europe/Kyiv';
+
+function pad2(value) {
+  return String(value).padStart(2, '0');
+}
+
+export function parseFlexibleIso(value) {
+  if (value == null || value === '') return NaN;
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value < 1e12 ? value * 1000 : value;
+  }
+  let raw = String(value).trim();
+  if (!raw) return NaN;
+  raw = raw.replace(/^(\d{4}-\d{2}-\d{2})[ ]+(\d{2}:)/, '$1T$2');
+  raw = raw.replace(/(\.\d{3})\d*\.000(?=Z$|[+-]\d{2}:?\d{2}$)/i, '$1');
+  raw = raw.replace(/(\.\d{3})\d+(?=Z$|[+-]\d{2}:?\d{2}$)/i, '$1');
+  raw = raw.replace(/([+-]\d{2})(\d{2})$/, '$1:$2');
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?$/.test(raw)) raw += 'Z';
+  const ms = Date.parse(raw);
+  return Number.isFinite(ms) ? ms : NaN;
+}
+
+export function formatUtcIso(value) {
+  const ms = parseFlexibleIso(value);
+  if (!Number.isFinite(ms)) return null;
+  return new Date(ms).toISOString();
+}
+
+export function nowUtcIso(now = Date.now()) {
+  return formatUtcIso(now);
+}
+
+function kyivOffset(ms) {
+  const d = new Date(ms);
+  const fmt = new Intl.DateTimeFormat('en-US', {
+    timeZone: DISPLAY_TIMEZONE,
+    timeZoneName: 'longOffset',
+    hour: '2-digit',
+  });
+  const name = fmt.formatToParts(d).find((part) => part.type === 'timeZoneName')?.value || '';
+  const match = /GMT([+-])(\d{1,2})(?::(\d{2}))?/.exec(name);
+  if (match) {
+    return `${match[1]}${pad2(match[2])}:${match[3] || '00'}`;
+  }
+  const utc = new Date(d.toLocaleString('en-US', { timeZone: 'UTC' })).getTime();
+  const kyiv = new Date(d.toLocaleString('en-US', { timeZone: DISPLAY_TIMEZONE })).getTime();
+  const minutes = Math.round((kyiv - utc) / 60000);
+  const sign = minutes >= 0 ? '+' : '-';
+  const abs = Math.abs(minutes);
+  return `${sign}${pad2(Math.floor(abs / 60))}:${pad2(abs % 60)}`;
+}
+
+function formatKyivIso(value) {
+  const ms = parseFlexibleIso(value);
+  if (!Number.isFinite(ms)) return null;
+  const d = new Date(ms);
+  const parts = Object.fromEntries(
+    new Intl.DateTimeFormat('en-US', {
+      timeZone: DISPLAY_TIMEZONE,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hourCycle: 'h23',
+    }).formatToParts(d).map((part) => [part.type, part.value]),
+  );
+  return `${parts.year}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}:${parts.second}.${String(ms % 1000).padStart(3, '0')}${kyivOffset(ms)}`;
+}
+
+export function formatKyivDisplay(value) {
+  const iso = formatKyivIso(value);
+  if (!iso) return '—';
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?([+-]\d{2}:\d{2})$/.exec(iso);
+  if (!match) return iso;
+  return `${match[3]}.${match[2]}.${match[1]} ${match[4]}:${match[5]}:${match[6]} (Київ ${match[7]})`;
+}
+
+export function isoOrNull(value) {
+  if (value == null || value === '') return null;
+  return formatUtcIso(value);
+}
+
+export function laterTimestamp(a, b) {
+  const left = parseFlexibleIso(a);
+  const right = parseFlexibleIso(b);
+  if (!Number.isFinite(left)) return b;
+  if (!Number.isFinite(right)) return a;
+  return left >= right ? a : b;
+}
+
+export function earlierTimestamp(a, b) {
+  const left = parseFlexibleIso(a);
+  const right = parseFlexibleIso(b);
+  if (!Number.isFinite(left)) return b;
+  if (!Number.isFinite(right)) return a;
+  return left <= right ? a : b;
+}

package/bin/session-client.js

@@ -0,0 +1,187 @@
+import { existsSync, readFileSync, readlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir as osHomedir } from 'os';
+import { execFileSync } from 'child_process';
+
+const VALID_PLATFORMS = new Set(['cursor', 'claude', 'amp']);
+const AMP_TTY_MAX_AGE_MS = 2 * 60 * 60 * 1000;
+
+function trim(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+function envFlagOn(value) {
+  if (value == null) return false;
+  const normalized = String(value).trim().toLowerCase();
+  return normalized !== '' && normalized !== '0' && normalized !== 'false';
+}
+
+export function ampDataRoot(env = {}, homedir) {
+  if (env.AMP_DATA_DIR && String(env.AMP_DATA_DIR).trim()) return String(env.AMP_DATA_DIR).trim();
+  if (env.XDG_DATA_HOME && String(env.XDG_DATA_HOME).trim()) {
+    return join(String(env.XDG_DATA_HOME).trim(), 'amp');
+  }
+  return join(homedir || env.HOME || osHomedir(), '.local', 'share', 'amp');
+}
+
+export function ampThreadIdFromEnv(env = {}) {
+  for (const key of ['AMP_CURRENT_THREAD', 'AMP_THREAD_ID']) {
+    const value = trim(env[key]);
+    if (value) return value;
+  }
+  return '';
+}
+
+export function isUsableTtyPath(raw) {
+  const path = String(raw || '').replace(/^tty:/, '').trim();
+  if (!path.startsWith('/dev/')) return false;
+  if (path === '/dev/null' || path.startsWith('/dev/null')) return false;
+  return true;
+}
+
+export function currentTtyKey(env = {}, readlink = null) {
+  const forced = trim(env.AOK_TTY);
+  if (forced) {
+    const path = forced.startsWith('tty:') ? forced.slice(4) : forced;
+    return isUsableTtyPath(path) ? (forced.startsWith('tty:') ? forced : `tty:${path}`) : '';
+  }
+  try {
+    const fn = readlink || readlinkSync;
+    const raw = String(fn('/proc/self/fd/0') || '').trim();
+    return isUsableTtyPath(raw) ? `tty:${raw}` : '';
+  } catch {
+    return '';
+  }
+}
+
+const AMP_THREAD_ID_RE = /\bT-[0-9a-fA-F-]{8,}\b/g;
+
+export function parseAmpThreadList(text) {
+  const ids = [];
+  for (const line of String(text || '').split('\n')) {
+    if (!line.trim() || /^Title\b/.test(line) || /^─/.test(line)) continue;
+    const matches = line.match(AMP_THREAD_ID_RE);
+    if (!matches || !matches.length) continue;
+    const id = matches[matches.length - 1];
+    if (!ids.includes(id)) ids.push(id);
+  }
+  return ids;
+}
+
+export function listRecentAmpThreadIds(options = {}) {
+  if (typeof options.listAmpThreads === 'function') {
+    try {
+      const out = options.listAmpThreads();
+      if (Array.isArray(out)) return out.map((id) => trim(id)).filter(Boolean);
+      return parseAmpThreadList(out);
+    } catch {
+      return [];
+    }
+  }
+  const env = options.env || {};
+  const bin = options.ampBin || trim(env.AOK_AMP_BIN) || 'amp';
+  if (bin !== 'amp' && !existsSync(bin)) return [];
+  try {
+    const text = execFileSync(bin, ['threads', 'list', '--limit', String(options.limit || 5)], {
+      encoding: 'utf-8',
+      timeout: options.timeoutMs != null ? Number(options.timeoutMs) : 15000,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return parseAmpThreadList(text);
+  } catch {
+    return [];
+  }
+}
+
+export function parentProcessComm(ppid = process.ppid, readFile = readFileSync) {
+  try {
+    return String(readFile(`/proc/${ppid}/comm`, 'utf-8')).trim();
+  } catch {
+    return '';
+  }
+}
+
+function looksLikeAmpProcess(comm) {
+  const name = String(comm || '').toLowerCase();
+  return name === 'amp' || name.startsWith('amp');
+}
+
+function isFreshTimestamp(value, now, maxAgeMs) {
+  if (value == null || value === '') return false;
+  const n = typeof value === 'number' ? (value < 1e12 ? value * 1000 : value) : Date.parse(String(value));
+  if (!Number.isFinite(n)) return false;
+  return now - n >= 0 && now - n <= maxAgeMs;
+}
+
+export function readAmpSessionHint(options = {}) {
+  const env = options.env || {};
+  const homedir = options.homedir || env.HOME;
+  const now = options.now != null ? Number(options.now) : Date.now();
+  const maxAgeMs = options.maxAgeMs != null ? Number(options.maxAgeMs) : AMP_TTY_MAX_AGE_MS;
+  const filePath = join(ampDataRoot(env, homedir), 'session.json');
+  if (!existsSync(filePath)) return { threadId: '', source: '' };
+  let data;
+  try {
+    data = JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return { threadId: '', source: '' };
+  }
+  if (!data || typeof data !== 'object') return { threadId: '', source: '', lastThreadId: '' };
+  const lastThreadId = trim(data.lastThreadId);
+  const rawTty = options.ttyKey != null ? options.ttyKey : currentTtyKey(env, options.readlink);
+  const ttyKey = isUsableTtyPath(rawTty) ? (String(rawTty).startsWith('tty:') ? rawTty : `tty:${rawTty}`) : '';
+  const byTty = data.lastThreadByTerminal && ttyKey ? data.lastThreadByTerminal[ttyKey] : null;
+  if (byTty && trim(byTty.lastThreadId) && isFreshTimestamp(byTty.updatedAt, now, maxAgeMs)) {
+    return { threadId: trim(byTty.lastThreadId), source: 'amp-session-tty', lastThreadId };
+  }
+  return { threadId: '', source: '', lastThreadId };
+}
+
+export function detectSessionClient(options = {}) {
+  const env = options.env || {};
+  const ampId = ampThreadIdFromEnv(env);
+  if (ampId) {
+    return { platform: 'amp', threadId: ampId, source: 'amp-env' };
+  }
+
+  if (envFlagOn(env.CURSOR_AGENT) || trim(env.CURSOR_CONVERSATION_ID)) {
+    return { platform: 'cursor', threadId: null, source: 'cursor-env' };
+  }
+  if (envFlagOn(env.CLAUDECODE) || envFlagOn(env.CLAUDE_CODE) || trim(env.CLAUDE_CODE_ENTRYPOINT)) {
+    return { platform: 'claude', threadId: null, source: 'claude-env' };
+  }
+
+  const comm = options.parentComm != null ? options.parentComm : parentProcessComm();
+  const hint = readAmpSessionHint(options);
+  if (looksLikeAmpProcess(comm)) {
+    if (hint.threadId) {
+      return { platform: 'amp', threadId: hint.threadId, source: 'amp-parent' };
+    }
+    const listed = listRecentAmpThreadIds(options);
+    return {
+      platform: 'amp',
+      threadId: listed[0] || null,
+      source: listed[0] ? 'amp-threads-list' : 'amp-parent',
+    };
+  }
+  if (hint.threadId) {
+    return { platform: 'amp', threadId: hint.threadId, source: hint.source };
+  }
+
+  return { platform: null, threadId: null, source: 'none' };
+}
+
+export function resolveRestoreClient(options = {}) {
+  const env = options.env || {};
+  const detected = detectSessionClient(options);
+  const flag = trim(options.platform || env.AOK_PLATFORM).toLowerCase();
+  if (flag && VALID_PLATFORMS.has(flag)) {
+    return {
+      platform: flag,
+      threadId: detected.threadId,
+      source: options.platform ? 'flag' : 'aok-platform',
+    };
+  }
+  return detected;
+}