merge: sync upstream through b883fc066 (41 commits)

.coderabbit.yaml

@@ -0,0 +1,4 @@
+reviews:
+  review_status: false
+  auto_review:
+    enabled: false

.macroscope/approvability.md

@@ -1,3 +1,7 @@
 Use Macroscope's default approvability criteria.
 
 Additionally, any pull request that changes product defaults is not auto-approvable and requires human review.
+
+Any pull request that adds or broadens a directive that disables or suppresses a lint,
+type-checker, LSP, or other static-analysis diagnostic is not auto-approvable and requires
+human review. This includes file-level, line-level, and configuration-level overrides.

.macroscope/check-run-agents/effect-service-conventions.md

@@ -82,6 +82,7 @@ Review changed TypeScript and directly affected call sites for the conventions b
 ## Change discipline
 
 - Preserve useful comments, invariants, and specification documentation while moving code.
+- Require every new or broadened directive that disables or suppresses a lint, type-checker, LSP, or other static-analysis diagnostic to have an adjacent comment explaining why that diagnostic must be disabled there. The directive itself is not an explanation. Report a missing explanation as a concrete violation.
 - Do not add large tests solely to prove a mechanical refactor. Update existing tests and imports as needed.
 - If backend behavior changes, require focused tests. Use test implementations/layers for external services only; do not mock out core business logic.
 - Do not require `Layer.effect`, universal namespace imports, generic `make`/`layer` names for abstract-port implementations, separate error classes for diagnostic-only fields, or new tests for import-only changes.

apps/desktop/package.json

@@ -21,7 +21,7 @@
     "@t3tools/ssh": "workspace:*",
     "@t3tools/tailscale": "workspace:*",
     "effect": "catalog:",
-    "electron": "41.5.0",
+    "electron": "43.4.1",
     "electron-store": "^8.2.0",
     "electron-updater": "^6.6.2",
     "playwright-core": "1.60.0",

apps/desktop/src/preview/BrowserSession.test.ts

@@ -184,7 +184,7 @@ describe("BrowserSession", () => {
         assert.strictEqual(browserSession.clearStorageData.mock.calls.length, 1);
         assert.deepEqual(browserSession.clearStorageData.mock.calls[0], [
           {
-            storages: ["cookies", "localstorage", "indexdb", "websql", "serviceworkers"],
+            storages: ["cookies", "localstorage", "indexdb", "serviceworkers"],
           },
         ]);
         assert.strictEqual(browserSession.clearCache.mock.calls.length, 1);

apps/desktop/src/preview/BrowserSession.ts

@@ -168,7 +168,7 @@ export const make = Effect.gen(function* BrowserSessionMake() {
           Effect.tryPromise({
             try: () =>
               browserSession.clearStorageData({
-                storages: ["cookies", "localstorage", "indexdb", "websql", "serviceworkers"],
+                storages: ["cookies", "localstorage", "indexdb", "serviceworkers"],
               }),
             catch: (cause) =>
               new BrowserSessionStorageClearError({

apps/desktop/src/settings/DesktopClientSettings.test.ts

@@ -53,8 +53,6 @@ const clientSettings: ClientSettings = {
   planModeEnabled: false,
   showSkillsInSlashMenu: false,
   providerModelPreferences: {},
-  sidebarAutoSettleAfterDays: 3,
-  sidebarAutoSettleOnMerge: true,
   sidebarProjectGroupingMode: "repository_path",
   sidebarProjectGroupingOverrides: {
     "environment-1:/tmp/project-a": "separate",

apps/mobile/app.config.ts

@@ -235,6 +235,7 @@ const config: ExpoConfig = {
       },
       NSLocalNetworkUsageDescription:
         "Allow T3 Code to connect to T3 Code servers on your local network or tailnet.",
+      NSPhotoLibraryAddUsageDescription: "Allow T3 Code to save images to your photo library.",
       ITSAppUsesNonExemptEncryption: false,
       // The App Store screenshot harness rotates the iPad interface from
       // inside the app (CI denies osascript the Accessibility access that

apps/mobile/modules/t3-native-controls/ios/T3NativeControlsModule.swift

@@ -3,9 +3,57 @@ import Security
 import UIKit
 
 public final class T3NativeControlsModule: Module {
+  private let presentationSources = T3PresentationSources()
+  private var videoPresentation: T3NativeVideoPresentation?
+  private var filePresentation: T3NativeFilePresentation?
+
   public func definition() -> ModuleDefinition {
     Name("T3NativeControls")
 
+    AsyncFunction("presentVideo") { (url: URL, title: String, sourceIdentifier: String, identifier: String, promise: Promise) in
+      try self.presentVideo(
+        url: url,
+        title: title,
+        sourceIdentifier: sourceIdentifier,
+        identifier: identifier,
+        promise: promise
+      )
+    }.runOnQueue(.main)
+
+    AsyncFunction("dismissVideo") { (identifier: String) in
+      self.dismissVideo(identifier: identifier)
+    }.runOnQueue(.main)
+
+    AsyncFunction("presentFile") { (url: URL, title: String, sourceIdentifier: String, identifier: String, promise: Promise) in
+      try self.presentFile(url: url, title: title, sourceIdentifier: sourceIdentifier,
+                           identifier: identifier, promise: promise)
+    }.runOnQueue(.main)
+
+    AsyncFunction("dismissFile") { (identifier: String) in
+      self.dismissFile(identifier: identifier)
+    }.runOnQueue(.main)
+
+    OnDestroy {
+      let presentation = self.videoPresentation
+      let file = self.filePresentation
+      DispatchQueue.main.async {
+        presentation?.dismiss()
+        file?.dismiss()
+      }
+    }
+
+    View(T3PresentationSourceView.self) {
+      ViewName("PresentationSource")
+      Prop("identifier") { (view: T3PresentationSourceView, identifier: String) in
+        view.sources = self.presentationSources
+        view.identifier = identifier
+      }
+    }
+
+    AsyncFunction("shareFileFromSource") { (url: URL, title: String, identifier: String, promise: Promise) in
+      try self.shareFile(url: url, title: title, sourceIdentifier: identifier, promise: promise)
+    }.runOnQueue(.main)
+
     Function("getShowcasePairingUrl") {
       let arguments = ProcessInfo.processInfo.arguments
       guard
@@ -101,4 +149,65 @@ public final class T3NativeControlsModule: Module {
       try? scene.write(toFile: readyPath, atomically: true, encoding: .utf8)
     }
   }
+
+  private func presentVideo(url: URL, title: String, sourceIdentifier: String, identifier: String, promise: Promise) throws {
+    let isPlayableURL = url.isFileURL
+      ? FileManager.default.isReadableFile(atPath: url.path)
+      : (["https", "http"].contains(url.scheme?.lowercased() ?? "") && url.host != nil)
+    guard videoPresentation == nil, filePresentation == nil,
+      let presenter = appContext?.utilities?.currentViewController(),
+      isPlayableURL
+    else {
+      throw NSError(
+        domain: "T3NativeVideo",
+        code: 2,
+        userInfo: [NSLocalizedDescriptionKey: "The video preview is no longer available."]
+      )
+    }
+    let presentation = T3NativeVideoPresentation(identifier: identifier, url: url, title: title) { [weak self] error in
+      self?.videoPresentation = nil
+      if let error { promise.reject(error) } else { promise.resolve(nil) }
+    }
+    videoPresentation = presentation
+    presentation.present(from: presenter, sources: presentationSources, sourceIdentifier: sourceIdentifier)
+  }
+
+  private func dismissVideo(identifier: String) {
+    if videoPresentation?.identifier == identifier { videoPresentation?.dismiss() }
+  }
+
+  private func presentFile(url: URL, title: String, sourceIdentifier: String,
+                           identifier: String, promise: Promise) throws {
+    guard filePresentation == nil, videoPresentation == nil,
+      let presenter = appContext?.utilities?.currentViewController()
+    else { throw URLError(.cannotLoadFromNetwork) }
+    let file = T3NativeFilePresentation(identifier: identifier, sources: presentationSources,
+                                        sourceIdentifier: sourceIdentifier) { [weak self] error in
+      self?.filePresentation = nil
+      if let error { promise.reject(error) } else { promise.resolve(nil) }
+    }
+    filePresentation = file
+    file.present(url: url, title: title, from: presenter)
+  }
+
+  private func dismissFile(identifier: String) {
+    if filePresentation?.identifier == identifier { filePresentation?.dismiss() }
+  }
+
+  private func shareFile(url: URL, title: String, sourceIdentifier: String, promise: Promise) throws {
+    guard let presenter = appContext?.utilities?.currentViewController() else {
+      throw NSError(
+        domain: "T3NativePresentation",
+        code: 2,
+        userInfo: [NSLocalizedDescriptionKey: "The presenting screen is no longer open."]
+      )
+    }
+    try presentFileShare(
+      url: url,
+      title: title,
+      source: presentationSources.view(for: sourceIdentifier),
+      presenter: presenter,
+      promise: promise
+    )
+  }
 }

apps/mobile/modules/t3-native-controls/ios/T3NativeFilePresentation.swift

@@ -0,0 +1,165 @@
+import ImageIO
+import QuickLook
+import UIKit
+import UniformTypeIdentifiers
+
+private final class FilePreviewItem: NSObject, QLPreviewItem {
+  var previewItemURL: URL?
+  var previewItemTitle: String?
+}
+
+private final class FilePreviewController: QLPreviewController {
+  var onAppear: (() -> Void)?
+
+  override func viewDidAppear(_ animated: Bool) {
+    super.viewDidAppear(animated)
+    onAppear?()
+  }
+}
+
+/// Quick Look owns image and document controls, zooming, and source-view transitions.
+final class T3NativeFilePresentation: NSObject, QLPreviewControllerDataSource,
+  QLPreviewControllerDelegate, UIAdaptivePresentationControllerDelegate {
+  let identifier: String
+  private var controller: UIViewController?
+  private let completion: (Error?) -> Void
+  private weak var sources: T3PresentationSources?
+  private let sourceIdentifier: String
+  private let item = FilePreviewItem()
+  private var loading: Task<Void, Never>?
+  private var dismissRequested = false
+  private var finished = false
+
+  init(identifier: String, sources: T3PresentationSources, sourceIdentifier: String, completion: @escaping (Error?) -> Void) {
+    self.identifier = identifier
+    self.sources = sources
+    self.sourceIdentifier = sourceIdentifier
+    self.completion = completion
+    super.init()
+  }
+
+  func present(url: URL, title: String, from presenter: UIViewController) {
+    loading = Task { @MainActor [self] in
+      do {
+        let file = try await Self.prepareFile(url: url, title: title)
+        guard !finished, !Task.isCancelled else {
+          try? FileManager.default.removeItem(at: file.deletingLastPathComponent())
+          return
+        }
+        item.previewItemURL = file
+        item.previewItemTitle = title
+        let preview = FilePreviewController()
+        preview.delegate = self
+        preview.dataSource = self
+        preview.onAppear = { [weak self] in self?.resumePendingDismissal() }
+        controller = preview
+        presenter.present(preview, animated: !UIAccessibility.isReduceMotionEnabled) { [self] in
+          resumePendingDismissal()
+        }
+        preview.presentationController?.delegate = self
+      } catch {
+        finish(error: error)
+      }
+    }
+  }
+
+  func dismiss() {
+    dismissRequested = true
+    loading?.cancel()
+    guard !finished else { return }
+    guard let controller else { finish(); return }
+    // Drain Close from viewDidAppear after opening or cancelling an interactive dismissal.
+    // Starting a second modal transition while UIKit is settling the first can strand it.
+    guard !controller.isBeingPresented, !controller.isBeingDismissed else { return }
+    controller.dismiss(animated: !UIAccessibility.isReduceMotionEnabled) { [self] in finish() }
+  }
+
+  private func resumePendingDismissal() {
+    // Appearance callbacks run before UIKit has cleared the current transition.
+    DispatchQueue.main.async { [weak self] in
+      if self?.dismissRequested == true { self?.dismiss() }
+    }
+  }
+
+  func numberOfPreviewItems(in controller: QLPreviewController) -> Int { item.previewItemURL == nil ? 0 : 1 }
+
+  func previewController(_ controller: QLPreviewController, previewItemAt index: Int) -> QLPreviewItem {
+    item
+  }
+
+  func previewController(_ controller: QLPreviewController, transitionViewFor item: QLPreviewItem) -> UIView? {
+    guard !UIAccessibility.isReduceMotionEnabled else { return nil }
+    return sources?.view(for: sourceIdentifier)
+  }
+
+  func previewController(_ controller: QLPreviewController, frameFor item: QLPreviewItem,
+                         inSourceView view: AutoreleasingUnsafeMutablePointer<UIView?>) -> CGRect {
+    guard !UIAccessibility.isReduceMotionEnabled, let source = sources?.view(for: sourceIdentifier) else { return .zero }
+    view.pointee = source
+    return source.bounds
+  }
+
+  func previewControllerDidDismiss(_ controller: QLPreviewController) { finish() }
+
+  func presentationControllerDidDismiss(_ presentationController: UIPresentationController) { finish() }
+
+  private func finish(error: Error? = nil) {
+    guard !finished else { return }
+    finished = true
+    loading?.cancel()
+    loading = nil
+    if let file = item.previewItemURL {
+      try? FileManager.default.removeItem(at: file.deletingLastPathComponent())
+    }
+    item.previewItemURL = nil
+    DispatchQueue.main.async { [completion] in completion(error) }
+  }
+
+  /// Copy original bytes so preview and sharing do not mutate a draft or workspace file.
+  nonisolated private static func prepareFile(url: URL, title: String) async throws -> URL {
+    try Task.checkCancellation()
+    let directory = FileManager.default.temporaryDirectory.appendingPathComponent("t3-preview-\(UUID().uuidString)")
+    try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+    do {
+      let download = directory.appendingPathComponent("original")
+      if url.isFileURL {
+        try FileManager.default.copyItem(at: url, to: download)
+      } else if url.scheme == "data" {
+        try Data(contentsOf: url).write(to: download, options: .atomic)
+      } else {
+        guard ["https", "http"].contains(url.scheme?.lowercased() ?? "") else {
+          throw URLError(.unsupportedURL)
+        }
+        let (temporaryFile, response) = try await URLSession.shared.download(from: url)
+        guard let response = response as? HTTPURLResponse, (200..<300).contains(response.statusCode) else {
+          throw URLError(.badServerResponse)
+        }
+        try FileManager.default.moveItem(at: temporaryFile, to: download)
+      }
+      try Task.checkCancellation()
+      let type: UTType
+      if let image = CGImageSourceCreateWithURL(download as CFURL, nil),
+        CGImageSourceGetCount(image) > 0, let imageType = CGImageSourceGetType(image),
+        let detectedType = UTType(imageType as String) {
+        type = detectedType
+      } else if CGPDFDocument(download as CFURL) != nil {
+        type = .pdf
+      } else {
+        throw URLError(.cannotDecodeContentData)
+      }
+      let filename = URL(fileURLWithPath: title).lastPathComponent as NSString
+      let originalExtension = filename.pathExtension
+      let fileExtension = UTType(filenameExtension: originalExtension) == type
+        ? originalExtension : type.preferredFilenameExtension ?? "png"
+      let stem = filename.deletingPathExtension
+      var name = String(stem.prefix(60)).components(separatedBy: .controlCharacters).joined(separator: "_")
+      while name.utf8.count > 200 { name.removeLast() }
+      let file = directory.appendingPathComponent("\(name.isEmpty ? "Preview" : name).\(fileExtension)")
+      try FileManager.default.moveItem(at: download, to: file)
+      return file
+    } catch {
+      try? FileManager.default.removeItem(at: directory)
+      throw error
+    }
+  }
+}