rird 1.0.200

package/src/session/retry.ts

@@ -0,0 +1,86 @@
+import type { NamedError } from "@opencode-ai/util/error"
+import { MessageV2 } from "./message-v2"
+
+export namespace SessionRetry {
+  export const RETRY_INITIAL_DELAY = 2000
+  export const RETRY_BACKOFF_FACTOR = 2
+  export const RETRY_MAX_DELAY_NO_HEADERS = 30_000 // 30 seconds
+
+  export async function sleep(ms: number, signal: AbortSignal): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(resolve, ms)
+      signal.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timeout)
+          reject(new DOMException("Aborted", "AbortError"))
+        },
+        { once: true },
+      )
+    })
+  }
+
+  export function delay(attempt: number, error?: MessageV2.APIError) {
+    if (error) {
+      const headers = error.data.responseHeaders
+      if (headers) {
+        const retryAfterMs = headers["retry-after-ms"]
+        if (retryAfterMs) {
+          const parsedMs = Number.parseFloat(retryAfterMs)
+          if (!Number.isNaN(parsedMs)) {
+            return parsedMs
+          }
+        }
+
+        const retryAfter = headers["retry-after"]
+        if (retryAfter) {
+          const parsedSeconds = Number.parseFloat(retryAfter)
+          if (!Number.isNaN(parsedSeconds)) {
+            // convert seconds to milliseconds
+            return Math.ceil(parsedSeconds * 1000)
+          }
+          // Try parsing as HTTP date format
+          const parsed = Date.parse(retryAfter) - Date.now()
+          if (!Number.isNaN(parsed) && parsed > 0) {
+            return Math.ceil(parsed)
+          }
+        }
+
+        return RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1)
+      }
+    }
+
+    return Math.min(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1), RETRY_MAX_DELAY_NO_HEADERS)
+  }
+
+  export function retryable(error: ReturnType<NamedError["toObject"]>) {
+    if (MessageV2.APIError.isInstance(error)) {
+      if (!error.data.isRetryable) return undefined
+      return error.data.message.includes("Overloaded") ? "Provider is overloaded" : error.data.message
+    }
+
+    if (typeof error.data?.message === "string") {
+      try {
+        const json = JSON.parse(error.data.message)
+        if (json.type === "error" && json.error?.type === "too_many_requests") {
+          return "Too Many Requests"
+        }
+        if (json.code.includes("exhausted") || json.code.includes("unavailable")) {
+          return "Provider is overloaded"
+        }
+        if (json.type === "error" && json.error?.code?.includes("rate_limit")) {
+          return "Rate Limited"
+        }
+        if (
+          json.error?.message?.includes("no_kv_space") ||
+          (json.type === "error" && json.error?.type === "server_error") ||
+          !!json.error
+        ) {
+          return "Provider Server Error"
+        }
+      } catch {}
+    }
+
+    return undefined
+  }
+}

package/src/session/revert.ts

@@ -0,0 +1,108 @@
+import z from "zod"
+import { Identifier } from "../id/id"
+import { Snapshot } from "../snapshot"
+import { MessageV2 } from "./message-v2"
+import { Session } from "."
+import { Log } from "../util/log"
+import { splitWhen } from "remeda"
+import { Storage } from "../storage/storage"
+import { Bus } from "../bus"
+import { SessionPrompt } from "./prompt"
+
+export namespace SessionRevert {
+  const log = Log.create({ service: "session.revert" })
+
+  export const RevertInput = z.object({
+    sessionID: Identifier.schema("session"),
+    messageID: Identifier.schema("message"),
+    partID: Identifier.schema("part").optional(),
+  })
+  export type RevertInput = z.infer<typeof RevertInput>
+
+  export async function revert(input: RevertInput) {
+    SessionPrompt.assertNotBusy(input.sessionID)
+    const all = await Session.messages({ sessionID: input.sessionID })
+    let lastUser: MessageV2.User | undefined
+    const session = await Session.get(input.sessionID)
+
+    let revert: Session.Info["revert"]
+    const patches: Snapshot.Patch[] = []
+    for (const msg of all) {
+      if (msg.info.role === "user") lastUser = msg.info
+      const remaining = []
+      for (const part of msg.parts) {
+        if (revert) {
+          if (part.type === "patch") {
+            patches.push(part)
+          }
+          continue
+        }
+
+        if (!revert) {
+          if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
+            // if no useful parts left in message, same as reverting whole message
+            const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
+            revert = {
+              messageID: !partID && lastUser ? lastUser.id : msg.info.id,
+              partID,
+            }
+          }
+          remaining.push(part)
+        }
+      }
+    }
+
+    if (revert) {
+      const session = await Session.get(input.sessionID)
+      revert.snapshot = session.revert?.snapshot ?? (await Snapshot.track())
+      await Snapshot.revert(patches)
+      if (revert.snapshot) revert.diff = await Snapshot.diff(revert.snapshot)
+      return Session.update(input.sessionID, (draft) => {
+        draft.revert = revert
+      })
+    }
+    return session
+  }
+
+  export async function unrevert(input: { sessionID: string }) {
+    log.info("unreverting", input)
+    SessionPrompt.assertNotBusy(input.sessionID)
+    const session = await Session.get(input.sessionID)
+    if (!session.revert) return session
+    if (session.revert.snapshot) await Snapshot.restore(session.revert.snapshot)
+    const next = await Session.update(input.sessionID, (draft) => {
+      draft.revert = undefined
+    })
+    return next
+  }
+
+  export async function cleanup(session: Session.Info) {
+    if (!session.revert) return
+    const sessionID = session.id
+    let msgs = await Session.messages({ sessionID })
+    const messageID = session.revert.messageID
+    const [preserve, remove] = splitWhen(msgs, (x) => x.info.id === messageID)
+    msgs = preserve
+    for (const msg of remove) {
+      await Storage.remove(["message", sessionID, msg.info.id])
+      await Bus.publish(MessageV2.Event.Removed, { sessionID: sessionID, messageID: msg.info.id })
+    }
+    const last = preserve.at(-1)
+    if (session.revert.partID && last) {
+      const partID = session.revert.partID
+      const [preserveParts, removeParts] = splitWhen(last.parts, (x) => x.id === partID)
+      last.parts = preserveParts
+      for (const part of removeParts) {
+        await Storage.remove(["part", last.info.id, part.id])
+        await Bus.publish(MessageV2.Event.PartRemoved, {
+          sessionID: sessionID,
+          messageID: last.info.id,
+          partID: part.id,
+        })
+      }
+    }
+    await Session.update(sessionID, (draft) => {
+      draft.revert = undefined
+    })
+  }
+}

package/src/session/sensitive-filter.test.ts

@@ -0,0 +1,327 @@
+/**
+ * Tests for sensitive data filter
+ * Run with: bun test sensitive-filter.test.ts
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test"
+import { SensitiveFilter } from "./sensitive-filter"
+
+describe("SensitiveFilter", () => {
+  const testSessionID = "test-session-123"
+
+  beforeEach(() => {
+    // Clear any previous session data
+    SensitiveFilter.clearSession(testSessionID)
+  })
+
+  describe("Credit Card Detection", () => {
+    it("should detect and redact valid Visa card numbers", () => {
+      const text = "My card is 4532015112830366"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("4532015112830366")
+      expect(result.text).toContain("[REDACTED-CREDIT_CARD]")
+      expect(result.redactions).toHaveLength(1)
+      expect(result.redactions[0].type).toBe("CREDIT_CARD")
+    })
+
+    it("should detect card numbers with dashes", () => {
+      const text = "Card: 4532-0151-1283-0366"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("4532-0151-1283-0366")
+      expect(result.text).toContain("[REDACTED-CREDIT_CARD]")
+    })
+
+    it("should detect card numbers with spaces", () => {
+      const text = "Card: 4532 0151 1283 0366"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("4532 0151 1283 0366")
+      expect(result.text).toContain("[REDACTED-CREDIT_CARD]")
+    })
+
+    it("should not redact numbers that fail Luhn check", () => {
+      const text = "Random number: 1234567890123456"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      // This should not be redacted as it fails Luhn
+      expect(result.redactions).toHaveLength(0)
+    })
+
+    it("should detect American Express (15 digits)", () => {
+      // Valid Amex test number
+      const text = "Amex: 378282246310005"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("378282246310005")
+      expect(result.text).toContain("[REDACTED-CREDIT_CARD]")
+    })
+  })
+
+  describe("SSN Detection", () => {
+    it("should detect and redact SSN format", () => {
+      const text = "SSN: 123-45-6789"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("123-45-6789")
+      expect(result.text).toContain("[REDACTED-SSN]")
+      expect(result.redactions).toHaveLength(1)
+      expect(result.redactions[0].type).toBe("SSN")
+    })
+
+    it("should handle multiple SSNs", () => {
+      const text = "SSN1: 123-45-6789, SSN2: 987-65-4321"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("123-45-6789")
+      expect(result.text).not.toContain("987-65-4321")
+      expect(result.redactions).toHaveLength(2)
+    })
+  })
+
+  describe("Password Detection", () => {
+    it("should detect password: value patterns", () => {
+      const text = "password: mySecretPass123"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("mySecretPass123")
+      expect(result.text).toContain("[REDACTED-PASSWORD]")
+      expect(result.text).toContain("password:")
+    })
+
+    it("should detect pwd=value patterns", () => {
+      const text = "config: pwd=hunter2"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("hunter2")
+      expect(result.text).toContain("[REDACTED-PASSWORD]")
+    })
+
+    it("should detect quoted passwords", () => {
+      const text = 'password="super_secret_123"'
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("super_secret_123")
+      expect(result.text).toContain("[REDACTED-PASSWORD]")
+    })
+
+    it("should detect secret: patterns", () => {
+      const text = "secret: my_api_secret_value"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("my_api_secret_value")
+      expect(result.redactions).toHaveLength(1)
+      expect(result.redactions[0].type).toBe("PASSWORD")
+    })
+  })
+
+  describe("API Key Detection", () => {
+    it("should detect OpenAI style keys (sk-*)", () => {
+      const text = "API key: sk-proj-abc123def456ghi789jkl012mno345pqr678stu"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("sk-proj")
+      expect(result.text).toContain("[REDACTED-API_KEY]")
+    })
+
+    it("should detect Slack tokens (xoxb-*)", () => {
+      const text = "Slack: xoxb-1234567890-1234567890123-abcdefghijklmnopqrstuvwx"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("xoxb-")
+      expect(result.text).toContain("[REDACTED-API_KEY]")
+    })
+
+    it("should detect GitHub tokens (ghp_*)", () => {
+      const text = "GitHub PAT: ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("ghp_")
+      expect(result.text).toContain("[REDACTED-API_KEY]")
+    })
+
+    it("should detect AWS access keys (AKIA*)", () => {
+      const text = "AWS key: AKIAIOSFODNN7EXAMPLE"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("AKIAIOSFODNN7EXAMPLE")
+      expect(result.text).toContain("[REDACTED-API_KEY]")
+    })
+
+    it("should detect api_key= patterns", () => {
+      const text = "config: api_key=abcdef1234567890abcdef"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("abcdef1234567890abcdef")
+      expect(result.text).toContain("[REDACTED-API_KEY]")
+    })
+  })
+
+  describe("Bearer Token Detection", () => {
+    it("should detect Bearer tokens", () => {
+      const text = "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9")
+      expect(result.text).toContain("Bearer [REDACTED-BEARER_TOKEN]")
+    })
+  })
+
+  describe("Email Detection (Optional)", () => {
+    it("should not redact emails by default", () => {
+      const text = "Contact: user@example.com"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).toContain("user@example.com")
+      expect(result.redactions).toHaveLength(0)
+    })
+
+    it("should redact emails when enabled", () => {
+      const text = "Contact: user@example.com"
+      const result = SensitiveFilter.filter(text, {
+        sessionID: testSessionID,
+        redactEmails: true,
+      })
+
+      expect(result.text).not.toContain("user@example.com")
+      expect(result.text).toContain("[REDACTED-EMAIL]")
+    })
+  })
+
+  describe("Restore Functionality", () => {
+    it("should restore redacted values", () => {
+      const originalText = "password: secretValue123"
+      const filtered = SensitiveFilter.filter(originalText, { sessionID: testSessionID })
+
+      expect(filtered.text).not.toContain("secretValue123")
+
+      const restored = SensitiveFilter.restore(filtered.text, testSessionID)
+      expect(restored).toContain("secretValue123")
+    })
+
+    it("should restore multiple redacted values", () => {
+      const originalText = "card: 4532015112830366, ssn: 123-45-6789"
+      const filtered = SensitiveFilter.filter(originalText, { sessionID: testSessionID })
+
+      expect(filtered.text).not.toContain("4532015112830366")
+      expect(filtered.text).not.toContain("123-45-6789")
+
+      const restored = SensitiveFilter.restore(filtered.text, testSessionID)
+      expect(restored).toContain("4532015112830366")
+      expect(restored).toContain("123-45-6789")
+    })
+  })
+
+  describe("containsSensitive Check", () => {
+    it("should detect sensitive patterns without redacting", () => {
+      const text = "My card is 4532015112830366 and SSN is 123-45-6789"
+      const check = SensitiveFilter.containsSensitive(text)
+
+      expect(check.hasSensitive).toBe(true)
+      expect(check.types).toContain("CREDIT_CARD")
+      expect(check.types).toContain("SSN")
+    })
+
+    it("should return false for clean text", () => {
+      const text = "This is just a regular message with no sensitive data"
+      const check = SensitiveFilter.containsSensitive(text)
+
+      expect(check.hasSensitive).toBe(false)
+      expect(check.types).toHaveLength(0)
+    })
+  })
+
+  describe("Session Management", () => {
+    it("should track redactions per session", () => {
+      const session1 = "session-1"
+      const session2 = "session-2"
+
+      SensitiveFilter.filter("password: secret1", { sessionID: session1 })
+      SensitiveFilter.filter("password: secret2", { sessionID: session2 })
+
+      const redactions1 = SensitiveFilter.getRedactions(session1)
+      const redactions2 = SensitiveFilter.getRedactions(session2)
+
+      expect(redactions1).toHaveLength(1)
+      expect(redactions1[0].original).toBe("secret1")
+
+      expect(redactions2).toHaveLength(1)
+      expect(redactions2[0].original).toBe("secret2")
+
+      // Clean up
+      SensitiveFilter.clearSession(session1)
+      SensitiveFilter.clearSession(session2)
+    })
+
+    it("should clear session data", () => {
+      SensitiveFilter.filter("password: secret", { sessionID: testSessionID })
+
+      expect(SensitiveFilter.getRedactions(testSessionID)).toHaveLength(1)
+
+      SensitiveFilter.clearSession(testSessionID)
+
+      expect(SensitiveFilter.getRedactions(testSessionID)).toHaveLength(0)
+    })
+
+    it("should use unique placeholders for multiple redactions", () => {
+      const text = "password: secret1, pwd: secret2, pass: secret3"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      // Should have 3 different placeholder IDs
+      const placeholders = result.text.match(/\[REDACTED-PASSWORD[^\]]*\]/g)
+      expect(placeholders).not.toBeNull()
+      expect(new Set(placeholders).size).toBe(3)
+    })
+  })
+
+  describe("Edge Cases", () => {
+    it("should not double-redact already redacted values", () => {
+      const text = "password: [REDACTED-PASSWORD]"
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).toBe("password: [REDACTED-PASSWORD]")
+      expect(result.redactions).toHaveLength(0)
+    })
+
+    it("should handle empty strings", () => {
+      const result = SensitiveFilter.filter("", { sessionID: testSessionID })
+
+      expect(result.text).toBe("")
+      expect(result.redactions).toHaveLength(0)
+    })
+
+    it("should handle text with no sensitive data", () => {
+      const text = "Hello, this is a normal message about coding."
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).toBe(text)
+      expect(result.redactions).toHaveLength(0)
+    })
+
+    it("should handle mixed sensitive data types", () => {
+      const text = `
+        Credit Card: 4532015112830366
+        SSN: 123-45-6789
+        Password: mySecret123
+        API Key: sk-proj-abcdefghijklmnopqrstuvwx
+        Bearer Token: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI
+      `
+      const result = SensitiveFilter.filter(text, { sessionID: testSessionID })
+
+      expect(result.text).not.toContain("4532015112830366")
+      expect(result.text).not.toContain("123-45-6789")
+      expect(result.text).not.toContain("mySecret123")
+      expect(result.text).not.toContain("sk-proj")
+      expect(result.text).not.toContain("eyJhbGciOiJIUzI1NiIsInR5cCI")
+
+      // Check all types were detected
+      const types = result.redactions.map((r) => r.type)
+      expect(types).toContain("CREDIT_CARD")
+      expect(types).toContain("SSN")
+      expect(types).toContain("PASSWORD")
+      expect(types).toContain("API_KEY")
+      expect(types).toContain("BEARER_TOKEN")
+    })
+  })
+})