@scanoss_test/sdk 2.0.1

package/src/binary.ts

@@ -0,0 +1,57 @@
+/**
+ * Binary resolution for SCANOSS daemon.
+ *
+ * The binary is provided by platform-specific packages (@scanoss_test/linux-x64, etc.).
+ * npm will automatically install the correct one based on the user's OS and CPU.
+ */
+
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+
+const PLATFORMS = [
+  '@scanoss_test/linux-x64',
+  '@scanoss_test/linux-arm64',
+  '@scanoss_test/darwin-x64',
+  '@scanoss_test/darwin-arm64',
+  '@scanoss_test/win32-x64',
+] as const;
+
+/**
+ * Get the path to the SCANOSS binary.
+ *
+ * @returns Path to the scanoss binary
+ * @throws Error if no binary package is installed
+ */
+export function getBinaryPath(): string {
+  // Try each platform package - npm only installs the matching one
+  for (const platform of PLATFORMS) {
+    try {
+      const binaryPath = require(platform);
+      if (existsSync(binaryPath)) {
+        return binaryPath;
+      }
+    } catch {
+      // Package not installed for this platform, try next
+    }
+  }
+
+  // Fallback: check if binary is in PATH
+  try {
+    const pathBinary = execSync('which scanoss', { encoding: 'utf-8' }).trim();
+    if (pathBinary && existsSync(pathBinary)) {
+      return pathBinary;
+    }
+  } catch {
+    // Not in PATH
+  }
+
+  throw new Error(
+    'SCANOSS binary not found. The platform-specific package should be installed automatically.\n' +
+      'If not, install it manually:\n' +
+      '  npm install @scanoss_test/linux-x64     # Linux x64\n' +
+      '  npm install @scanoss_test/linux-arm64   # Linux ARM64\n' +
+      '  npm install @scanoss_test/darwin-x64    # macOS Intel\n' +
+      '  npm install @scanoss_test/darwin-arm64  # macOS Apple Silicon\n' +
+      '  npm install @scanoss_test/win32-x64     # Windows x64'
+  );
+}

package/src/client.ts

@@ -0,0 +1,327 @@
+/**
+ * SCANOSS SDK client using protobuf binary protocol
+ */
+
+import { spawn, ChildProcess } from 'child_process';
+import { create, toBinary, fromBinary } from '@bufbuild/protobuf';
+import { getBinaryPath } from './binary';
+import { ScanossError } from './errors';
+import {
+  RequestSchema,
+  ResponseSchema,
+  ScanCommandSchema,
+  FilterFilesCommandSchema,
+  FingerprintCommandSchema,
+  GenerateSbomCommandSchema,
+  VersionCommandSchema,
+} from './gen/scanoss/v1/commands_pb';
+import type {
+  Request,
+  Response,
+  ScanResult,
+  FilterFilesResult,
+  FingerprintResult,
+  GenerateSbomResult,
+  VersionResult,
+} from './gen/scanoss/v1/commands_pb';
+import { OutputFormat, ScanType } from './gen/scanoss/v1/enums_pb';
+import type {
+  ScanParams,
+  FilterFilesParams,
+  FingerprintParams,
+  GenerateSbomParams,
+} from './types';
+
+/** Options for creating a Scanoss instance */
+export interface ScanossOptions {
+  /** Path to the scanoss binary. If not provided, will be auto-detected. */
+  binaryPath?: string;
+}
+
+interface PendingRequest {
+  resolve: (value: Response) => void;
+  reject: (reason: Error) => void;
+}
+
+/**
+ * SCANOSS SDK client.
+ *
+ * This client communicates with the SCANOSS daemon process via stdin/stdout
+ * using length-prefixed protobuf binary protocol.
+ *
+ * Wire format:
+ * ```
+ * ┌──────────────────┬─────────────────────────┐
+ * │  4 bytes (BE)    │  N bytes                │
+ * │  message length  │  protobuf binary data   │
+ * └──────────────────┴─────────────────────────┘
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const scanoss = new Scanoss();
+ * const result = await scanoss.scan({ path: '/path/to/project' });
+ * console.log(result);
+ * await scanoss.close();
+ * ```
+ */
+export class Scanoss {
+  private process: ChildProcess | null = null;
+  private requestId = 0;
+  private pending = new Map<number, PendingRequest>();
+  private binaryPath: string;
+  private closed = false;
+  private buffer: Buffer = Buffer.alloc(0);
+  private expectedLength: number | null = null;
+
+  constructor(options: ScanossOptions = {}) {
+    this.binaryPath = options.binaryPath ?? getBinaryPath();
+    this.start();
+  }
+
+  private start(): void {
+    this.process = spawn(this.binaryPath, ['daemon'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    // Handle binary data from stdout
+    this.process.stdout!.on('data', (chunk: Buffer) => {
+      this.buffer = Buffer.concat([this.buffer, chunk]);
+      this.processBuffer();
+    });
+
+    this.process.on('error', (err) => {
+      console.error('Daemon process error:', err);
+      this.rejectAllPending(err);
+    });
+
+    this.process.on('exit', (code) => {
+      if (!this.closed) {
+        const err = new Error(`Daemon process exited unexpectedly with code ${code}`);
+        this.rejectAllPending(err);
+      }
+    });
+  }
+
+  private processBuffer(): void {
+    while (true) {
+      // Read length prefix if we don't have it
+      if (this.expectedLength === null) {
+        if (this.buffer.length < 4) {
+          return; // Need more data
+        }
+        this.expectedLength = this.buffer.readUInt32BE(0);
+        this.buffer = this.buffer.subarray(4);
+      }
+
+      // Read message if we have enough data
+      if (this.buffer.length < this.expectedLength) {
+        return; // Need more data
+      }
+
+      const messageData = this.buffer.subarray(0, this.expectedLength);
+      this.buffer = this.buffer.subarray(this.expectedLength);
+      this.expectedLength = null;
+
+      // Parse response
+      try {
+        const response = fromBinary(ResponseSchema, messageData);
+        const pending = this.pending.get(response.id);
+        if (pending) {
+          if (response.result.case === 'error') {
+            pending.reject(new ScanossError(
+              response.result.value.code,
+              response.result.value.message
+            ));
+          } else {
+            pending.resolve(response);
+          }
+          this.pending.delete(response.id);
+        }
+      } catch (err) {
+        console.error('Failed to parse daemon response:', err);
+      }
+    }
+  }
+
+  private rejectAllPending(err: Error): void {
+    for (const pending of this.pending.values()) {
+      pending.reject(err);
+    }
+    this.pending.clear();
+  }
+
+  private send(request: Request): Promise<Response> {
+    return new Promise((resolve, reject) => {
+      if (!this.process || this.closed) {
+        reject(new Error('Daemon process is not running'));
+        return;
+      }
+
+      this.pending.set(request.id, { resolve, reject });
+
+      // Serialize to binary
+      const data = toBinary(RequestSchema, request);
+
+      // Write length prefix (4 bytes, big-endian)
+      const lengthBuf = Buffer.alloc(4);
+      lengthBuf.writeUInt32BE(data.length);
+
+      this.process.stdin!.write(lengthBuf);
+      this.process.stdin!.write(data);
+    });
+  }
+
+  /**
+   * Scan files for open source matches.
+   */
+  async scan(params: ScanParams): Promise<ScanResult> {
+    const id = ++this.requestId;
+
+    const scanCmd = create(ScanCommandSchema, {
+      path: params.path,
+      format: formatToEnum(params.format ?? 'json'),
+      scanType: scanTypeToEnum(params.scanType ?? 'identify'),
+      include: params.include ?? [],
+      exclude: params.exclude ?? [],
+      apiUrl: params.apiUrl,
+      apiKey: params.apiKey,
+    });
+
+    const request = create(RequestSchema, {
+      id,
+      command: { case: 'scan', value: scanCmd },
+    });
+
+    const response = await this.send(request);
+    if (response.result.case !== 'scan') {
+      throw new Error('Unexpected response type');
+    }
+    return response.result.value;
+  }
+
+  /**
+   * Filter files in a directory.
+   */
+  async filterFiles(params: FilterFilesParams): Promise<FilterFilesResult> {
+    const id = ++this.requestId;
+
+    const cmd = create(FilterFilesCommandSchema, {
+      path: params.path,
+      include: params.include ?? [],
+      exclude: params.exclude ?? [],
+      skipHidden: params.skipHidden ?? true,
+    });
+
+    const request = create(RequestSchema, {
+      id,
+      command: { case: 'filterFiles', value: cmd },
+    });
+
+    const response = await this.send(request);
+    if (response.result.case !== 'filterFiles') {
+      throw new Error('Unexpected response type');
+    }
+    return response.result.value;
+  }
+
+  /**
+   * Generate WFP fingerprints for files.
+   */
+  async fingerprint(params: FingerprintParams): Promise<FingerprintResult> {
+    const id = ++this.requestId;
+
+    const cmd = create(FingerprintCommandSchema, {
+      path: params.path,
+      include: params.include ?? [],
+      exclude: params.exclude ?? [],
+    });
+
+    const request = create(RequestSchema, {
+      id,
+      command: { case: 'fingerprint', value: cmd },
+    });
+
+    const response = await this.send(request);
+    if (response.result.case !== 'fingerprint') {
+      throw new Error('Unexpected response type');
+    }
+    return response.result.value;
+  }
+
+  /**
+   * Generate SBOM from scan results.
+   */
+  async generateSbom(params: GenerateSbomParams): Promise<GenerateSbomResult> {
+    const id = ++this.requestId;
+
+    const cmd = create(GenerateSbomCommandSchema, {
+      inputPath: params.path,
+      format: formatToEnum(params.format ?? 'spdx'),
+    });
+
+    const request = create(RequestSchema, {
+      id,
+      command: { case: 'generateSbom', value: cmd },
+    });
+
+    const response = await this.send(request);
+    if (response.result.case !== 'generateSbom') {
+      throw new Error('Unexpected response type');
+    }
+    return response.result.value;
+  }
+
+  /**
+   * Get version information.
+   */
+  async version(): Promise<VersionResult> {
+    const id = ++this.requestId;
+
+    const cmd = create(VersionCommandSchema, {});
+
+    const request = create(RequestSchema, {
+      id,
+      command: { case: 'version', value: cmd },
+    });
+
+    const response = await this.send(request);
+    if (response.result.case !== 'version') {
+      throw new Error('Unexpected response type');
+    }
+    return response.result.value;
+  }
+
+  /**
+   * Close the daemon process.
+   */
+  async close(): Promise<void> {
+    this.closed = true;
+
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+
+    this.pending.clear();
+  }
+}
+
+function formatToEnum(format: string): OutputFormat {
+  const formats: Record<string, OutputFormat> = {
+    json: OutputFormat.JSON,
+    spdx: OutputFormat.SPDX,
+    cyclonedx: OutputFormat.CYCLONEDX,
+    csv: OutputFormat.CSV,
+    wfp: OutputFormat.WFP,
+  };
+  return formats[format.toLowerCase()] ?? OutputFormat.JSON;
+}
+
+function scanTypeToEnum(scanType: string): ScanType {
+  const types: Record<string, ScanType> = {
+    identify: ScanType.IDENTIFY,
+    blacklist: ScanType.BLACKLIST,
+  };
+  return types[scanType.toLowerCase()] ?? ScanType.IDENTIFY;
+}

package/src/errors.ts

@@ -0,0 +1,22 @@
+/**
+ * Error types for SCANOSS SDK
+ */
+
+/**
+ * Error thrown by SCANOSS operations
+ */
+export class ScanossError extends Error {
+  /** Error code from the daemon */
+  readonly code: number;
+
+  constructor(code: number, message: string) {
+    super(`[${code}] ${message}`);
+    this.name = 'ScanossError';
+    this.code = code;
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ScanossError);
+    }
+  }
+}