Add Hermes Agent and Pi ACP providers

apps/mobile/src/components/ProviderIcon.tsx

@@ -12,6 +12,32 @@ export function ProviderIcon(props: ProviderIconProps) {
   const size = props.size ?? 16;
   const mono = isDarkMode ? "#e5e5e5" : "#171717";
 
+  if (props.provider === "pi") {
+    return (
+      <Svg width={size} height={size} viewBox="0 0 800 800" fill="none">
+        <Path
+          fill="#000"
+          d="M160 0h480c88.4 0 160 71.6 160 160v480c0 88.4-71.6 160-160 160H160C71.6 800 0 728.4 0 640V160C0 71.6 71.6 0 160 0Z"
+        />
+        <Path
+          fill="#fff"
+          d="M165.29 165.29h352.07V400H400v117.36H282.65v117.36H165.29Zm117.36 117.36V400H400V282.65ZM517.36 400h117.36v234.72H517.36Z"
+        />
+      </Svg>
+    );
+  }
+
+  if (props.provider === "hermes") {
+    return (
+      <Svg width={size} height={size} viewBox="0 0 24 24" fill="none">
+        <Path
+          fill={mono}
+          d="M4 5h3v5h10V5h3v14h-3v-6H7v6H4V5Zm-3 2 3 2v3L1 10V7Zm22 0v3l-3 2V9l3-2Z"
+        />
+      </Svg>
+    );
+  }
+
   if (props.provider === "claudeAgent") {
     return (
       <Svg width={size} height={size} viewBox="0 0 256 257" fill="none">

apps/server/src/provider/Drivers/HermesDriver.ts

@@ -0,0 +1,22 @@
+import { HermesSettings, ProviderDriverKind } from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
+
+import { makeHermesAdapter } from "../Layers/HermesAdapter.ts";
+import { makeStandardAcpCliDriver, type StandardAcpCliDriverEnv } from "./StandardAcpCliDriver.ts";
+
+const DRIVER_KIND = ProviderDriverKind.make("hermes");
+const decodeSettings = Schema.decodeSync(HermesSettings);
+
+export type HermesDriverEnv = StandardAcpCliDriverEnv;
+
+export const HermesDriver = makeStandardAcpCliDriver({
+  driverKind: DRIVER_KIND,
+  displayName: "Hermes Agent",
+  defaultBinary: "hermes-acp",
+  settingsSchema: HermesSettings,
+  defaultSettings: () => decodeSettings({}),
+  makeAdapter: makeHermesAdapter,
+  excludedAuthMethodIds: new Set(["hermes-setup"]),
+  setupHint: "Run `hermes-acp --setup` to configure Hermes credentials.",
+  missingCommandMessage: "Hermes Agent (`hermes-acp`) is not installed or not on PATH.",
+});

apps/server/src/provider/Drivers/PiDriver.ts

@@ -0,0 +1,22 @@
+import { PiSettings, ProviderDriverKind } from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
+
+import { makePiAdapter } from "../Layers/PiAdapter.ts";
+import { makeStandardAcpCliDriver, type StandardAcpCliDriverEnv } from "./StandardAcpCliDriver.ts";
+
+const DRIVER_KIND = ProviderDriverKind.make("pi");
+const decodeSettings = Schema.decodeSync(PiSettings);
+
+export type PiDriverEnv = StandardAcpCliDriverEnv;
+
+export const PiDriver = makeStandardAcpCliDriver({
+  driverKind: DRIVER_KIND,
+  displayName: "Pi",
+  defaultBinary: "pi-acp",
+  settingsSchema: PiSettings,
+  defaultSettings: () => decodeSettings({}),
+  makeAdapter: makePiAdapter,
+  setupHint:
+    "Install both `pi-acp` and `@earendil-works/pi-coding-agent`, then authenticate with `pi`.",
+  missingCommandMessage: "Pi ACP (`pi-acp`) is not installed or not on PATH.",
+});

apps/server/src/provider/Drivers/StandardAcpCliDriver.ts

@@ -0,0 +1,191 @@
+import {
+  type ProviderDriverKind,
+  type ServerProvider,
+  TextGenerationError,
+} from "@t3tools/contracts";
+import * as Crypto from "effect/Crypto";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import { ChildProcessSpawner } from "effect/unstable/process";
+
+import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts";
+import { ServerConfig } from "../../config.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
+import type { TextGenerationShape } from "../../textGeneration/TextGeneration.ts";
+import { ProviderDriverError } from "../Errors.ts";
+import type { StandardAcpAdapterLiveOptions } from "../Layers/StandardAcpAdapter.ts";
+import {
+  buildInitialStandardAcpCliProviderSnapshot,
+  checkStandardAcpCliProviderStatus,
+  type StandardAcpCliProviderConfig,
+} from "../Layers/StandardAcpCliProvider.ts";
+import { ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts";
+import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
+import { makeManualOnlyProviderMaintenanceCapabilities } from "../providerMaintenance.ts";
+import {
+  defaultProviderContinuationIdentity,
+  type ProviderDriver,
+  type ProviderInstance,
+} from "../ProviderDriver.ts";
+import { mergeProviderInstanceEnvironment } from "../ProviderInstanceEnvironment.ts";
+import type { ServerProviderDraft } from "../providerSnapshot.ts";
+
+const SNAPSHOT_REFRESH_INTERVAL = Duration.minutes(5);
+
+export interface StandardAcpCliSettings {
+  readonly enabled: boolean;
+  readonly binaryPath: string;
+  readonly customModels: ReadonlyArray<string>;
+}
+
+export type StandardAcpCliDriverEnv =
+  | BackgroundPolicy.BackgroundPolicy
+  | ChildProcessSpawner.ChildProcessSpawner
+  | Crypto.Crypto
+  | FileSystem.FileSystem
+  | Path.Path
+  | ProviderEventLoggers
+  | ServerConfig
+  | ServerSettingsService;
+
+export interface StandardAcpCliDriverConfig<Settings extends StandardAcpCliSettings> {
+  readonly driverKind: ProviderDriverKind;
+  readonly displayName: string;
+  readonly defaultBinary: string;
+  readonly settingsSchema: Schema.Codec<Settings, unknown>;
+  readonly defaultSettings: () => Settings;
+  readonly makeAdapter: (
+    settings: Settings,
+    options: StandardAcpAdapterLiveOptions,
+  ) => Effect.Effect<ProviderInstance["adapter"], never, StandardAcpCliDriverEnv | Scope.Scope>;
+  readonly setupHint: string;
+  readonly missingCommandMessage: string;
+  readonly excludedAuthMethodIds?: ReadonlySet<string>;
+}
+
+function makeUnsupportedTextGeneration(displayName: string): TextGenerationShape {
+  const fail = (operation: TextGenerationError["operation"]) =>
+    Effect.fail(
+      new TextGenerationError({
+        operation,
+        detail: `${displayName} ACP is not supported for headless text generation. Select a different provider instance for generated metadata.`,
+      }),
+    );
+  return {
+    generateCommitMessage: () => fail("generateCommitMessage"),
+    generatePrContent: () => fail("generatePrContent"),
+    generateBranchName: () => fail("generateBranchName"),
+    generateThreadTitle: () => fail("generateThreadTitle"),
+  };
+}
+
+export function makeStandardAcpCliDriver<Settings extends StandardAcpCliSettings>(
+  driverConfig: StandardAcpCliDriverConfig<Settings>,
+): ProviderDriver<Settings, StandardAcpCliDriverEnv> {
+  const maintenanceCapabilities = makeManualOnlyProviderMaintenanceCapabilities({
+    provider: driverConfig.driverKind,
+    packageName: null,
+  });
+
+  const withInstanceIdentity =
+    (input: {
+      readonly instanceId: ProviderInstance["instanceId"];
+      readonly displayName: string | undefined;
+      readonly accentColor: string | undefined;
+      readonly continuationGroupKey: string;
+    }) =>
+    (snapshot: ServerProviderDraft): ServerProvider => ({
+      ...snapshot,
+      instanceId: input.instanceId,
+      driver: driverConfig.driverKind,
+      ...(input.displayName ? { displayName: input.displayName } : {}),
+      ...(input.accentColor ? { accentColor: input.accentColor } : {}),
+      continuation: { groupKey: input.continuationGroupKey },
+    });
+
+  return {
+    driverKind: driverConfig.driverKind,
+    metadata: { displayName: driverConfig.displayName, supportsMultipleInstances: true },
+    configSchema: driverConfig.settingsSchema,
+    defaultConfig: driverConfig.defaultSettings,
+    create: ({ instanceId, displayName, accentColor, environment, enabled, config }) =>
+      Effect.gen(function* () {
+        const crypto = yield* Crypto.Crypto;
+        const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const processEnv = mergeProviderInstanceEnvironment(environment);
+        const effectiveConfig = { ...config, enabled } satisfies Settings;
+        const continuationIdentity = defaultProviderContinuationIdentity({
+          driverKind: driverConfig.driverKind,
+          instanceId,
+        });
+        const stampIdentity = withInstanceIdentity({
+          instanceId,
+          displayName,
+          accentColor,
+          continuationGroupKey: continuationIdentity.continuationKey,
+        });
+        const providerConfig: StandardAcpCliProviderConfig = {
+          provider: driverConfig.driverKind,
+          displayName: driverConfig.displayName,
+          command: effectiveConfig.binaryPath || driverConfig.defaultBinary,
+          enabled: effectiveConfig.enabled,
+          customModels: effectiveConfig.customModels,
+          environment: processEnv,
+          setupHint: driverConfig.setupHint,
+          missingCommandMessage: driverConfig.missingCommandMessage,
+          ...(driverConfig.excludedAuthMethodIds
+            ? { excludedAuthMethodIds: driverConfig.excludedAuthMethodIds }
+            : {}),
+        };
+
+        const eventLoggers = yield* ProviderEventLoggers;
+        const adapter = yield* driverConfig.makeAdapter(effectiveConfig, {
+          instanceId,
+          environment: processEnv,
+          ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}),
+        });
+        const checkProvider = checkStandardAcpCliProviderStatus(providerConfig).pipe(
+          Effect.map(stampIdentity),
+          Effect.provideService(Crypto.Crypto, crypto),
+          Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+        );
+        const snapshot = yield* makeManagedServerProvider<StandardAcpCliProviderConfig>({
+          maintenanceCapabilities,
+          getSettings: Effect.succeed(providerConfig),
+          streamSettings: Stream.never,
+          haveSettingsChanged: () => false,
+          initialSnapshot: (settings) =>
+            buildInitialStandardAcpCliProviderSnapshot(settings).pipe(Effect.map(stampIdentity)),
+          checkProvider,
+          refreshInterval: SNAPSHOT_REFRESH_INTERVAL,
+        }).pipe(
+          Effect.mapError(
+            (cause) =>
+              new ProviderDriverError({
+                driver: driverConfig.driverKind,
+                instanceId,
+                detail: `Failed to build ${driverConfig.displayName} snapshot: ${cause.message ?? String(cause)}`,
+                cause,
+              }),
+          ),
+        );
+
+        return {
+          instanceId,
+          driverKind: driverConfig.driverKind,
+          continuationIdentity,
+          displayName,
+          accentColor,
+          enabled,
+          snapshot,
+          adapter,
+          textGeneration: makeUnsupportedTextGeneration(driverConfig.displayName),
+        } satisfies ProviderInstance;
+      }),
+  };
+}