@aria-cli/tools 1.0.9 → 1.0.11

package/tests/slack/desktop-session.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  extractCachedSlackDesktopState,
-  extractLiveSlackTokenFromMultipartBody,
-  extractWorkspaceHostFromAppHtml,
-} from "../../src/slack/desktop-session.js";
-
-describe("Slack desktop session helpers", () => {
-  it("extracts cached team ids and cached token from desktop local storage text", () => {
-    const levelDbText = [
-      "prefix localConfig_v2",
-      'teams! T04L44BRZ something {"name":"Axon Enterprise, Inc.","token":"xoxc-4684147883-2782313908196-9922914813107-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}',
-      "more-bytes",
-      'teams! T1234567890 something {"name":"Sandbox","token":"xoxc-1234567890-1111111111111-2222222222222-bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}',
-    ].join("");
-
-    expect(extractCachedSlackDesktopState(levelDbText)).toEqual({
-      cachedToken:
-        "xoxc-4684147883-2782313908196-9922914813107-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-      teamIds: ["T04L44BRZ", "T1234567890"],
-    });
-  });
-
-  it("extracts the workspace host from authenticated app html", () => {
-    const html = [
-      '<script src="https://a.slack-edge.com/bv1-13/application.123.min.js"></script>',
-      '<meta content="https://api.slack.com">',
-      '<div data-team-host="https://axon.enterprise.slack.com"></div>',
-    ].join("");
-
-    expect(extractWorkspaceHostFromAppHtml(html)).toBe("axon.enterprise.slack.com");
-  });
-
-  it("extracts the live token from a captured Slack multipart request body", () => {
-    const requestBody = [
-      "------WebKitFormBoundary123",
-      'Content-Disposition: form-data; name="token"',
-      "",
-      "xoxc-8458081292387-2782313908196-9922914813107-cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
-      "------WebKitFormBoundary123",
-      'Content-Disposition: form-data; name="channel"',
-      "",
-      "C04L44C27",
-    ].join("\r\n");
-
-    expect(extractLiveSlackTokenFromMultipartBody(requestBody)).toBe(
-      "xoxc-8458081292387-2782313908196-9922914813107-cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
-    );
-  });
-});

package/tests/test-lane-manifest.ts

@@ -1,440 +0,0 @@
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { getMaxWorkers } from "../../../vitest.shared.ts";
-
-export type ToolsTestLaneId = "unit" | "integration" | "native" | "e2e";
-export type ToolsTestProofClassId = "gate" | "system" | "live";
-
-export interface ToolsTestPlacement {
-  lane: ToolsTestLaneId;
-  proofClass: ToolsTestProofClassId;
-  resourceKeys: string[];
-}
-
-export interface ToolsTestLaneManifest {
-  defaultLane: "unit";
-  lanes: Record<ToolsTestLaneId, string[]>;
-  setupFiles: Record<ToolsTestLaneId, string[]>;
-  maxWorkers: Record<ToolsTestLaneId, number>;
-  pool: Record<ToolsTestLaneId, "forks">;
-  fileParallelism: Record<ToolsTestLaneId, boolean>;
-  unclassified: string[];
-  proofClasses: Record<ToolsTestProofClassId, string[]>;
-  resourceKeysByFile: Record<string, string[]>;
-  unclassifiedProofClasses: string[];
-}
-
-const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const scanRoots = [path.join(packageRoot, "tests"), path.join(packageRoot, "src")];
-const SAFE_UNIT_WORKERS = Math.min(4, getMaxWorkers());
-const EMPTY_SETUP: string[] = [];
-const UNIT_ALLOWLIST = new Set([
-  "src/__tests__/web-fetch-download.test.ts",
-  "src/__tests__/web-tools.test.ts",
-  "tests/cache/web-cache.test.ts",
-  "tests/definitions/apply-patch.test.ts",
-  "tests/definitions/browser.test.ts",
-  "tests/definitions/messaging-address-space.contract.test.ts",
-  "tests/definitions/delegation-pause-resume.test.ts",
-  "tests/definitions/messaging-address-space.contract.test.ts",
-  "tests/definitions/process.test.ts",
-  "tests/definitions/slack.test.ts",
-  "tests/definitions/tool-inventory.test.ts",
-  "tests/executors/apply-patch.test.ts",
-  "tests/executors/arion.test.ts",
-  "tests/executors/conversation-primitives.test.ts",
-  "tests/executors/deploy.test.ts",
-  "tests/executors/filesystem-tools.test.ts",
-  "tests/executors/frg.test.ts",
-  "tests/executors/frg-freshness.test.ts",
-  "tests/executors/frg-merge.test.ts",
-  "tests/executors/frg-session-content.test.ts",
-  "tests/executors/filesystem.test.ts",
-  "tests/executors/memory-bugfixes.test.ts",
-  "tests/executors/memory.test.ts",
-  "tests/executors/meta-tools.test.ts",
-  "tests/executors/meta.test.ts",
-  "tests/executors/path-containment.test.ts",
-  "tests/executors/quest-security.test.ts",
-  "tests/executors/read-file-media.test.ts",
-  "tests/executors/recall-knowledge-schema.test.ts",
-  "tests/executors/recall-tags.test.ts",
-  "tests/executors/remember-null-safety.contract.test.ts",
-  "tests/executors/restart.test.ts",
-  "tests/executors/search-unified.test.ts",
-  "tests/executors/session-history.test.ts",
-  "tests/executors/session-transcript.test.ts",
-  "tests/executors/shell-env-blocklist.test.ts",
-  "tests/executors/shell-env-process.test.ts",
-  "tests/executors/web-abort-vs-timeout.test.ts",
-  "tests/executors/web-symlink.test.ts",
-  "tests/executors/web.test.ts",
-  "tests/executors/write-stdin.test.ts",
-  "tests/extraction/content-extraction.test.ts",
-  "tests/guards/tools-default-test-lane.integration.test.ts",
-  "tests/guards/tools-test-lane-manifest.contract.test.ts",
-  "tests/loading-tier.test.ts",
-  "tests/mcp/client-reconnect.test.ts",
-  "tests/mcp/connection.test.ts",
-  "tests/mcp/injectable-logger.test.ts",
-  "tests/mcp/jsonrpc.test.ts",
-  "tests/mcp/lifecycle.test.ts",
-  "tests/network-runtime/address-advertisement-revisions.contract.test.ts",
-  "tests/network-runtime/accept-invite-request.contract.test.ts",
-  "tests/network-runtime/address-types.contract.test.ts",
-  "tests/network-runtime/control-endpoint-advertisement.contract.test.ts",
-  "tests/network-runtime/delegation-peer-principal-surface.contract.test.ts",
-  "tests/network-runtime/delivery-ack-principal.contract.test.ts",
-  "tests/network-runtime/delivery-api-surface.contract.test.ts",
-  "tests/network-runtime/deploy-runtime-owner.contract.test.ts",
-  "tests/network-runtime/durable-receipt-semantics.contract.test.ts",
-  "tests/network-runtime/local-control-api.contract.test.ts",
-  "tests/network-runtime/local-control-invite-token.contract.test.ts",
-  "tests/network-runtime/local-control-contract.test.ts",
-  "tests/network-runtime/local-control-operations.contract.test.ts",
-  "tests/network-runtime/local-control-pairing-request.contract.test.ts",
-  "tests/network-runtime/local-control-peer-view.contract.test.ts",
-  "tests/network-runtime/local-control-principal-identity.contract.test.ts",
-  "tests/network-runtime/local-control-repair-peerid.contract.test.ts",
-  "tests/network-runtime/local-control-repair-revisions.contract.test.ts",
-  "tests/network-runtime/local-control-revoke-peerid.contract.test.ts",
-  "tests/network-runtime/local-control-run-policy.contract.test.ts",
-  "tests/network-runtime/runtime-socket-local-control-client.test.ts",
-  "tests/network-runtime/local-runtime-summary.contract.test.ts",
-  "tests/network-runtime/network-control-peerid.contract.test.ts",
-  "tests/network-runtime/network-control-principal-surface.contract.test.ts",
-  "tests/network-runtime/network-control-revoke-peerid.contract.test.ts",
-  "tests/network-runtime/network-runtime-surface-leakage.contract.test.ts",
-  "tests/network-runtime/nearby-peer-principal.contract.test.ts",
-  "tests/network-runtime/node-store-contract.test.ts",
-  "tests/network-runtime/peer-principal-ref.contract.test.ts",
-  "tests/network-runtime/peer-state-machine.contract.test.ts",
-  "tests/network-runtime/pending-pair-request-view.contract.test.ts",
-  "tests/network-runtime/pair-protocol-nodeid.contract.test.ts",
-  "tests/network-runtime/relay-pending-nodeid.contract.test.ts",
-  "tests/network-runtime/relay-pending-response.contract.test.ts",
-  "tests/network-runtime/persisted-inbox-identity.contract.test.ts",
-  "tests/network-runtime/pair-protocol-nodeid.contract.test.ts",
-  "tests/network-runtime/continuity-bind-schema.contract.test.ts",
-  "tests/network-runtime/protocol-schemas.contract.test.ts",
-  "tests/network-runtime/runtime-bootstrap-contract.test.ts",
-  "tests/network-runtime/wait-for-message-script.test.ts",
-  "tests/network-runtime/runtime-contract-removal.contract.test.ts",
-  "tests/network-runtime/runtime-journal.contract.test.ts",
-  "tests/network-runtime/runtime-outbox.contract.test.ts",
-  "tests/network-runtime/runtime-owner-record.contract.test.ts",
-  "tests/network-runtime/runtime-revision-types.contract.test.ts",
-  "tests/parallel.test.ts",
-  "tests/policy.test.ts",
-  "tests/providers/brave.test.ts",
-  "tests/providers/duckduckgo.test.ts",
-  "tests/providers/exa.test.ts",
-  "tests/providers/firecrawl.test.ts",
-  "tests/providers/jina.test.ts",
-  "tests/providers/router.test.ts",
-  "tests/providers/tavily.test.ts",
-  "tests/registry-validation.test.ts",
-  "tests/registry.test.ts",
-  "tests/registry/discovery.test.ts",
-  "tests/registry/injectable-logger.test.ts",
-  "tests/registry/input-validation.test.ts",
-  "tests/registry/interface-completeness.test.ts",
-  "tests/registry/mcp-read-only-hint.test.ts",
-  "tests/registry/memoria-discovery.test.ts",
-  "tests/registry/nested-validation.test.ts",
-  "tests/registry/pseudo-tool-filtering.test.ts",
-  "tests/registry/registration-lifecycle.test.ts",
-  "tests/security/dns-pinning.test.ts",
-  "tests/security/external-content.test.ts",
-  "tests/security/ssrf.test.ts",
-  "tests/shell-safety.test.ts",
-  "tests/slack/desktop-session.test.ts",
-  "tests/tool-factory.test.ts",
-  "tests/utils/retry.test.ts",
-  "tests/utils/url.test.ts",
-]);
-const NATIVE_PATTERNS = [
-  /better-sqlite3/,
-  /from\s*["']@aria\/memoria(?:\/storage)?["']/,
-  /await\s+import\(["']node-pty["']\)/,
-  /from\s*["']node-pty["']/,
-  /from\s*["'][^"']*\/executors\/pty\.js["']/,
-  /\bcreatePTYSession\(/,
-  /\brunInPTY\(/,
-];
-
-let cachedManifest: ToolsTestLaneManifest | null = null;
-const contentCache = new Map<string, string>();
-
-function normalizeRelativePath(filePath: string): string {
-  return path.relative(packageRoot, filePath).split(path.sep).join("/");
-}
-
-function statSafe(targetPath: string): ReturnType<typeof statSync> | null {
-  try {
-    return statSync(targetPath);
-  } catch {
-    return null;
-  }
-}
-
-function collectTestFiles(dir: string, out: string[]): void {
-  if (!statSafe(dir)?.isDirectory()) return;
-
-  for (const entry of readdirSync(dir)) {
-    if (entry === "node_modules" || entry === "dist" || entry === ".worktrees") continue;
-
-    const fullPath = path.join(dir, entry);
-    const stat = statSync(fullPath);
-    if (stat.isDirectory()) {
-      collectTestFiles(fullPath, out);
-      continue;
-    }
-
-    if (entry.endsWith(".test.ts") || entry.endsWith(".test.tsx")) {
-      out.push(normalizeRelativePath(fullPath));
-    }
-  }
-}
-
-function basename(relativePath: string): string {
-  return path.posix.basename(relativePath);
-}
-
-function readRelativeFile(relativePath: string): string {
-  const normalized = relativePath.split(path.sep).join("/");
-  const cached = contentCache.get(normalized);
-  if (cached !== undefined) {
-    return cached;
-  }
-
-  const content = readFileSync(path.join(packageRoot, normalized), "utf8");
-  contentCache.set(normalized, content);
-  return content;
-}
-
-function isE2ESuite(relativePath: string): boolean {
-  const name = basename(relativePath);
-  return relativePath.includes("/e2e/") || /(^|[.-])e2e\./.test(name);
-}
-
-function isNativeSuite(relativePath: string): boolean {
-  const name = basename(relativePath);
-  if (relativePath.includes("/native/") || /(^|[.-])native\./.test(name)) {
-    return true;
-  }
-
-  const content = readRelativeFile(relativePath);
-  return NATIVE_PATTERNS.some((pattern) => pattern.test(content));
-}
-
-function isIntegrationSuite(relativePath: string): boolean {
-  const name = basename(relativePath);
-  return relativePath.includes("/integration/") || /(^|[.-])integration\./.test(name);
-}
-
-function cloneStringArray(values: string[]): string[] {
-  return [...values];
-}
-
-function cloneLaneRecord<T>(record: Record<ToolsTestLaneId, T>): Record<ToolsTestLaneId, T> {
-  return {
-    unit: record.unit,
-    integration: record.integration,
-    native: record.native,
-    e2e: record.e2e,
-  };
-}
-
-function defaultProofClassForLane(lane: ToolsTestLaneId): ToolsTestProofClassId {
-  return lane === "unit" ? "gate" : "system";
-}
-
-export function classifyToolsTestPlacement(relativePath: string): ToolsTestPlacement | null {
-  const normalized = relativePath.split(path.sep).join("/");
-  if (!normalized.endsWith(".test.ts") && !normalized.endsWith(".test.tsx")) {
-    return null;
-  }
-
-  let lane: ToolsTestLaneId;
-  if (UNIT_ALLOWLIST.has(normalized)) {
-    lane = "unit";
-  } else if (isE2ESuite(normalized)) {
-    lane = "e2e";
-  } else if (isIntegrationSuite(normalized)) {
-    lane = "integration";
-  } else if (isNativeSuite(normalized)) {
-    lane = "native";
-  } else {
-    lane = "integration";
-  }
-
-  return {
-    lane,
-    proofClass: defaultProofClassForLane(lane),
-    resourceKeys: [],
-  };
-}
-
-export function classifyToolsTestFile(relativePath: string): ToolsTestLaneId | null {
-  return classifyToolsTestPlacement(relativePath)?.lane ?? null;
-}
-
-export function classifyToolsTestProofClass(relativePath: string): ToolsTestProofClassId | null {
-  return classifyToolsTestPlacement(relativePath)?.proofClass ?? null;
-}
-
-export function loadToolsTestLaneManifest(): ToolsTestLaneManifest {
-  if (cachedManifest) {
-    return {
-      ...cachedManifest,
-      lanes: Object.fromEntries(
-        Object.entries(cachedManifest.lanes).map(([lane, files]) => [
-          lane,
-          cloneStringArray(files),
-        ]),
-      ) as Record<ToolsTestLaneId, string[]>,
-      setupFiles: Object.fromEntries(
-        Object.entries(cachedManifest.setupFiles).map(([lane, files]) => [
-          lane,
-          cloneStringArray(files),
-        ]),
-      ) as Record<ToolsTestLaneId, string[]>,
-      maxWorkers: cloneLaneRecord(cachedManifest.maxWorkers),
-      pool: cloneLaneRecord(cachedManifest.pool),
-      fileParallelism: cloneLaneRecord(cachedManifest.fileParallelism),
-      unclassified: cloneStringArray(cachedManifest.unclassified),
-      proofClasses: {
-        gate: cloneStringArray(cachedManifest.proofClasses.gate),
-        system: cloneStringArray(cachedManifest.proofClasses.system),
-        live: cloneStringArray(cachedManifest.proofClasses.live),
-      },
-      resourceKeysByFile: Object.fromEntries(
-        Object.entries(cachedManifest.resourceKeysByFile).map(([file, resourceKeys]) => [
-          file,
-          cloneStringArray(resourceKeys),
-        ]),
-      ),
-      unclassifiedProofClasses: cloneStringArray(cachedManifest.unclassifiedProofClasses),
-    };
-  }
-
-  const files: string[] = [];
-  for (const scanRoot of scanRoots) {
-    collectTestFiles(scanRoot, files);
-  }
-
-  const manifest: ToolsTestLaneManifest = {
-    defaultLane: "unit",
-    lanes: {
-      unit: [],
-      integration: [],
-      native: [],
-      e2e: [],
-    },
-    setupFiles: {
-      unit: EMPTY_SETUP,
-      integration: EMPTY_SETUP,
-      native: EMPTY_SETUP,
-      e2e: EMPTY_SETUP,
-    },
-    maxWorkers: {
-      unit: SAFE_UNIT_WORKERS,
-      integration: 1,
-      native: 1,
-      e2e: 1,
-    },
-    pool: {
-      unit: "forks",
-      integration: "forks",
-      native: "forks",
-      e2e: "forks",
-    },
-    fileParallelism: {
-      unit: true,
-      integration: false,
-      native: false,
-      e2e: false,
-    },
-    unclassified: [],
-    proofClasses: {
-      gate: [],
-      system: [],
-      live: [],
-    },
-    resourceKeysByFile: {},
-    unclassifiedProofClasses: [],
-  };
-
-  for (const relativePath of files) {
-    const placement = classifyToolsTestPlacement(relativePath);
-    if (!placement) {
-      manifest.unclassified.push(relativePath);
-      manifest.unclassifiedProofClasses.push(relativePath);
-      continue;
-    }
-
-    manifest.lanes[placement.lane].push(relativePath);
-    manifest.proofClasses[placement.proofClass].push(relativePath);
-    manifest.resourceKeysByFile[relativePath] = [...placement.resourceKeys];
-  }
-
-  for (const lane of Object.keys(manifest.lanes) as ToolsTestLaneId[]) {
-    manifest.lanes[lane].sort();
-  }
-  manifest.unclassified.sort();
-
-  cachedManifest = manifest;
-  return loadToolsTestLaneManifest();
-}
-
-export function getToolsTestLaneFiles(lane: ToolsTestLaneId): string[] {
-  return cloneStringArray(loadToolsTestLaneManifest().lanes[lane]);
-}
-
-export function getToolsTestLaneSetupFiles(lane: ToolsTestLaneId): string[] {
-  return cloneStringArray(loadToolsTestLaneManifest().setupFiles[lane]);
-}
-
-export function getToolsTestLaneMaxWorkers(lane: ToolsTestLaneId): number {
-  return loadToolsTestLaneManifest().maxWorkers[lane];
-}
-
-export function getToolsTestLanePool(lane: ToolsTestLaneId): "forks" {
-  return loadToolsTestLaneManifest().pool[lane];
-}
-
-export function getToolsTestLaneFileParallelism(lane: ToolsTestLaneId): boolean {
-  return loadToolsTestLaneManifest().fileParallelism[lane];
-}
-
-export function getToolsDiagnosticBreadthFiles(
-  view: "unit" | "integration" | "e2e" | "native",
-): string[] {
-  switch (view) {
-    case "unit":
-      return getToolsTestLaneFiles("unit");
-    case "integration":
-      return getToolsTestLaneFiles("integration");
-    case "e2e":
-      return getToolsTestLaneFiles("e2e");
-    case "native":
-      return getToolsTestLaneFiles("native");
-  }
-}
-
-export function getToolsTestProofClassFiles(proofClass: ToolsTestProofClassId): string[] {
-  return [...loadToolsTestLaneManifest().proofClasses[proofClass]];
-}
-
-export const PACKAGE_TEST_AUTHORITY = {
-  classifyPlacement: classifyToolsTestPlacement,
-  classifyLane: classifyToolsTestFile,
-  classifyProofClass: classifyToolsTestProofClass,
-  loadManifest: loadToolsTestLaneManifest,
-  getLaneFiles: getToolsTestLaneFiles,
-  getLaneGlobalSetup: () => [],
-  getDiagnosticBreadthFiles: getToolsDiagnosticBreadthFiles,
-  getProofClassFiles: getToolsTestProofClassFiles,
-};

package/tests/test-utils.ts

@@ -1,27 +0,0 @@
-/**
- * Test Utilities
- *
- * Shared utilities for test files
- */
-
-/**
- * Create a conditional skip wrapper for test functions.
- *
- * Usage: `it("name", skipIf(condition, reason)(async () => { ... }))`
- *
- * When condition is true, returns an empty async function (test passes trivially).
- * When condition is false, returns the original test function unchanged.
- *
- * Note: Tests skipped this way will show as "passed" not "skipped" in vitest output.
- * For proper skip reporting, use `it.skipIf(condition)` directly.
- */
-export function skipIf(condition: boolean, _reason: string) {
-  return (testFn: () => Promise<void>): (() => Promise<void>) => {
-    if (condition) {
-      return async () => {
-        // Silently pass — API key not available
-      };
-    }
-    return testFn;
-  };
-}