[PM-9035] desktop build logic to provide credentials to os on sync (#10181)

* feat: scaffold desktop_objc

* feat: rename fido2 to autofill

* feat: scaffold electron autofill

* feat: auto call hello world on init

* feat: scaffold call to basic objc function

* feat: simple log that checks if autofill is enabled

* feat: adding some availability guards

* feat: scaffold services and allow calls from inspector

* feat: create custom type for returning strings across rust/objc boundary

* chore: clean up comments

* feat: enable ARC

* feat: add util function `c_string_to_nsstring`

* chore: refactor and rename to `run_command`

* feat: add try-catch around command execution

* feat: properly implement command calling

Add static typing. Add proper error handling.

* feat: add autoreleasepool to avoid memory leaks

* chore: change objc names to camelCase

* fix: error returning

* feat: extract some helper functions into utils class

* feat: scaffold status command

* feat: implement status command

* feat: implement password credential mapping

* wip: implement sync command

This crashes because we are not properly handling the fact that `saveCredentialIdentities` uses callbacks, resulting in a race condition where we try to access a variable (result) that has already gotten dealloc'd.

* feat: first version of callback

* feat: make run_command async

* feat: functioning callback returns

* chore: refactor to make objc code easier to read and use

* feat: refactor everything to use new callback return method

* feat: re-implement status command with callback

* fix: warning about CommandContext not being FFI-safe

* feat: implement sync command using callbacks

* feat: implement manual password credential sync

* feat: add auto syncing

* docs: add todo

* feat: add support for passkeys

* chore: move desktop autofill service to init service

* feat: auto-add all .m files to builder

* fix: native build on unix and windows

* fix: unused compiler warnings

* fix: napi type exports

* feat: add corresponding dist command

* feat: comment signing profile until we fix signing

* fix: build breaking on non-macOS platforms

* chore: cargo lock update

* chore: revert accidental version change

* feat: put sync behind feature flag

* chore: put files in autofill folder

* fix: obj-c code not recompiling on changes

* feat: add `namespace` to commands

* fix: linting complaining about flag

* feat: add autofill as owner of their objc code

* chore: make autofill owner of run_command in core crate

* fix: re-add napi annotation

* fix: remove dev bypass

apps/desktop/src/platform/main/autofill/command.ts

@@ -0,0 +1,23 @@
+import { NativeAutofillStatusCommand } from "./status.command";
+import { NativeAutofillSyncCommand } from "./sync.command";
+
+export type CommandDefinition = {
+  namespace: string;
+  name: string;
+  input: Record<string, unknown>;
+  output: Record<string, unknown>;
+};
+
+export type CommandOutput<SuccessOutput> =
+  | {
+      type: "error";
+      error: string;
+    }
+  | { type: "success"; value: SuccessOutput };
+
+export type IpcCommandInvoker<C extends CommandDefinition> = (
+  params: C["input"],
+) => Promise<CommandOutput<C["output"]>>;
+
+/** A list of all available commands */
+export type Command = NativeAutofillSyncCommand | NativeAutofillStatusCommand;

apps/desktop/src/platform/main/autofill/native-autofill.main.ts

@@ -0,0 +1,53 @@
+import { ipcMain } from "electron";
+
+import { LogService } from "@bitwarden/common/platform/abstractions/log.service";
+import { autofill } from "@bitwarden/desktop-napi";
+
+import { CommandDefinition } from "./command";
+
+export type RunCommandParams<C extends CommandDefinition> = {
+  namespace: C["namespace"];
+  command: C["name"];
+  params: C["input"];
+};
+
+export type RunCommandResult<C extends CommandDefinition> = C["output"];
+
+export class NativeAutofillMain {
+  constructor(private logService: LogService) {}
+
+  async init() {
+    ipcMain.handle(
+      "autofill.runCommand",
+      <C extends CommandDefinition>(
+        _event: any,
+        params: RunCommandParams<C>,
+      ): Promise<RunCommandResult<C>> => {
+        return this.runCommand(params);
+      },
+    );
+  }
+
+  private async runCommand<C extends CommandDefinition>(
+    command: RunCommandParams<C>,
+  ): Promise<RunCommandResult<C>> {
+    try {
+      const result = await autofill.runCommand(JSON.stringify(command));
+      const parsed = JSON.parse(result) as RunCommandResult<C>;
+
+      if (parsed.type === "error") {
+        this.logService.error(`Error running autofill command '${command.command}':`, parsed.error);
+      }
+
+      return parsed;
+    } catch (e) {
+      this.logService.error(`Error running autofill command '${command.command}':`, e);
+
+      if (e instanceof Error) {
+        return { type: "error", error: e.stack ?? String(e) } as RunCommandResult<C>;
+      }
+
+      return { type: "error", error: String(e) } as RunCommandResult<C>;
+    }
+  }
+}

apps/desktop/src/platform/main/autofill/status.command.ts

@@ -0,0 +1,20 @@
+import { CommandDefinition, CommandOutput } from "./command";
+
+export interface NativeAutofillStatusCommand extends CommandDefinition {
+  name: "status";
+  input: NativeAutofillStatusParams;
+  output: NativeAutofillStatusResult;
+}
+
+export type NativeAutofillStatusParams = Record<string, never>;
+
+export type NativeAutofillStatusResult = CommandOutput<{
+  support: {
+    fido2: boolean;
+    password: boolean;
+    incrementalUpdates: boolean;
+  };
+  state: {
+    enabled: boolean;
+  };
+}>;

apps/desktop/src/platform/main/autofill/sync.command.ts

@@ -0,0 +1,37 @@
+import { CommandDefinition, CommandOutput } from "./command";
+
+export interface NativeAutofillSyncCommand extends CommandDefinition {
+  name: "sync";
+  input: NativeAutofillSyncParams;
+  output: NativeAutofillSyncResult;
+}
+
+export type NativeAutofillSyncParams = {
+  credentials: NativeAutofillCredential[];
+};
+
+export type NativeAutofillCredential =
+  | NativeAutofillFido2Credential
+  | NativeAutofillPasswordCredential;
+
+export type NativeAutofillFido2Credential = {
+  type: "fido2";
+  cipherId: string;
+  rpId: string;
+  userName: string;
+  /** Should be Base64URL-encoded binary data */
+  credentialId: string;
+  /** Should be Base64URL-encoded binary data */
+  userHandle: string;
+};
+
+export type NativeAutofillPasswordCredential = {
+  type: "password";
+  cipherId: string;
+  uri: string;
+  username: string;
+};
+
+export type NativeAutofillSyncResult = CommandOutput<{
+  added: number;
+}>;