Added file storage

Author: djthorpe

client.go

@@ -34,6 +34,9 @@ type Client struct {
 	sync.Mutex
 	*http.Client
 
+	// Parent object for client options
+	Parent any
+
 	endpoint *url.URL
 	ua       string
 	rate     float32 // number of requests allowed per second

clientopts.go

@@ -113,3 +113,16 @@ func OptHeader(key, value string) ClientOpt {
 		return nil
 	}
 }
+
+// OptParent sets the parent client for this client, which is
+// used for setting additional client options in the parent
+func OptParent(v any) ClientOpt {
+	return func(client *Client) error {
+		if v == nil {
+			return ErrBadParameter.With("OptParent")
+		} else {
+			client.Parent = v
+		}
+		return nil
+	}
+}

cmd/api/anthropic.go

@@ -54,7 +54,7 @@ func anthropicParse(flags *Flags, opts ...client.ClientOpt) error {
 
 func anthropicChat(w *tablewriter.Writer, args []string) error {
 	// Request -> Response
-	message := schema.NewMessage(schema.Anthropic, "user", nil)
+	message := schema.NewMessage("user")
 	for _, arg := range args {
 		message.Add(arg)
 	}

cmd/api/bitwarden.go

@@ -34,11 +34,10 @@ const (
 )
 
 var (
-	bwClient                   *bitwarden.Client
-	bwClientId, bwClientSecret string
-	bwPassword                 string
-	bwConfigDir                string
-	bwForce                    bool
+	bwClient    *bitwarden.Client
+	bwPassword  string
+	bwConfigDir string
+	bwForce     bool
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -58,7 +57,6 @@ func bwRegister(flags *Flags) {
 		Parse:       bwParse,
 		Fn: []Fn{
 			{Name: "auth", Description: "Authenticate with Bitwarden", Call: bwAuth},
-			{Name: "sync", Description: "Sync items from Bitwarden", Call: bwSync},
 			{Name: "folders", Description: "Retrieve folders", Call: bwFolders},
 			{Name: "logins", Description: "Retrieve login items", Call: bwLogins, MaxArgs: 1},
 			{Name: "password", Description: "Print a password to stdout", Call: bwGetPassword, MinArgs: 1, MaxArgs: 1},
@@ -67,12 +65,6 @@ func bwRegister(flags *Flags) {
 }
 
 func bwParse(flags *Flags, opts ...client.ClientOpt) error {
-	if client, err := bitwarden.New(opts...); err != nil {
-		return err
-	} else {
-		bwClient = client
-	}
-
 	// Get config directory
 	if config, err := os.UserConfigDir(); err != nil {
 		return err
@@ -84,14 +76,23 @@ func bwParse(flags *Flags, opts ...client.ClientOpt) error {
 	}
 
 	// Set defaults
-	bwClientId = flags.GetString("bitwarden-client-id")
-	bwClientSecret = flags.GetString("bitwarden-client-secret")
-	if bwClientId == "" || bwClientSecret == "" {
+	clientId := flags.GetString("bitwarden-client-id")
+	clientSecret := flags.GetString("bitwarden-client-secret")
+	if clientId == "" || clientSecret == "" {
 		return ErrBadParameter.With("Missing -bitwarden-client-id or -bitwarden-client-secret argument")
 	}
 	bwForce = flags.GetBool("force")
 	bwPassword = flags.GetString("bitwarden-password")
 
+	// Create the client
+	opts = append(opts, bitwarden.OptCredentials(clientId, clientSecret))
+	opts = append(opts, bitwarden.OptFileStorage(bwConfigDir))
+	if client, err := bitwarden.New(opts...); err != nil {
+		return err
+	} else {
+		bwClient = client
+	}
+
 	// Return success
 	return nil
 }
@@ -100,173 +101,58 @@ func bwParse(flags *Flags, opts ...client.ClientOpt) error {
 // API METHODS
 
 func bwAuth(w *tablewriter.Writer, _ []string) error {
-	// Load session or create a new one
-	session, err := bwReadSession()
-	if err != nil {
-		return err
-	}
-
-	// Login options
-	opts := []bitwarden.LoginOpt{
-		bitwarden.OptCredentials(bwClientId, bwClientSecret),
-	}
-	if session.Device == nil {
-		opts = append(opts, bitwarden.OptDevice(schema.Device{
-			Name: bwName,
-		}))
-	}
+	opts := []bitwarden.RequestOpt{}
 	if bwForce {
 		opts = append(opts, bitwarden.OptForce())
 	}
 
-	// Perform the login
-	if err := bwClient.Login(session, opts...); err != nil {
-		return err
-	}
-
-	// Save session
-	if err := bwWriteSession(session); err != nil {
+	// Login
+	if err := bwClient.Login(opts...); err != nil {
 		return err
 	}
 
-	// Print out session
-	w.Write(session)
-
-	// Return success
-	return nil
-}
-
-func bwSync(w *tablewriter.Writer, _ []string) error {
-	// Load session or create a new one
-	session, err := bwReadSession()
-	if err != nil {
-		return err
-	}
-	// If the session is not valid, then return an error
-	if !session.IsValid() {
-		return ErrOutOfOrder.With("Session is not valid, login first")
-	}
-	// Perform the sync
-	sync, err := bwClient.Sync(session)
-	if err != nil {
-		return err
-	} else if err := bwWrite("profile.json", sync.Profile); err != nil {
-		return err
-	} else if err := bwWrite("folders.json", sync.Folders); err != nil {
-		return err
-	} else if err := bwWrite("ciphers.json", sync.Ciphers); err != nil {
-		return err
-	} else if err := bwWrite("domains.json", sync.Domains); err != nil {
+	// Sync
+	if profile, err := bwClient.Sync(opts...); err != nil {
 		return err
+	} else {
+		return w.Write(profile)
 	}
-
-	// Output the profile
-	w.Write(sync.Profile)
-
-	// Return success
-	return nil
 }
 
 func bwFolders(w *tablewriter.Writer, _ []string) error {
-	// Load the profile
-	profile, err := bwReadProfile()
-	if err != nil {
-		return err
+	opts := []bitwarden.RequestOpt{}
+	if bwForce {
+		opts = append(opts, bitwarden.OptForce())
 	}
-
-	// Load session or create a new one
-	session, err := bwReadSession()
+	folders, err := bwClient.Folders(opts...)
 	if err != nil {
 		return err
 	}
 
-	// Make an encryption key
-	if bwPassword == "" {
-		if v, err := bwReadPasswordFromTerminal(); err != nil {
-			return err
-		} else {
-			bwPassword = v
-		}
-	}
-	if err := session.CacheKey(profile.Key, profile.Email, bwPassword); err != nil {
-		return err
-	}
-
-	// Read the folders
-	folders := schema.Folders{}
-	if err := bwRead("folders.json", &folders); err != nil {
-		return err
-	}
-
 	// Decrypt the folders from the session
-	for i, folder := range folders {
-		if decrypted, err := folder.Decrypt(session); err != nil {
-			return err
-		} else {
-			folders[i] = decrypted.(*schema.Folder)
-		}
+	var result []*schema.Folder
+	for folder := folders.Next(); folder != nil; folder = folders.Next() {
+		result = append(result, folders.Decrypt(folder))
 	}
-
-	// Output the folders
-	w.Write(folders)
-
-	// Return success
-	return nil
+	return w.Write(result)
 }
 
 func bwLogins(w *tablewriter.Writer, _ []string) error {
-	// Load the profile
-	profile, err := bwReadProfile()
-	if err != nil {
-		return err
+	opts := []bitwarden.RequestOpt{}
+	if bwForce {
+		opts = append(opts, bitwarden.OptForce())
 	}
-
-	// Load session or create a new one
-	session, err := bwReadSession()
+	ciphers, err := bwClient.Ciphers(opts...)
 	if err != nil {
 		return err
 	}
 
-	// Make an encryption key
-	if bwPassword == "" {
-		if v, err := bwReadPasswordFromTerminal(); err != nil {
-			return err
-		} else {
-			bwPassword = v
-		}
-	}
-	if err := session.CacheKey(profile.Key, profile.Email, bwPassword); err != nil {
-		return err
-	}
-
-	// Read the ciphers
-	ciphers := schema.Ciphers{}
-	result := []bwCipher{}
-	if err := bwRead("ciphers.json", &ciphers); err != nil {
-		return err
-	}
 	// Decrypt the ciphers from the session
-	for _, cipher := range ciphers {
-		if cipher.Type != schema.CipherTypeLogin {
-			continue
-		}
-		if decrypted, err := cipher.Decrypt(session); err != nil {
-			return err
-		} else {
-			result = append(result, bwCipher{
-				Name:     decrypted.(*schema.Cipher).Name,
-				Username: decrypted.(*schema.Cipher).Login.Username,
-				URI:      decrypted.(*schema.Cipher).Login.URI,
-				Folder:   decrypted.(*schema.Cipher).FolderId,
-			})
-		}
+	var result []*schema.Cipher
+	for cipher := ciphers.Next(); cipher != nil; cipher = ciphers.Next() {
+		result = append(result, ciphers.Decrypt(cipher))
 	}
-
-	// Output the ciphers
-	w.Write(result)
-
-	// Return success
-	return nil
+	return w.Write(result)
 }
 
 func bwGetPassword(w *tablewriter.Writer, _ []string) error {
@@ -291,73 +177,3 @@ func bwReadPasswordFromTerminal() (string, error) {
 		return string(value), nil
 	}
 }
-
-func bwReadProfile() (*schema.Profile, error) {
-	result := schema.NewProfile()
-	filename := filepath.Join(bwConfigDir, "profile.json")
-	if _, err := os.Stat(filename); os.IsNotExist(err) {
-		// Return an error
-		return nil, ErrNotFound.With("Profile not found")
-	} else if err != nil {
-		return nil, err
-	}
-
-	// Open the file
-	file, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	// Read and return the session
-	return result, result.Read(file)
-}
-
-func bwReadSession() (*schema.Session, error) {
-	result := schema.NewSession()
-	filename := filepath.Join(bwConfigDir, "session.json")
-	if _, err := os.Stat(filename); os.IsNotExist(err) {
-		// Return a new, empty session
-		return result, nil
-	} else if err != nil {
-		return nil, err
-	}
-
-	// Open the file
-	file, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	// Read and return the session
-	return result, result.Read(file)
-}
-
-func bwWriteSession(session *schema.Session) error {
-	return bwWrite("session.json", session)
-}
-
-func bwWrite(filename string, obj schema.ReaderWriter) error {
-	path := filepath.Join(bwConfigDir, filename)
-	w, err := os.Create(path)
-	if err != nil {
-		return err
-	}
-	defer w.Close()
-
-	// Write the object and return any errors
-	return obj.Write(w)
-}
-
-func bwRead(filename string, obj schema.ReaderWriter) error {
-	path := filepath.Join(bwConfigDir, filename)
-	r, err := os.Open(path)
-	if err != nil {
-		return err
-	}
-	defer r.Close()
-
-	// Write the object and return any errors
-	return obj.Read(r)
-}