@aria-cli/tools 1.0.0

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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,436 @@
+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/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

@@ -0,0 +1,27 @@
+/**
+ * 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;
+  };
+}