Add correct file path and correct running version

Author: AndyTitu

client_builder.go

@@ -26,12 +26,16 @@ func NewClient(ctx context.Context, opts ...ClientOption) (*Client, error) {
 		}
 	}
 
+	if client.usesDesktopApp && client.config.SAToken != "" {
+		return nil, fmt.Errorf("cannot use both SA token and desktop app authentication")
+	}
+
 	var core internal.Core
 	var err error
 	if client.usesDesktopApp {
-		core, err = internal.NewSharedLibCore()
+		core, err = internal.GetSharedLibCore()
 	} else {
-		core, err = internal.GetSharedCore()
+		core, err = internal.GetExtismCore()
 	}
 
 	if err != nil {

example/main.go

@@ -12,6 +12,7 @@ import (
 
 // [developer-docs.sdk.go.sdk-import]-start
 import "github.com/1password/onepassword-sdk-go"
+
 // [developer-docs.sdk.go.sdk-import]-end
 
 func main() {

internal/shared_extism_core.go renamed to internal/extism_core.go

@@ -24,17 +24,17 @@ const (
 	releaseClientFuncName = "release_client"
 )
 
-var core *SharedCore
+var core *ExtismCore
 
-// GetSharedCore initializes the shared core once and returns the already existing one on subsequent calls.
-func GetSharedCore() (*SharedCore, error) {
+// GetExtismCore initializes the shared core once and returns the already existing one on subsequent calls.
+func GetExtismCore() (*ExtismCore, error) {
 	runtimeCtx := context.Background()
 	if core == nil {
 		p, err := loadWASM(runtimeCtx)
 		if err != nil {
 			return nil, err
 		}
-		core = &SharedCore{plugin: p}
+		core = &ExtismCore{plugin: p}
 	}
 
 	return core, nil
@@ -44,16 +44,16 @@ func ReleaseCore() {
 	core = nil
 }
 
-// SharedCore implements Core in such a way that all created client instances share the same core resources.
-type SharedCore struct {
+// ExtismCore implements Core in such a way that all created client instances share the same core resources.
+type ExtismCore struct {
 	// lock is used to synchronize access to the shared WASM core which is single threaded
 	lock sync.Mutex
 	// plugin is the Extism plugin which represents the WASM core loaded into memory
 	plugin *extism.Plugin
 }
 
 // InitClient creates a client instance in the current core module and returns its unique ID.
-func (c *SharedCore) InitClient(ctx context.Context, config ClientConfig) (*uint64, error) {
+func (c *ExtismCore) InitClient(ctx context.Context, config ClientConfig) (*uint64, error) {
 	marshaledConfig, err := json.Marshal(config)
 	if err != nil {
 		return nil, err
@@ -73,7 +73,7 @@ func (c *SharedCore) InitClient(ctx context.Context, config ClientConfig) (*uint
 }
 
 // Invoke calls specified business logic from core
-func (c *SharedCore) Invoke(ctx context.Context, invokeConfig InvokeConfig) (*string, error) {
+func (c *ExtismCore) Invoke(ctx context.Context, invokeConfig InvokeConfig) (*string, error) {
 	input, err := json.Marshal(invokeConfig)
 	if err != nil {
 		return nil, err
@@ -92,7 +92,7 @@ func (c *SharedCore) Invoke(ctx context.Context, invokeConfig InvokeConfig) (*st
 }
 
 // ReleaseClient releases memory in the core associated with the given client ID.
-func (c *SharedCore) ReleaseClient(clientID uint64) {
+func (c *ExtismCore) ReleaseClient(clientID uint64) {
 	marshaledClientID, err := json.Marshal(clientID)
 	if err != nil {
 		c.plugin.Log(extism.LogLevelWarn, fmt.Sprintf("memory couldn't be released: %s", err.Error()))
@@ -103,7 +103,7 @@ func (c *SharedCore) ReleaseClient(clientID uint64) {
 	}
 }
 
-func (c *SharedCore) callWithCtx(ctx context.Context, functionName string, serializedParameters []byte) ([]byte, error) {
+func (c *ExtismCore) callWithCtx(ctx context.Context, functionName string, serializedParameters []byte) ([]byte, error) {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
@@ -114,7 +114,7 @@ func (c *SharedCore) callWithCtx(ctx context.Context, functionName string, seria
 	return response, nil
 }
 
-func (c *SharedCore) call(functionName string, serializedParameters []byte) ([]byte, error) {
+func (c *ExtismCore) call(functionName string, serializedParameters []byte) ([]byte, error) {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 

internal/shared_so_core.go renamed to internal/shared_lib_core.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"path/filepath"
 	"runtime"
 	"unsafe"
 )
@@ -18,14 +19,42 @@ import (
 #include <stdlib.h>
 #include <stdint.h>
 
-// Define a function pointer type matching Rust's send_message
+// Function pointer types matching Rust exports
 typedef int32_t (*send_message_t)(
     const uint8_t* msg_ptr,
     size_t msg_len,
     uint8_t** out_buf,
-    size_t* out_len
+    size_t* out_len,
+    size_t* out_cap
 );
 
+typedef void (*free_message_t)(
+    uint8_t* buf,
+    size_t len,
+    size_t cap
+);
+
+// Trampoline wrappers so Go can call the function pointers
+static inline int32_t call_send_message(
+    send_message_t fn,
+    const uint8_t* msg_ptr,
+    size_t msg_len,
+    uint8_t** out_buf,
+    size_t* out_len,
+    size_t* out_cap
+) {
+    return fn(msg_ptr, msg_len, out_buf, out_len, out_cap);
+}
+
+static inline void call_free_message(
+    free_message_t fn,
+    uint8_t* buf,
+    size_t len,
+    size_t cap
+) {
+    fn(buf, len, cap);
+}
+
 // dlopen wrapper
 static void* open_library(const char* path) {
     return dlopen(path, RTLD_NOW);
@@ -46,63 +75,77 @@ import "C"
 type SharedLibCore struct {
 	handle      unsafe.Pointer
 	sendMessage C.send_message_t
+	freeMessage C.free_message_t
 }
 
-// Find1PasswordPath tries to return the default installation path of 1Password
-func find1PasswordPath() (string, error) {
+var coreLib *SharedLibCore
+
+// find1PasswordLibPath returns the path to the 1Password shared library
+// (libop_sdk_ipc_client.dylib/.so/.dll) depending on OS.
+func find1PasswordLibPath() (string, error) {
 	switch runtime.GOOS {
 	case "darwin": // macOS
-		// 1Password is typically installed as an app bundle
-		paths := []string{
-			"/Applications/1Password.app",
+		// Typical locations for the 1Password bundle
+		executables := []string{
+			"/Applications/1Password/Contents/MacOS/1Password",
 		}
-		for _, p := range paths {
-			if _, err := os.Stat(p); err == nil {
-				return p, nil
+
+		for _, exe := range executables {
+			if _, err := os.Stat(exe); err == nil {
+				// Replace the executable name with the dylib name
+				libPath := filepath.Join(filepath.Dir(exe), "libop_sdk_ipc_client.dylib")
+				if _, err := os.Stat(libPath); err == nil {
+					return libPath, nil
+				}
 			}
 		}
 
 	case "linux":
-		// Linux installations vary
-		paths := []string{
-			"/var/lib/1password",
-			"/opt/1Password",
+		// On Linux, it might live under /opt/1Password or similar
+		candidates := []string{
+			"/opt/1Password/libop_sdk_ipc_client.so",
+			"/usr/lib/1password/libop_sdk_ipc_client.so",
 		}
-		for _, p := range paths {
-			if _, err := os.Stat(p); err == nil {
-				return p, nil
+		for _, lib := range candidates {
+			if _, err := os.Stat(lib); err == nil {
+				return lib, nil
 			}
 		}
 
 	case "windows":
-		// On Windows, 1Password installs under Program Files
-		paths := []string{
+		// On Windows, shared libs are DLLs in the install directory
+		executables := []string{
 			`C:\Program Files\1Password\1Password.exe`,
 		}
-		for _, p := range paths {
-			if _, err := os.Stat(p); err == nil {
-				return p, nil
+		for _, exe := range executables {
+			if _, err := os.Stat(exe); err == nil {
+				libPath := filepath.Join(filepath.Dir(exe), "op_sdk_ipc_client.dll")
+				if _, err := os.Stat(libPath); err == nil {
+					return libPath, nil
+				}
 			}
 		}
 	}
 
-	return "", fmt.Errorf("1Password not found")
+	return "", fmt.Errorf("1Password desktop application not found")
 }
 
-func NewSharedLibCore() (*SharedLibCore, error) {
-	path, err := find1PasswordPath()
-	if err != nil {
-		return nil, err
-	}
-	coreLib, err := LoadCore(path)
-	if err != nil {
-		return nil, err
+func GetSharedLibCore() (*SharedLibCore, error) {
+	if coreLib == nil {
+		path, err := find1PasswordLibPath()
+		if err != nil {
+			return nil, err
+		}
+		coreLib, err = loadCore(path)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	return coreLib, nil
 }
 
-func LoadCore(path string) (*SharedLibCore, error) {
+func loadCore(path string) (*SharedLibCore, error) {
 	cPath := C.CString(path)
 	defer C.free(unsafe.Pointer(cPath))
 
@@ -111,18 +154,28 @@ func LoadCore(path string) (*SharedLibCore, error) {
 		return nil, errors.New("failed to open library")
 	}
 
-	symbol := C.CString("send_message")
+	symbol := C.CString("op_sdk_ipc_send_message")
 	defer C.free(unsafe.Pointer(symbol))
 
-	fn := C.load_symbol(handle, symbol)
-	if fn == nil {
+	fnSend := C.load_symbol(handle, symbol)
+	if fnSend == nil {
 		C.close_library(handle)
 		return nil, errors.New("failed to load send_message")
 	}
 
+	symbolFree := C.CString("op_sdk_ipc_free_response")
+	defer C.free(unsafe.Pointer(symbolFree))
+
+	fnFree := C.load_symbol(handle, symbolFree)
+	if fnFree == nil {
+		C.close_library(handle)
+		return nil, errors.New("failed to load free_message")
+	}
+
 	return &SharedLibCore{
 		handle:      handle,
-		sendMessage: (C.send_message_t)(fn),
+		sendMessage: (C.send_message_t)(fnSend),
+		freeMessage: (C.free_message_t)(fnFree),
 	}, nil
 }
 
@@ -182,20 +235,24 @@ func (c *SharedLibCore) ReleaseClient(clientID uint64) {
 func (c *SharedLibCore) callSharedLibrary(input []byte) ([]byte, error) {
 	var outBuf *C.uint8_t
 	var outLen C.size_t
+	var outCap C.size_t
 
-	retCode := c.sendMessage(
+	retCode := C.call_send_message(
+		c.sendMessage,
 		(*C.uint8_t)(unsafe.Pointer(&input[0])),
 		C.size_t(len(input)),
 		&outBuf,
 		&outLen,
+		&outCap,
 	)
 
 	if retCode != 0 {
 		return nil, fmt.Errorf("send_message failed: %d", int(retCode))
 	}
 
 	resp := C.GoBytes(unsafe.Pointer(outBuf), C.int(outLen))
-	C.free(unsafe.Pointer(outBuf))
+	// Call trampoline with the function pointer
+	C.call_free_message(c.freeMessage, outBuf, outLen, outCap)
 
 	return resp, nil
 }