feat: ship a self-updating .rpm and import exported CLI transcripts

.github/workflows/release-desktop.yml

@@ -447,7 +447,8 @@ jobs:
         shell: bash
         run: |
           sudo apt-get update
-          sudo apt-get install -y libsecret-1-dev pkg-config
+          # rpm provides rpmbuild, which electron-builder needs for the .rpm.
+          sudo apt-get install -y libsecret-1-dev pkg-config rpm
           if ! command -v magick >/dev/null 2>&1 && ! command -v convert >/dev/null 2>&1; then
               sudo apt-get install -y imagemagick
           fi
@@ -701,6 +702,7 @@ jobs:
             "release/*.zip"
             "release/*.AppImage"
             "release/*.deb"
+            "release/*.rpm"
             "release/*.exe"
           )
           # Preview builds have no publish config, so electron-builder writes

.github/workflows/release.yml

@@ -883,6 +883,7 @@ jobs:
             echo 'release-assets/*.zip'
             echo 'release-assets/*.AppImage'
             echo 'release-assets/*.deb'
+            echo 'release-assets/*.rpm'
             echo 'release-assets/*.exe'
             if [[ "${{ needs.preflight.outputs.release_channel }}" != "preview" ]]; then
               echo 'release-assets/*.blockmap'

README.md

@@ -68,6 +68,14 @@ Download the `.deb` from [GitHub Releases](https://github.com/pingdotgg/t3code/r
 sudo apt install ./T3-Code-*.deb
 ```
 
+#### Fedora, openSUSE (`.rpm`)
+
+Download the `.rpm` from [GitHub Releases](https://github.com/pingdotgg/t3code/releases), then:
+
+```bash
+sudo dnf install ./T3-Code-*.rpm
+```
+
 #### Arch Linux (AUR)
 
 Stable:

apps/desktop/resources/linux/rpm-after-remove.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# electron-builder's after-remove template, run as %postun. rpm passes the number of installs
+# left: 0 on erase, 1 when an upgrade runs the old package's %postun after the new %post.
+# Cleaning up then would remove the link and profile the new package just installed.
+[ "$1" = "0" ] || exit 0
+
+if type update-alternatives >/dev/null 2>&1; then
+    update-alternatives --remove '${executable}' '/opt/${sanitizedProductName}/${executable}'
+else
+    rm -f '/usr/bin/${executable}'
+fi
+
+APPARMOR_PROFILE_DEST='/etc/apparmor.d/${executable}'
+
+if [ -f "$APPARMOR_PROFILE_DEST" ]; then
+  if apparmor_status --enabled > /dev/null 2>&1; then
+    if ! { [ -x '/usr/bin/ischroot' ] && /usr/bin/ischroot; } && hash apparmor_parser 2>/dev/null; then
+      apparmor_parser --remove "$APPARMOR_PROFILE_DEST" || true
+    fi
+  fi
+  rm -f "$APPARMOR_PROFILE_DEST"
+fi

apps/desktop/src/app/DesktopCliShim.ts

@@ -4,6 +4,7 @@ import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
 
 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
+import * as DesktopLinuxPackage from "./DesktopLinuxPackage.ts";
 import { makeComponentLogger } from "./DesktopObservability.ts";
 
 // AppImage mounts change each run; the launcher must mount the image itself.
@@ -127,16 +128,23 @@ export const install = Effect.gen(function* () {
   const windows = environment.platform === "win32";
   const shimPath = launcherPath(environment);
   const entry = path.join(environment.serverRoot, SERVER_ENTRY);
+  const systemPackage = yield* DesktopLinuxPackage.findSystemPackageBesideAppImage(environment);
   const target: CliShimTarget = windows
     ? { kind: "windows", executable: process.execPath, entry }
-    : Option.match(environment.appImagePath, {
-        onSome: (appImage) => ({
-          kind: "appimage" as const,
-          appImage,
-          executableName: path.basename(process.execPath),
-        }),
-        onNone: () => ({ kind: "direct" as const, executable: process.execPath, entry }),
-      });
+    : Option.isSome(systemPackage)
+      ? {
+          kind: "direct",
+          executable: systemPackage.value.executable,
+          entry: systemPackage.value.serverEntry,
+        }
+      : Option.match(environment.appImagePath, {
+          onSome: (appImage) => ({
+            kind: "appimage" as const,
+            appImage,
+            executableName: path.basename(process.execPath),
+          }),
+          onNone: () => ({ kind: "direct" as const, executable: process.execPath, entry }),
+        });
   const content = renderCliShim({ target, shimPath, t3Home: environment.baseDir });
 
   return yield* Effect.gen(function* () {

apps/desktop/src/app/DesktopLinuxPackage.ts

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+
+import type * as DesktopEnvironment from "./DesktopEnvironment.ts";
+
+// electron-builder writes resources/package-type into its .deb and .rpm; electron-updater reads
+// the same marker to install updates with dpkg, or dnf/zypper.
+const SYSTEM_PACKAGE_TYPES: ReadonlyArray<string> = ["deb", "rpm"];
+
+export const isSystemPackageType = (marker: string) => SYSTEM_PACKAGE_TYPES.includes(marker.trim());
+
+// electron-builder installs the .deb and .rpm at /opt/<productName>; the packaged product name is
+// the display name, so each channel has its own install.
+export const systemPackagePaths = (displayName: string) => {
+  const root = `/opt/${displayName}`;
+  return {
+    marker: `${root}/resources/package-type`,
+    executable: `${root}/t3code`,
+    serverEntry: `${root}/resources/app.asar/apps/server/dist/bin.mjs`,
+  };
+};
+
+/**
+ * The .deb or .rpm of this channel when an AppImage runs beside one. Shared launch integration
+ * points at the package then, so removing the AppImage leaves links and the `t3` command working.
+ */
+export const findSystemPackageBesideAppImage = Effect.fn(
+  "DesktopLinuxPackage.findSystemPackageBesideAppImage",
+)(function* (environment: DesktopEnvironment.DesktopEnvironment["Service"]) {
+  if (environment.platform !== "linux" || Option.isNone(environment.appImagePath)) {
+    return Option.none<ReturnType<typeof systemPackagePaths>>();
+  }
+  const fileSystem = yield* FileSystem.FileSystem;
+  const paths = systemPackagePaths(environment.displayName);
+  const marker = yield* fileSystem.readFileString(paths.marker).pipe(Effect.option);
+  return Option.filter(marker, isSystemPackageType).pipe(Option.as(paths));
+});

apps/desktop/src/app/DesktopLinuxUrlHandler.test.ts

@@ -69,6 +69,7 @@ const layerHandler = (
     readonly xdgMimeExitCode?: number;
     readonly writeError?: PlatformError.PlatformError;
     readonly existingEntry?: string;
+    readonly systemPackageType?: string;
     readonly iconSource?: string;
     readonly iconCopyError?: PlatformError.PlatformError;
   } = {},
@@ -98,7 +99,12 @@ const layerHandler = (
               : Effect.sync(() => {
                   recorded.copies.push({ source, destination });
                 }),
-          readFileString: () => Effect.succeed(input.existingEntry ?? ""),
+          readFileString: (path) =>
+            Effect.succeed(
+              path === "/opt/T3 Code (Alpha)/resources/package-type"
+                ? (input.systemPackageType ?? "")
+                : (input.existingEntry ?? ""),
+            ),
           makeDirectory: (path) =>
             Effect.sync(() => {
               recorded.directories.push(path);
@@ -237,6 +243,23 @@ describe("DesktopLinuxUrlHandler", () => {
     });
   });
 
+  it.effect("hands links to an installed .deb or .rpm instead of the AppImage beside it", () =>
+    Effect.gen(function* () {
+      for (const systemPackageType of ["deb\n", "rpm"]) {
+        const recorded = emptyRecording();
+        yield* runRegister(recorded, { systemPackageType });
+        assert.include(recorded.files[0]?.content, 'Exec="/opt/T3 Code (Alpha)/t3code" %U');
+      }
+
+      const unrelated = emptyRecording();
+      yield* runRegister(unrelated, { systemPackageType: "pacman" });
+      assert.include(
+        unrelated.files[0]?.content,
+        "Exec=/home/alice/Applications/T3-Code.AppImage %U",
+      );
+    }),
+  );
+
   it.effect("launches a distribution package through its configured launcher", () => {
     const recorded = emptyRecording();
 

apps/desktop/src/app/DesktopLinuxUrlHandler.ts

@@ -10,6 +10,7 @@ import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import * as DesktopAssets from "./DesktopAssets.ts";
 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
+import * as DesktopLinuxPackage from "./DesktopLinuxPackage.ts";
 import { makeComponentLogger } from "./DesktopObservability.ts";
 
 // AppImage integrators choose the .desktop filename, so setDesktopName cannot identify it for protocol registration.
@@ -122,6 +123,7 @@ export const make = Effect.gen(function* () {
   const assets = yield* DesktopAssets.DesktopAssets;
 
   const scheme = ElectronProtocol.getDesktopScheme(environment.isDevelopment);
+  const systemPackage = yield* DesktopLinuxPackage.findSystemPackageBesideAppImage(environment);
   const desktopEntryPath = environment.path.join(
     environment.linuxApplicationsDir,
     environment.linuxDesktopEntryName,
@@ -137,6 +139,7 @@ export const make = Effect.gen(function* () {
     // Inside the mounted AppImage, process.execPath points at a transient
     // /tmp/.mount_* path — the handler must launch the AppImage itself.
     const execTarget = environment.desktopLauncherPath.pipe(
+      Option.orElse(() => Option.map(systemPackage, (installed) => installed.executable)),
       Option.orElse(() => environment.appImagePath),
       Option.getOrElse(() => process.execPath),
     );

apps/desktop/src/app/DesktopPreReadyPlatform.ts

@@ -11,6 +11,7 @@ import * as HostProcess from "@t3tools/shared/HostProcess";
 
 import * as DesktopEarlyElectronStartup from "./DesktopEarlyElectronStartup.ts";
 import { resolveDesktopAppBranding } from "./DesktopEnvironment.ts";
+import { isSystemPackageType, systemPackagePaths } from "./DesktopLinuxPackage.ts";
 import { renderUrlHandlerDesktopEntry } from "./DesktopLinuxUrlHandler.ts";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 
@@ -102,16 +103,28 @@ export const make = Effect.gen(function* () {
             );
           } catch {}
         }
+        const { displayName } = resolveDesktopAppBranding({
+          isDevelopment: linux.isDevelopment,
+          appVersion: Electron.app.getVersion(),
+        });
+        // Same target as DesktopLinuxUrlHandler, which leaves an identical entry untouched.
+        const appImage = process.env.APPIMAGE?.trim();
+        const systemPackage = systemPackagePaths(displayName);
+        let besideSystemPackage = false;
+        if (appImage) {
+          try {
+            besideSystemPackage = isSystemPackageType(
+              NodeFS.readFileSync(systemPackage.marker, "utf8"),
+            );
+          } catch {}
+        }
         NodeFS.writeFileSync(
           NodePath.posix.join(applicationsDir, linux.linuxDesktopEntryName),
           renderUrlHandlerDesktopEntry({
-            displayName: resolveDesktopAppBranding({
-              isDevelopment: linux.isDevelopment,
-              appVersion: Electron.app.getVersion(),
-            }).displayName,
+            displayName,
             execTarget:
               process.env.T3CODE_DESKTOP_LAUNCHER_PATH?.trim() ||
-              process.env.APPIMAGE?.trim() ||
+              (besideSystemPackage ? systemPackage.executable : appImage) ||
               process.execPath,
             scheme: ElectronProtocol.getDesktopScheme(linux.isDevelopment),
             ...(iconPath === undefined ? {} : { iconPath }),

apps/desktop/src/updates/DesktopUpdates.test.ts

@@ -22,7 +22,7 @@ import * as DesktopUpdates from "./DesktopUpdates.ts";
 import { flushCallbacks, makeHarness } from "./updatesTestHarness.ts";
 
 describe("DesktopUpdates", () => {
-  it.effect("updates Linux .deb installs and leaves other non-AppImage installs off", () =>
+  it.effect("updates Linux .deb and .rpm installs and leaves other non-AppImage installs off", () =>
     Effect.gen(function* () {
       const linuxState = (packageType: string | undefined) =>
         Effect.scoped(
@@ -36,6 +36,12 @@ describe("DesktopUpdates", () => {
       const deb = yield* linuxState("deb\n");
       assert.equal(deb.status, "idle");
 
+      const rpm = yield* linuxState("rpm");
+      assert.equal(rpm.status, "idle");
+
+      const pacman = yield* linuxState("pacman");
+      assert.equal(pacman.status, "disabled");
+
       const unmarked = yield* linuxState(undefined);
       assert.equal(unmarked.status, "disabled");
     }),

apps/desktop/src/updates/DesktopUpdates.ts

@@ -28,6 +28,7 @@ import * as Stream from "effect/Stream";
 import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts";
 import * as DesktopConfig from "../app/DesktopConfig.ts";
 import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
+import * as DesktopLinuxPackage from "../app/DesktopLinuxPackage.ts";
 import * as DesktopObservability from "../app/DesktopObservability.ts";
 import * as DesktopState from "../app/DesktopState.ts";
 import * as ElectronUpdater from "../electron/ElectronUpdater.ts";
@@ -319,7 +320,7 @@ function getAutoUpdateDisabledReason(args: {
   isPackaged: boolean;
   platform: NodeJS.Platform;
   appImage?: string | undefined;
-  isDebPackage: boolean;
+  isSystemPackage: boolean;
   disabledByEnv: boolean;
   hasUpdateFeedConfig: boolean;
 }): string | null {
@@ -332,8 +333,8 @@ function getAutoUpdateDisabledReason(args: {
   if (args.disabledByEnv) {
     return "Automatic updates are disabled by the T3CODE_DISABLE_AUTO_UPDATE setting.";
   }
-  if (args.platform === "linux" && !args.appImage && !args.isDebPackage) {
-    return "Automatic updates on Linux require the AppImage or the .deb package.";
+  if (args.platform === "linux" && !args.appImage && !args.isSystemPackage) {
+    return "Automatic updates on Linux require the AppImage, .deb, or .rpm package.";
   }
   return null;
 }
@@ -419,13 +420,12 @@ export const make = Effect.gen(function* () {
     ),
   );
 
-  // electron-updater uses this marker to install .deb updates with dpkg.
-  const isDebPackage =
+  const isSystemPackage =
     environment.platform === "linux" && environment.isPackaged
       ? yield* fileSystem
           .readFileString(environment.path.join(environment.resourcesPath, "package-type"))
           .pipe(
-            Effect.map((packageType) => packageType.trim() === "deb"),
+            Effect.map(DesktopLinuxPackage.isSystemPackageType),
             Effect.orElseSucceed(() => false),
           )
       : false;
@@ -442,7 +442,7 @@ export const make = Effect.gen(function* () {
         isPackaged: environment.isPackaged,
         platform: environment.platform,
         appImage: Option.getOrUndefined(config.appImagePath),
-        isDebPackage,
+        isSystemPackage,
         disabledByEnv: config.disableAutoUpdate,
         hasUpdateFeedConfig: hasFeedConfig,
       }),

apps/marketing/src/pages/download.astro

@@ -109,7 +109,9 @@ const imageProps = {
           </a>
         </div>
         <p class="intel-note">
-          On ARM? Download the arm64 <a data-asset="arm64.deb" href={RELEASES_URL}>.deb</a> or
+          Fedora or openSUSE? Download the <a data-asset="x86_64.rpm" href={RELEASES_URL}>.rpm</a>.
+          On ARM? Download the arm64 <a data-asset="arm64.deb" href={RELEASES_URL}>.deb</a>,
+          <a data-asset="aarch64.rpm" href={RELEASES_URL}>.rpm</a>, or
           <a data-asset="arm64.AppImage" href={RELEASES_URL}>AppImage</a>.
         </p>
       </section>

apps/server/src/observability/RpcInstrumentation.ts

@@ -157,6 +157,7 @@ const RPC_AGGREGATES = {
   [WS_METHODS.filesystemGetMetadata]: "workspace",
   [WS_METHODS.agentSessionsScan]: "workspace",
   [WS_METHODS.agentSessionsImport]: "workspace",
+  [WS_METHODS.agentSessionsImportTranscript]: "orchestration",
   [WS_METHODS.assetsCreateUrl]: "workspace",
   [WS_METHODS.assetsPersistChatAttachments]: "orchestration",
   [WS_METHODS.attachmentsCreateUploadUrl]: "workspace",

apps/server/src/project/AgentSessionImporter.test.ts

@@ -235,9 +235,42 @@ const makeImporter = Effect.fn(function* (
     ),
   );
   const importer = Context.get(context, AgentSessionImporter.AgentSessionImporter);
-  return { run: importer.importRecentAgentThreads({ projectId }), published };
+  return { run: importer.importRecentAgentThreads({ projectId }), importer, published };
 });
 
+it.effect("imports an exported transcript as a thread without a native session", () =>
+  Effect.gen(function* () {
+    const projections = yield* ProjectionStore.ProjectionStoreV2;
+    const { importer } = yield* makeImporter([]);
+
+    const result = yield* importer.importClaudeExport({
+      projectId,
+      contents: "> Fix it\n\n⏺ Bash(vp test)\n  ⎿  1 failed\n\n⏺ Fixed\n",
+    });
+
+    expect(result.messageCount).toBe(2);
+    const records = yield* projections.getThreadRecords(result.threadId, [
+      "messages",
+      "providerThreads",
+    ]);
+    expect(records.messages.map((message) => [message.role, message.text])).toEqual([
+      ["user", "Fix it"],
+      ["assistant", "Fixed"],
+    ]);
+    expect(records.thread).toMatchObject({
+      projectId,
+      title: "Fix it",
+      historyOrigin: "v1_import",
+      activeProviderThreadId: null,
+    });
+    expect(records.providerThreads).toEqual([]);
+    const unreadable = yield* importer
+      .importClaudeExport({ projectId, contents: "not an export" })
+      .pipe(Effect.flip);
+    expect(unreadable._tag).toBe("AgentSessionTranscriptUnreadableError");
+  }).pipe(Effect.scoped, Effect.provide(persistence)),
+);
+
 it.effect(
   "ignores owned sessions, including archived and deleted threads, but imports other instances and unowned sessions",
   () =>