Index of every page on this site: llms.txt
All skills
jeremylongshore avatar

/deepgram-data-handling

@820dfc8
Run it yourself

Implement audio data handling best practices for Deepgram integrations. Use when managing audio file storage, implementing data retention, or ensuring GDPR/HIPAA compliance for transcription data. Trigger: "deepgram data", "audio storage", "transcription data", "deepgram GDPR", "deepgram HIPAA", "deepgram privacy", "PII redaction".

Use this Skill: https://skilld.dev/gh/jeremylongshore/tons-of-skills-marketplace/deepgram-data-handling

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

referencesimplementation.md

≈2.2k tokens on demand. Your agent reads this file only when SKILL.md points to it.

Deepgram Data Handling - Implementation Details

Secure Upload Handler

import crypto from 'crypto';
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
import { KMSClient, GenerateDataKeyCommand } from '@aws-sdk/client-kms';

interface UploadOptions {
  userId: string;
  purpose: string;
  retentionDays: number;
  encrypted: boolean;
}

export class SecureAudioUpload {
  private s3: S3Client;
  private kms: KMSClient;
  private bucket: string;
  private kmsKeyId: string;

  constructor() {
    this.s3 = new S3Client({});
    this.kms = new KMSClient({});
    this.bucket = process.env.AUDIO_BUCKET!;
    this.kmsKeyId = process.env.KMS_KEY_ID!;
  }

  async upload(audioBuffer: Buffer, options: UploadOptions): Promise<{ audioId: string; url: string }> {
    const audioId = crypto.randomUUID();
    if (!this.isValidAudio(audioBuffer)) throw new Error('Invalid audio format');

    let encryptedData = audioBuffer;
    let dataKey: string | undefined;
    if (options.encrypted) {
      const { encrypted, key } = await this.encryptData(audioBuffer);
      encryptedData = encrypted;
      dataKey = key;
    }

    const hash = crypto.createHash('sha256').update(audioBuffer).digest('hex');
    const key = `audio/${options.userId}/${audioId}`;
    const expirationDate = new Date();
    expirationDate.setDate(expirationDate.getDate() + options.retentionDays);

    await this.s3.send(new PutObjectCommand({
      Bucket: this.bucket, Key: key, Body: encryptedData, ContentType: 'audio/wav',
      Metadata: {
        'user-id': options.userId, 'purpose': options.purpose,
        'content-hash': hash, 'encrypted': String(options.encrypted),
        'data-key': dataKey || '', 'expiration-date': expirationDate.toISOString(),
      },
      ServerSideEncryption: 'aws:kms', SSEKMSKeyId: this.kmsKeyId,
    }));
    return { audioId, url: `s3://${this.bucket}/${key}` };
  }

  private isValidAudio(buffer: Buffer): boolean {
    const headers = {
      wav: Buffer.from([0x52, 0x49, 0x46, 0x46]),
      mp3: Buffer.from([0xFF, 0xFB]),
      flac: Buffer.from([0x66, 0x4C, 0x61, 0x43]),
    };
    return Object.values(headers).some(header => buffer.slice(0, header.length).equals(header));
  }

  private async encryptData(data: Buffer): Promise<{ encrypted: Buffer; key: string }> {
    const { Plaintext, CiphertextBlob } = await this.kms.send(
      new GenerateDataKeyCommand({ KeyId: this.kmsKeyId, KeySpec: 'AES_256' })
    );
    const iv = crypto.randomBytes(12);
    const cipher = crypto.createCipheriv('aes-256-gcm', Plaintext!, iv);
    const encrypted = Buffer.concat([iv, cipher.update(data), cipher.final(), cipher.getAuthTag()]);
    return { encrypted, key: CiphertextBlob!.toString('base64') };
  }
}

PII Redaction

const redactionRules = [
  { name: 'ssn', pattern: /\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b/g, replacement: '[SSN REDACTED]' },
  { name: 'credit_card', pattern: /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g, replacement: '[CARD REDACTED]' },
  { name: 'phone', pattern: /\b(\+1[-\s]?)?\(?\d{3}\)?[-\s]?\d{3}[-\s]?\d{4}\b/g, replacement: '[PHONE REDACTED]' },
  { name: 'email', pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, replacement: '[EMAIL REDACTED]' },
  { name: 'date_of_birth', pattern: /\b(0?[1-9]|1[0-2])\/\-\/\-\d{2}\b/g, replacement: '[DOB REDACTED]' },
];

export function redactPII(transcript: string) {
  let redacted = transcript;
  const redactions: Array<{ type: string; count: number }> = [];
  for (const rule of redactionRules) {
    const matches = redacted.match(rule.pattern);
    if (matches?.length) {
      redactions.push({ type: rule.name, count: matches.length });
      redacted = redacted.replace(rule.pattern, rule.replacement);
    }
  }
  return { redacted, redactions };
}

export async function transcribeWithRedaction(client: DeepgramClient, audioUrl: string) {
  const { result, error } = await client.listen.prerecorded.transcribeUrl(
    { url: audioUrl },
    { model: 'nova-2', redact: ['pci', 'ssn', 'numbers'], smart_format: true }
  );
  if (error) throw error;
  const transcript = result.results.channels[0].alternatives[0].transcript;
  const { redacted } = redactPII(transcript);
  return { transcript, redactedTranscript: redacted };
}

Data Retention Policy

import { S3Client, ListObjectsV2Command, DeleteObjectsCommand } from '@aws-sdk/client-s3';

const policies = [
  { name: 'standard', retentionDays: 30, dataTypes: ['audio', 'transcript'], complianceReasons: ['business'] },
  { name: 'legal_hold', retentionDays: 365 * 7, dataTypes: ['audio', 'transcript', 'metadata'], complianceReasons: ['legal', 'regulatory'] },
  { name: 'hipaa', retentionDays: 365 * 6, dataTypes: ['audio', 'transcript', 'access_logs'], complianceReasons: ['hipaa'] },
];

export class RetentionManager {
  private s3: S3Client;
  private bucket: string;

  constructor() { this.s3 = new S3Client({}); this.bucket = process.env.AUDIO_BUCKET!; }

  async enforceRetention() {
    const stats = { checked: 0, deleted: 0, retained: 0 };
    const now = new Date();
    const { Contents } = await this.s3.send(new ListObjectsV2Command({ Bucket: this.bucket, Prefix: 'audio/' }));
    if (!Contents) return stats;

    const toDelete: string[] = [];
    for (const object of Contents) {
      stats.checked++;
      if (!object.Key) continue;
      const metadata = await this.getMetadata(object.Key);
      const policy = this.getApplicablePolicy(metadata);
      const expirationDate = new Date(metadata.uploadDate);
      expirationDate.setDate(expirationDate.getDate() + policy.retentionDays);
      if (now > expirationDate && !metadata.legalHold) { toDelete.push(object.Key); stats.deleted++; }
      else { stats.retained++; }
    }
    if (toDelete.length > 0) await this.deleteObjects(toDelete);
    return stats;
  }

  private getApplicablePolicy(metadata: Record<string, string>) {
    if (metadata.legalHold === 'true') return policies.find(p => p.name === 'legal_hold')!;
    if (metadata.hipaa === 'true') return policies.find(p => p.name === 'hipaa')!;
    return policies.find(p => p.name === 'standard')!;
  }

  private async deleteObjects(keys: string[]) { /* batch delete implementation */ }
  private async getMetadata(key: string): Promise<Record<string, string>> { return {}; }
}

GDPR Right to Deletion

export class GDPRCompliance {
  private s3: S3Client;
  constructor() { this.s3 = new S3Client({}); }

  async processRightToErasure(userId: string) {
    const deletedItems = { transcripts: 0, audioFiles: 0, metadata: 0 };
    try {
      const transcriptResult = await db.transcripts.deleteMany({ userId });
      deletedItems.transcripts = transcriptResult.deletedCount;

      const audioFiles = await this.listUserAudioFiles(userId);
      for (const file of audioFiles) {
        await this.s3.send(new DeleteObjectCommand({ Bucket: process.env.AUDIO_BUCKET!, Key: file }));
        deletedItems.audioFiles++;
      }

      const metadataResult = await db.userMetadata.deleteMany({ userId });
      deletedItems.metadata = metadataResult.deletedCount;
      await this.logDeletion(userId, deletedItems);
      return { success: true, deletedItems };
    } catch (error) { throw error; }
  }

  async exportUserData(userId: string): Promise<Buffer> {
    const userData = {
      transcripts: await db.transcripts.find({ userId }).toArray(),
      metadata: await db.userMetadata.findOne({ userId }),
      usageHistory: await db.usage.find({ userId }).toArray(),
      exportedAt: new Date().toISOString(),
    };
    return Buffer.from(JSON.stringify(userData, null, 2));
  }
}

Audit Logging

export class AuditLogger {
  async log(event: { action: string; userId: string; resourceType: string; resourceId: string; details: Record<string, unknown> }) {
    const fullEvent = { ...event, timestamp: new Date() };
    await db.auditLog.insertOne({ ...fullEvent, hash: this.computeHash(fullEvent) });
    if (process.env.SIEM_ENDPOINT) await this.sendToSIEM(fullEvent);
  }

  private computeHash(event: any): string {
    return crypto.createHash('sha256').update(JSON.stringify(event)).digest('hex');
  }

  private async sendToSIEM(event: any): Promise<void> {
    await fetch(process.env.SIEM_ENDPOINT!, {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(event),
    });
  }
}

Tons of Skills by Intent Solutions | jeremylongshore.com

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning2mo3 checks · Risk SAFE
  • Gen Agent Trust Hub2mo

    The skill provides implementation patterns for Deepgram PII redaction and secure storage. It is rated as low risk due to the processing of untrusted transcript data, which creates an indirect prompt injection surface.

  • Socket2mo

    1 alert: gptAnomaly

  • Snyk2mo

    Risk: LOW · No issues

Signed by skilld at 820dfc8. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 3 months ago
What it can do
Reads files Edits files Runs commands
version
1.13.0
author
Jeremy Longshore <jeremy@intentsolutions.io>
tags
[
  "saas",
  "deepgram",
  "data",
  "compliance",
  "privacy"
]
All 5 allowed tools
ReadWriteEditBash(aws:*)Bash(gcloud:*)
Other metadata
compatibility
Designed for Claude Code

README badge

README badge for jeremylongshore/tons-of-skills-marketplace/deepgram-data-handling